Programmation Python/Listes
Déclaration.
Les listes sont des séquences, des collections ordonnées d'objets séparés par des virgules. On les déclare avec l'opérateur d'indiçage ([]) :
» maListe = ['a','b','c']
» maListe
['a','b','c']
Lecture.
Comme les caractères dans une chaîne, les objets placés dans une liste sont rendus accessibles par l'intermédiaire d'un "index" (un nombre qui indique l'emplacement de l'objet dans la séquence, à partir de zéro). De plus, le "slicing" (« découpage en tranches ») permet aussi de dégager une sous-liste en précisant deux index correspondant aux bornes de la plage.
Une sortie indicée donne :
» maListe[0]
'a'
» maListe[-1]
'c'
Une séquence donne par slicing :
» maListe[0:2]
['a','b']
» maListe[1:]
['b','c']
Types.
Les éléments qui constituent une liste peuvent être de types variés :
»> jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]
»> print(jour)
['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]
Dans cet exemple, en effet, les premiers éléments sont des chaînes de caractères, puis il y a un entier et un réel. À cet égard, le concept de liste est donc différent des tableaux ("array") que l'on rencontre les langages de programmation de , où tous les éléments doivent être du même type.
Recherche.
Vous pouvez aisément déterminer si un élément fait partie d'une liste à l'aide de l'instruction codice_1 :
 print("a" in ["a", "b", "c"]) # True
 print(not "a" in ["a", "b", "c"]) # False
Si l'emplacement de l'élément importe dans la liste :
 print ["a", "b", "c"].index("a") == 0 # True
 print ["a", "b", "c"].index("z") # ValueError
Modification.
Affectation.
À la différence de ce qui se passe pour les chaînes, qui constituent un type de données non-modifiables, il est possible de changer les éléments individuels d'une liste :
»> jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]
»> jour[5] = jour[5] + 1016
»> print(jour)
['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 1492, 3.142]
Les exemples ci-dessus devraient attirer votre attention sur le fait qu'une "tranche" découpée dans une liste est toujours elle-même une liste (même s'il s'agit d'une tranche qui ne contient qu'un seul élément), alors qu'un élément isolé peut contenir n'importe quel type de donnée.
Exemple en deux dimensions :
»> jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', ['samedi matin', 'samedi après-midi', 'samedi soir'], 'dimanche']
»> jour[5][0] = "samedi midi"
»> jour
»> jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', ['samedi midi', 'samedi après-midi', 'samedi soir'], 'dimanche']
Ainsi, dans l'exemple ci-dessus on remplace le premier élément d'une liste (n° 0), qui est elle-même l'élément n° 5 d'une autre liste.
Opérations.
On peut appliquer aux listes les opérateurs + (concaténation) et * (multiplication) :
»> fruits = ['orange','citron']
»> legumes = ['poireau','oignon','tomate']
»> fruits + legumes
['orange', 'citron', 'poireau', 'oignon', 'tomate']
»> fruits * 3
['orange', 'citron', 'orange', 'citron', 'orange', 'citron']
L'opérateur * est particulièrement utile pour créer une liste de "n" éléments identiques :
»> sept_zeros = [0]*7
»> sept_zeros
[0, 0, 0, 0, 0, 0, 0]
Techniques de slicing avancées pour modifier une liste.
Insertion.
Insertion d'un ou plusieurs éléments n'importe où dans une liste :
»> mots = ['jambon', 'fromage', 'confiture', 'chocolat']
»> mots[2:2] = ["miel"]
»> mots
['jambon', 'fromage', 'miel', 'confiture', 'chocolat']
»> mots[5:5] = ['saucisson', 'ketchup']
»> mots
['jambon', 'fromage', 'miel', 'confiture', 'chocolat', 'saucisson', 'ketchup']
Pour utiliser cette technique, vous devez prendre en compte les particularités suivantes :
Suppression.
Suppression / remplacement d'éléments :
»> mots[2:5] = [] # [] désigne une liste vide
»> mots
['jambon','fromage','saucisson', 'ketchup']
»> mots[1:3] = ['salade']
»> mots
['jambon', 'salade', 'ketchup']
»> mots[1:] = ['mayonnaise', 'poulet', 'tomate']
»> mots
['jambon', 'mayonnaise', 'poulet', 'tomate']
Différence.
Pour obtenir la différence entre deux listes :
a = ['jambon','fromage','saucisson', 'ketchup']
b = ['jambon', 'mayonnaise', 'poulet', 'tomate']
print([item for item in a if item not in b])
Intersection.
Pour l'intersection entre deux listes (en préservant l'ordre des éléments y compris leurs doublons), on applique la différence de la différence :
a = ['jambon','fromage','saucisson', 'ketchup']
b = ['jambon', 'mayonnaise', 'poulet', 'tomate']
dif = [item for item in a if item not in b]
print [item for item in a if item not in dif]
Copie.
Considérons que vous disposez d'une liste fable que vous souhaitez recopier dans une nouvelle variable que vous appellerez phrase. La première idée qui vous viendra à l'esprit sera certainement d'écrire une simple affectation telle que :
»> phrase = fable
En procédant ainsi, sachez que vous ne créez pas une véritable copie. À la suite de cette instruction, il n'existe toujours qu'une seule liste dans la mémoire de l'ordinateur. Ce que vous avez créé est seulement "une nouvelle référence vers cette liste". Essayez par exemple :
»> fable = ['Je','plie','mais','ne','romps','point']
»> phrase = fable
»> fable[4] ='casse'
»> phrase
['Je', 'plie', 'mais', 'ne', 'casse', 'point']
Si la variable phrase contenait une véritable copie de la liste, cette copie serait indépendante de l'original et ne devrait donc pas pouvoir être modifiée par une instruction telle que celle de la troisième ligne, qui s'applique à la variable codice_6. Vous pouvez encore expérimenter d'autres modifications, soit au contenu de codice_6, soit au contenu de phrase. Dans tous les cas, vous constaterez que les modifications de l'une sont répercutées dans l'autre, et vice-versa.
En fait, les noms codice_6 et codice_9 désignent tous deux un seul et même objet en mémoire. Pour décrire cette situation, les informaticiens diront que le nom phrase est un "alias" du nom codice_6.
Nous verrons plus tard l'utilité des "alias". Pour l'instant, nous voudrions disposer d'une technique pour effectuer une véritable copie d'une liste. Avec les notions vues précédemment, vous devriez pouvoir en trouver une par vous-même. 
Cette fonctionnalité vous permet d'améliorer la lisibilité de vos programmes. Exemple :
couleurs = ['noir', 'brun', 'rouge',
 'orange', 'jaune', 'vert',
 'bleu', 'violet', 'gris', 'blanc']
