Langage Python

2023-2024

AZBEG Kebira
Collections
Collections
• En Python, le terme "collections" fait référence à des structures de
données qui permettent de stocker, organiser et manipuler des
données.
• Les collections offrent différentes fonctionnalités en fonction des
besoins spécifiques, et Python propose plusieurs types de
collections intégrées.
Collections
LES LISTES
 Listes

• Une liste (ou list) en python est une variable dans laquelle on peut mettre
plusieurs variables (les éléments peuvent être quelconques).

• Les listes Python sont des structures de données dynamiques, permettant d'ajouter
ou de retirer des éléments sans avoir besoin de spécifier une taille fixe au moment
de la déclaration.

• Elles sont similaires aux tableaux de taille dynamique dans d'autres langages tels
que « Vector » en C++ et « ArrayList » en Java.

• Elles sont utilisées pour stocker plusieurs éléments dans une seule variable.

• Les listes font partie des 4 types de données intégrés à Python pour stocker des
collections de données, aux côtés de Tuple, Set et Dictionary, chacun ayant des
qualités et des utilisations spécifiques.
 Listes

• Créer une liste vide:

maListe = [];
ou
maListe = list()

• Initialiser une liste:

maListe = [1,2,3]

maListe = ["Java", "C++", "Python"]

 Listes

• Les éléments d'une liste sont ordonnés, modifiables et peuvent être dupliqués.
• Les éléments d'une liste sont indexés : le premier élément a l'index [0], le
deuxième élément a l'index [1], … Le dernier élément à l’index [-1].
• Les éléments d'une liste peuvent être de n'importe quel type de données.
• Une liste peut contenir différents types de données.

maListe = [1, 2, 3, 'quatre', 5.0]

 Listes

• Retourner la taille d’une liste:

maListe = [1,2,3,4,5]
len(maListe) #retourne 5

• Retourner l’élément par l'indice (les indices commencent à 0):

maListe = [1,2,3,4,5]
maListe[2] #retourne 3

• Retourner le dernier élément :

maListe = [1,2,3,4,5]
maListe[-1] #retourne 5
 Listes

• Retourner une sous liste:

maListe = [1,2,3,4,5]
maListe[1:3] #retourne [2, 3]

=> La recherche commencera à l'index 1 (inclus) et se terminera à l'index 3 (non inclus)

maListe = [1,2,3,4,5]
maListe[1:] #retourne [2, 3, 4, 5]

=> En omettant la valeur finale, l'intervalle se prolongera jusqu'à la fin de la liste

maListe = [1,2,3,4,5]
maListe[:3] #retourne [1, 2, 3]
=> En omettant la valeur de départ, l'intervalle commencera au premier élément
 Listes

• Insérer un élément à un endroit spécifique:

maListe = [1,2,3,4,5]
maListe.insert(2, "Z") # [1, 2, 'Z', 3, 4, 5] (insertion à l’indice 2)
# comme maListe[2:2] = "Z")
maListe[0:0] = ['x','y'] #['x', 'y', 1, 2, 'Z', 3, 4, 5] (insertion au début)
• Supprimer un élément (par un indice):
maListe = [1,2,3,4,5]
del maListe[2] #supprime 3

• Inverser la liste :
maListe.reverse()
Ou
maListe[::-1]
 Listes

• Changer la valeur d’un élément spécifique

maListe = [1,2,3,4,5]
maListe[2] = 8 #[1, 2, 8, 4, 5]

• Vérifier si un élément existe dans la liste

maListe = [1,2,3,4,5]
print(4 in maListe) #Affiche True
print(8 in maListe) #Affiche False
 Listes

• Concaténer 2 listes : maListe1 + maListe2

• Copie de liste :
• maListe2 = maListe1 : maListe2 et maListe1 référencent la même liste.
• maListe2 = maListe1[:] : maListe2 est une copie de la liste maListe1.
• maListe2 = list(maListe1) : maListe2 est une copie de la liste maListe1.
 Listes

Fonctions sur les listes :

