Listes

définition d'une liste (les éléments peuvent être quelconques) :

myList = [] : liste vide.
on peut aussi faire myList = list().
myList = [2, 4, 6] : exemple de liste.
myList = ['ab', 2, 'cd', 5] une liste peut avoir des éléments de type hétérogènes.
myList = ['a', ['b', 'c'], 'd'] : liste contenant des listes.
myList = [2, 4, 5]; myList2 = [3 * x for x in myList] : liste calculée à partir d'un autre (donne ici [6, 12, 15]).
myList = [2, 4, 5]; myList3 = [3 * x for x in myList if x > 3] : idem, mais en prenant certains éléments seulement (donne [12, 15]).

Opérations sur les listes :

myList = ['a', 'b', 'c', 'd'].
myList[2] : donne 'c' (indices commencent à 0).
myList[-1] : dernier élément, ici 'd'.
myList[0:2] : sous liste commençant à l'indice 0 et terminant à l'indice précédent 2, donc ici ['a', 'b'].
myList[0:-2] : tous les éléments sauf les deux derniers, donc ici ['a', 'b'] (marche aussi si myList a moins de 2 éléments).
myList[0:4:2] : sous liste commençant à l'indice 0 et terminant à l'indice précédent 4, et par pas de 2, donc ici ['a', 'c'].
myList[-3:len(myList)] : les 3 derniers éléments, ici ['b', 'c', 'd'].
myList[1] = 'x' : affectation, donne ici ['a', 'x', 'c', 'd'].
myList[1:1] = ['x'] : insertion d'un élément à la position 1, donne ici ['a', 'x', 'b', 'c', 'd'].
myList[0:0] = ['x', 'y'] : insertion des éléments x et y en début de liste
attention : ne pas faire myList[1:1] = 'x', car sinon, cela insert la séquence 'x' à la position 1 :
- ici, cela revient au-même.
- mais si on fait myList[1:1] = 'xy', cela donne ['a', 'x', 'y', 'b', 'c', 'd'], peut-être pas ce que l'on veut faire ...
myList[0:2] = ['x', 'y'] : remplacement d'une sous-liste par une autre liste, donne ici ['x', 'y', 'c', 'd'].
myList[0:2] = ['x', 'y', 'z'] : on peut remplacer une sous-liste par une liste qui n'a pas la même taille, donne ici ['x', 'y', 'z', 'c', 'd'].
myList[0:2] = [] : délétion, donne ici ['c', 'd'].
del myList[2] : détruit l'élément d'indice 2, donne ici ['a', 'b', 'd'].
del myList[0:2] : détruit la slice de 0 à 2 - 1, donc ici ['c', 'd'].
del myList : détruit toute la liste.
len(myList) : longueur de la liste.
myList[::-1] : renvoie la liste renversée, donc ici ['d', 'c', 'b', 'a'].

Adressage d'une liste hors limites : si myList est la liste ['a', 'b', 'c', 'd'] :

myList[4] renvoie une erreur
par contre, myList[2:5] marche et renvoie ['c', 'd']
myList[4:5] renvoie une liste vide

Pour concaténer 2 listes : l1 + l2

Copie de liste :

l2 = l1 : l2 et l1 référencent la même liste.
l2 = l1[:] : l2 est une copie de la liste l1.
l2 = list(l1) : l2 est une copie de la liste l1.

Opérateur de répétition :

répétition d'une liste : ['a'] * 5 ou [None] * 100 par exemple.
dicts = [{}] * 3 : attention, ce n'est pas bon, c'est 3 fois la même réference au dictionnaire ! Pareil avec une liste.
dicts = [{} for i in range(3)] : c'est bon, c'est 3 réferences différentes !

Range :

range(3) : donne un itérateur sur la liste [0, 1, 2].
range(2, 7) : donne un itérateur sur la liste [2, 3, 4, 5, 6].
range(1, 7, 2) : range un itérateur de 1 à 7 exclus, mais par pas de 2 (sur la liste [1, 3, 5])
range(5, -1, -1) : range de 5 à -1 exclus, mais en décroissant (par pas de -1), donc donne un itérateur sur la liste [5, 4, 3, 2, 1, 0], très pratique pour boucler sur une liste dans l'ordre décroissant.
range(4, 4) : donne un itérateur sur la liste vide [].
range(6, 4) : donne un itérateur sur la liste vide [].

Fonctions sur les listes :

