python:bases:listes

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:listes [2024/02/28 19:05] – [2. Construction] philpython:bases:listes [2024/02/29 08:42] (Version actuelle) – [9. Liste de listes (tableaux à plusieurs dimensions)] phil
Ligne 5: Ligne 5:
 ===== Python - Listes ===== ===== Python - Listes =====
  
-[Mise à jour le : 28/2/2024]+[Mise à jour le : 29/2/2024]
  
   * **Source**   * **Source**
Ligne 38: Ligne 38:
 //Exemples// //Exemples//
 <code python *.py> <code python *.py>
-# Deux variables pointent vers le même objet+# Deux variables pointent vers le même objet (aliasing)
 t1 = ['a', 'b', 'c'] t1 = ['a', 'b', 'c']
 t2 = t1 # Python ne crée pas un autre tableau mais une référence (pointeur) vers t1 t2 = t1 # Python ne crée pas un autre tableau mais une référence (pointeur) vers t1
Ligne 65: Ligne 65:
 </code>   </code>  
  
-{{ :python:bases:pointeurb.png?nolink&|}}+{{ :python:bases:pointeurb.png?nolink& |}}
  
 <callout type="warning" icon="true">Les **crochets [ ]** délimitent les **listes**.</callout> <callout type="warning" icon="true">Les **crochets [ ]** délimitent les **listes**.</callout>
Ligne 104: Ligne 104:
  
 //Exemple// //Exemple//
 +{{ :python:bases:pointeure.png?nolink&350|}}
 <code python *.py> <code python *.py>
 impaire = [1,3,5,7,9,13] impaire = [1,3,5,7,9,13]
Ligne 118: Ligne 119:
  
 //Exemple// //Exemple//
 +{{ :python:bases:pointeurd.png?nolink&300|}}
 <code python *.py> <code python *.py>
 t1 = [1,2,3] t1 = [1,2,3]
 t2 = [4,5,6] t2 = [4,5,6]
 t3 = t1 + t2 t3 = t1 + t2
-print(t3)             # Résultat : [1,2,3,4,5,6]+print(t3)              
 + 
 +# Résultat : [1,2,3,4,5,6]
 </code> </code>
 ==== 5. Suppression d'éléments ==== ==== 5. Suppression d'éléments ====
Ligne 182: Ligne 186:
 </code> </code>
  
-<callout type="warning" icon="true">L'itération directe sur les éléments est plus simple à lire et à écrire mais n'est applicable que lorsqu'il n'est pas nécessaire de connaître l'indice.</callout>+<callout type="warning" icon="true">L'**itération directe** sur les éléments est **plus simple** à lire et à écrire mais n'est applicable que lorsqu'il n'est pas nécessaire de connaître l'indice.</callout>
  
   * Utilisation de **enumerate**   * Utilisation de **enumerate**
-<callout type="primary" icon="true">**enumerate** renvoie des **tuples** constitués de la **position d'un élément** dans la liste et de **sa valeur**.</callout>+<callout type="primary" icon="true">La fonction native **enumerate()** permet de parcourir un itérable tout en gardant un compte des itérations. enumerate() renvoie des **tuples** constitués de la **position d'un élément** dans la liste et de **sa valeur**. </callout> 
 + 
 +  * __Syntaxe__ 
 +    * enumerate(iterable) 
 +    * enumerate(iterable, start=0)
  
 <code python *.py> <code python *.py>
 adresse =['Lycée', 'Pierre-Emile','Martin','1 Avenue de Gionne', '18000', 'Bourges'] adresse =['Lycée', 'Pierre-Emile','Martin','1 Avenue de Gionne', '18000', 'Bourges']
 for element in enumerate(adresse): for element in enumerate(adresse):
-    print(element) # Resultat : (0, 'Lycée') +    print(element) 
-                                (1, 'Pierre-Emile') etc.+
  
-# pour récupérer la position indépendamment de la valeur, on utilise deux variables+# Résultat  (figure ci-dessous) 
 +(0, 'Lycée') 
 +(1, 'Pierre-Emile') etc. 
 + 
 +# Pour récupérer la position indépendamment de la valeur, on utilise deux variables
 for i, val in enumerate(adresse): for i, val in enumerate(adresse):
     print(val,"est à la position",i)     print(val,"est à la position",i)
 +
 # Résultat # Résultat
 # Lycée est à la position 0 # Lycée est à la position 0
 # Pierre-Emile est à la position 1 etc. # Pierre-Emile est à la position 1 etc.
 </code> </code>
 +{{ :python:bases:pointeurc.png?nolink& |}}
 ==== 7. Affectation sur les slices ==== ==== 7. Affectation sur les slices ====
-<callout type="primary" icon="true">L'affectation sur un slice permet de **remplacer** ou **d'effacer** des éléments dans une liste.</callout>+<callout type="primary" icon="true">L'affectation sur un [[python:bases:chaines|slice]] permet de **remplacer** ou **d'effacer** des éléments dans une liste.</callout>
  
 // Exemple //: remplacement d'objets // Exemple //: remplacement d'objets
 +{{ :python:bases:pointeurf.png?nolink&400|}}
 <code python *.py> <code python *.py>
 l=[0,1,2,3,10,11,7,8,9]  # Création d'une liste l=[0,1,2,3,10,11,7,8,9]  # Création d'une liste
 l[4:6]=[4,5,6]           # Affectaion sur le slice l[4:6]=[4,5,6]           # Affectaion sur le slice