• maListe.append(x) : ajoute un élément x.
• maListe.extend(maListe2) : ajoute la liste maListe2 à la fin.
• maListe.remove(x) : enlève le premier élément identique à x (erreur si non trouvé).
• maListe.pop() : enlève le dernier élément et le renvoie.
• maListe.pop(0) : enlève le premier élément et le renvoie.
• maListe.pop(i) : enlève l'élément à la position i et le renvoie.
• maListe.index(x) : renvoie l'index du 1er élément identique à x (erreur si non trouvé).
• maListe.count(x) : compte combien de fois l'élément x est dans la liste.
• maListe.sort() : trie en place les éléments de la liste.
 Listes

Exercice d’application :
1. Créez une liste appelée nombres contenant les nombres de 1 à 5.
2. Ajoutez le nombre 6 à la fin de la liste.
3. Supprimez le nombre 3 de la liste.
4. Triez la liste par ordre décroissant.
5. Créez une deuxième liste appelée nombresPairs contenant les nombres pairs de 2
à 10.
6. Fusionnez les deux listes en une seule liste appelée tousLesNombres.
7. Affichez tous les éléments de tousLesNombres en utilisant une boucle.
 Listes

Exercice d’application :
# 1.
nombres = [1, 2, 3, 4, 5] # 5.
# 2. nombresPairs = [2, 4, 6, 8, 10]
nombres.append(6) # 6.
# 3. tousLesNombres = nombres + nombresPairs
nombres.remove(3) # 7.
# 4. for nombre in tousLesNombres:
nombres.sort() print(nombre)
nombres.reverse()
Ou
nombres.sort(reverse=True)
Collections
LES TUPLES
 Tuples

• Les tuples sont comme une liste, sauf que les éléments ne peuvent pas être
changés (immuables), il est impossible de les remplacer ou de les supprimer.

• Un tuple est une collection ordonnée et inchangeable.

 Tuples

• Création d'un tuple :

t = () #tuple à 0 élément
t = ('a', 'b', 2) #tuple à 3 élément
t = ('a',) ou t = 'a’, (avec la virgule dans les 2 cas !) #tuple à 1 élément
t = ('a', 'b') ou t = 'a', 'b’ #tuple à 2 éléments

• Longueur d'un tuple : len(t)

 Tuples

• Les Tuples fournissent seulement deux méthodes:

• t.count (x), qui renvoie le nombre de fois l’objet x se produit dans le tuple t.
• t.index (x), qui renvoie la position de la première occurrence de x.

• Les tuples peuvent être utilisés avec les opérateurs :

• + (concaténation),
• * (réplication)
• [] (tranche),
• in et not in pour critère de l'appartenance.

• Le += et *= opérateurs d'affectation augmentée peuvent être utilisés.

 Tuples

• Les tuples peuvent être comparées en utilisant les opérateurs de

comparaison standard (<, <=, ==,! =,> =,>).
• Les comparaisons sont appliquées article par article (et récursivement pour
les éléments imbriqués comme tuples intérieur tuples).
 Tuples

Exercice d’application :
1. Créez un tuple appelé coordonnees contenant les coordonnées (3, 4).
2. Décomposez le tuple coordonnees en deux variables x et y.
3. Créez un deuxième tuple appelé autres_coordonnees contenant les coordonnées
(1, 8).
4. Concaténez les deux tuples en un nouveau tuple appelé toutes_les_coordonnees.
5. Affichez la longueur du tuple toutes_les_coordonnees.
 Tuples

Exercice d’application :
# 1.
coordonnees = (3, 4)
# 2.
x, y = coordonnees
# 3.
autres_coordonnees = (1, 8)
# 4.
toutes_les_coordonnees = coordonnees + autres_coordonnees
# 5.
longueur = len(toutes_les_coordonnees)
print(longueur)
Collections
LES SÉQUENCES
 Séquences

• En python, une séquence est : une string (chaîne), une list (liste) ou un tuple.

• in, not in : opérateurs de condition pour savoir si une valeur est présente dans une séquence.

• is, is not : pour savoir si 2 objets mutables (liste) sont réellement les mêmes.

• Conversion des séquences :

