Chapitre 2

Les conteneurs standards

avec
Les conteneurs standards
• Les listes
• Les tuples
• Les ensembles
• Les dictionnaires
 Conteneurs standards Les listes

Listes
• Les listes servent à stocker des collections ordonnées d’élémentsavec
possibilité de les étendre ou de les manipuler facilement
Initialisation
• L1=[ ]; L2=list( ) #Listes vides
• L1= [1, 2, 3, 4, 5]; L2= ['point', 'triangle', ‘rectangle']
• L=[1, 4, ‘ali', 4, ‘laila', ['point', 6]]
• L=[3]*6 # L=[3, 3, 3, 3, 3, 3]
Concaténation

Entrée(s) Résultat
L1, L2 = [1, 2, 3], [4, 5, 6]
[1, 2, 3]
print(L1)
print(L2) [4, 5, 6]
print(L1+L2) [1, 2, 3, 4, 5, 6]
3/19
 Conteneurs standards Les listes

Manipulation des listes

Syntaxe Sémantique

len(L) Nombre d’éléments dans la liste ‘L’

del(L[n]) Détruit l’élément d’indice ‘n’ de la liste ‘L’
L1 + L2 Concaténation de ‘L1’ et ‘L2’

L*n Répétition ’n’ fois de la liste ‘L’

L[n] Extraction de l’élément d’indice ‘n’ en partant du début de la liste

L[-n] Extraction de l’élément de position ‘n’ en partant de la fin de la liste
L[n:m] Extraction des éléments en partant de l’indice ‘n’ à l’indice ‘m-1’
L[:n] Extraction des ‘n’ premiers éléments de la liste (du début à n-1)
L[n:] Extraction des éléments à partir de l’indice ‘n’ jusqu’à la fin de la liste
L[-n:] Extraction des ‘n’ derniers éléments de la liste

4/19
 Conteneurs standards Les listes

Manipulation des listes

Syntaxe Sémantique

[Link]() Vide la liste ‘L’.

[Link]() Renvoie une copie de la liste ‘L’.

[Link](e) Ajoute l’élément 'e' à la fin de la liste 'L'.

[Link](n, e) Insère l’élément 'e' à l’indice 'n' dans la liste 'L'.

[Link]() Trie la liste L par ordre croissant.

[Link]() Inverse la liste L.

[Link](e) Retourne l’indice de l’élément 'e’ qui est dans la liste L.

[Link](e) Retirer l’élément 'e' de la liste L.

[Link]() Retirer le dernier élément de la liste L et retourne cet élément.

[Link](ind) Retirer l’élément qui est dans l’indice 'ind' de la liste L et retourne cet élément.

5/19
 Conteneurs standards Les listes

Exemples
cours=['Hist','Math','Phy','Ar','Sc']
print(cours) ['Hist', 'Math', 'Phy', 'Ar', 'Sc']
print(len(cours)) 5
print(cours[1]) Math
print(cours[-2]) Ar
print(cours[1:3]) ['Math', 'Phy']
print(cours[:2]) ['Hist', 'Math']
print(cours[2:]) ['Phy', 'Ar', 'Sc']
[Link]('Fr'); print(cours) ['Hist', 'Math', 'Phy', 'Ar', 'Sc', 'Fr']
p=[Link](); print(cours) ['Hist', 'Math', 'Phy', 'Ar', 'Sc']
print(p) Fr
[Link](1,'Art');
print(cours) ['Hist', 'Art', 'Math', 'Phy', 'Ar', 'Sc']
cours=['Hist','Math','Phy','Ar']
cours2=['Ang','Fr']
[Link](1,cours2); print(cours) ['Hist', ['Ang', 'Fr'], 'Math', 'Phy', 'Ar']
#insertion en tant que liste et non en tant que valeurs
[Link](cours2); print(cours) -> ['Hist', 'Math', 'Phy', 'Ar']
[Link](cours2); print(cours) -> ['Hist', 'Math', 'Phy', 'Ar', 'Ang', 'Fr']
6/19
 Conteneurs standards Les listes

Exemples
cours =['Hist','Math','Phy','Ar','Sc']
print(cours); ['Sc', 'Ar', 'Phy', 'Math', 'Hist']
[Link]();print(cours) ['Sc', 'Ar', 'Phy', 'Math', 'Hist']
[Link](reverse=True);
print(cours) ['Sc', 'Phy', 'Math', 'Hist', 'Ar']
cours =['Hist','Math','Phy','Math',‘Ar']
coursTrié=sorted(cours)
print(coursTrié) ['Ar', 'Hist', 'Math', 'Math', 'Phy']
print(cours) ['Hist', 'Math', 'Phy', 'Math', 'Ar']
print([Link]('Math')) 1
print([Link]('FR')) Erreur
print('Hist' in cours) True
txt=' - '.join(cours)
print(txt) ‘Hist - Math - Phy - Math – Ar’
cours2=[Link](' - ')
print(cours2) ['Hist', 'Math', 'Phy', 'Math', 'Ar']

7/19
 Conteneurs standards Les listes

Exemples
cours =['Hist','Math','Phy'] Hist
for matiere in cours: print(matiere) Math
for i,matiere in enumerate(cours): 0 Hist Phys
print(i,matiere) 1 Math
2 Phys
for i,matiere in
enumerate(cours,start=1): 1 Math
print(i,matiere)
2 Phys
L=[4,2,6,1]
[Link](reverse=True)
print(L) [6, 4, 2, 1]
print(min(L)) 1
print(sum(L)) 13
L=[2,5,7]
L1=3*L; print(L1) [2, 5, 7, 2, 5, 7, 2, 5, 7]
L2=[3*x for x in L]; print(L2) [6, 15, 21]
print([3*x for x in L if x>2]) [15, 21]

8/19
 Conteneurs standards Les listes

Suppression d’un élément

• remove: Retire la première occurrence d’un élément de la liste
Exemple: L=[1, 2, 4, 2]
[Link](2)
print(L) [1, 4, 2]

• del: supprime un élément de la liste à partir de son indice

Exemple: L=[1, 2, 4, 2]
del(L[2])
print(L) [1, 2, 2]
• pop: supprime un élément à partir de son indice et le retourne
Exemple: L=[1, 2, 4, 2]
x=[Link](2)
print(x) 4
print(L) [1, 2, 2]

9/19
 Conteneurs standards Les listes

Copie d’une liste La variable T a pointé vers la même case mémoire que L
=> Tout changement dans T se produira dans L

L =['Hist','Math','Phy','Ar','Sc']
T=L
print(L) ['Hist', 'Math', 'Phy', 'Ar', 'Sc']
print(T) ['Hist', 'Math', 'Phy', 'Ar', 'Sc']
T[2]="Fr"
print(T) ['Hist', 'Math', 'Fr', 'Ar', 'Sc']
print(L) ['Hist', 'Math', 'Fr', 'Ar', 'Sc']

L =['Hist','Math','Phy','Ar','Sc'] Le concept de sous liste évite

T=L[:] # T=[Link]( ) le pointage de T dans la même
T[2]="Fr" case mémoire que L
print(T) ['Hist', 'Math', 'Fr', 'Ar', 'Sc']
print(L) ['Hist', 'Math', 'Phy', 'Ar', 'Sc']

Remarque:
Les listes sont mutables: ils peuvent subir des modifications

10/19
 Conteneurs standards Les tuples

Tuples
• Ils permettent de grouper des éléments de différentes natures pour créer une
structure qui les englobe
Initialisation
• T1=(); T2=tuple()
• T= 'a', 'b', 'c', 'd'
• T= ('a', 'b', 'c', 'd') # T=('a', 'b', 'c', 'd')
• T= (1, 2)*3 T=(1, 2, 1, 2, 1, 2)
Concaténation
T1,T2=(1,2),("ali","laila")
print("T1=",T1) T1= (1, 2)
print("T2=",T2) T2= ('ali', 'laila')
print("T1+T2=",T1+T2) -> T1+T2= (1, 2, 'ali', 'laila')

11/19
 Conteneurs standards Les tuples

Tuples
• Les tuples ne sont pas modifiables: Ils sont immuables
Exemple

t =('Hist','Math','Phy','Ar','Sc')
print(t) ('Hist', 'Math', 'Phy', 'Ar', 'Sc')
print(t[2]) Phy Les tuples prennent en
consideration l’ordre de
print(t[2:]) ('Phy', 'Ar', 'Sc')
ces éléments.
print(t[-2]) Ar
t2=t
print(t2) ('Hist', 'Math', 'Phy', 'Ar', 'Sc')
t2[0]='Art' Error: 'tuple' object does not support item assignment
print(t2)
print(t)

12/19
 Conteneurs standards Les ensembles

Ensembles
• Un ensemble est une collection d'objets sans répétition et sans ordre (donc
sans numérotation). Ce n'est pas une séquence
• On les note comme en maths avec des accolades {...}. Les éléments sont de
types quelconques
Initialisation
• S=set() # Ensembles vides
• S={"rouge","vert","noir"}
• S= {5,'foo',(3,-2),7.4}
Remarque
•S={ } crée un dictionnaire et non pas un ensemble
Opérations
• Les seules opérations que l’on peut faire sur les ensembles sont toutes les
opérations ensemblistes (appartenance, intersection, union, …)

13/19
 Conteneurs standards Les ensembles

Exemples
color1={'rouge','vert','bleu','noir'} L’ordre n’est pas pris
print(color1) {'bleu', 'noir', 'vert', 'rouge'} en considération à
l’affichage
color1={'rouge','vert','bleu','noir','vert'}
print(color1) {'bleu', 'noir', 'vert', 'rouge'} Il n’accepte pas les
doublons
print(color1[1]) Error: 'set' object does not support indexing
print(len(color1)) 4
print('vert' in color1) True
print('belu' not in color1) True
color2={'rose','vert'}
c=color1|color2; print(c) {'bleu', 'rose', 'vert', 'noir', 'rouge'}
print([Link](color2)) {'bleu', 'rose', 'vert', 'noir', 'rouge'}
c=color1 & color2; print(c) {'vert'}
print([Link](color2)) {'vert'}
print(color1^color2) ce qui n’est pas en commun -> {'bleu', 'rose', 'noir', 'rouge'}
print([Link](color1)) False
print({'rouge','bleu'}.issubset(color1)) ->True
14/19
 Conteneurs standards Les dictionnaires

Dictionnaires
• Un dictionnaire est une collection non numérotée de couples var:val où var
est un objet non mutable (la clé) et où val est n'importe quelle valeur
• On peut accéder à un élément d’un dictionnaire à partir d’une clé
• Les clés d’un dictionnaires doivent être distinctes et ne peuvent pas être
modifiées
Initialisation
• D={ }; Dc=dict( ) #Dictionnaire vide
• stock={"pomme":40,"orange":30}
• etudiant={'nom':'ali','age':20,'cours':['Math','Phys']}
Insertion/Modification
On peut modifier la valeur associée à une clé, ou rajouter un nouveau couple
clé/valeur :
 stock={"pomme":40,"orange":30}
 stock["kiwi"]=60 #stock={'pomme': 40, 'orange': 30, 'kiwi': 60}
 stock['orange']='cent' # stock={'pomme': 40, 'orange': 'cent', 'kiwi': 60}
15/19
 Conteneurs standards Les dictionnaires

Accès à un élément
• On peut rapidement accéder à la valeur associée à une clé. C'est le principal
intérêt des dictionnaires
Exemple
stock={"pomme":40,"orange":30}
print(stock[“kiwi“])
print(stock["pomme“])

40 Erreur
• La clé doit être non mutable. Donc essentiellement des chaînes et des
nombres mais pas de listes. On peut utiliser des tuples comme clés à
condition qu'ils ne contiennent aucun objet mutable
• Il est aussi possible de demander si la clé existe, avec l'opérateur in
Exemple
print(“pomme“ in stock) print(“kiwi“ in stock)

True False 16/19

 Conteneurs standards Les dictionnaires

Principales méthodes
Syntaxe Sémantique
len(d) Nombre d’éléments du dictionnaire
del(d[k]) Détruit l’entrée dont la clé est 'k' du dictionnaire
[Link]() Supprime tous les éléments du dictionnaire 'd'
[Link]() Renvoie une copie du dictionnaire 'd'
[Link]() Renvoie la liste des clés utilisées dans le dictionnaire
[Link]() Renvoie la liste des valeurs utilisées dans le dictionnaire 'd'
d.has_key(k) Renvoie True si la clé passée en paramètre existe, False sinon
[Link]() Renvoie une liste équivalente de tuples à partir du dictionnaire 'd'
[Link](cle, val) Supprime et retourne d[cle] si la clé est présente sinon retourne val
[Link](d1) Ajoute la paire clé-valeur de 'd1' à 'd'
sorted(d) Retourne une liste ordonnée des clés du dictionnaire d

17/19
 Conteneurs standards Les dictionnaires

Exemples
etud={'nom':'ali','age':20,'cours':['math','phys']}
print(etud) {'nom': 'ali', 'age': 20, 'cours': ['math', 'phys']}
print(len(etud)) 3
print(etud['nom']) ali
print(etud['tel']) Erreur
print(etud['cours']) -> ['math', 'phys']
print([Link]('nom')) -> ali
print([Link]('tel')) -> None
print([Link]('tel','clé inexistante'))-> clé inexistante
etud['adresse']='agadir‘
etud['nom']='imad‘
print(etud) -> {'nom': 'imad', 'age': 20, 'cours': ['math', 'phys'], 'adresse': ‘agadir '}
etud2={'nom':'laila','pays':'Tunisie’ ,‘adresse’: ‘Tunis’}
[Link](etud2)
print(etud) ->{'nom': 'laila', 'age': 20, 'cours': ['math', 'phys'], 'adresse': 'Tunis ', 'pays': 'Tunisie'}
del(etud[‘cours'])
print(etud) -> {'nom': 'laila', 'age': 20, 'adresse': 'Tunis ', 'pays': 'Tunisie'}

18/19
 Conteneurs standards Les dictionnaires

Exemples
etud={'nom':'ali','age':20,'cours':['math','phys']}
x=[Link]('nom','clé inexistante')
print(x) ali
print(etud) {'age': 20, 'cours': ['math', 'phys']}
print([Link]('tel',-1)) -1
etud={'nom':'ali','age':20,'cours':['math','phys']}
print([Link]()) dict_keys(['nom', 'age', 'cours'])
print([Link]()) dict_values(['ali', 20, ['math', 'phys']])

for i in etud: nom:ali

print(i,":",etud[i]) age:20
cours:[‘math’,’phys’]
nom:ali
for cle,val in [Link](): age:20
print (cle,val) cours:[‘math’,’phys’]

19/19