l.append(x) : ajoute un élément x.
l.extend(l2) : ajoute la liste l2 à la fin.
l.insert(i, x) : insert l'élément i à la position x, et décale le reste (comme l[i:i] = x).
l.remove(x) : enlève le premier élément identique à x (erreur si non trouvé).
l.pop() : enlève le dernier élément et le renvoie.
l.pop(0) : enlève le premier élément et le renvoie.
l.pop(i) : enlève l'élément à la position i et le renvoie.
l.index(x) : renvoie l'index du 1er élément identique à x (erreur si non trouvé).
l.count(x) : compte combien de fois l'élément x est dans la liste.
l.sort() : trie en place les éléments de la liste.
l.sort(key = lambda x: x[1]) : effectue le tri sur les valeurs calculées en appliquant la fonction donnée chaque élément (exemple de tri case-insensitif : l.sort(key = str.lower)). Pour faire du tri sur une clef multiple, on peut utiliser un tuple.
on peut aussi faire : sorted(l, key = lambda x: ...) (comme avec sort)
l.sort(reverse = True) : effectue le tri dans l'autre sens.
sorted(l) : renvoie la liste triée, mais sans affecter la liste de départ (sorted peut prendre les mêmes options key et reverse que sort()).
sorted(l, myOrder) : quand on veut utiliser une fonction de tri personnalisée (comme avec sort)
sort et sorted font des tris stables (ordre de clefs identiques est conservé).
l.reverse() : renverse la liste en place.
reversed(l) : renvoie un itérateur qui permet de boucler sur les éléments de la liste en sens inverse.

Pour tester si une chaîne est dans une liste : s = 'cd'; s in ['ab', 'cd', 'ef'] : donne True.

Listes de compréhension :

[x ** 2 for x in [1, 2, 3, 4]] : renvoie [1, 4, 9, 16] (liste de tous les carrés).
on peut rajouter une condition : [x ** 2 for x in [1, 2, 3, 4] if x != 2 and x != 3] : renvoie [1, 16].
on peut utiliser 2 boucles, la 2ème boucle étant interne : l1 = ['a', 'b']; l2 = [1, 2]; [(x1, x2) for x1 in l1 for x2 in l2] donne [('a', 1), ('a', 2), ('b', 1), ('b', 2)]. Les deux "for" sont dans le même ordre que si c'était 2 boucles imbriquées.
autre exemple : [(x,y) for x in ('a', 'b', 'c') for y in ('A', 'B')] donne [('a', 'A'), ('a', 'B'), ('b', 'A'), ('b', 'B'), ('c', 'A'), ('c', 'B')].
Trouver tous les index d'une liste ayant une certaine valeur : l = ['a', 'b', 'c', 'a']; [i for i in range(len(l)) if l[i] == 'a'] donne [0, 3]

Pour mettre à plat une liste de listes (i.e. les concaténer) :

par exemple, myList = [['a', 'b'], ['c'], [], ['d', 'e', 'f']]
1ère possibilité : sum(myList, []) : renvoie ['a', 'b', 'c', 'd', 'e', 'f']).
2ème possibilité : [item for sublist in myList for item in sublist] : renvoie aussi ['a', 'b', 'c', 'd', 'e', 'f']).
3ème possibilité : [x for subList in myList for x in subList]

On peut récupérer les valeurs d'un appel de fonction avec une liste de variables : [x, y, z] = s.split(','), mais il faut être sur d'avoir le bon nombre de valeurs retournées, sinon une exception levée !

min et max :

min(4, 2, 7) : renvoie 2
min([4, 2, 7]) : renvoie 2 (action sur une liste)

Attention, on ne peut pas mettre à jour les éléments d'une liste dans une boucle :

l = [1, 2, 3]
for x in l:
    x += 1

n'affecte pas la liste de départ.

si on veut modifier la liste de départ, il faut faire :

l = [1, 2, 3]
for in range(len(l)):
    l[i] += 1

On peut tester l'égalité de 2 listes l1 == l2 : deux listes sont égales ssi elles ont même nombre d'éléments et tous les éléments sont identiques.

Tri d'une liste selon l'ordre d'une autre liste :

on veut trier l2 selon l'ordre de tri de l1, avec l1 = ['a', 'd', 'e', 'b', 'c']; l2 = [1, 4, 5, 2, 3].
première solution : map(lambda x: x[1], sorted(zip(l1, l2), key = lambda x: x[0])) (donne [1, 2, 3, 4, 5]).
deuxième solution en utilisant une liste intermédiaire qui donne l'ordre (utile si plusieurs listes à ranger toujours dans le même ordre) : listOrder = sorted(range(len(l1)), key = lambda x: l1[x]); [l2[x] for x in listOrder] (donne aussi [1, 2, 3, 4, 5] et listOrder vaut [0, 3, 4, 1, 2]).

iter(myList) : convertit une liste en itérateur

next(iter(myList), 'a') : renvoie la première valeur de la liste, et si elle est vide, renvoie 'a'.

programmer en python, tutoriel python, graphes en python, Aymeric Duclert