• list('abc') : convertit une chaîne en liste, ici ['a', 'b', 'c'].
• tuple('abc') : convertit une chaîne en tuple, ici ('a', 'b', 'c').
• list(('a', 'b', 'c')) : convertit un tuple en liste, ici ['a', 'b', 'c'].
• tuple(['a', 'b', 'c']) : convertit une liste en tuple, ici ('a', 'b', 'c').

• Affectation : du moment que les séquences ont le même nombre d'éléments, on peut faire :
• (x, y, z) = (1, 2, 3)
• [x, y, z] = [1, 2, 3]
• mais aussi (x, y, z) = [1, 2, 3] et [x, y, z] = (1, 2, 3)
• et même : (x, y, z) = 'abc' ou [x, y, z] = 'abc'
 Collections
LES DICTIONNAIRES
 Dictionnaires

• Les dictionnaires en Python sont des structures de données qui permettent

de stocker des paires clé-valeur.

• Chaque élément dans un dictionnaire a une clé associée, et cette clé est
utilisée pour accéder à la valeur correspondante.

• Les dictionnaires sont définis par des accolades ({}) et les éléments sont
séparés par des virgules.

• Un dictionnaire en python est une sorte de liste mais au lieu d'utiliser des
index, on utilise des clés alphanumériques.
 Dictionnaires

• Création de dictionnaire:

d = {} ou d = dict() # Initialisation à vide

d = {'toto': 1, 'titi': 2} # Initialisation avec 2 valeurs

• Affectation et ajout d'une valeur:

d['toto'] = 5 # {'toto': 5, 'titi': 2}
d['tata'] = 10 # {'toto': 5, 'titi': 2, 'tata': 10}

• Destruction d'une clef:

del d['toto'] # {'titi': 2, 'tata': 10}
 Dictionnaires

• Renvoie les clefs sous forme d'une nouvelle liste:

l=d.keys() # ['titi', 'tata’]

• Test de l'existence (non existence ) d'une clef:

d= {'titi': 2, 'tata': 10}
'toto' in d # False
'toto' not in d # True

• Nombre d'items dans le dictionnaire :

len(d) #2
 Dictionnaires

Fonctions sur les dictionnaires:

