python:bases:tuples

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
Prochaine révision		 Révision précédente
python:bases:tuples [2022/01/31 19:09] – [7. Fonction renvoyant un tuple] philpython:bases:tuples [2025/06/19 19:29] (Version actuelle) – modification externe 127.0.0.1
Ligne 12: Ligne 12:
   * ** Mots-clés** : immuable, unpacking, tuple   * ** Mots-clés** : immuable, unpacking, tuple
  
-<note important>Les mots ci-dessous sont dits "réservés". Ils ne peuvent pas être utilisés comme nom de variable. Les mots __soulignés__ sont une nouveauté de Python 3. Les mots en **gras** sont utilisés dans cette page.</note>+<callout type="warning" icon="true">Les mots ci-dessous sont dits "réservés". Ils ne peuvent pas être utilisés comme nom de variable. Les mots __soulignés__ sont une nouveauté de Python 3. Les mots en **gras** sont utilisés dans cette page.</callout>
  
 |  and        |  continue   |  finally  |    is          |  raise      | |  and        |  continue   |  finally  |    is          |  raise      |
Ligne 27: Ligne 27:
  
 ==== 1. Introduction ==== ==== 1. Introduction ====
-Le tuple est une séquence. Comme la liste, il référence des objets hétérogène. On peut lui appliquer le test d'appartenance avec **in**, accéder aux différents éléments avec un crochet, faire du slicing etc. La raison d'être principale du type tuple est de construire des objets globalement immuables.+Le tuple est une séquence. Comme la liste, il référence des objets hétérogènes. On peut lui appliquer le test d'appartenance avec **in**, accéder aux différents éléments avec un crochet, faire du slicing etc. La raison d'être principale du type tuple est de construire des objets globalement immuables.
  
-<note Important>Un **tuple**, ou **P-uplet** est une liste de **constantes**. Il est **immuable** donc non modifiable. Les **parenthèses (  )** délimitent les **tuples**.</note>+<callout type="warning" icon="true">Un **tuple**, ou **P-uplet** est une liste de **constantes**. Il est **immuable** donc non modifiable. Les **parenthèses (  )** délimitent les **tuples**.</callout>
  
 ==== 2. Création ==== ==== 2. Création ====
Ligne 36: Ligne 36:
 <code python *.py> <code python *.py>
 # Affectation simple # Affectation simple
-tp =  "a","b",4 # Création d'un tuple à 3 éléments  +>>> tp =  "a","b",4 # Création d'un tuple à 3 éléments  
-tp = () # Création d'un tuple vide (peu d'intérêt) +>>> tp = () # Création d'un tuple vide (peu d'intérêt) 
-tp = 6, # un élément nécessite une virgule+>>> tp = 6, # un seul élément nécessite une virgule !!!
  
 # Les parenthèses sont obligatoires dès que l'écriture d'un tuple est contenu dans une expression plus longue. # Les parenthèses sont obligatoires dès que l'écriture d'un tuple est contenu dans une expression plus longue.
-tp = 3,(1,True,4.5,8, "a") # différent types+>>> tp = 3,(1,True,4.5,8, "a") # différent types 
 +>>> tp # renvoie (3, (1, True, 4.5, 8, 'a'))
  
 # Tuple contenant des tuples # Tuple contenant des tuples
-t2d = (1,"a"), # équivalent à (1,"a"),(2,"b") +>>> t2d = (1,"a"), (2,"b") # équivalent à (1,"a"), 
-      (2,"b")+                           #              (2,"b")
  
-# Affectation  multiple  +# Affectation  multiple = tuple unpacking 
-a,b,c = 1,2,3 # a=1, b=2, c=3+>>> a,b,c = 1,2,3 # a=1, b=2, c=3
 </code> </code>
  
-<note important>Un tuple avec **un seul élément** nécessite une **virgule**.</note>+<callout type="warning" icon="true">Un tuple avec **un seul élément** nécessite une **virgule**.</callout>
  
 ==== 3. Accès aux éléments ==== ==== 3. Accès aux éléments ====
