Nouvelles mises à jour

TD01/code/08-conversion_exercices.py

-# 8 Conversion de types
-
-# Exercice
-
-# Écrire la fonction convertir(S) qui convertit son paramètre (un string) 
-# en un entier. Pour que la conversion soit possible, le paramètre S doit 
-# être être composé de chiffres éventuellement précédé d'un signe.
-
-def convertir(S) : # S est une liste de caractères
-
-    # Il y a un signe au début ou pas ?
-    signe= +1                                         # Initialisation du signe
-    if S[0:1] in '+-':
-        if S[0:1]=='-' : signe=-1
-        S = S[1:]                                        # On enlève le signe
-
-    if S.isdigit(): return int(S) * signe             # On peut aussi écrire : str.isdigit(xs) !
-    else: return (S + " n'est pas un nombre")
-
-S=input('Donner  une chaine de chiffres: ')
-print(convertir(S))
-
-# Donner  une chaine de chiffres: -124
-# -124
-# Donner  une chaine de chiffres: 12a
-
-#  Une version qui n'utilise ni int() ni isdigit()
-def convertir02(S1) :       # S est une liste de caractères
-    assert(S1 != '' and S1 != None)
-    signe= +1                                       # Initialisation du signe
-    val = 0; S=S1
-    if S[0] in '+-':
-        if S[0:1]=='-' : signe=-1
-        S = S[1:]
-    for car in S :
-        if car in "0123456789": val = 10*val+ord(car)-ord('0')
-        else : return (S1 + " n'est pas un nombre")
-    return val * signe             # On peut aussi écrire : str.isdigit(xs) !
-
-S=input('Donner  une chaine de chiffres : ')
-print(convertir02(S))
-
-# Exercice
-# Écrire la fonction {\tt convertir2r(S)} qui convertit son paramètre (un 
-# string) en un réel (loat). Pour que la conversion soit possible, le
-# paramètre {\it S} doit être être éventuellement précédé d'un signe, puis 
-# composé de chiffres suivis d'un '.' puis une série de chiffres. La
-# présence d'un '.' est obligatoire, et qui est forcément suivi d'au moins
-# un chiffre.
-
-def convertir2r(S) :                       # S est une liste de caractères
-    assert('.' in S)                        # '.' obligatoire
-    lst_2_parties=S.split('.')              # une liste des 2 parties
-    val_int=0
-    if lst_2_parties[0] != '' : val_int=convertir02(lst_2_parties[0])
-        
-    # vérifier que la partie décimale ne comporte  pas un second signe !
-    assert(lst_2_parties[1][0] not in '+-')
-
-    val_reel=0
-    if lst_2_parties[1] != '' : val_reel=convertir02(lst_2_parties[1])
-
-    # La partie décimale s'ajoute ou se retrache suivant le signe de val_int'
-    if val_int >= 0 :
-        return val_int + val_reel/(10**len(lst_2_parties[1]))
-    else : return val_int - val_reel/(10**len(lst_2_parties[1]))
-
-
-S=input('Donner  une chaine de chiffres (un réel) : ')
-print(convertir2r(S))
-convertir2r('12.34')
-convertir2r('0.12')
-convertir2r('13.0')
-convertir2r('-3.001')
\ No newline at end of file

TD01/code/comprehension.py

+S = [x**2 for x in range(10)]
+V = [2**i for i in range(13)]
+M = [x for x in S if x % 2 == 0]
+
+print(S); print(V); print(M)
+# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+# [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]
+# [0, 4, 16, 36, 64]
+
+
+S = {x**2 for x in range(10)}           # {} au lieu de [] : on veut un ensemble
+print(S)
+# {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
+type(S)
+#set
+
+V = (2**i for i in range(13))
+print(V)
+# <generator object <genexpr> at 0x7f7bb55edc18>
+
+type(V)
+# generator
+
+# On peut mieux comprendre les listes en compréhension à travers leurs fonctions équivalentes
+S = []
+for i in range(10):
+    S.append(i*2)
+
+# Et 
+S = [i*2 for i in range(10)]
+
+S
+# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
+
+[c for c in "foobar"]
+
+# Donne ['f', 'o', 'o', 'b', 'a', 'r']
\ No newline at end of file

TD01/code/dict.py

+# Trois fonctions importantes sur les dicts  : keys(), values() et items()
+
+a = dict(one=1, two=2, three=3)
+b = {'one': 1, 'two': 2, 'three': 3}
+c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
+d = dict([('two', 2), ('one', 1), ('three', 3)])
+e = dict({'three': 3, 'one': 1, 'two': 2})
+a == b == c == d == e
+# True
+
+capitals = {'Iowa':'DesMoines','Wisconsin':'Madison'}
+print(capitals['Iowa'])
+# DesMoines
+
+capitals['Utah']='SaltLakeCity'
+print(capitals)
+# {'Iowa': 'DesMoines', 'Utah': 'SaltLakeCity', 'Wisconsin': 'Madison'}
+
+capitals['California']='Sacramento'
+print(len(capitals))
+# 4
+
+for k in capitals:
+    print(capitals[k]," is the capital of ", k)
+# DesMoines  is the capital of  Iowa
+# SaltLakeCity  is the capital of  Utah
+# Madison  is the capital of  Wisconsin
+# Sacramento  is the capital of  California
+
+phone_ext={'david':1410, 'brad':1137}
+phone_ext
+# {'brad': 1137, 'david': 1410}
+
+phone_ext.keys()                    # Renvoie les clés de phone_ext
+# dict_keys(['brad', 'david'])
+
+list(phone_ext.keys())
+# ['brad', 'david']
+
+"brad" in phone_ext
+# True
+
+1137 in phone_ext
+# False                             # 1137 n'est pas une clé
+
+phone_ext.values()                  # Renvoie les valeurs de phone_ext
+# dict_values([1137, 1410])
+
+list(phone_ext.values())
+# [1137, 1410]
+
+phone_ext.items()
+# dict_items([('brad', 1137), ('david',1410)])
+
+phone_ext.get("kent")
+# Rien !    La clé n'y est pas.
+
+phone_ext.get("kent","NO ENTRY")    # Si on veut récupérer la réponse en cas d'absence de la clé.
+'NO ENTRY'
+
+del phone_ext["david"]
+phone_ext
\ No newline at end of file

TD01/code/division.py

+def division(x, y):
+    return x / y
+
+if __name__=="__main__": 
+    try:
+        r = division(2, 1)
+        # division(2, 0)
+        # division("2", "1")
+    except ZeroDivisionError:
+        print("Division par zero !")
+    else:
+        print("Le résultat est", r)
+    finally:
+        print("Clause finale")
+

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