• d.clear() : efface tout.
• d.copy() : shallow copie (Crée une copie indépendante de d)
• d.get(key) (ou d.get(key, defaultVal) ): renvoie la valeur si clef présente, sinon None (ou
defaultVal)
• d.items() : renvoie une copie du dictionnaire sous forme de liste de paires (key, value).
• d.pop(key) (ou d.pop(key, val) ) : enlève la clef et renvoie la valeur si clef n'existe pas
KeyError ( ou val sans lever une exception).
• d.popitem() : renvoie une paire (key, value et la retire du dictionnaire.
• d.values() : renvoie une copie de la liste des valeurs.
• d.setdefault(key, defaultVal) : si la clef existe, renvoie sa valeur, si la clef n'existe pas,
insère la clef avec la valeur defaultVal et renvoie sa valeur.
 Dictionnaires

Exercice d’application:
1. Créez un dictionnaire appelé informations_personnelles avec les clés "nom", "âge"
et "ville".
2. Affichez la valeur associée à la clé "âge".
3. Modifiez la valeur associée à la clé "ville".
4. Supprimez la clé "ville" du dictionnaire.
5. Affichez toutes les clés restantes dans le dictionnaire.
 Dictionnaires

Exercice d’application:

# 1.
informations_personnelles = {'nom': 'Ahmad', 'age': 30, 'ville': 'Casablanca'}
# 2.
print(informations_personnelles['age'])
# 3.
informations_personnelles['ville'] = 'Rabat'
# 4.
del informations_personnelles['ville']
# 5.
print(informations_personnelles.keys())
Collections
LES ENSEMBLES
 Ensembles
• Un Ensemble (ou set) en python est une collection d’éléments non ordonnée, sans
index et qui ne peut pas posséder d’élément dupliqué.

• Les ensembles sont mutables, facile à ajouter ou supprimer des éléments, mais
comme ils sont désordonnés, ils n'ont aucune notion de position (indice d’élément).

• C’est une sorte de dictionnaire où les valeurs seraient ignorées, seules les clefs
comptent.
 Ensembles
• Création d’un ensemble:

# Ensemble vide (set avec aucun élément):

s= set()

# Ensemble avec des éléments:

s = set(['a', 'b', 'c'])
ou
s={'a', 'b', 'c’}
ou
s = set('abc’)

#définition d'un set non modifiable:

s = frozenset(['a', 'b', 'c'])
 Ensembles
• Test si un élément appartient au set:
s = set(['a', 'b', 'c'])
'a' in s #True
'a' not in s #False

• Ajout d'un élément:

s = set(['a', 'b', 'c'])
s.add('d') #Ajouter ‘d’ à l’ensemble s

• Retrait d'un élément:

s.discard('d’)
ou
s.remove('d’) #remove donne une exception KeyError si non présent
 Ensembles
• Enlever un élément et le renvoyer:
s.pop()

• Effacer tous les éléments :

s.clear()

• Nombre d'éléments du set : len(s)

len(s)
 Ensembles
Fonctions sur les ensembles:
• s.isdisjoint(s2): Les ensembles sont disjoints si et seulement si leurs intersection est un
ensemble vide.
• s.issubset(s2): Teste si tous les éléments du s sont dans s2.
• s.issuperset(s2): Teste si tous les éléments de s2 sont dans l'ensemble s.
• s <s2 : inclusion stricte (déterminer si l'ensemble s1 est un sous-ensemble strict de
l'ensemble s2) (pareil avec s <= s2, s >= s2, s > s2).
• s.union(s2) : l’union, renvoie un nouvel ensemble dont les éléments viennent des deux
ensembles, n'affecte pas les sets de départ (on peut aussi faire s | s2).
• s.intersection(s2) l’intersection(on peut aussi faire s & s2).
• set.union(s1, s2, s3) , set.intersection(s1, s2, s3) : renvoie l’union (intersection) de plusieurs
sets (on peut aussi faire s1 | s2 | s3, s1 & s2 & s3 ).
• s.difference(s2) (on peut aussi faire s - s2): Renvoie un nouvel ensemble dont les éléments
sont dans l'ensemble s mais ne sont pas dans s2.
 Ensembles
Fonctions sur les ensembles:
• s.symmetric_difference(s2) (on peut aussi faire s ^ s2). Renvoie un nouvel ensemble dont les
éléments sont soit dans l'ensemble s, soit dans s2, mais pas dans les deux.
• s.symmetric_difference_update(s2) : la différence symétrique et modifie s (on peut aussi
faire s ^= s2). Met à jour le set, ne gardant que les éléments trouvés dans un des ensembles
mais pas dans les deux.
• s.copy() : renvoie une shallow copy (superficielle).
• s.update(s2) : rajoute les éléments à s et modifie s (on peut aussi faire s |= s2).
• s.intersection_update(s2) : l'intersection et modifie s (on peut aussi faire s &= s2).
• s.difference_update(s2) : la différence et modifie s (on peut aussi faire s -= s2).
• s.symmetric_difference_update(s2) : la différence symétrique et modifie s (on peut aussi
faire s ^= s2).
 Ensembles
Exercice d’application:
1. Créez deux ensembles, ensemble1 et ensemble2, contenant quelques nombres.
2. Trouvez et affichez l'union des deux ensembles.
3. Trouvez et affichez l'intersection des deux ensembles.
4. Trouvez et affichez la différence entre ensemble1 et ensemble2.
5. Ajoutez un élément à chaque ensemble.
6. Trouvez et affichez la différence symétrique entre ensemble1 et ensemble2.
 Ensembles
Exercice d’application:

# 1.
ensemble1 = {1, 2, 3, 4, 5}
ensemble2 = {4, 5, 6, 7, 8}
# 2.
union_resultat = ensemble1.union(ensemble2)
print(union_resultat)
# 3.
intersection_resultat = ensemble1.intersection(ensemble2)
print(intersection_resultat)
# 4.
difference_resultat = ensemble1.difference(ensemble2)
print(difference_resultat)
 Ensembles
Exercice d’application:

# 5.
ensemble1.add(9)
ensemble2.add(10)
# 6.
symmetric_difference_resultat = ensemble1.symmetric_difference(ensemble2)
print(symmetric_difference_resultat)