Méthodes.
Sous Python, les listes sont des objets à part entière, et vous pouvez donc leur appliquer un certain nombre de "méthodes" particulièrement efficaces, après l'opérateur "." :
»> nombres = [17, 38, 10, 25, 72]
»> nombres.sort() # trier la liste
»> nombres
[10, 17, 25, 38, 72]
»> nombres.append(12) # ajouter un élément à la fin
»> nombres
[10, 17, 25, 38, 72, 12]
»> nombres.reverse() # inverser l'ordre des éléments
»> nombres
[12, 72, 38, 25, 17, 10]
»> nombres.index(17) # retrouver l'index d'un élément
4
»> nombres.remove(38) # enlever (effacer) un élément
»> nombres
[12, 72, 25, 17, 10]
"append".
codice_11 (ajouter) : l'exemple suivant qui fait appel à la méthode "append" de l'objet "liste" (déclarée vide) illustre ce concept.
Il s'agit de remplir la hotte du Père Noël.
 #!/usr/bin/python
 # -*- coding: iso8859-1 -*-
 # on prépare une liste encore vide
 cadeaux = []
 # on va ajouter des éléments à la liste
 unCadeau = ""
 # la suite des éléments à introduire dans la liste est définie par l'utilisateur
 # lorsqu'il a terminé, l'utilisateur indique le mot "fin" qui ne sera pas introduit dans la liste
 while unCadeau <> "fin":
 unCadeau = raw_input ("Père Noël, je voudrais que tu m'apportes ")
 # si l'utilisateur n'a pas frappé "fin", le mot est ajouté à la liste
 if unCadeau <> "fin":
 cadeaux.append(unCadeau)
 # finalement, on écrit la suite des éléments introduits dans la liste
 for chaqueCadeau in cadeaux:
 print chaqueCadeau
