Types composés en python
Types composés : Listes, chaînes de caractères, Tuples, dictionnaires, ensembles
1. Les tuples
Un tuple est une collection d’objets séparés par une virgule, et délimitées par des parenthèses.
▪ Exemple
• T=tuple() # Création d’un tuple vide
• Tup=(3,) # Création d’un tuple avec un seul élément
• Tupl=(3,5,8)
▪ Remarques
-- Les parenthèses aux extrémités sont facultatives (l’important, ce sont les virgules) mais
recommandées pour la lisibilité.
>>> a=123,'abcd ',4.56,True
>>> b=(123,'abcd ',4.56,True)
>>> print(a==b)
True
-- Pour former un tuple à un seul élément, il faut faire suivre cet élément d’une virgule.
► Accès à un élément
Les éléments d’un tuple sont indexés comme les éléments d’une liste et on peut sélectionner une partie d’un tuple
avec la même syntaxe que celle utilisée pour les listes.
▪ Exemple
>>> t = (1, 2.2)
Pour obtenir la première composante du couple, on pourra alors évaluer :
>>> t[0]
1
>>> t[1]
2.2
► Affectations multiples
Les tuples en Python permettent d’effectuer des affectations multiples.
>>> a,b,c=1,2,3
On peut donc s’en servir pour échanger les valeurs de deux variables d’un coup (sans introduire
de variable auxiliaire) :
a=2
b=3
print('Avant :',a,b)
a , b = b , a
print('Après :',a,b)
Avant : 2 3
Après : 3 2
MPSI-PCSI 1/3
Attention : Valeurs immuables (nom modifiables)
Les tuples sont immuables. Cela signifie qu’il n’est pas possible d’affecter de nouvelles valeurs aux composantes.
Ainsi l’instruction suivante produit une erreur :
>>> t[0] = 2
TypeError: 'tuple' object does not support item assignment
► Test d’appartenance
Il est possible de tester si une valeur appartient à un tuple à l’aide de l’opérateur in :
>>> 3 in (1,2,3)
True
► Terminons par quelques opérations possibles sur les tuples :
>>> (1,2,3) + (4,5) # concatenation de deux tuples
(1, 2, 3, 4, 5)
>>> (1,2) + 3
TypeError: can only concatenate tuple (not "int") to tuple
L’expression correcte est :
>>> (1,2) + (3,)
(1,2,3)
>>> (0,)*5 # le ‘tuple’ (0) répété 5 fois
(0, 0, 0, 0, 0)
2. Dictionnaires
Les types composés que nous avons abordés jusqu'à présent (chaînes, listes et tuples) étaient tous des séquences,
c'est-à-dire des suites ordonnées d'éléments. Dans une séquence, il est facile d'accéder à un élément quelconque à
l'aide d'un index.
Les dictionnaires ressemblent aux listes dans une certaine mesure (ils sont modifiables comme elles), mais
ce ne sont pas des séquences (non ordonnées). Nous pourrons accéder à n'importe lequel d'entre eux à
l'aide d'un index spécifique que l'on appellera une clé, laquelle pourra être alphabétique, numérique,…etc.
▪ Exemple
>>> dico = {} # Un dictionnaire vide
>>> dico['computer'] = 'ordinateur'
>>> dico['mouse'] ='souris'
>>> dico['keyboard'] ='clavier'
>>> print dico
{'computer': 'ordinateur', 'keyboard': 'clavier', 'mouse': 'souris'}
► Parcourir un dictionnaire
def afficheDic(d) :
for e in d:
print (e,'\t', d[e])
MPSI-PCSI 2/3
>>> afficheDic(dico)
keyboard clavier
mouse souris
computer ordinateur
► Longueur d’un dictionnaire
>>> len(dico)
3
► Manipulation des dictionnaires (méthodes)
Python inclut des méthodes de manipulation des dictionnaires :
► Test d’appartenance
>>> 'mouse' in dico
True
>>> 'mouse' in [Link]()
True
>>> 'souris' in dico
False
>>> 'souris' in [Link]()
True
MPSI-PCSI 3/3
