Génération de listes

7.1 Multiplication

Python a une syntaxe pratique qui te permet d'augmenter le nombre d'éléments. Pour cela, on utilise le simple opérateur de multiplication.

Génération de chaînes

Tu peux l'appliquer aux chaînes :

print("Maman" * 5)  # affiche MamanMamanMamanMamanMaman
        

Ou, par exemple, afficher rapidement une ligne de séparation :

print("-" * 40)  # affiche ----------------------------------------
        

Génération de listes

Tu peux aussi augmenter le nombre d'éléments dans une liste :

print(["apple"] * 5)  # affiche ['apple', 'apple', 'apple', 'apple', 'apple']
        

Cet opérateur a une application plus pratique. Par exemple, tu veux créer une liste de 10 éléments, remplie de zéros :

alist = [0] * 10
print(alist)  # affiche [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] 
        

Tu peux même faire un tableau à deux dimensions. Par exemple, tu veux créer un tableau 20x10, rempli de zéros. C'est tout aussi simple :

alist = [[0] * 10] * 20 
print(alist)  # affiche [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ...]
        

Pratique, hein ?

7.2 List Comprehension

En Python, il y a un outil pratique appelé « List Comprehension » — c'est une méthode pratique et compacte pour créer des listes. Cet outil syntaxique te permet de générer de nouvelles listes en appliquant une expression à chaque élément d'un objet itérable dans une seule ligne de code concise.

C'est plus facile à montrer qu'à décrire. Cet outil syntaxique ressemble à ça :

[expression for variable in séquence]

Où :

• variable — l'identifiant d'une certaine variable,
• séquence — la séquence de valeurs prises par cette variable (ça peut être une liste, une chaîne ou un objet obtenu avec la fonction range),
• expression — une certaine expression, généralement dépendante de la variable utilisée dans le générateur, qui remplira les éléments de la liste.

Important ! Toute l'expression doit être entre crochets.

Voici quelques exemples d'utilisation des générateurs :

Créer une liste de n zéros avec un générateur :

alist = [0 for i in range(100)]
        

Créer une liste remplie de carrés de nombres entiers :

n = 5
alist = [i ** 2 for i in range(n)]            
        

Créer une liste remplie de nombres entiers de 1 à n :

n = 10
alist = [i + 1 for i in range(n)]
        

Et voilà comment obtenir une liste remplie de nombres aléatoires de 1 à 9 (en utilisant la fonction randrange() du module random) :

from random import randrange

n = 10
alist = [randrange(1, 10) for i in range(n)]
        

7.3 Boucle dans List Comprehension

List Comprehension peut être utilisé non seulement pour générer des listes. En principe, c'est juste une façon compacte d'écrire une boucle for.

Par exemple, tu peux l'utiliser pour simplement afficher certaines valeurs de la liste à l'écran :

alist = ["apple", "banana", "cherry"]
[print(x) for x in alist]
        

Ou même, tu peux entrer les valeurs depuis le clavier :

a = [input() for i in range(int(input()))]
        

Dans cet exemple, la liste sera composée de chaînes lues depuis l'entrée standard : tu dois d'abord entrer le nombre d'éléments de la liste (cette valeur sera utilisée comme argument de la fonction range), puis entrer le nombre de chaînes spécifié.

Dans la forme que tu connais, ce code ressemble à ça :

n = int(input())
a = []
for i in range(n):
    x = input()  
    a.append(x)
        

En fait, les possibilités avec List Comprehension sont nombreuses :

Tu peux utiliser des conditions :

Inclure des conditions dans l'expression permet de filtrer les éléments, par exemple, tu peux créer une liste seulement avec des nombres pairs :

[x for x in range(10) if x % 2 == 0]
        

Les boucles imbriquées :

Le générateur te permet d'utiliser des boucles imbriquées, par exemple, pour créer des tableaux multidimensionnels :

[(x, y) for x in range(3) for y in range(3)]