Ligne 59: Ligne 60:
 # Accès à une valeur en lecture # Accès à une valeur en lecture
 tp = "a",2,8,7,"b" tp = "a",2,8,7,"b"
-len(tp) # renvoie 5 +>>> tp # renvoie ('a', 2, 8, 7, 'b') 
-tp[2] # renvoie 8+>>> len(tp) # renvoie 5 
 +>>> tp[2] # renvoie 8
 # i peut être négatif ! # i peut être négatif !
-tp[-1] # renvoie "b" +>>> tp[-1] # renvoie "b" car on parcourt le tuple en partant de la fin
 </code> </code>
  
-====4. Construction====+==== 4. Construction ==== 
 +  * **Issue d'une concatenation avec +**
  
-  * **Concatenation avec +** +<callout type="primary" icon="true">Bien que le type tuple soit immuable, il est tout à fait légal d'"additionner" deux tuples, et l'"addition" va produire un **nouveau** tuple.</callout>
- +
-<note>Bien que le type tuple soit immuable, il est tout à fait légal d'"additionner" deux tuples, et l'"addition" va produire un **nouveau** tuple</note>+
  
 //Exemple// //Exemple//
 <code python *.py> <code python *.py>
-tuple1 = (1, 2,) +>>> tuple1 = (1, 2,) 
-tuple2 = (3, 4,) +>>> tuple2 = (3, 4,) 
-print('Resultat:', tuple1 + tuple2) # Résultat: (1, 2, 3, 4)+>>> print('Resultat:', tuple1 + tuple2) # Résultat: (1, 2, 3, 4)
 </code> </code>
  
-  * ** Concaténation avec * **+  * ** Issue d'une concaténation avec * **
 //Exemple// //Exemple//
 <code python *.py> <code python *.py>
-tuple3 = 3*tuple1 # (1,2,1,2,1,2)+>>> tuple3 = 3*tuple1 # Renvoie (1,2,1,2,1,2)
 </code> </code>
  
-  * **A partir d'une liste**+  * **Issue d'une liste**
 //Exemple// //Exemple//
 <code python *.py> <code python *.py>
-liste = list(range(10)) # résultat[0,1,2,3,4,5,6,7,8,9] +>>> liste = list(range(10)) # résultat[0,1,2,3,4,5,6,7,8,9] 
-liste[9] = 'Inconnu' # résultat[0,1,2,3,4,5,6,7,8,'Inconnu'] +>>> liste[9] = 'Inconnu' # résultat[0,1,2,3,4,5,6,7,8,'Inconnu'] 
-del liste [2:5] # résultat : [0, 1, 5, 6, 7, 8, 'Inconnu'] +>>> del liste [2:5] # résultat : [0, 1, 5, 6, 7, 8, 'Inconnu'] 
-mon_tuple = tuple(liste) # résultat : (0, 1, 5, 6, 7, 8, 'Inconnu')+>>> mon_tuple = tuple(liste) # résultat : (0, 1, 5, 6, 7, 8, 'Inconnu')
 </code> </code>
  
Ligne 98: Ligne 98:
  
 <code python *.py> <code python *.py>
-t = "a","b","c" +>>> t = "a","b","c" 
-"c" in  t # renvoie True +>>> "c" in  t # renvoie True 
-"d" in  t # renvoie False+>>> "d" in  t # renvoie False
 </code> </code>
  
 ====6. Modification !==== ====6. Modification !====
-<note warning>Comme l'objet est immuable, la modification est impossible. Il faut transformer le tuple en liste et créer un nouveau tuple à partir de la liste modifiée.</note>+<callout type="warning" icon="true">Comme l'objet est immuable, la modification est impossible. Il faut transformer le tuple en liste et créer un nouveau tuple à partir de la liste modifiée.</callout>
  
 //Exemple// //Exemple//
  
 <code python *.py> <code python *.py>
 +>>> tp = "a",2,8,7,"b" 
 +>>> tp # renvoie ('a', 2, 8, 7, 'b') 
 +>>> tp[2] = 3 # Renvoie une erreur car un tuple est immuable 
 +              # Traceback (most recent call last): 
 +              #       File "<stdin>", line 1, in <module> 
 +              #  TypeError: 'tuple' object does not support item assignment 
 +>>> lst = list(tp) 
 +>>> lst # renvoie la liste ['a', 2, 8, 7, 'b'] 
 +>>> lst[2] = 3 # modification de la liste 
 +>>> tp = tuple(lst) # conversion en un tuple 
 +>>> tp # renvoie le tuple ('a', 2, 3, 7, 'b')
 </code> </code>
  
 ====7. Fonction renvoyant un tuple ==== ====7. Fonction renvoyant un tuple ====