"split".
codice_12 : convertit une chaîne en une liste de sous-chaînes. On peut choisir le caractère séparateur en le fournissant comme argument, sinon c'est un espace, par défaut.
»> chaine ="Votez pour moi"
»> tableau = chaine.split()
»> print tableau
['Votez', 'pour', 'moi']
»> chaine = "Cet exemple, parmi d'autres, peut encore servir"
»> chaine.split(",")
['Cet exemple', " parmi d'autres", ' peut encore servir']
"join".
codice_13 : rassemble une liste de chaînes en une seule (Cette méthode fait donc l'inverse de la précédente). Attention : la chaîne à laquelle on applique cette méthode est celle qui servira de séparateur (un ou plusieurs caractères) ; l'argument transmis est la liste des chaînes à rassembler.
»> tableau = ["Salut", "les", "copains"]
»> print " ".join(tableau)
Salut les copains
»> print "___".join(tableau)
Salut___les___copains
"pop".
codice_14 retire et renvoie l'élément de la liste d'index "i". Si "i" est vide, il traite le dernier élément.
»> list = [1, 2, 3, 4]
»> print(list.pop(0))
1
»> list
[2, 3, 4]
»> print(list.pop())
4
»>list
[2, 3]
Fonctions.
"len".
La "fonction intégrée" codice_15, que nous avons déjà rencontrée à propos des chaînes, s'applique aussi aux listes. Elle renvoie le nombre d'éléments présents dans la liste :
»> len(jour)
7
Supposons par exemple que vous voulez créer une liste codice_16 qui contienne le même nombre d'éléments qu'une autre liste codice_17. Vous pouvez obtenir ce résultat de différentes manières, mais l'une des plus simples consistera à effectuer : codice_18.
"del".
Une autre "fonction intégrée" permet de supprimer d'une liste un élément ou plusieurs éléments quelconques à partir de leurs index. Il s'agit de la fonction codice_19 :
»> jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]
»> del(jour[5:7])
»> print(jour)
['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi']
»> del(jour[0])
»> print(jour)
['mardi', 'mercredi', 'jeudi', 'vendredi']
"min" et "max".
»> jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi']
»> min(jour)
'jeudi'
»> max(jour)
'vendredi'
"range".
Si vous devez manipuler des séquences de nombres, vous pouvez les créer très aisément à l'aide de cette fonction :
Sous python 3.6:
print(list(range(10)))
La fonction codice_22 génère une liste de nombres entiers de valeurs croissantes. Si vous appelez codice_22 avec un seul argument, la liste contiendra un nombre de valeurs égal à l'argument fourni, mais en commençant à partir de zéro ("c'est-à-dire que codice_24 génère les nombres de 0 à n-1").
Notez bien que l'argument fourni n'est jamais dans la liste générée.
On peut aussi utiliser codice_22 avec deux, ou même trois arguments séparés par des virgules, afin de générer des séquences de nombres plus spécifiques :
Si vous avez du mal à assimiler l'exemple ci-dessus, considérez que codice_22 attend toujours trois arguments, que l'on pourrait intituler codice_27, codice_28 et codice_29. codice_27 est la première valeur à générer, codice_28 est la dernière (ou plutôt la dernière + un), et codice_29 le « pas » à sauter pour passer d'une valeur à la suivante. S'ils ne sont pas fournis, les paramètres codice_27 et codice_29 prennent leurs valeurs par défaut, qui sont respectivement 0 et 1.
Parcours d'une liste à l'aide de for, range() et len().
L'instruction codice_35 est l'instruction idéale pour parcourir une liste :
Il est très pratique de combiner les fonctions codice_22 et codice_15 pour obtenir automatiquement tous les indices d'une séquence (liste ou chaîne). Exemple :
fable = ['Maître','Corbeau','sur','un','arbre','perché']
for index in range(len(fable)):
 print index, fable[index]
Mais il existe également une syntaxe adaptée à cela :
for (cle, valeur) in enumerate(fable):
 print(cle, valeur)
L'exécution de ce script donne le résultat :
Tableau à trois lignes :
monTableau = range(1, 5)
monTableau[1] = u'ligne 1'
monTableau[2] = u'ligne 2'
monTableau[3] = u'ligne 3'
for ligne in range(1, 4):
 print(monTableau[ligne])
Tableau à deux dimensions :
ligne = 3
colonne = 2
monTableau = # ! l'élément inséré doit être une liste
 c, d = c+2, d+1
</pre>
</li>
<li>Réfléchissez !</li>
<li>Réfléchissez !</li>
<li>Réfléchissez !</li>
<li>
<syntaxhighlight lang=python>
lst = [1]*1000 
for i in range(2,1000):
 # Mettre à zéro les éléments suivants dans la liste,
 # dont les indices sont des multiples de i :
 for j in range(i*2, 1000, i):
 lst[j] = 0
for i in range(1,1000):
 if lst[i]:
 print i,
</li>
</ol>