IPEI EL MANAR Module II : Environnement de développement Python 3 Année universitaire : 2020/2021

Les Conteneurs en python : les séquences, les dictionnaires et les ensembles

1. Propriétés communes aux séquences (hors “mutations”)

Les séquences en Python sont les objets des trois types suivants : les chaînes de caractères, les listes, et les
tuples. Les séquences ont un certain nombre de propriétés importantes en commun :
• elles sont composées d’un nombre fini d’éléments (la numérotation commence à 0).
• On peut compter à partir de la fin. Ainsi seq[-1] désigne le dernier élément d’une séquence.
• on peut effectuer des coupes (le terme anglais est slice).
Dans le tableau ci-dessous, s et t désignent des séquences (chaînes, listes ou tuples), x désigne un objet
pouvant appartenir à s, et on note i; j; k; n des entiers :

Remarque: les fonctions intégrées list, tuple et str permettent de passer d’un type de séquence à l’autre :

>>> s = [1,[2,3],"abc"] ; str(s) ; tuple(s) ; # une liste ,on la transforme en chaîne et en tuple
>>> t = ("xyz",(1,3.14),[0,2]) ; str(t) ; list(t) ; # un tuple, on le transforme en chaîne et en liste
>>> c = "abcdef" ;list(c) ; tuple(c) ; # une chaîne, on la transforme en une liste et en tuple de ses
caractères

2. Séquences mutables ou non

Il y a une différence entre les listes d’une part, et les chaînes et tuples de l’autre : les listes sont dites
mutables, mais les chaînes et les tuples ne le sont pas. Un objet est mutable : on peut modifier un (ou
plusieurs) élément(s), sans pour autant créer une nouvelle référence vers l’objet ainsi modifié (l’adresse du
début reste inchangée).
Considérons l’exemple suivant :

>>> x = [1,2,3]; id(x) # la variable x contient en fait l’adresse de la liste [1,2,3]

>>> y = [x,x,x,x]; id(y) # la variable y contient l’adresse de la liste [x,x,x,x]
>>> [id(e) for e in y] # les éléments de la liste y pointent l’adresse de la liste [1,2,3]
>>> x = [4,5,6]; id(x) # on redéfinit le contenu de x. L’adresse change!
>>>y # mais le contenu de la liste y n’a pas changé
>>> [id(e) for e in y] # normal car les adresses pointent toujours sur la liste [1,2,3]

Reprenons l’exemple précédent, en le modifiant légèrement :

>>> x = [1,2,3]; id(x) # la variable x contient l’adresse de la liste [1,2,3]

>>> y = [x,x,x,x]; id(y) # la variable y contient l’adresse de la liste [x,x,x,x]

Classe : 1ère Année MP, PC, PT Page 1

IPEI EL MANAR Module II : Environnement de développement Python 3 Année universitaire : 2020/2021

>>> [id(e) for e in y] # les éléments de la liste y pointent l’adresse de la liste [1,2,3]
>>>x[0] = 9; id(x) # on mute la liste x, on ne la redéfinit pas: adresse inchangée!
>>>y # toutes les composantes de y ont changé en même temps
>>> [id(e) for e in y] # normal car elles pointent la même adresse, où on a maintenant [9,2,3]

3. Listes définies “en compréhension”

Les listes peuvent être formées :
• en évaluant l’expression list() ou []. On obtient la liste vide.
• en combinant des éléments [elt0, elt1,..., eltn], ou en convertissant une séquence par list(seq).
• En fait, les listes peuvent être construites “en compréhension” d’une façon plus générale encore.

[ expression for indice_1 in iterable_1 [if condition_1].........for indice_n in iterable_n [if condition_n] ]

Chacune des conditions est facultative (et la condition n°i s’applique à l’indice n°i).Exemple :
>>> [x*x for x in range(1,100) if x%10 == 3]
>>> [100*i+j for i in range(1,5) for j in range(1,4)]
>>> [[100*i+j for i in range(1,5)] for j in range(1,4)]

4. Opérations de mutation de listes

