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
Dernière révisionLes deux révisions suivantes
python:bases:tuples [2022/01/31 19:23] – [3. Accès aux éléments] philpython:bases:tuples [2022/08/09 15:37] – [8. tuple unpacking] 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 29: Ligne 29:
 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è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.
  
-<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.txt
  • Dernière modification : 2022/08/29 18:52
  • de phil