Cours TP3

IPEI EL MANAR Module II : Environnement de développement Python 3 Année universitaire : 2018/2019
Les Conteneurs en python : lessé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 ontun 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, tupleetstrpermettent 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), sanspour 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]
>>> [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)]
Classe : 1ère Année MP, PC, PT Page 1
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
>>>s[3] = ’info’; t # remplace s[3] ; modification répercutée sur t
>>>del s[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’
>>>dels[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

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 *
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.
>>> 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 ens 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

Cours TP3

Transféré par

Droits d'auteur :

Formats disponibles

Cours TP3

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours TP3

Transféré par

Droits d'auteur :

Formats disponibles

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

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

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

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

4. Opérations de mutation de listes

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

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

6. Les chaînes de caractères

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

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

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

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

Vous aimerez peut-être aussi