TD01/code/set-exemples.py

-{3,6,"cat",4.5,False}
-
-# {False, 4.5, 3, 6, 'cat'}     # L'ensemble est ordonné
-my_set = {3,6,"cat",4.5,False}
-my_set
-
-#{False, 3, 4.5, 6, 'cat'}
-
-len(my_set)
-# 5
-
-False in my_set
-# True
-
-"dog" in my_set
-#False
-
-your_set =  {99,3,100}
-my_set.union(your_set)
-# {False, 3, 4.5, 6, 99, 'cat', 100}
-
-my_set | your_set
-# {False, 3, 4.5, 6, 99, 'cat', 100}
-
-my_set.intersection(your_set)
-# {3}
-
-my_set & your_set
-# {3}
-
-my_set.difference(your_set)
-# {False, 4.5, 6, 'cat'}
-
-my_set - your_set
-# {False, 4.5, 6, 'cat'}
-
-{3,100}.issubset(your_set)
-# True
-
-{3,100} <= your_set
-# True
-
-my_set.add("house")
-my_set
-# {False, 3, 4.5, 6, 'house', 'cat'}
-
-my_set.remove(4.5)
-my_set
-# {False, 3, 6, 'house', 'cat'}
-
-my_set.pop()
-# False
-
-my_set
-# {3, 6, 'house', 'cat'}
-
-my_set.clear()
-my_set
-set()               # Ensemble vide
\ No newline at end of file

TD01/code/tas.py

