Sommaire :
- Contenaires :
Contenaires :
- Entité en Python qui contient une collection d'autres objets.
- Déjà vus :
- Chaine de caractères
- Liste
- range
- à Voir :
- tuple
- set
- Dictionnaire,
Contenaires : Propriétés
test d'appartenance
L = [20, 10, 30]
print(10 in L)
print(11 in L)
print(31 not in L)
ch = "ABCD"
print('A' in ch)
print("C" in ch)
print('AB' in ch)
print('E' in ch)
print('T' not in ch)
r = range(10,20)
print(10 in r)
print('10' in r)
print(20 in r)
print(21 not in r)
Len (longueur)
print("longuer L :",len(L))
print("longuer ch :",len(ch))
print("longuer r :",len(r))
Tuples : (Fr : n-uplets)
- Les tuples sont écrits entre parenthèses
- Les tuples sont utilisés pour stocker plusieurs éléments
dans une seule variable.
- Le tuple est l'un des quatre types de données intégrés à
Python utilisés pour stocker des collections de données,
les trois autres sont :
- list,
- set,
- dictionary,
- Un tuple est une collection ordonnée et immuable.
- Les tuples sont plus rapides à créer et à parcourir que les listes, car ils sont plus légers en mémoire (optimisés pour la lecture).
import timeit
print(timeit.timeit("(1, 2, 3, 4, 5)", number=10_000_000)) # tuple
print(timeit.timeit("[1, 2, 3, 4, 5]", number=10_000_000)) # list
import dis # dis : pour disassemble
dis.dis("(1, 2, 3, 4, 5)")
dis.dis("[1, 2, 3, 4, 5]") # instruction spéciale BUILD_LIST pour créer une nouvelle liste
-
Les tuples peuvent être des clés dans un dictionnaire ou être des éléments dans un set (car ils sont immuables) : cf TDP
-
Les listes ne le peuvent pas (elles sont non-hashables, car elles ne sont pas immuables).
mytuple = ("Apple", "orange", "Kiwi")
print(mytuple)
print(type(mytuple))
('Apple', 'orange', 'Kiwi')
<class 'tuple'>
- Il est aussi possible d'utiliser la fonction constructeur tuple() pour créer un tuple.
thistuple = tuple(("Apple", "Orange", "cherry")) # notez les doubles parenthèses
# thistuple = tuple("Apple", "Orange", "cherry") # notez les doubles parenthèses
print(thistuple)
type(thistuple)
thistuple = tuple(["Apple", "Orange", "cherry"])
print(thistuple)
type(thistuple)
- Les éléments de tuple peuvent être de n’importe quel type de données :
tuple1 = ("apple", "orange", "cherry")
tuple2 = (1, 5, 7, 9, 3)
tuple3 = (True, False, False)
print(tuple1)
print(tuple2)
print(tuple3)
- Un tuple peut contenir différents types de données :
TupleAnim = ("abc", 27, True, 70, "male")
print(TupleAnim)
# longueur d'un Tuple
mytuple = ("Apple", "orange", "Kiwi")
print(len(mytuple))
- Les éléments du tuple T sont indexés :
- le premier élément a un index [0],
- le deuxième élément a un index [1],
- ...
- le dernier a un index [len(T)-1] ou [-1]
mytuple = ("Apple", "orange", "Kiwi")
print(mytuple)
print(mytuple[0])
print(mytuple[-1])
- Autoriser les doublons
- Les tuples étant indexés, ils peuvent comporter des éléments ayant la même valeur :
thistuple = ("apple", "banana", "cherry", "apple", "cherry")
print(thistuple, "de longueur :", len(thistuple))
('apple', 'banana', 'cherry', 'apple', 'cherry') de longueur : 5
- Les tuples ne sont pas modifiables.
my_tuple = ("Apple", "orange", "Kiwi")
print(my_tuple)
('Apple', 'orange', 'Kiwi')
my_tuple[0] = "Pomme"
print(my_tuple)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[4], line 1
----> 1 my_tuple[0] = "Pomme"
2 print(my_tuple)
TypeError: 'tuple' object does not support item assignmentMytuple = ("Apple", "orange", "Kiwi")
Mytuple.append("Melon")
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
Cell In[8], line 1
----> 1 Mytuple.append("Melon")
AttributeError: 'tuple' object has no attribute 'append'Mytuple.remove("Apple")
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
Cell In[9], line 1
----> 1 Mytuple.remove("Apple")
AttributeError: 'tuple' object has no attribute 'remove'Mytuple.pop()
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) Cell In[10], line 1 ----> 1 Mytuple.pop() AttributeError: 'tuple' object has no attribute 'pop'
Mytuple.add("Melon")
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
Cell In[11], line 1
----> 1 Mytuple.add("Melon")
AttributeError: 'tuple' object has no attribute 'add'Une Astuce :
x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)
print(x, " - ", type(x))
Mytuple = ("Apple", "orange", "Kiwi")
print(Mytuple, " de type :",type(Mytuple))
L = list(Mytuple)
L.append("Melon")
Mytuple = tuple(L)
print(Mytuple, "de type :",type(Mytuple))
Attention : Conversion Implicite
Mytuple = ("Apple", "orange", "Kiwi")
print(Mytuple, "de type :", type(Mytuple))
tupleTrie = sorted(Mytuple)
print(tupleTrie, "de typeT :", type(tupleTrie))
print(Mytuple, "de type :", type(Mytuple))
Attention !
- Tuple avec un seul élément
- Ne pas oublier la virgule
#NOT a tuple
thistuple = ("apple")
print(type(thistuple))
thistuple = ("apple",) # Ne pas oublier la virgule
print(type(thistuple))
# A tuple
Thistuple = tuple("apple")
print(type(Thistuple))
Copier un Tuple ?
mytuple = ("Apple", "orangE", "Kiwi")
othTuple = mytuple
print(mytuple, "id My: ",id(mytuple))
print(othTuple, "id Oth:",id(othTuple))
# Essayer .copy() ??
cpTuple = mytuple.copy()
LT = list(mytuple)
CopTuple = tuple(LT)
print(mytuple, "id My: ",id(mytuple), type(mytuple))
print(CopTuple, "id Cop:",id(CopTuple), type(CopTuple))
CopTuple_ = tuple(list(mytuple))
print(mytuple, "id My: ",id(mytuple))
print(CopTuple_, "id Cop:",id(CopTuple_))
UT = ("TestT",)
print(UT, type(UT), "lg :",len(UT))
DT = tuple("TestT")
print(DT, type(DT), "lg :",len(DT))
DT = tuple(("TestTe",))
print(DT, type(DT), "lg :",len(DT))
Parcours d'un Tuple
thistuple = ("apple", "orange", "cherry")
for elemT in thistuple:
print(elemT)
Sets :
- initialisé via {}
- Un set est une collection de donnée qui ne permet pas de duplication.
thisSet = {"apple", "banana", "cherry", "apple"}
print(thisSet, "type : ",type(thisSet), "de longueur :", len(thisSet))
{'banana', 'cherry', 'apple'} type : <class 'set'> de longueur : 3
- Remarque :
- True et 1 sont considérés comme identiques
- False et 0 sont considérés comme identiques
UnSet = {"apple", False, "banana", "cherry", True, 0, 1, 2}
print(UnSet, "de longueur :", len(UnSet) )
Ls = ["apple", False, "banana", "cherry", True, 0, 1, 2]
print(Ls)
['apple', False, 'banana', 'cherry', True, 0, 1, 2]
SetConv = set(Ls)
print(SetConv)
# Constructeur
IniSet = set(("appLe", "banNana", "cherry")) # noter la double parenthèse
# IniSet = set("appLe", "banNana", "cherry") # noter la double parenthèse
print(IniSet)
- Un set est une collection non indexée
myset = {"apple", "OranGe", "cherry" , "Fruit"}
print(myset[0])
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[14], line 2
1 myset = {"apple", "OranGe", "cherry" , "Fruit"}
----> 2 print(myset[0])
TypeError: 'set' object is not subscriptablemyL = ["apple", "OranGe", "cherry"]
print(myL, "Type : ",type(myL))
['apple', 'OranGe', 'cherry'] Type : <class 'list'>
- Les ensembles (set) ne sont pas ordonnés, l'ordre d'apparition des éléments est imprévisible
- à vérifier pour version à venir (3.x ... ) !!!
myset = {"apple", "OranGe", "cherry" , "Fruit"}
print(myset, "Type : ",type(myset))
Cependant, on peut supprimer des éléments et en ajouter de nouveaux.
- Ajouter un élément à un Ensemble Set
thisset = {"apple", "banana", "cherry"}
print("id av set : ", id(thisset))
thisset.add("orange")
print(thisset)
print("id ap set : ", id(thisset))
s = set()
s.add("a")
s.add("b")
s.add("c")
print(s) # Résultat : {'a', 'b', 'c'} ???
{'c', 'a', 'b'}
- Supprimer un élément d'un Ensemble Set
thisset = {"apple", "banana", "cherry"}
print("id ap set : ", id(thisset))
thisset.remove("banana")
print(thisset)
print("id ap set : ", id(thisset))
id ap set : 1516566326720
{'cherry', 'apple'}
id ap set : 1516566326720
Parcourir les éléments d'un Set :
thisset = {"apple", "banana", "cherry"}
for elemS in thisset:
print(elemS)
banana cherry apple
UNset = {"apple"}
print(UNset, type(UNset))
{'apple'} <class 'set'>
Dictionnaires :
- Non-ordonnées (Non séquentiels, comme les listes ou chaînes de caractères),
- les valeurs qu'ils contiennent ne sont pas rangées selon un index, mais suivant un identifiant exclusif (discriminatoire) : clé (unique).
- Entité de correspondance (mapping),
- Permet d’associer une valeur (simple, ou composée) à une clé: (clé , val)
- Appelés tableaux associatifs
- Analogie avec un dictionnaire linguistique : accéder à une définition / mot
- Analogie :
# clé entière
L = [5, 4, 22]
print(L[1])
Créer un dictionnaire python :
a = {}
print(type(a))
b = dict()
print(type(b))
Opérations sur dictionnaires (Exemples):
- Aj / Supp / Rempl / vérifier existence (clé , val)
- Trouver une Val / clé
Ajouter des valeurs dans un dictionnaire python :
- indiquer une clé ainsi qu'une valeur:
a = dict()
a["nom"] = "Benahmed"
a["prenom"] = "Amine"
print(a)
# autrement
b = {}
b = {"nom": "BenAhmed", "prenom" : "Nabil", "poids": 70, "taille": 1.73}
print(b)
print(b["nom"]) # indexation ??
print(b[0]) # indexation ??
c = {0:"zero" , 1:"one", 2:"two"}
print(c[1])
Doublons non autorisés !
- Les dictionnaires ne peuvent pas avoir deux éléments avec la même clé :
MyDict = {
"brand": "Hyundai",
"model": "Accent",
"year": 2024,
"model": "Elantra"
}
print(MyDict)
- Conclusion : La dernière utilisation écrase la valeur de la première utilisation
Récupérer une valeur / clé : méthode get()
# print(b)
b = {}
b = {"nom": "BenAhmed", "prenom" : "Nabil", "poids": 70, "taille": 1.73}
name = b.get("nom")
# name = b.get("name")
print(name)
Si clé Introuvale : donner une valeur à retourner par défaut
RechAdr = b.get("Adresse")
print(RechAdr)
# Solution : donner une valeur à retourner par défaut:
RechAdrPr = b.get("Adresse", "Champs 'Adresse' Intouvale !")
print(RechAdrPr)
RechAdr = b.get("Adresse")
print(RechAdr)
# champ = "age"
champ = "salaire"
RechGen = b.get(champ, f"Champ '{champ}' Intouvale !")
print(RechGen)
Vérifier la présence d'une clé dans un dictionnaire :
# Revenons au dictionnaire a
print(a)
cle = "nom"
print( f"Clé '{cle}' in : ", cle in a)
# ------------------ Sensible à la casse
cle = "Nom"
print( f"Clé '{cle}' in : ", cle in a)
Supprimer une entrée dans un dictionnaire python :
- indiquer sa clé (comme pour les listes)
a = {"nom": "BenAhmed", "prenom" : "Nabil", "poids": 70, "taille": 1.73}
print("Av : ", a)
del a["nom"]
print("Ap : ", a)
print("Champ Prenom : ", a["prenom"])
# pop()
a = {"nom": "BenAhmed", "prenom" : "Nabil", "poids": 70, "taille": 1.73}
print("Av : ", a)
pre = a.pop("prenom")
print("Pop :", pre)
print("Ap : ", a)
Récupérer les clés d'un dictionnaire python par une boucle
- Utiliser la méthode .keys()
Fiche = {"nom":" Benahmed", "prenom":"Amine"}
for UneCle in Fiche.keys():
print(UneCle)
Récupérer les valeurs d'un dictionnaire python par une boucle
- Utiliser la méthode .values()
fichE = {"nom":"Benahmed", "prenom":"Amine"}
for UneVal in fichE.values():
print(UneVal)
Récupérer les clés et les valeurs d'un dictionnaire python par une boucle
- Utiliser la méthode .items() retourne un tuple
FichE = {"nom":"Benahmed", "prenom":"Amine"}
for CleVal in FichE.items():
print(CleVal, type(CleVal))
FichE = {"nom":"Benahmed", "prenom":"Amine"}
for cle, val in FichE.items():
print(cle, val)
Combinaison Dictionnaire / Tuple
- Utilisation des tuples comme clé :
- Exemple : Coordonnées d'un point dans un plan comme clé
b = {}
b[(3,2)] = 12
b[(4,5)] = 13
print("Dicrtionnaire b :", b)
coord = (3,2)
cc = (coord , 12)
print(f"Verifier presence {coord} in b :", coord in b)
val = 12
print(f"Verifier presence {val} in b :", val in b)
print(f"Verifier presence {val} in b.values() :", val in b.values())
print(f"Verifier presence {val} in b.items() :", val in b.items())
print(f"Verifier presence {coord} in b.items() :", coord in b.items())
print(f"Verifier presence {cc} in b.items() :", cc in b.items())
Copie de dictionnaire
- Créer une copie indépendante :
- à ne pas faire !!
- dic1 = dic2
d = {"k1":"Bensadik", "k2":"Ali"}
e = d
d["k2"] = "ZAID"
print(e)
méthode .copy()
d = {"k1":"Bensadik", "k2":"Nabil"}
e = d.copy()
d["k1"] = "ZAID"
print("d :", d)
print("e :" , e)
Fusionner des dictionnaires python :
- méthode .update()
d = {'nom': 'Ali'}
tr = {'prenom': 'Bensadik'}
d.update(tr)
print("Dict d : ", d)
print("Dict t : ", tr)
Liste, dict comprehension
- Syntaxe subtile pour créer des listes, dictionnaires, en évitant d'utiliser des boucles explicites :
[ expression for élément in iterable if condition ]
# Pb : creer une liste de carrés des entiers jusqu'à 10
LCar = []
for i in range(11):
LCar.append(i**2)
print(LCar)
# List comprehension
LCC = [i**2 for i in range(11)]
print(LCar)
print(LCC)
import time
# Pour de grandes tailles
Lt1 = list()
deb = time.time()
for i in range(1_000_000):
Lt1.append(i**2)
fin = time.time()
print(f"Liste de {len(Lt1)} elem, tps :",fin-deb)
# Première amélioration
Lt2 = list()
deb_ = time.time()
for i in range(1_000_000):
Lt2.append(i*i)
fin_ = time.time()
print(f"Liste de {len(Lt2)} elem, tps :",fin_ - deb_)
# List comprehension
deb_c = time.time()
LCarC = [i*i for i in range(1_000_000)]
fin_c = time.time()
tps = fin_c - deb_c
print(f"Liste de {len(LCarC)} elem, tps :",tps)
# List comprehension : temps moyen
tps = 0
nbRepet = 10
for k in range(nbRepet):
deb_c = time.time()
LCarC = [i*i for i in range(1_000_000)]
fin_c = time.time()
tps = tps + fin_c - deb_c
print(f"Liste de {len(LCarC)} elem, tps :",tps/nbRepet)
import time
# Dimensions de la matrice
m = 3_000 # nb lignes
n = 5_000 # nb colonnes
mat = []
tps = 0
deb_c = time.time()
for i in range(m):
ligne = []
for j in range(n):
ligne.append(i + j)
mat.append(ligne)
fin_c = time.time()
tps = tps + fin_c - deb_c
print(f"Matrice, tps :",tps)
# Affichage de la matrice
# for ligne in mat:
# print(ligne)
tps = 0
deb_c = time.time()
LCimb = [[i+j for i in range(m)] for j in range(n)]
fin_c = time.time()
tps = tps + fin_c - deb_c
print(f"Matrice, tpsC :",tps)
# for lg in LCimb:
# print(lg)
# dict comprehension
FrP = {
"raisin":20,
"Banane":13,
"pomme":19,
"peches":17
}
print(FrP)
LFr = ["raisin", "Banane", "pomme", "peches"]
LP = [20, 13, 19, 17 ]
dicFrP = {Fruit:Prix for Fruit,Prix in zip(LFr,LP) }
print(dicFrP)
# avec condition(s)
dicFrP_2 = {Fruit:Prix for Fruit,Prix in zip(LFr,LP) if Prix < 18}
print(dicFrP_2)
- Exercice Dict:
ch = "DUTXTSAISIPOURFAIRDESTESTS"
import random
import string
# Génération d'un texte de 100 lettres (majuscules et minuscules)
longueur = 10
ch = ''.join(random.choices(string.ascii_letters, k=longueur))
ch = ch.upper()
print(ch)
dictCH = {}
for L in ch:
if L in dictCH:
dictCH[L] = dictCH[L]+1
else:
dictCH[L] = 1
print(dictCH)
import time
import random
# Générer une liste de 1 million d'entiers
taille = 10**6
liste = list(range(taille))
dictionnaire = {i: True for i in liste} # table de hachage
# Choisir un élément à rechercher (par exemple, un élément en fin de structure)
element_a_rechercher = taille - 1
# Recherche dans la liste
debut_liste = time.time()
present_dans_liste = element_a_rechercher in liste
fin_liste = time.time()
# Recherche dans le dictionnaire (table de hachage)
debut_dict = time.time()
present_dans_dico = element_a_rechercher in dictionnaire
fin_dict = time.time()
# Afficher les résultats
print(f"Résultat dans liste : {present_dans_liste}")
print(f"Temps recherche liste : {fin_liste - debut_liste:.6f} secondes")
print(f"Résultat dans dictionnaire: {present_dans_dico}")
print(f"Temps recherche dictionnaire : {fin_dict - debut_dict:.6f} secondes")