From 3dc01f7f9848cbcee468121479eaf8ac43ac60ca Mon Sep 17 00:00:00 2001
From: Romain Vuillemot <romain.vuillemot@gmail.com>
Date: Tue, 2 Feb 2021 07:54:50 +0100
Subject: [PATCH] =?UTF-8?q?Nouvelles=20mises=20=C3=A0=20jour?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
TD01/code/.gitkeep | 0
TD01/code/08-conversion_exercices.py | 74 ----------------------------
TD01/code/comprehension.py | 37 ++++++++++++++
TD01/code/dict.py | 62 +++++++++++++++++++++++
TD01/code/division.py | 15 ++++++
TD01/code/set-exemples.py | 59 ++++++++++++++++++++++
6 files changed, 173 insertions(+), 74 deletions(-)
delete mode 100644 TD01/code/.gitkeep
delete mode 100644 TD01/code/08-conversion_exercices.py
create mode 100644 TD01/code/comprehension.py
create mode 100644 TD01/code/dict.py
create mode 100644 TD01/code/division.py
create mode 100644 TD01/code/set-exemples.py
diff --git a/TD01/code/.gitkeep b/TD01/code/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/TD01/code/08-conversion_exercices.py b/TD01/code/08-conversion_exercices.py
deleted file mode 100644
index d8ec3d3..0000000
--- a/TD01/code/08-conversion_exercices.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# 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
diff --git a/TD01/code/comprehension.py b/TD01/code/comprehension.py
new file mode 100644
index 0000000..d5ae9d7
--- /dev/null
+++ b/TD01/code/comprehension.py
@@ -0,0 +1,37 @@
+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
diff --git a/TD01/code/dict.py b/TD01/code/dict.py
new file mode 100644
index 0000000..8446bdf
--- /dev/null
+++ b/TD01/code/dict.py
@@ -0,0 +1,62 @@
+# 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
diff --git a/TD01/code/division.py b/TD01/code/division.py
new file mode 100644
index 0000000..0ef7cb0
--- /dev/null
+++ b/TD01/code/division.py
@@ -0,0 +1,15 @@
+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")
+
diff --git a/TD01/code/set-exemples.py b/TD01/code/set-exemples.py
new file mode 100644
index 0000000..68ed6cd
--- /dev/null
+++ b/TD01/code/set-exemples.py
@@ -0,0 +1,59 @@
+{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
--
GitLab