HOWTO · Python

Appliquer une fonction à une liste en Python

Il existe 4 méthodes principales pour appliquer une fonction à une liste en Python : la boucle for, la fonction map(), la compréhension de liste et l'expression génératrice.

Sur cette page

Pour appliquer une fonction à chaque élément d’une liste Python, appelez-la pour chaque élément et rassemblez les valeurs renvoyées. Par exemple, multiplier chaque nombre par 10 transforme [1, 2, 3, 4] en [10, 20, 30, 40]. Vous pouvez utiliser une boucle for, map(), une compréhension de liste ou une expression génératrice. Les exemples ci-dessous utilisent la même fonction et la même liste d’entrée afin de comparer la façon dont chaque approche produit ou fournit les résultats.

Utiliser la boucle for pour appliquer une fonction à une liste en Python

Une boucle for rend chaque étape explicite : créer une liste de résultats, appeler la fonction pour chaque valeur d’entrée et ajouter chaque valeur renvoyée. Cette approche est utile lorsque la boucle doit comporter des instructions supplémentaires ou des conditions. L’exemple suivant applique la fonction à chaque nombre et affiche la liste obtenue.

def multiply_by_ten(number):
    return 10 * number


numbers = [1, 2, 3, 4]
results = []

for number in numbers:
    results.append(multiply_by_ten(number))

print(results)

La boucle laisse numbers inchangée et construit results dans une liste distincte. Modifiez le corps de la fonction pour effectuer la transformation adaptée à vos données.

Utiliser la fonction map() pour appliquer une fonction à une liste en Python

La fonction map() de Python prend une fonction appelable et un itérable, puis fournit le résultat de la fonction pour chaque élément. En Python 3, map() renvoie un itérateur ; enveloppez-le dans list() si le reste de votre code a besoin d’une liste.

def multiply_by_ten(number):
    return 10 * number


numbers = [1, 2, 3, 4]
results = list(map(multiply_by_ten, numbers))
print(results)

Cette forme est concise lorsque vous disposez déjà d’une fonction à appliquer. L’itérateur est consommé au fur et à mesure que list() en demande les valeurs ; si vous devez les parcourir de nouveau, conservez la liste obtenue ou créez un nouvel itérateur.

Utiliser une compréhension de liste pour appliquer une fonction à une liste en Python

Une compréhension de liste crée une nouvelle liste en plaçant l’expression à évaluer pour chaque élément avant la clause for. Il s’agit d’une construction du langage Python, et non d’une méthode. C’est une forme concise lorsque la transformation tient clairement sur une seule ligne.

def multiply_by_ten(number):
    return 10 * number


numbers = [1, 2, 3, 4]
results = [multiply_by_ten(number) for number in numbers]
print(results)

L’expression multiply_by_ten(number) détermine chaque résultat, tandis que la clause for fournit chaque élément d’entrée. Une compréhension peut aussi inclure une condition pour ne retenir que certains éléments.

Utiliser une expression génératrice pour appliquer une fonction à une liste en Python

Une expression génératrice place une expression de type compréhension entre parenthèses. Elle produit les valeurs à la demande, au lieu de construire immédiatement une liste de résultats. Cela peut éviter de garder en mémoire toutes les valeurs transformées à la fois ; toutefois, convertir le générateur en liste matérialise ces valeurs.

def multiply_by_ten(number):
    return 10 * number


numbers = [1, 2, 3, 4]
results = (multiply_by_ten(number) for number in numbers)
print(list(results))

Chaque valeur est produite pendant l’itération. Un générateur est consommé au fil de son parcours : un second passage sur le même générateur ne répète donc pas les valeurs. Créez un nouveau générateur ou stockez les valeurs dans une liste si vous devez les réutiliser.

Conclusion

Choisissez une boucle for si vous voulez contrôler explicitement chaque étape, et utilisez map() lorsqu’il est naturel d’appliquer une fonction existante à un itérable. Une compréhension de liste crée directement une nouvelle liste avec une syntaxe concise. Utilisez une expression génératrice pour parcourir les résultats à la demande sans tous les matérialiser immédiatement. Ces quatre approches peuvent appeler des fonctions intégrées comme des fonctions que vous définissez ; par exemple, une compréhension peut appliquer str à chaque élément avec [str(item) for item in numbers].