VaultBy ENSAMIENParrainage
Star Ensamien Parrainage
Notebook

Site intéressant : https://www.w3schools.com/python/

04-tuple-set-dictionnaire.ipynb

Download .ipynb

Sommaire :

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 assignment
Mytuple = ("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 subscriptable
myL = ["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")

Fin

Esc

    Type at least 2 letters. ↑ ↓ to move, Enter to open.