-                         # Les éléments 3 et 4 sont supprimés +                         # Les éléments aux positions 4 et 5 sont supprimés 
-                         # puis remplacés par 4,5,6 +                         # puis remplacés par les valeurs 4,5,6 (4,5 remplacent 10,11.  
 +                         # 6 est ajouté avant 7. 7,8,9 sont décalés)
                          # Résultat : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]                          # Résultat : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 </code> </code>
  
 // Exemple //: effacement d'objets // Exemple //: effacement d'objets
 +{{ :python:bases:pointeurg.png?nolink&400|}}
 <code python *.py> <code python *.py>
 l=[0,1,2,3,10,11,7,8,9]  # Création d'une liste l=[0,1,2,3,10,11,7,8,9]  # Création d'une liste
-l[4:6]=[]                # Les éléments 3 et 4 sont supprimés +l[4:6]=[]                # Les éléments aux positions 4 et 5 sont supprimés 
-                         # mais non remplacés+                         # et non remplacés
                          # Résultat : [0,1,2,3,7,8,9]                          # Résultat : [0,1,2,3,7,8,9]
 </code> </code>
Ligne 223: Ligne 238:
 ==== 8. Compréhensions de liste ==== ==== 8. Compréhensions de liste ====
  
-<callout type="warning" icon="true">Les compréhensions de liste facilitent la **rédaction d'un code très propre** qui se lit presque comme un langage naturel. \\ //liste// = **[**//operation sur la variable// **for** //variable// **in** //liste// **if** //condition//**]**</callout>+<callout type="warning" icon="true">Les compréhensions de liste facilitent la **rédaction d'un code très propre** qui se lit presque comme un langage naturel. \\ \\ 
 +//Organisation// \\ 
 +//liste// = **[**//operation sur la variable// **for** //variable// **in** //liste// **if** //condition//**]**</callout>
  
-//Exemples//+//Exemple de création d'une liste par compréhension// 
 + 
 +<code python *.py> 
 +# Forme habituelle 
 +t = [0]*100 
 +for i in range(100): 
 +    t[i] = 3*i+1 
 +     
 +# Notation par compréhension 
 +t = [3*i+1 for i in range 100] 
 +</code>
  
 +//Exemples de traitement de listes par compréhension//
 +{{ :python:bases:pointeurh.png?nolink&400|}}
 <code python *.py> <code python *.py>
 prenom = ['aliCe', 'eVe', 'sonia', 'Bob'] prenom = ['aliCe', 'eVe', 'sonia', 'Bob']
Ligne 245: Ligne 274:
 [x for x in range(i,j)] [x for x in range(i,j)]
 # ou # ou
 +# La fonction prédéfinie list transforme l'ensemble des éléments en un tableau
 list(range(i,j)) list(range(i,j))
 </code> </code>
Ligne 256: Ligne 286:
 t = [[1,0,0,0,0],[1,1,0,0,0],[1,2,1,0,0]] t = [[1,0,0,0,0],[1,1,0,0,0],[1,2,1,0,0]]
 </code> </code>
- +{{ :python:bases:pointeuri.png?nolink&400 |}}
-{{ :python:bases:tableau2dimb.png?nolink&200|}} +
-  * **Accès à un élément** +
-<code python *.py> +
-a = t[2][1] # renvoi 2 +
-</code>+
  
   * **Construction par compréhension**   * **Construction par compréhension**
Ligne 267: Ligne 292:
 # Tableau 3 x 5 # Tableau 3 x 5
 t = [[0]*5 for i in range(3)] t = [[0]*5 for i in range(3)]
 +</code>
 +
 +{{ :python:bases:pointeurj.png?nolink&400|}}
 +<callout title="Erreur" icon="fa fa-hand-stop-o" color="red">Il pourrait être tentant d'écrire t = <nowiki>[[0] * 3]</nowiki> mais cela **ne donne pas** le résultat ci-dessus mais celui ci-contre.</callout>
 +
 +  * **Accès à un élément**
 +<code python *.py>
 +a = t[2][1] # renvoi 2
 </code> </code>
  
Ligne 364: Ligne 397:
   * On peut supprimer des éléments d'une liste avec le mot-clé **del**, la méthode **remove** ou une opération de slice.   * On peut supprimer des éléments d'une liste avec le mot-clé **del**, la méthode **remove** ou une opération de slice.
   * On peut créer des fonctions attendant un nombre inconnu de paramètres en plaçant une ** * ** devant le nom du paramètre.   * On peut créer des fonctions attendant un nombre inconnu de paramètres en plaçant une ** * ** devant le nom du paramètre.
-  * Les compréhensions de liste permettent de parcourir et filtrer une séquence en en renvoyant une nouvelle avec la syntaxe \\ //nouvelle_seq//= [//elem// **for** //elem// **in** //ancienne_seq// **if** //condition//].+  * Les compréhensions de liste permettent de parcourir et filtrer une séquence en renvoyant une nouvelle avec la syntaxe \\ //nouvelle_seq//= [//elem// **for** //elem// **in** //ancienne_seq// **if** //condition//].
   * Un tuple est une séquence pouvant contenir des objets. À la différence de la liste, le tuple ne peut pas être modifié une fois créé.   * Un tuple est une séquence pouvant contenir des objets. À la différence de la liste, le tuple ne peut pas être modifié une fois créé.
  
  • python/bases/listes.1709143554.txt.gz
  • Dernière modification : 2024/02/28 19:05
  • de phil