python:bases:listes [WebGEPEM]

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
[[python:bases:tuples|{{ :suivant.png?nolink&30|Tuples}}]] 
[[:python:bases:chaines|{{ :retour.png?nolink&30|Chaînes de caractères}}]] 
[[:python:accueilpython|{{ :iconemaison.jpg?nolink&30|Sommaire Python et microPython}}]]

===== Python - Listes =====

[Mise à jour le : 29/2/2024]

  * **Source**
    * **Documentation** sur Python.org : <html><html><a href="https://docs.python.org/fr/3.6/reference/index.html" target="_blank">référence du langage</a>, <a href="https://docs.python.org/fr/3.6/library/stdtypes.html#sequence-types-list-tuple-range" target="_blank">types séquentiels list, tuple, range</a>, <a href="https://docs.python.org/fr/3/tutorial/datastructures.html" target="_blank">compléments sur les listes</a>, <a href="https://docs.python.org/fr/3.5/library/functions.html" target="_blank">fonctions natives</a></html> (built-in)

  * ** Mots-clés** : mutable, tableau, méthode, parcours de liste, compréhension de liste

<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      |
|  as         |  def        |  **for**  |  lambda        |  return     |
|  assert     |  **del**    |  from     |  __None__      |  __True__   |
|  __async__  |  elif       |  global   |  __nonlocal__  |  try        |
|  __await__  |  else       |  **if**   |  **not**       |  **while**  |
|  break      |  except     |  import   |  or            |  with       |
|  class      |  __False__  |  **in**   |  pass          |  yield      |

  * <html><a href="https://docs.python.org/fr/3.5/library/functions.html" target="_blank">Fonctions natives</a></html>** (built-in)**((Fonctions toujours disponibles.)) utilisées dans les exemples : **len**(), **list**(), **print**().

----

==== 1. Introduction ====
Les tableaux de Python diffèrent des tableaux que l'on trouve dans les autres langages de programmations par plusieurs aspects : \\
- ils sont appelés //**listes**// dans la documentation de Python; \\
- ils peuvent être **agrandis** ou **rétrécis** du côté des indices les plus grands avec //append// et //pop//; \\
- accéder à un tableau Python avec un **indice négatif** ne provoque pas nécessairement une erreur. Par exemple t[-1] permet d'accéder au dernier élément du tableau t, t[-2] à l'avant dernier, etc. Pour un tableau de taille //n//, seul un indice en dehors de l'intervalle **[-n, n-1]** provoquera une **erreur**.

Une liste est une **séquence d'objets hétérogènes** : entiers, réels, caractères, chaînes, etc.  Elle stocke des **références** vers les objets. La **taille** de l'objet liste est **indépendante** du type d'objets référencés.  

<callout type="warning" icon="true">La liste est un **objet mutable** (modifiable **__ou__** il est stocké). Elle stocke des **__références__** vers les objets. En général on utilise le terme « **tableau** » lorsque les éléments sont tous de même type.</callout>

//Exemples//
<code python *.py>
# Deux variables pointent vers le même objet (aliasing)
t1 = ['a', 'b', 'c']
t2 = t1 # Python ne crée pas un autre tableau mais une référence (pointeur) vers t1
</code>
{{ :python:bases:pointeur3.png?nolink&300 |}}

<code python *.py>
# on modifie l'objet avec la référence t1
t1 += ['d', 'e', 'f'] # les deux variables pointent toujours vers le même objet
</code>
{{ :python:bases:pointeur4.png?nolink&400 |}}

==== 2. Construction ====
{{ :python:bases:pointeura.png?nolink&250|}}
<code python *.py>
# Liste vide
t = list() # On crée une liste vide
t = []     # Autre méthode pour créer une liste vide (à privilégier)

# Liste non vide
t = [1, 2, 3, 4, 5]                   # Construction en extension d'une liste contenant cinq entiers et
ma_liste = [1, 3.5, "une chaine", []] # autre exemple avec une liste dans une liste

# Grande liste
t = [0]*1000 # Création d'une liste de 1000 cases initialisées à 0
</code>  

{{ :python:bases:pointeurb.png?nolink& |}}

<callout type="warning" icon="true">Les **crochets [ ]** délimitent les **listes**.</callout>

==== 3. Accès et modification des éléments ====
//Exemple//
<code python *.py>
t = ['c', 'f', 'm']
t[0]                # On accède au premier élément de la liste, ici 'c'
t[2]                # Troisième élément, ici 'm'
t[1] = 'Z'          # On remplace 'f' par 'Z', t renvoie ['c', 'Z', 'm']
</code>

