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:23] – [3. Accès aux éléments] philpython:bases:tuples [2022/08/29 18:52] (Version actuelle) – [1. Introduction] phil
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 66: Ligne 67:
 </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 = "a",2,8,7,"b"
 >>> tp # renvoie ('a', 2, 8, 7, 'b') >>> tp # renvoie ('a', 2, 8, 7, 'b')
 >>> tp[2] = 3 # Renvoie une erreur car un tuple est immuable >>> tp[2] = 3 # Renvoie une erreur car un tuple est immuable
Ligne 115: Ligne 115:
               #       File "<stdin>", line 1, in <module>               #       File "<stdin>", line 1, in <module>
               #  TypeError: 'tuple' object does not support item assignment               #  TypeError: 'tuple' object does not support item assignment
-lst = list(tp)+>>> lst = list(tp)
 >>> lst # renvoie la liste ['a', 2, 8, 7, 'b'] >>> lst # renvoie la liste ['a', 2, 8, 7, 'b']
-lst[2] = 3 # modification de la liste +>>> lst[2] = 3 # modification de la liste 
-tp = tuple(lst) # conversion en un tuple+>>> tp = tuple(lst) # conversion en un tuple
 >>> tp # renvoie le tuple ('a', 2, 3, 7, 'b') >>> tp # renvoie le tuple ('a', 2, 3, 7, 'b')
 </code> </code>
Ligne 148: 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 168: 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 190: 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 215: 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.1643653380.txt.gz
  • Dernière modification : 2022/01/31 19:23
  • de phil