Attention : la plupart des instructions précédentes renvoient la valeur None mais mutent la liste (sans
changer son adresse).
>>> s = t = list(range(10,20)); t # place dans s et t la même liste (même adresse!)
>>> u = s.copy(); u # met dans u une copie indépendante de l’original
>>>#Vous pouvez utiliser la fonction intégrée list () pour copier:
>>>new_list = list( t )
>>>#Vous pouvez utiliser copy.copy générique () pour faire une copie superficielle :
>>>import copy
>>>new_list = copy.copy( t )
>>>#Copie profonde (deep copy) avec copy.deepcopy():
>>>import copy
>>>new_list = copy.deepcopy( t )
>>>s[3] = ’info’; t # remplace s[3] ; modification répercutée sur t
>>>dels[3]; t # supprime s[3] ; modification répercutée sur t
>>>s.insert(3,0); t # insère 0 en position 3 dans s (idem dans t)
>>>s[1:9:2] # lit une coupe de longueur 4 dans s
>>>s[1:9:2] = ’abcd’; t # remplace ces 4 élts par ceux de ’abcd’
Classe : 1ère Année MP, PC, PT Page 2
IPEI EL MANAR Module II : Environnement de développement Python 3 Année universitaire : 2020/2021

>>>del s[1:5]; t # efface les éléments de positions 1 à 4

>>>s.append(’xyz’); t # ajoute l’objet ’xyz’ à la fin de la liste
>>>s.extend(’uvw’); t # complète la liste par les éléments de ’uvw’
>>>s.pop(5) # renvoie s[5], et le supprime de la liste
>>>s.remove(16); t ;s.reverse(); t # supprime la première occurence de la valeur 16 , inverse la liste s
>>>u # pendant ce temps-là, l’original n’a pas changé

Pour trier la liste contenue dans une variable s (reverse=True/False pour inverser l’ordre du tri).

>>>L = [831, 348, 562, 879, 130, 886, 756, 355]; L

>>>sorted(L);L # renvoie la liste triée mais l’original n’a pas été modifié
>>>L.sort(); L # ici le tri s’effectue sur place

5. Les tuples
Les tuples sont des séquences non mutables d’objets. Les tuples peuvent être formés :
• en évaluant l’expression tuple() ou (). On obtient le tuple vide.
• en combinant des éléments (elt0, elt1,..., eltn), ou en convertissant une séquence par tuple(seq).
• en “compréhension”, par la syntaxe plus générale suivante

>>>tuple( expression for indice_1 in iterable_1 [if condition_1].............for indice_n in iterable_n [if
condition_n] )

Quelques remarques :
• Les parenthèses aux extrémités sont facultatives (l’important, ce sont les virgules).
• Pour former un tuple à un seul élément, il faut faire suivre cet élément d’une virgule.
• Les opérations sur les séquences non mutables s’appliquent aux tuples.

>>> t = (123, ’abc’, 3.14); type(t) # on définit un tuple de longueur 3

>>>t[1] # on accède en lecture à l’élément en position 1
>>>t[1] = ’uvw’ # impossible de modifier un élément !!!

Voici quelques exemples de manipulations d’un tuple t défini en compréhension :

>>> t = tuple(x*x for x in range(1,9)); t ; id(t) # un tuple défini en compréhension

>>>t[::-1] # le même tuple, mais à l’envers
>>>t = t + (2013,); t ;id(t) # on ajoute l’élément 2013 (NB la virgule!)# mais attention, c’est un tout
nouvel objet!!!
>>>t[1:6:2] # le tuple (t[1],t[3],t[5])
>>>t[-1] # le dernier élément du tuple t
>>> (1,2,3)+(4,5) # concaténation de deux tuples
>>> (1,2,3),(4,5) # on forme un ‘2uple’ (un ‘3uple’ puis un ‘2uple’)
>>> (0,)*5 # le ‘1uple’ (0) répété 5 fois
>>>x,y,z = (5,6,7) # on ‘dépacke’ un tuple
>>>z, y, x # on repacke, mais en changeant l’ordre

Classe : 1ère Année MP, PC, PT Page 3

IPEI EL MANAR Module II : Environnement de développement Python 3 Année universitaire : 2020/2021

6. Les chaînes de caractères

Les chaînes sont des séquences de caractères non mutables. On ne peut donc pas modifier un ou plusieurs
caractères. Si on ajoute un caractère (ou une autre chaîne) par concaténation à une chaîne existante, le
résultat est la création d’une nouvelle chaîne à une nouvelle adresse en mémoire.
• Les chaînes sont délimitées par des guillemets simples ('bonjour') doubles ("bonjour") ou triples
('''bonjour''').
• Les opérations sur les séquences non mutables s’appliquent aux chaînes
• Tout comme les listes et les tuples, les chaînes sont itérables.

>>> ’abc’ + ’uvwxyz’ ;’abc’ * 5 # concaténation de deux chaînes ; répétition d’une même chaîne
>>>st = ’abxyztcabaabaabcabw’ # définition d’une chaîne
>>> for c in st: print(ord(c),end=’ ’) # boucle d’affichage des codes des caractères
>>>len(st), st[2:5], st[-1] # lecture de caractères par leurs indices
>>>st[::-1] ; (’abc’ in st, ’abcd’ in st, ’ab’ not in st) # inverser l’ordre des caractères ; appartenance ou
non
>>>st.count(’aba’), st.index(’aba’),st.index(’aba’,8) # nbre d’occurrences, 1èreocc,1ère occ à partir de
la position 8
>>>st[2]=’h’ # impossible de modifier un caractère