==== 4. Ajout d'éléments ====
On dispose de plusieurs méthodes dans la classe **list** (append, extend, insert, etc).

  * **Ajout d'un élément à la fin d'une liste, ou d'une liste à la fin d'une autre liste**
<callout type="primary" icon="true">On utilise la méthode **append**().</callout>

//Exemple//
<code python *.py>
# Ajout d'un élément
impaire = [1,3,5,7]
t4 = impaire.append(9)
print(impaire)      # Résultat : [1, 3, 5, 7, 9]
print t4            # Résultat : aucun, la liste impaire est modifiée où elle se trouve, append ne renvoie rien !

# Ajout d'une liste
t1 = [1,3,5,7]
t2 = [9,11,13]
t3 = t1.extend(t2)
print(t1)           # Résultat : [1, 3, 5, 7, 9, 11, 13]
print(t3)           # Résultat : aucun, la liste impaire est modifiée où elle se trouve, extend ne renvoie rien !
</code>

  * **Ajout d'un élément __dans__ la liste**
<callout type="primary" icon="true">On utilise la méthode **insert**(//position//,//valeur//) ou une opération de slice **liste[**//début//://fin//**]** avec début = fin.</callout>

//Exemple//
{{ :python:bases:pointeure.png?nolink&350|}}
<code python *.py>
impaire = [1,3,5,7,9,13]
impaire.insert(5,11)      # la valeur 11 est placée à la cinquième position de la liste (début=0!)
print(impaire)            # Résultat : [1, 3, 5, 7, 9, 11, 13]

# Opération de slice
impaire = [1,3,5,7,9,13]
impaire[5:5]=[11]         # Résultat : [1, 3, 5, 7, 9, 11, 13]
</code>

  * **Concaténation de listes**
<callout type="warning" icon="true">On utilise **+** pour assembler (concaténer) des listes. A la différence de append et extend qui modifient la liste sur laquelle elle travaillent, **+ crée un nouvel objet**.</callout>

//Exemple//
{{ :python:bases:pointeurd.png?nolink&300|}}
<code python *.py>
t1 = [1,2,3]
t2 = [4,5,6]
t3 = t1 + t2
print(t3)             

# Résultat : [1,2,3,4,5,6]
</code>
==== 5. Suppression d'éléments ====
<callout type="primary" icon="true">On utilise le mot-clé **del** ou la méthode **remove**.</callout>

//Exemples//

<code python *.py>
# mot-clé del
# Prend en argument la position de l'élément à supprimer
liste3 = [1, 2, 3, 4, 5, 6]
del(liste3[2])
print(liste3) # Résultat : [1, 2, 4, 5, 6]

# Méthode remove
# Prend en argument la valeur de l'élément à supprimer
t3 = [1, 2, 3, 4, 5, 6]
t3.remove(2) 
print(t3) # Résultat : [1, 3, 4, 5, 6]

# Slicing (développé au §7)
t3 = [1, 2, 3, 4, 5, 6]
t3[2:4]=[]
print(t3) # Résultat : [1, 2, 5, 6]
</code>

<callout type="warning" icon="true">La méthode **remove** retire uniquement le premier élément trouvé dans une liste.</callout>


==== 6. Parcours des listes ====

  * Utilisation de la boucle **while ...**

<code python *.py>
# Exemple avec while
adresse =['Lycée', 'Pierre-Emile','Martin','1 Avenue de Gionne', '18000', 'Bourges']
i=0
while i<len(adresse):
    print(adresse[i]+" ", end='') # end='' supprime le retour à la ligne après chaque mot
    i+=1
    
# Résultat
Lycée Pierre-Emile Martin 1 Avenue de Gionne 18000 Bourges
</code>

  * Utilisation de la boucle  **for ...**

<code python *.py>
adresse =['Lycée', 'Pierre-Emile','Martin','1 Avenue de Gionne', '18000', 'Bourges']

# solution 1. Utilisation d'un indice 
for i in range(len(adresse)): # renvoit : Lycée Pierre-Emile Martin 1 Avenue de Gionne 18000 Bourges
    elemt = adresse[i]+' '
    print(elemt,end='')
    
# solution 2. Itération directe sur les éléments de la liste (plus simple !)
for elemt in adresse: # elemt va prendre les valeurs successives des éléments de ma_liste
    print(elemt+" ", end='')
</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>

  * Utilisation de **enumerate**
<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>
adresse =['Lycée', 'Pierre-Emile','Martin','1 Avenue de Gionne', '18000', 'Bourges']
for element in enumerate(adresse):
    print(element) 

# 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):
    print(val,"est à la position",i)

# Résultat
# Lycée est à la position 0
# Pierre-Emile est à la position 1 etc.
</code>
{{ :python:bases:pointeurc.png?nolink& |}}
==== 7. Affectation sur les slices ====
<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
{{ :python:bases:pointeurf.png?nolink&400|}}
<code python *.py>
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
                         # Les éléments aux positions 4 et 5 sont supprimés
                         # 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]
</code>

// Exemple //: effacement d'objets
{{ :python:bases:pointeurg.png?nolink&400|}}
<code python *.py>
l=[0,1,2,3,10,11,7,8,9]  # Création d'une liste
l[4:6]=[]                # Les éléments aux positions 4 et 5 sont supprimés
                         # et non remplacés
                         # Résultat : [0,1,2,3,7,8,9]
</code>

==== 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. \\ \\
//Organisation// \\
//liste// = **[**//operation sur la variable// **for** //variable// **in** //liste// **if** //condition//**]**</callout>

//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>
prenom = ['aliCe', 'eVe', 'sonia', 'Bob']
chiffres = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# On passe tous les prénoms en minuscule (la liste prenom est modifiée)
prenom = [p.lower() for p in prenom]             # Résultat ['alice', 'eve','sonia','bob']

# On extrait et on affiche les chiffres pairs (une liste est crée à partir du contenu d'une autre)
pair = [x for x in chiffres if x % 2 is 0]
print(pair)                                      # Résultat : [2, 4, 6, 8]

# On extrait et on affiche les chiffres impairs (une liste est crée à partir du contenu d'une autre)
impair = [y for y in chiffres if y not in pair]
print(impair)                                    # Résultat : [1, 3, 5, 7, 9]

# Cas particulier : liste contenant de i à j exclus
[x for x in range(i,j)]
# ou
# La fonction prédéfinie list transforme l'ensemble des éléments en un tableau
list(range(i,j))
</code>

==== 9. Liste de listes (tableaux à plusieurs dimensions) ====
Les listes peuvent contenir des listes.

  * **Construction en extension**
{{ :python:bases:tableau2dim.png?nolink|}}
<code python *.py>
t = [[1,0,0,0,0],[1,1,0,0,0],[1,2,1,0,0]]
</code>
{{ :python:bases:pointeuri.png?nolink&400 |}}

  * **Construction par compréhension**
<code python *.py>
# Tableau 3 x 5
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>

  * **Parcours d'un tableau à plusieurs dimensions**
<code python *.py>
# Exemple : somme des éléments d'un tableau 3 x 5
t = [[1,0,0,0,0],[1,1,0,0,0],[1,2,1,0,0]]
# Solution 1 # Définition des intervalles
s=0

for i in range(3):
    for j in range(5):
        s+=t[i][j]
print(s)              # donne 7

# solution 2 # Itération directe sur les éléments de la liste (plus simple !)
s=0
for ligne in t:
    for colonne in ligne:
        s+=colonne
print(s)              # donne 7
</code>
==== 10. Transformations ====
  * ** Transformation d'une chaîne en liste **
On utilise la méthode de chaîne **split**.

<code python *.py>
texte = "Le manuel de Python"
print(texte.split()) # Résultat : ['Le', 'manuel', 'de', 'Python']
                     # Le séparateur est passé en paramètre à split. Par défaut, il s'agit de la virgule.
</code>

  * ** Transformation d'une liste en chaîne **
On utilise la méthode de list **join**.

<code python *.py>
liste = ['Le', 'manuel', 'de', 'Python']
texte = " ".join(liste) # les guillemets contiennent le séparateur (si rien, le séparateur est la virgule)
print(texte)            # Résultat : Le manuel de Python
</code>

  * **Transformation d'une liste en paramètre de fonction**
Si on dispose d'un tuple ou d'une liste contenant des paramètres, on peut les transformer en paramètre avant de les passer à une fonction.

//Exemple//
<code python *.py>
impair = [1,3,5,7,9]
# On imprime la liste
print(impair)                                         # Résultat : [1, 3, 5, 7, 9]
# On imprime les paramètres contenus dans la liste !
print(*impair)                                        # Résultat : 1 3 5 7 9
</code>
==== 11. Méthodes et fonctions de la classe list ====
  * **Source** : <html><a href="https://www.w3schools.com/python/python_ref_list.asp" target="_blank">w3school.com</a></html> 

=== 11.1 Méthodes ===
^  Méthodes   ^  Paramètres      ^  Effet                                                              ^  Structure                           ^
|**append**   |//elem//          |Ajoute un élément //elem// à la fin de la liste.                     |//lst//.**append**(//elem//)          |
|**clear**    |                  |Supprime tous les éléments de la liste.                              |//lst//.**clear**()                   |
|**copy**     |                  |Renvoie une copie de la liste.                                       |//lst//.**copy**()                    |
|**count**    |//elem//          |Renvoie le nombre d'éléments avec la valeur spécifiée.               |//lst//.**count**(//elem//)           |
|**extend**   |//iterable//      |Ajoute une liste à une autre.                                        |//lst//.**extend**(//iterable//)      |
|**index**    |//elem//          |Renvoie la position de la première occurence de la valeur spécifiée  |//lst//.**index**(//elem//)           |
|**insert**   |//pos//, //elem// |Ajoute un élément //elem// à la position //pos//.                    |//lst//.**insert**(//pos//,//elem//)  |
|**pop**      |//pos//           |Supprime l'élément à la position spécifiée.                          |//lst//.**pop**(//pos//)              |
|**remove**   |//elem//          |supprime le premier élément //elem// trouvé dans la liste            |//lst//.**remove**(//elem//)          |
|**reverse**  |                  |Inverse l'ordre dans la liste.                                       |//lst//.**reverse**()                 |
|**sort**     |reverse, //func// |Trie les éléments d'une liste dans l'ordre croissant ou décroissant. |//lst//.**sort**(reverse=True/False, key=myFunc) |

=== 11.2 Fonctions applicables aux listes ===
^  Fonctions   ^  Paramètres       ^  Effet                                                              ^  Structure                                   ^
|**len**      |//liste//           |Renvoie le nombre d'éléments de la liste                               |**len**(//liste//)                          | 
|**max (min)**|//liste//           |Renvoie le plus grand (petit) élément de la liste                      |**max**(//liste//)                          |
|**comp**     |//pos//             |Compare les éléments de deux listes. Retourne 0 si elles sont égales, -1 si la première est < à la seconde, 1 sinon | | 
|**sorted**   |//liste//           |Renvoie une copie triée de la liste.                                   |**sorted**(//liste//)
|**+**        |//liste X liste//   |Renvoie une concaténation des deux listes                              |//liste3// = //liste1// **+** //liste2//    |
|** * **      |//liste X entier//  |Renvoie une liste formée de N fois la liste paramètres                 |//liste2// = //liste1// ***** //n//         |

//Exemples//

<code python exliste1.py>
une_liste = ["Journal", 9, 2.714, "pi"]
print(une_liste) # Résultat : ['Journal', 9, 2.714, 'pi']
len(une_liste) # Résultat 4  
une_liste.append("fin") # Résultat : ['Journal', 9, 2.714, 'pi', 'fin']
del(une_liste[2]) # Résultat : ['Journal', 9, 'pi', 'fin']
</code>



----

==== Résumé ====
  * Une liste est une séquence **mutable** (modifiable après sa création) pouvant contenir plusieurs objets.
  * Une liste se construit avec la syntaxe //nomliste// = **[**//élément<sub>1</sub>//**,** //élément<sub>2</sub>//**,** //élément<sub>N</sub>//].
  * On peut insérer des éléments dans une liste à l'aide des méthodes **append**, **insert** et **extends**.
  * 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.
  * 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éé.

----

{{ :python:bases:realpython.png?nolink|}}
==== Quiz ====
  * <html><a href="https://realpython.com/quizzes/python-lists-tuples/" target="_blank">Python List and Tuples Quiz</a></html>

----

{{ :python:bases:realpython.png?nolink|}}
==== Pour aller plus loin ... ====
  * <html><a href="https://realpython.com/python-append/" target="_blank">Python's .append(): Add Items to Your Lists in Place</a></html>
  * <html><a href="https://realpython.com/python-reverse-list/" target="_blank">Reverse Python Lists: Beyond .reverse() and reversed()</a></html>
  * <html><a href="https://realpython.com/python-filter-function/#the-square-of-even-numbers-filter-and-map" target="_blank">Python's filter(): Extract Values From Iterables</a></html>
  * <html><a href="https://realpython.com/inherit-python-list/" target="_blank">Custom Python Lists: Inheriting From list vs UserList</a></html>
  * <html><a href=" https://realpython.com/len-python-function/#:~:text=The%20function%20len()%20is,with%20many%20different%20data%20types" target="_blank">Using the len() Function in Python</a></html>