-class Tas():
-    def __init__(self):
-        self.__values = []
-
-    def push(self, value):
-        self.__values.append(value)
-
-    def peek(self, i): # pop sans suppression
-        return self.__values[i], i
-        
-    def fg(self, i):
-        left_i = 2 * i + 1
-        if left_i > len(self.__values):
-            return None, left_i
-        else:
-            return self.__values[left_i], left_i
-
-    def fd(self, i):
-        droite_i = 2 * i + 2
-        if droite_i > len(self.__values):
-            return None, droite_i
-        else:
-            return self.__values[droite_i], droite_i
-
-    def parent(self, i):
-        return self.__values[(i - 1) // 2]
-
-    def afficher(self):
-        return ' '.join(str(v) for v in self.__values)
-
-    def inserer(self, value):
-        self.push(value)
-        i = len(self.__values) - 1
-        while (i + 1) // 2 > 0:
-            if self.__values[i] < self.parent(i):
-                tmp = self.__values[i // 2]
-                self.__values[i // 2] = self.__values[i]
-                self.__values[i] = tmp
-            i = i // 2
-        
-    def supprimer(self, i):
-
-        v = self.__values.pop(i)
-        max_i = i
-        n = len(self.__values) - 1
-
-        while self.__values[i] > self.fg(i)[0] or self.__values[i] > self.fd(i)[0]:
-
-            max = self.__values[i]
-            
-            if i < n and max > self.fg(i)[0]:
-                max_i = 2 * i + 1
-
-            if i < n and max > self.fd(i)[0]:
-                max_i = 2 * i + 2
-
-            if max_i != i: 
-                self.__values[i], self.__values[max_i] = self.__values[max_i], self.__values[i]
-
-            i = max_i
-
-        return v
\ No newline at end of file

TD01/code/time.py

-import timeit
-
-print(timeit.timeit("x = 2 + 2"))
-#.0188..............
-
-print(timeit.timeit("x = range(10)"))
-#.589.........

TD01/code/tirage-des.py

-from random import *
-
-effectifs=[0,0,0,0,0,0]
-# OU 
-# effectif=[0]*6
-for n in range(10000):
-    dice=randint(1,6)
-    effectifs[dice-1]+=1
-
-print(effectifs)
-
-#--> [1642, 1710, 1683, 1661, 1678, 1626]
-# Donner l'intervalle de confiance associé à ce résultat à 95%
-
-#Même chose avec 2 dés
-from random import *
-
-effectifs=[0]*11
-for n in range(10000):
-    de1=randint(1,6)
-    de2=randint(1,6)
-    twodice=de1+de2
-    effectifs[twodice-2]+=1
-
-print(effectifs)
-# --> [299, 540, 832, 1159, 1401, 1665, 1401, 1103, 787, 541, 272]
\ No newline at end of file

TD01/code/tirage-gaussienne.py

-from math import *
-from random import *
-
-def tirage_gauss_centre_reduit():
-    x=uniform(0,1)
-    y=sqrt(-2*log(uniform(0,1)))
-    y = y*cos(x*2*pi)
-    return y 
- 
-try :
-  n=int(input("combien de valeurs : "))
-  for i in range(n) :
-    print("Le tirage : ", tirage_gauss_centre_reduit())
-except ValueError as err :
-  print("Error: {0}".format(err))    
-
-""" TRACE :
-combien de valeurs : 5
-Le tirage :  0.1675459650607427
-Le tirage :  -0.8810297798592189
-Le tirage :  0.4764601603767129
-Le tirage :  -1.8446292482050937
-Le tirage :  -0.35483078367598453
-"""
\ No newline at end of file

TD01/code/tirage-random.py

-# imports
-from random import seed, random
-
-# fonctions
-def listAleatoireFloat(n):
-    """Retourne une liste de <n> flottants aleatoires."""
-    return [random() for i in range(n)]
-
-# programme principal  
-n = int(input("Entrez un entier [2 .. 100] : "))
-while not (2 <= n <= 100): # saisie filtree
-    n = int(input("Entrez un entier [2 .. 100], s.v.p. : "))
-
-seed() # initialise le generateur de nombres aleatoires
-t = listAleatoireFloat(n) # construction de la liste
-
-print("Liste :", t)
-print("Amplitude : {:.2f}".format(max(t) - min(t)))
-print("Moyenne : {:.2f}".format(sum(t)/n))
\ No newline at end of file

TD01/code/tirage-remise.py

-from math import *
-from random import *
-
-# Simulation d'un tirage avec remise de k objets parmi n
-
-def tirage_uniforme_k_of_n_avec_remise(n,k):
-    if k > n :
-        raise ValueError("k (%d) doit être =< que n (%d) " % (k,n))
-    T=[x for x in range(1,n+1,1)]   # On constitue une urne avec p objets
-
-    for i in range(k) : # Tirage de k numéros
-            d=randint(1,n)
-            # On permute le d-ème élément de l'urne et la derniere
-            temp=T[d-1]
-            T[d-1]=T[n-1]
-            T[n-1]=temp
-            n=n-1
-    return T[n:n+k+1]
-    
-
-n=int(input("La valeur de n ? "))
-k=int(input("La valeur de k (parmi n) ? "))
-try :
-    print("Le tirage : ", tirage_uniforme_k_of_n_avec_remise(n,k))
-except ValueError as err :
-    print("Error: {0}".format(err))
\ No newline at end of file

TD01/code/tri-analyse.py

-# Comparaison des différents tris
-import time
-import random
-import matplotlib.pyplot as plt
-import numpy as np
-
-# On commence par définir une petite méthode "utilitaire" qui va nous servir souvent.
-# permute permet de permuter deux éléments situés aux indices i et j d'un tableau.
-def permute(tab, i, j):
-    '''
-    :e/s: tab, un tableau d'éléments
-    :entrees i et j: (int) les indices des éléments à permuter
-    :pre-cond: i et j sont des indices valides dans tab
-    :post-cond: le tableau est modifié, deux valeurs sont perumtées
-    '''
-    temp = tab[i]
-    tab[i] = tab[j]
-    tab[j] = temp
-
-# Tri par sélection
-# Rappel : on recherche le minimum du tableau, et on le permute avec l'élément dans la première case.
-#          Ensuite, on recherche le minimum dans le reste du tableau, et on le permute avec l'élément dans la 2ème case.
-#          Et ainsi de suite...
-
-
-def triSelection(tab):
-    '''
-    :e/s tab: tableau (de float)
-    :post-cond:
-       - ∀ i ∈ [0;len(tab)[, ∃ j ∈ [0;len(tab)[,  tabₛ[j] = tabₑ[i]
-         (les éléments de tab ont simplent changé d'ordre)
-       - ∀ i ∈ [1;len(tab)[,  tabₛ[i] ≥ tabₛ[i-1]
-         (les éléments de tab sont triés par valeur croissante)
-    :complexité : 𝓞(n²)
-    '''
-    for i in range(len(tab)-1):
-        indice_min = i
-        
-        # Boucle de recherche du minimum dans le tableau restant
-        for j in range(i+1,len(tab)):
-            if tab[j]<tab[indice_min]: 
-                indice_min=j
-        
-        # Une fois le min trouvé, on le permute pour le mettre à sa place
-        permute(tab, i, indice_min)
-        
-
-# Tri par insertion 
-# Rappel : on considère que le "début" du tableau est trié. 
-#          On se place au niveau de la première valeur non triée, et on la décale à gauche jusqu'à ce qu'elle trouve sa place
-#          Observez que la partie gauche du tableau est déjà triée... 
-
-
-# On commence par écrire une petite fonction utilitaire (une autre).
-# Cette fonction prend un élément à un indice i, et le décale sur 
-#   sa gauche jusqu'à ce qu'il soit à sa place... en faisant 
-#   l'hypothèse que tous les éléments sur sa gauche sont bien triés.
-
-def insereElt(tab, i):
-    '''
-    :e/s tab: tableau d'éléments
-    :entrée i: int
-    :pré-cond:
-       - 1 ≤ i < len(tab)
-       - ∀ j ∈ [1;i[,  tab[j] ≥ tab[j-1]  (tab est trié entre 0 et i-1)
-    :post-cond:
-       - ∀ j ∈ [0;i+1[, ∃ k ∈ [0;i+1[,  tabₛ[k] = tabₑ[j]
-         (les éléments entre 0 et i+1 ont simplement changé d'ordre)
-       - ∀ j ∈ [i+1;len(tab)[,  tabₛ[j] = tabₑ[j]
-         (les éléments au delà de i n'ont pas été modifiés)
-       - ∀ j ∈ [1;i+1[,  tab[j] ≥ tab[j-1]
-         (tab est trié entre 0 et i)
-    '''
-    while (tab[i-1] > tab[i]) and i>0 :
-        permute(tab, i, i-1)
-        i -= 1   
-
-# On écrit ensuite l'algo principal qui consiste à prendre
-#  tour à tour chaque élément "non trié", et à l'insérer dans
-#  le tableau trié (c'est-à-dire à le décaler jusqu'à sa bonne
-#  place sur sa gauche). 
-def triInsertion(tab):
-    '''
-    :e/s tab: tableau d'éléments
-    :pré- et post-conditions usuelles
-    '''
-    for i in range(1,len(tab)):
-        insereElt(tab, i)
-
-
-# Tri binaire, ou quicksort
-# Le quicksort est un tri récursif par excellence. 
-# Le principe est que l'on choisit une valeur pivot, 
-#   on range toutes les valeurs plus petites que le pivot à gauche du pivot
-#   et toutes les valeurs plus grandes à droite. 
-# Ensuite, on applique la même démarche sur les sous-tableaux gauche et droite. 
-# Une simulation intéressante est disponible ici : 
-# http://interactivepython.org/runestone/static/pythonds/SortSearch/TheQuickSort.html
-
-
-# On définit une méthode utilitaire qui va nous aider à partitionner notre tableau autour d'un pivot
-def partitionne(tab, imin, imax):
-    '''
-    :e/s tab: tableau d'éléments 
-    :entrée imin: int
-    :entrée imax: int
-    :sortie idroite: int
-    :pré-cond: 0 ≤ imin ≤ imax < len(tab)
-    :post-cond:
-       - imin ≤ idroite ≤ imax
-       - ∀ i ∈ [0;imin[ U ]imax;len(tab)[, tabₛ[i] = tabₑ[i]
-         (tab n'est pas modifié en dehors de la plage [imin;imax])
-       - ∀ i ∈ [imin;imax], ∃ j ∈ [imin;imax],  tabₛ[j] = tabₑ[i]
-         (les éléments de tab ont simplent changé d'ordre entre imin et imax)
-       - ∀ i ∈ [imin;idroite], tabₛ[i] ≤ tabₛ[idroite]
-         (les éléments à gauche du pivot lui sont inférieurs ou égaux)
-       - ∀ i ∈ ]idroite;imax], tabₛ[i] > tabₛ[idroite]
-         (les éléments à droite du pivot lui sont supérieurs)
-    '''
-    pivot = tab[imin] # On choisit arbitrairement le premier élément comme pivot 
-
-    igauche = imin + 1
-    idroite = imax
-    fini = False
-    while not fini:
-        while igauche <= idroite and tab[igauche] <= pivot:
-            igauche = igauche + 1
-        while tab[idroite] >= pivot and idroite >= igauche:
-            idroite = idroite - 1
-        if idroite < igauche:
-            fini= True
-        else:
-            temp = tab[igauche]
-            tab[igauche] = tab[idroite]
-            tab[idroite] = temp
-            #permute(tab, igauche, idroite)
-    temp = tab[imin]
-    tab[imin] = tab[idroite]
-    tab[idroite] = temp
-    #permute(tab, imin, imax)
-    return idroite
-
-
-# Si notre tableau n'est pas vide, on appelle tri_rec :
-# Sinon, le tableau vide n'est pas modifié. 
-def triRecursif(tab):
-    if len(tab) > 0:
-        tri_rec(tab, 0, len(tab)-1)
-
-def tri_rec(tab, imin, imax):
-    '''
-    :e/s tab: tableau d'éléments
-    :entrée imin: int
-    :entrée imax: int
-    :pré-cond: 0 ≤ imin ≤ imax < len(tab) (les indices existent dans le tableau)
-    :post-cond:
-       - ∀ i ∈ [0;imin[ U ]imax;len(tab)[, tabₛ[i] = tabₑ[i]
-         (tab n'est pas modifié en dehors de la plage [imin;imax])
-       - ∀ i ∈ [imin;imax], ∃ j ∈ [imin;imax],  tabₛ[j] = tabₑ[i]
-         (les éléments de tab ont simplent changé d'ordre entre imin et imax)
-       - ∀ i ∈ [imin;imax[,  tabₛ[i+1] ≥ tabₛ[i]
-         (tab est trié entre imin et imax)
-    '''
-    if imin < imax:
-        # partition the list
-        pivot = partitionne(tab, imin, imax)
-        # sort both halves
-        tri_rec(tab, imin, pivot-1)
-        tri_rec(tab, pivot+1, imax)
-    return tab
-
-# Tri bulle 
-def triBulle(tab):
-    '''
-    :entree/sortie: tab un tableau d'éléments
-    :post-condition : tab est trié
-    ''' 
-    swap = True
-    while swap == True:
-        swap = False
-        for j in range(0,len(tab)-1):
-            if tab[j]>tab[j+1]:
-                swap = True
-                temp=tab[j]
-                tab[j]=tab[j+1]
-                tab[j+1]=temp
-
-
-
-
-nvalues = [10, 100, 500, 1000]
-timesSelection = []
-timesInsertion = []
-timesBulle = []
-timesRecursif = []
-
-for i in nvalues:
-    random.seed()
-    p = 12**2 # Ordre de grandeur des valeurs
-    liste = []
-    
-    for x in range(i): liste.append(random.randint(0, p))
-
-    tableau = list(liste)
-    a=time.process_time()
-    triSelection(tableau)
-    if x <= 10:
-        print(tableau)
-    b=time.process_time()
-    timesSelection.append(b-a)
-
-    tableau = list(liste)
-    a=time.process_time()
-    triInsertion(tableau)
-    if x <= 10:
-        print(tableau)
-    b=time.process_time()
-    timesInsertion.append(b-a)
-
-    tableau = list(liste)
-    a=time.process_time()
-    triRecursif(tableau)
-    if x <= 10:
-        print(tableau)
-    b=time.process_time()
-    timesRecursif.append(b-a)
-    
-    tableau = list(liste)
-    a=time.process_time()
-    triBulle(tableau)
-    if x <= 10:
-        print(tableau)
-    b=time.process_time()
-    timesBulle.append(b-a)
-
-print(nvalues)
-
-print(timesSelection)
-print(timesInsertion)
-print(timesRecursif)
-print(timesBulle)
-
-
-#xs = range(0,1000)
-plt.plot(nvalues,timesSelection, "r-", label="Tri par sélection")
-plt.plot(nvalues,timesInsertion, "g-", label="Tri par insertion")
-plt.plot(nvalues,timesRecursif, "b-", label="Tri par récursif")
-plt.plot(nvalues,timesBulle, "g--", label="Tri bulles")
-
-#plt.plot(nvalues,timesRecursif, "b-", label="Quick sort")
-#plt.plot(xs, sqrt(xs), "r-", label=" √n")
-plt.title("Comparaison des performances des différents algorithmes de tri")
-
-
-
-plt.savefig('analyse-tri.png')
-
-# Outil pour tester les algos de tri à la main 
-tableauATrier = [42,1,6,0,8,9,2,4,7,3,19,34,23,67,45,23,105,18,190,20]
-triBulle(tableauATrier)
-print(tableauATrier)

TD01/code/tri-bulle.py

-def tri_bulle_iteratif(lst):
-    """ Tri par bulle """
-    taille = len(lst)
-    for i in range(taille-1) :
-        for j in range(i+1,  taille) :
-            if lst[i] > lst[j] :
-                lst[i] , lst[j] = lst[j] , lst[i]   # permutaion
-    return lst
-    
-liste=[1,3,13,4,7,2,9,2,18] 
-print(tri_bulle_iteratif(liste))
-# [1, 2, 2, 3, 4, 7, 9, 13, 18]
\ No newline at end of file

TD01/code/tri-comparaison.py

-# TODO: comparaison de différents tris
\ No newline at end of file

TD01/code/tri-fusion.py

-from random import seed, randint, shuffle
-
-def tri_split_merge(L) :
-    """ TRI SPLIT-MERGE avec 2 fonctions imbriquées """
-    def my_split(L) :
-        choix=True              # on met dans L1, sinon dans L2 
-        L1=[]; L2=[] ; N =len(L)
-        i=0
-        while i < N :
-            crt=L[i]
-            if choix : L1.append(crt)
-            else : L2.append(crt)
-            i +=1
-            # voyons si on a une séquence Descendante
-            while i < N and L[i] >= crt :
-                crt=L[i]
-                if choix : L1.append(crt)
-                else : L2.append(crt)
-                i +=1
-                
-            choix = not choix
-            
-        return(L1,L2)
-    
-    #---------------------  
-    def my_merge(L1,L2) :
-        N1=len(L1)
-        N2=len(L2)
-        L=[]; i,j=0,0
-        while(i < N1 and j < N2) :
-            if L1[i] <= L2[j] : 
-                L.append(L1[i]) 
-                i+=1
-            else :
-                L.append(L2[j]) 
-                j+=1
-        L.extend(L1[i:])    # Ajouter le reste de L1 (s'il y en a) à L
-        L.extend(L2[j:])    # Ajouter le reste de L2 (s'il y en a) à L
-        return L
-        
-    # Fonction tri_split_merge
-    while True :
-        (L1,L2) = my_split(L)
-        if (L2==[]) : break # Fini
-        L=my_merge(L1,L2)  
-    return L
-        
-# programme principal -----------------------------------------------
-seed() # initialise le generateur de nombres aleatoires
-N=10
-L = [randint(2, N*4) for i in range(N)] # construction de la liste
-print("Avant le tri, liste = {}".format(L))
-L=tri_split_merge(L)
-print("Après le tri, liste = {}".format(L))
-
-""" Deux Traces
-Avant le tri, liste = [9, 17, 12, 24, 36, 26, 35, 25, 5, 31]
-Après le tri, liste = [5, 9, 12, 17, 24, 25, 26, 31, 35, 36]
-
-Avant le tri, liste = [30, 14, 2, 11, 5, 15, 5, 21, 29, 31]
-Après le tri, liste = [2, 5, 5, 11, 14, 15, 21, 29, 30, 31]
-"""
\ No newline at end of file

TD01/code/tri-insertion.py

-from random import seed, randint
-
-        
-def tri_insertion_iter(T) :
-    def inserer_a_sa_place_iter(ind) : # insere le Ieme dans T[0:i]
-        save = T[ind]
-        i=ind
-        while (i>0 and T[i-1] > save) : 
-            T[i]=T[i-1]
-            i -= 1
-        T[i]=save
-        
-    if len(T) < 2 : return
-    for i in range(1,len(T)) :
-        inserer_a_sa_place_iter(i)  # insere le Ieme dans T[0:i]
-        
-# ------- Prog Princ
-seed()                                      # initialise le generateur de nombres aleatoires
-N=10
-T = [randint(2, 3*N) for i in range(N)]     # construction de la liste
-print("Avant le tri, liste = {}".format(T))
-TT=[]                                       # Avant d'utiliser TT, il faut la faire exister !
-TT[:]=T[:]
-tri_insertion_iter(T)
-TT.sort()
-if (T == TT) :
-    print("Après le tri, liste = {}".format(T))
-else :
-    print("ERREUR !!, T={}, TT={}".format(T,TT)) 
-
-""" TRACE :
-Avant le tri, liste = [14, 11, 24, 24, 27, 14, 30, 22, 22, 17]
-Après le tri, liste = [11, 14, 14, 17, 22, 22, 24, 24, 27, 30]
-"""
\ No newline at end of file

TD01/code/tri-rapide.py

-def quicksort(t):
-    if t == []:
-        return []
-    else:
-        pivot = t[0]
-    t1 = []
-    t2 = []
-    for x in t[1:]:
-        print(x, pivot)
-        if x < pivot:
-            t1.append(x)
-        else:
-            t2.append(x)
-        return quicksort(t1) + [pivot] + quicksort(t2)
-
-if __name__=="__main__": 
-    quicksort([1 ,4, 5])
\ No newline at end of file

TD01/code/tri-selection.py

-def selectionSort(alist):
-
-    for l in range(len(alist )-1,0,-1):
-        positionOfMax =0
-
-        for location in range (1, l+1):
-            if alist[location]>alist[ positionOfMax ]:
-                positionOfMax = location
-
-        temp = alist[l]
-        alist[l] = alist[positionOfMax]
-        alist[positionOfMax] = temp
-
-alist = [54 ,26 ,93 ,17 ,77 ,31 ,44 ,55 ,20]
-selectionSort(alist)
-print(alist)
\ No newline at end of file

TD01/code/tri-stabilite.py

-def algo(words):
-    t = []
-    for word in words:
-       t.append((len(word), word))
-
-    t.sort(key=lambda t: t[1][-1])
-
-    res = []
-    for l, w in t:
-        res.append(w)
-
-    res = filter(lambda t: 'a' in t, res) 
-
-    return list(res)
-
-
-print(algo(["Pierre", "Jean", "Marie", "Eric", "Nathalie", "Yvonne"]))
\ No newline at end of file

TD01/code/util-commentaires.py

-# Un commentaire court commence par un # et se limite à la fin de la ligne
-
-"""
-On peut aussi créer un commentaire long = une zone de 
-commentaires  sur plusieurs lignes placées
-entre une paire de triple-guillements dont le second suit :
-"""
-
-# Remarques : 
-# Un ';' à la fin d'une ligne rend la ligne muette (pas d'affichage des résultats). 
-# Il permet également de placer plusieurs expressions sur la même ligne.
-
-# Si vous placez un commentaire immédiatement après la signature d'une fonction} 
-# (ou une méthode, une classe, etc.) entre un couple de  """, 
-# votre commentaire (appelé docstring) devient accessible avec help
\ No newline at end of file

TD01/code/util-format.py

-from math import pi
-
-s = "Python"
-s.center(10)         # centrer sur 10 positions
-print(s)
-# Donne -->'  Python  '
-
-s.center(10,"*")       # centrer sur 10 positions en complétant par des '*'
-# Donne -->'**Python**'
-print(s)
-
-s = "Training"
-s.ljust(12)           # justifier à gauche sur 12 positions} 
-# Donne -->'Training    '
-print(s)
-
-s.ljust(12,":")
-# Donne -->'Training::::'
-
-s = "Programming"
-s.rjust(15)
-# Donne -->'    Programming'
-s.rjust(15, "~")
-# Donne -->'~~~~Programming'
-
-account_number = "43447879"
-account_number.zfill(12)
-# Donne -->'000043447879'
-
-# Même chose avec rjust : 
-account_number.rjust(12,"0")
-# Donne -->'000043447879'
-
-s = 'Hello, world.'
-str(s)
-# Donne -->'Hello, world.'
-
-repr(s)
-# Donne --> "'Hello, world.'"
-str(1/7)
-# Donne --> '0.14285714285714285'
-
-r=2
-print("La surface pour un rayon {rayon:3d} sera {surface:8.3f}".format(surface=r*r*pi, rayon=r))
-# Donne -->  'La surface pour un rayon   2 sera   12.566'
-
-x = 10 * 3.25
-y = 200 * 200
-s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
-print(s)
-# Donne --> The value of x is 32.5, and y is 40000...
-
-# Le repr() d'un string ajoute des quotes et backslashes:
-hello = 'hello, world\n'
-str(hello)
-# Donne --> 'hello world\n'
-repr(hello)
-# Donne --> 'hello, world\\n' %*  {\color{magenta}  noter le double slash}    *)
-
-# L'argument d'appel de repr() peut être n'importe quel objet  Python :
-repr((x, y, ('spam', 'eggs')))
-# Donne -->"(32.5, 40000, ('spam', 'eggs'))"
-
-for x in range(1, 11):
-    print(repr(x).rjust(2), repr(x*x).rjust(3), repr(x*x*x).rjust(4))
-# Donne -->
-#  1   1    1
-#  2   4    8 
-#  3   9   27
-#  4  16   64
-#  5  25  125
-#  6  36  216
-#  7  49  343
-#  8  64  512
-#  9  81  729
-# 10 100 1000
-
-for x in range(1, 6):
-    print(repr(x).rjust(2), end='#'*x+'\n')    # on ajoute x fois \# + \textbackslash n à la fin de chaque ligne}  *)
-
-# Donne -->
-#  1#
-#  2##
-#  3###
-#  4####
-#  5##### 
-# 
\ No newline at end of file

TD01/code/util-types-conversion.py

-# 8 Conversion de types
-
-list1 = ['1', '2', '3']
-str1 = ''.join(list1)
-
-str1
-# '123'
-
-list1 = [1, 2, 3]
-str1 = ''.join(str(e) for e in list1)   # ou avec "" à la place de ''
-
-str1
-# '123'
-
-
-a = "545.2222"
-float(a)
-# 545.2222      suivant le système, on peut avoir des '0' après les '2'
-
-int(float(a))
-# 545
-
-def is_float(value):
-  try:
-    float(value)
-    return True
-  except:
-    return False
-
-# On peut aussi utiliser la prédéfinie eval() qui évalue du code Python
-eval("1.5") 
-# 1.5
-
-# Une alternative plus sûre à eval()
-import ast
-ast.literal_eval("545.2222")
-545.2222
-
-ast.literal_eval("31")
-31
-
-# Des cas d'erreur 
-eval(toto)          # toto non défini ou n'est pas un str/octes/code
-ast.literal_eval(toto)
-# Erreur dans les 2 cas
-
-
-# Converstion en binaire
-st = "hello Debase"
-' '.join(format(ord(x), 'b') for x in st)
-# '1101000 1100101 1101100 1101100 1101111 100000 1000100 1100101 1100010 1100001 1110011 1100101'
-
-# Conversion de string en hexadécimal
-s='Hello Debase of Ecl'
-' '.join(format(ord(x), 'x') for x in s)
-# '48 65 6c 6c 6f 20 44 65 62 61 73 65 20 6f 66 20 45 63 6c'
-
-# Conversion entier en Unicode
-chr(16)     # Quelle est la forme hexa de 16 ?
-#'\x10'
-
-# Conversions décimal <==> base xx
-
-int('12',8) # Quelle est la valeur décimale du nombre octal '12' (octal car base = 8)
-# 10    
-
-int('12',16) # Quelle est la valeur décimale du nombre hexa '12' (hexa car base = 16)
-# 18
-
-int('12')   # Quelle est la valeur décimale du nombre décimale '12' (décimal car base par défaut = 10)
-# 12
-
-int('1000',2)   # Que donne le nombre binaire '1000' en décimal (binaire car base = 2)
-# 8   
-
-# Pour convertir un entier en octal
-
-oct(12)
-# '0o14'        #un 'O' au début (pour Octal)
-
-oct(8)
-# '0o10'
-
-# Autres conversions
-
-# octal
-eval('0o010') == 10     # La valeur décimale de '0o010' est-elle 10
-# False
-
-eval('0o010')
-# 8
-
-oct(42)               # La valeur octale de l'entier 42
-# '0o52'
-
-int('0o52', 0)      # La valeur décimale de l'octale  '0o52' (si base=0 alors base est dans le string)
-# 42
-
-int('1101', 2)      # La valeur décimale du binaire '1101'  (base explicite = 2)
-#13
-
-int('0b1101', 2)    # Idem, base explicitée = 2, peut importe '0b'
-#13
-
-int('0b1101', 0)    # La valeur décimale du binaire '0b1101' (base = 0 --> la base '0b' est dans le string)
-#13
-
-from struct import *
-
-pack('hhl', 1, 2, 3)
-# b'\x01\x00\x02\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00'
-# b veut dire byte (2 octes). \x veut dire hexa
-
-pack('b', 1)
-# b'\x01'
-
-pack('b', 16) # signed char de taille 1. On convertie 16 en signed char
-# b'\x10' 
-
-In [39]: pack('B', 16)  # unsigned char de taille 1
-# b'\x10'
-
-pack('h', 1)
-# b'\x01\x00'
-
-calcsize('h')
-# 2
-
-calcsize('b')
-# 1
-
-unpack('b', b'\x10')
-# (16,)
-
-type(unpack('b', b'\x10'))
-# tuple
-
-unpack('b', b'\x10')[0]    # Première élé. Il y a virgule car taille tuple >= 2  
-# 16
-
-pack('B',65) # donne b'A'   = i.e. le caractère dont le code = 65
\ No newline at end of file

TD01/code/util-types.py

-# 7 Types principaux en Python
-
-if type(1) is not int : print('oups')
-
-if type('1') is not int : print(1)
-
-type(3.14)
-# float
-
-type(None)
-# NoneType
-
-f = lambda c : c if type(c) is str and  c.isalpha() else '?'
-type(f)
-# function
-
-# Utilisation de f (voir plus loin les "lambda expressions") :
-f('a')  # donne 'a' car 'a' est alphabétique
-f('1')  # donne '?' car '1' n'est  pas alphabétique
-f(1)    # donne '?'  car  1 n'est  pas une chaine
-
-import sys;
-
-print(sys.int_info)
-# sys.int_info(bits_per_digit=30, sizeof_digit=4)
-
-print(sys.float_info)
-# sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308,
-# min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15,
-# mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)
-
-print(sys.getsizeof(float))     # La taille de  la classe float
-# 400
-print(sys.getsizeof(float()))   # La taille d'un  float
-# 24                            # Ce que coute en octes un réel 
-                                # (valeur  + infos supplémentaires)
-
-
-

TD01/code/util-version-python.py

-# Vous devez valider ce code qui affiche le numéro de version
-# Rien d'autre à faire !
-import sys
-
-if not sys.version_info.major == 3 and sys.version_info.minor >= 7:
-    print("Python 3.7 ou supérieur est nécessaire !")
-else:
-    print("Vous utilisez {}.{}.".format(sys.version_info.major, sys.version_info.minor))
-    sys.exit(1)
\ No newline at end of file