Voir également la section suivante pour une analyse détaillée de certaines méthodes importantes.

7. Méthodes importantes sur les chaînes (split, join)

La split permet de découper une chaîne en une liste de sous-chaînes. La méthode joinest l’inverse de la
méthode split.

>>> t = "être ou ne pas être, là est la question"

>>>t.split() ;t.split(’être’) ;t.split(‘,’)
>>> ’’.join([’abc’,’def’,’ghi’]) ;’*’.join([’abc’,’def’,’ghi’]) # joint les chaînes de la liste, avec un sép vide ;
en séparant par *

Classe : 1ère Année MP, PC, PT Page 4

IPEI EL MANAR Module II : Environnement de développement Python 3 Année universitaire : 2020/2021

8. Dictionnaires
Les dictionnaires sont des structures mutables, non ordonnées. Les dictionnaires peuvent être formés :
• en évaluant l’expression dict() ou {}. On obtient le dictionnaire vide
• en délimitant une séquence de paires clé :valeur : {clé1:val1, clé2:val2,..., clén:valn}
• en évaluant par exemple : dict([[clé1,val1],[clé2,val2],...,[clén,valn]])
• en ajoutant des paires clé :valeur à un dictionnaire existant.
• en “compréhension”, par exemple D = {x:x*2 for x in range(10)}
Voici quelques méthodes applicables à un objet dic de type dictionnaire. On note ici cle une clé et val une
valeur :

Voici un exemple (très simple !) de dictionnaire (les clés sont des noms, les valeurs des âges...) :

>>>ages = {'Paul':41, 'Léon':25, 'Jeanne':134} ;ages # un dict de trois entrées ;l'ordre affiché est non
prévisible
>>> 'Paul' in ages, 'Jean' in ages ; ages['Jeanne'] # teste la présence de deux clés ; demander l’âge de
Jean
>>>ages['Marc'] = 33 ; delages['Paul'] ;ages # crée un nouvel enregistrement ; supprime un
enregistrement
>>> for elt in ages: print(elt) # itérer un dictionnaire, c’est itérer les clés
>>>ages.items() ; list(ages)# voici comment itérer sur les paires (clé,valeur) ; la conversion ne donne
ici que les clés
>>>list(ages.keys()) ; list(ages.values()) # autre façon d’obtenir la liste des clés ; la liste des valeurs
>>>max(ages.values()) # la valeur maximum
>>> [(n,a) for n,a in ages.items()] # voici la liste des enregistrements

9. Ensembles
Un ensemble peut contenir des valeurs de type quelconque. Les éléments d’un objet de type ensemble ne
sont pas ordonnés (on ne peut pasy accéder par un indice).On forme un ensemble en utilisant le
constructeur set.

Classe : 1ère Année MP, PC, PT Page 5

IPEI EL MANAR Module II : Environnement de développement Python 3 Année universitaire : 2020/2021

>>> e = {1,5,2,3,2,7,5,2,1,3,2} # forme un ensemble par une séquence de valeurs entre f et g

>>> e = set([1,5,2,3,2,7,5,2,1,3,2]) # même résultat en convertissant une liste
>>>e # dans un ensemble, tous les doublons ont été éliminés
>>>set(’abracadabra’) # l’ensemble des caractères distincts d’une chaîne

Les objets de type “ensemble” sont mutables. Voici quelques méthodes applicables à un objet e de type
ensemble (set).

On continue sur la lancée de l’exemple précédent

>>>e.discard(5) ;e ;e.add(0) ;e ;4 in e # on retire l’élt 5 ;on ajoute l’élt 0 ; on demande si 4 est dans
l’ensemble

Les objets de type “ensemble” ont des méthodes pour les opérations ensemblistes usuelles :

Voici quelques exemples (on voit que l’ordre des éléments d’un ensemble est imprévisible) :

>>> m3=set(range(0,50,3)); m5=set(range(0,50,5)); m7=set(range(0,50,7))

>>>m3 ; m5 ; m7# les multiples de 3, 5 et 7 dans l’intervalle [0,50[
>>> m5 | m7 ; m3 - m7 ;m3 ^ m5 ; m3 & m5#union m5 ou m7 ;m3 qui ne sont pas m7 ;les m3 ou
m5 ;les m3 et de m5

Classe : 1ère Année MP, PC, PT Page 6