-Les affectations multiples s'utilisent souvent dans les fonctions renvoyant un tuple.+Les affectations multiples (§2) s'utilisent souvent dans les fonctions renvoyant un tuple.
  
 //Exemple// : calcul des longueurs des trois côtés d'un triangle. //Exemple// : calcul des longueurs des trois côtés d'un triangle.
Ligne 138: Ligne 148:
 ====8. tuple unpacking ==== ====8. tuple unpacking ====
  
-<note tip>L'affectation dans Python peut concerner plusieurs variables à la fois.</note> +<callout type="tip" icon="true">L'affectation dans Python peut concerner plusieurs variables à la fois.</callout> 
  
 //Exemple 1// //Exemple 1//
Ligne 158: Ligne 168:
 </code> </code>
  
-<note warning>Les seules contraintes fixées par Python sont que : \\+<callout icon="fa fa-hand-stop-o" color="red" title="STOP">Les seules contraintes fixées par Python sont que : \\
 - le terme à droite du signe = soit un itérable (tuple, liste, string, etc.) ; \\ - le terme à droite du signe = soit un itérable (tuple, liste, string, etc.) ; \\
 - le terme à gauche soit écrit comme un tuple ou une liste - notons tout de même que l'utilisation d'une liste à gauche est rare et peu pythonique ; \\ - le terme à gauche soit écrit comme un tuple ou une liste - notons tout de même que l'utilisation d'une liste à gauche est rare et peu pythonique ; \\
-- les deux termes aient la même longueur - en tout cas avec les concepts que l'on a vus jusqu'ici, mais voir aussi plus bas l'utilisation de *arg avec le extended unpacking.</note>+- les deux termes aient la même longueur - en tout cas avec les concepts que l'on a vus jusqu'ici, mais voir aussi plus bas l'utilisation de *arg avec le extended unpacking.</callout>
  
 //Exemple 3// //Exemple 3//
  
-<note tip> Il est possible de faire une boucle for qui itère sur une seule liste mais qui agit sur **plusieurs variables**.</note>+<callout type="tip" icon="true">Il est possible de faire une boucle for qui itère sur une seule liste mais qui agit sur **plusieurs variables**.</callout>
  
 <code python *.py> <code python *.py>
Ligne 180: Ligne 190:
 ====9. Extended unpacking==== ====9. Extended unpacking====
  
-<note>Le mécanisme ici est une extension de sequence unpacking ; Python vous autorise à mentionner une seule fois, parmi les variables qui apparaissent à gauche de l'affectation, une variable précédée de *.</note>+<callout type="primary" icon="true">Le mécanisme ici est une extension de sequence unpacking ; Python vous autorise à mentionner une seule fois, parmi les variables qui apparaissent à gauche de l'affectation, une variable précédée de *.</callout>
  
 //Exemple 1// //Exemple 1//
Ligne 205: Ligne 215:
 </code> </code>
  
-<note conseil>On peut utiliser plusieurs fois la même variable dans la partie gauche de l'affectation.</note>+<callout type="info" icon="true">On peut utiliser plusieurs fois la même variable dans la partie gauche de l'affectation.</callout>
  
 Cette technique n'est utilisée en pratique que pour les parties de la structure dont on n'a que faire dans le contexte. Dans ces cas-là, il arrive qu'on utilise le nom de variable _. Cette technique n'est utilisée en pratique que pour les parties de la structure dont on n'a que faire dans le contexte. Dans ces cas-là, il arrive qu'on utilise le nom de variable _.
  • python/bases/tuples.1643652546.txt.gz
  • Dernière modification : 2025/06/19 19:25
  • (modification externe)