Chapire 1 - Partie 3
Cette partie est consacrée aux tuples tuple
1. Les variables séquentielles (suite)¶
1.1. Les chaînes str (voir partie 1)
1.2. Les listes (voir partie 2)
1.3. Les tuples¶
-
- 1.1. Les chaînes str (voir partie 1)
- 1.2. Les listes (voir partie 2)
- 1.3. Les tuples
-
- 2.1. Création d'un tuple
- 2.2. Opérations sur les tuples
- 2.2.1. Indices et comptage d'éléments
- 2.2.2. Concaténation et réplication
- 2.2.3. Fonctions de conversion
- 2.2.4. Affectation multiple d'un tuple
- 2.3. Tuple de combinaison zip
2. Le tuple¶
Tout comme une liste un tuple est une collection de données ordonnée mais immuable.
Ordonné : Chaque élément possède un index, il accessible via l'opérateur
[].L'ordre des éléments ne change pas une fois le tuple créé.
Immuable : Une fois le tuple créé, on ne peut pas modifier, ajouter ou supprimer ses éléments.
Il est donc impossible d'en changer la taille ou le contenu.Hétérogène : Comme la liste, le tuple peut contenir des éléments de différents types (nombres, chaînes de caractères, listes, d'autres tuples, etc.).
Permet les doublons : Un tuple peut contenir plusieurs fois le même élément.
Par rapport à la liste, le tuple est utile pour:
- la certitude que son contenu ne changera pas au cours du temps;
- le mécanisme d'appel de fonction
- pour des raisons d'efficacité, car en travaillant avec un nombre constant d'éléments, l'interpréteur est en mesure de faire certaines optimisations.
2.1. Création d'un tuple¶
Pour créer un tuple, on utilise les parenthèses () à l'intérieur desquelles on insère des éléments séparés avec des virgules. t = (elem1, elem2,...)
Les virgules sont très importantes, elles permettent de distinguer le tuple d'une expression mathématique entourée de parenthèses. Même si le tuple contient un seul et unique élément, il faut une virgule.
On crée un tuple vide avec une paire de parenthèses sans aucun élément dedans.
t = () # un tuple vide
a = (2.71,) # un tuple avec un seul élément (il faut la virgule)
b = (2.71) # une expression qui donne un float
c = (5, 7) # tuple de deux éléments:
# la virgule avant la parenthèse fermante est optionnelle
print(f"{t = } \t {type(t) = }")
print(f'{a = } \t {type(a) = }')
print(f'{b = } \t {type(b) = }')
print(f'{c = } \t {type(c) = }')
t = () type(t) = <class 'tuple'> a = (2.71,) type(a) = <class 'tuple'> b = 2.71 type(b) = <class 'float'> c = (5, 7) type(c) = <class 'tuple'>
Voici un tuple complexe avec accès à ses éléments.
a = (1, 'a', 'abc', [7,3], (2, 5)) # tuple complexe
print(f'{a[0] = } \t {type(a[0]) = }')
print(f'{a[2] = } \t {type(a[2]) = }')
print(f'{a[3] = } \t {type(a[3]) = }')
print(f'{a[4] = } \t {type(a[4]) = }')
print(f'{a[3][0] = } \t {type(a[3][0]) = }') # accès aux éléments de la liste [7,3]
print(f'{a[4][1] = } \t {type(a[4][1]) = }') # accès aux éléments du tuple (2,5)
a[0] = 1 type(a[0]) = <class 'int'> a[2] = 'abc' type(a[2]) = <class 'str'> a[3] = [7, 3] type(a[3]) = <class 'list'> a[4] = (2, 5) type(a[4]) = <class 'tuple'> a[3][0] = 7 type(a[3][0]) = <class 'int'> a[4][1] = 5 type(a[4][1]) = <class 'int'>
2.2. Opérations sur les tuples¶
2.2.1. Indices et comptage d'éléments¶
L'accès aux éléments, leurs indices et leur comptage sont les mêmes opérations que dans les liste. On montre juste quelques exemple, se référer à la section 1.2.2.1 du fichier traitant les listes
tpl = (1,'a',8, 'h', 6, 'h')
print("Position de 'h' :", tpl.index('h'))
print("'h' est un élément de tpl :", 'h' in tpl)
print("nombre de 'h' dans tpl :", tpl.count("h"))
Position de 'h' : 3 'h' est un élément de tpl : True nombre de 'h' dans tpl : 2
2.2.2. Concaténation et réplication¶
Dans ce cas aussi les opérateurs + et * s'appliquent sur les tuples de la même manière qu'ils s'appliquent sur les listes et sur les chaînes de caractères.
print((1, 2, 3) + (4, 5, 6))
print((1, 2, 3) * 3)
(1, 2, 3, 4, 5, 6) (1, 2, 3, 1, 2, 3, 1, 2, 3)
2.2.3. Fonctions de conversion¶
On peut facilement convertir un tuple en liste, ou une liste en tuple grace au transtypage en utilisant
list et tuple.
Le transtypage de tuple en liste est particulièrement utile lorsqu'on est amenés à modifier un tuple. Par définition du tuple, on ne peut pas trier ses éléments ni en supprimer ou en ajouter comme on peut le faire avec les listes, car le tuple est immuable.
Concernant le tri, on peut toujours appliquer la fonction sorted qui renvoie par contre une liste et non pas un
t = ('cc', 'bb', 'aa', 'dd')
l = sorted(t) # ça renvoie une liste ordonnée
s = tuple(sorted(t)) # si on veut un tuple, on doit transtyper
print(t, type(t))
print(l, type(l))
print(s, type(s))
('cc', 'bb', 'aa', 'dd') <class 'tuple'>
['aa', 'bb', 'cc', 'dd'] <class 'list'>
('aa', 'bb', 'cc', 'dd') <class 'tuple'>
2.2.4. Affectation multiple d'un tuple¶
L’affectation multiple d'un tuple est une forme d’affectation parallèle où les éléments d’un tuple (ou d’une séquence) sont déballés et affectés à plusieurs variables en une seule instruction.
Voici deux exemples :
# Exemple 1: cas de déballage de coordonnées
coords = (2.4, 1.5, 3.2) # coordonnées d'un point en tuple
x, y, z = coords # affectation à 3 variables de position
print(f'{x = } , {y = } , {z = }')
x = 2.4 , y = 1.5 , z = 3.2
# Exemple 2 : valeurs et vecteurs propres
# Souvent les résultats de calcul de valeurs et vecteurs propres se présentent
# sous forme de tuple contenant un float (valeur propre) et une liste (vecteur propre)
val, vect = (1.2, [2/7, 3/7, 6/7])
print(f'{val = } , {vect = }')
val = 1.2 , vect = [0.2857142857142857, 0.42857142857142855, 0.8571428571428571]
Remarque 1 :
Il est possible d'affecter certains éléments d'un tuple à quelques variables et d'affecter le reste à une seule autre variable.
Cette variable qui prend le reste, sera précédée de l'opérateur étoile et elle est dite variable étoilée, et elle sera de type list.
Voici quelques affectations possibles :
t = (1,2,3,4,5)
a, b, *c = t
print(f'{a = } \t\t {b = }\t\t {c = }')
*a, b, c = t
print(f'{a = }\t {b = }\t\t {c = }')
a, *b, c = t
print(f'{a = }\t\t {b = }\t {c = }')
a = 1 b = 2 c = [3, 4, 5] a = [1, 2, 3] b = 4 c = 5 a = 1 b = [2, 3, 4] c = 5
Remarque 2 :
L'affectation multiple avec variable étoilée ou sans, s'applique aussi pour les listes
l = [1,2,3,4,5]
a, b, *c = l
print(f'{a = }, {b = }, {c = }')
a = 1, b = 2, c = [3, 4, 5]
2.3. Tuple de combinaison zip¶
En Python, la fonction zip() retourne un objet de type zip, qui est un itérateur de tuples. Cet itérateur combine les éléments des itérables passés en entrée, génère des tuples en associant leurs éléments par position.
z = zip(iterable1,iterable2, ...)
Les variables iterables peuvent être de type tuple, liste ou str.
Le résultat z de zip et de type <class 'zip'>, c'est un itérateur, donc il ne stocke pas tous les tuples en mémoire mais les génère à la demande (lazy evaluation).
Pour voir ou manipuler le résultat de zip, on doit convertir l'objet zip en une liste (list(z)), un tuple (tuple(z)), un dictionnaire (dict()), ou bien l'utiliser dans une boucle.
L'objet zip est épuisé après une itération ou une conversion (par exemple, après list(z), il devient vide).
Pour le réutiliser, on stocke le résultat converti (par exemple, liste = list(zip(...))).
# Exemple de génération d'un tuple de tuples par zip
a = 'UDTQ' # chaîne str
b = ('un', 'deux', 'trois', 'quatre') # tuple de str
c = (1,2,3,4) # tuple d'entiers
z = zip(a,b,c) # combinaison zip
print(z)
print('utilisation 1 :', tuple(z)) # affichage sous forme de tuple de tuples
print('utilisation 2 :', tuple(z)) # le 2eme print montre que z a été vidé par la 1ere utilisation
<zip object at 0x000001C36CD1E140>
utilisation 1 : (('U', 'un', 1), ('D', 'deux', 2), ('T', 'trois', 3), ('Q', 'quatre', 4))
utilisation 2 : ()
# On reprend l'exemple précédent avec des listes
#a = ['U', 'D', 'T', 'Q']
a = 'UDTQ'
b = ['un','deux', 'trois', 'quatre']
c = [1, 2, 3, 4]
z = zip(a,b,c)
print(z,type(z))
lz = list(z)
print(lz) # on obtient une liste de tuples
<zip object at 0x000002520F467900> <class 'zip'>
[('U', 'un', 1), ('D', 'deux', 2), ('T', 'trois', 3), ('Q', 'quatre', 4)]
Aucun commentaire:
Enregistrer un commentaire