Comment multiplier des listes en Python : 7 moyens rapides

La multiplication de listes en Python est une opération courante lors de l'exécution de calculs mathématiques ou de la résolution de problèmes de manipulation de données. Il existe plusieurs façons d'accomplir cette tâche, en fonction de vos besoins et des bibliothèques dont vous disposez.

Pour multiplier les listes en Python, vous pouvez utiliser les boucles for, la compréhension de liste, les fonctions zip et map, ou le module intégré functools. Vous pouvez également utiliser les fonctions d'une bibliothèque Python externe telle que NumPy.

Cet article vous montrera de nombreuses façons différentes de multiplier des listes, chacune avec un exemple de code et des résultats expliqués.

Commençons!

Table des matières

• 2 types de multiplication de listes numériques en Python
  • 1. Multiplication par valeur
  • 2. Multiplication de liste par élément
• Comment utiliser une boucle For pour plusieurs éléments de liste en Python
• Comment utiliser les compréhensions de liste pour la multiplication
• Comment utiliser la fonction Zip pour la multiplication Element-Wise
  • Travailler avec des tuples et des constructeurs
• Comment utiliser une fonction Map et Lambda en Python
• Comment utiliser le module opérateur en Python
• Bibliothèque NumPy : les fonctions de tableau et de multiplication
• Comment combiner Functools et NumPy en Python
• Travailler avec des listes et d'autres structures de données en Python
• Dernières pensées

2 types de multiplication de listes numériques en Python

Avant de plonger dans les méthodes spécifiques, vous devez comprendre le type de multiplication de liste qu'elles permettent d'obtenir.

Python a plusieurs concepts différents qui sont sous le terme général de multiplication de liste. Cela inclut la réplication des listes ou la réalisation du produit cartésien des éléments d'une liste.

Cet article se concentre plutôt sur deux types de multiplication arithmétique d'éléments au sein d'une liste :

1. Multiplication par valeur

2. Multiplication élément par élément

Examinons rapidement ces deux concepts.

1. Multiplication par valeur

Lorsque vous avez une liste d'entiers, vous pouvez multiplier chaque élément par une valeur spécifique. Par exemple, vous avez une liste [1, 2, 3] et vous souhaitez multiplier chaque élément par la valeur 3.

Vous pouvez essayer (incorrectement) d'utiliser l'opérateur de multiplication comme dans ce morceau de code :

list1 = [1, 2, 3]
result = list1 * 3

Vous pourriez être surpris que le résultat soit [1, 2, 3, 1, 2, 3, 1, 2, 3]. C'est ce qu'on appelle la réplication de liste .

2. Multiplication de liste par élément

Supposons que vous ayez deux listes : [1, 2, 3] et [4, 5, 6]

Vous voulez multiplier les éléments au même index dans la liste pour produire [4, 10, 18] comme résultat.

Si vous essayez de multiplier deux listes Python à l'aide de l'opérateur '*', vous obtiendrez une erreur :

TypeError : impossible de multiplier la séquence par un non-entier de type "liste"

C'est parce que l'opérateur de multiplication n'est pas conçu pour fonctionner avec des listes comme il le fait avec des entiers ou des flottants. Au lieu de cela, la multiplication des listes nécessite une opération connue sous le nom de multiplication élément par élément.

La multiplication élément par élément associe les éléments correspondants de deux listes et les multiplie ensemble, formant une nouvelle liste.

Maintenant que vous comprenez ces deux concepts. Travaillons à travers une gamme de techniques pour obtenir les bons résultats.

Comment utiliser une boucle For pour plusieurs éléments de liste en Python

Supposons que vous souhaitiez multiplier les éléments de la liste par une valeur. Pour cette approche, vous pouvez parcourir les éléments avec une boucle for et multiplier chacun par une seconde valeur.

Voici un exemple avec une liste. La variable de résultat contient la liste de sortie.

list1 = [1, 2, 3, 4]
factor = 3
result = []

for element in list1:
    result.append(element * factor)

Dans ce cas, la liste des résultats sera [3, 6, 9, 12].

Comment utiliser les compréhensions de liste pour la multiplication

Les compréhensions de liste fournissent un moyen concis d'effectuer le type numérique des multiplications de liste. Vous obtenez le même résultat qu'en utilisant une boucle for , mais avec une syntaxe plus compacte.

Voici l'exemple précédent utilisant la compréhension de liste :

list1 = [1, 2, 3, 4]
factor = 3
result = [element * factor for element in list1]

Ce code donne le même résultat qu'auparavant : [3, 6, 9, 12].

Comment utiliser la fonction Zip pour la multiplication Element-Wise

Si vous avez deux listes d'entiers, vous pouvez multiplier les listes élément par élément. Cela signifie que vous multipliez le premier élément de la première liste par le premier élément de la deuxième liste et ainsi de suite avec des éléments à la même position.

La fonction zip() peut y parvenir lorsque vous la combinez avec la compréhension de liste.

La fonction combine les éléments de deux listes d'entrée, vous permettant de les parcourir en parallèle. Voici un exemple utilisant des listes de même taille :

list1 = [1, 2, 3, 4]
list2 = [2, 3, 4, 5]
result = [a * b for a, b in zip(list1, list2)]

Dans ce cas, la variable de résultat contiendra la liste résultante : [4, 10, 18].

Travailler avec des tuples et des constructeurs

Parfois, vous devrez peut-être travailler avec des listes contenant des tuples plutôt que de simples entiers.

Pour multiplier deux listes de tuples , vous pouvez utiliser une combinaison de :

• fonction zip()

• constructeurs de tuples

• liste des compréhensions

Voici un exemple :

list1 = [(1, 2), (3, 4)]
list2 = [(5, 6), (7, 8)]

result = [tuple(a * b for a, b in zip(t1, t2)) for t1, t2 in zip(list1, list2)]

Voici le résultat : [(5, 12), (21, 32)].

Comment utiliser une fonction Map et Lambda en Python

La fonction map en Python est un moyen pratique d'appliquer une fonction à chaque élément d'un itérable comme une liste.

Une fonction lambda en Python est une petite fonction anonyme. Cela signifie que c'est une fonction sans nom.

Pour multiplier deux listes élément par élément, vous pouvez combiner les fonctions map et lambda :

list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = list(map(lambda x, y: x * y, list1, list2))

La variable de résultat contiendra les listes multipliées : [4, 10, 18].

Comment utiliser le module opérateur en Python

Le module opérateur fournit une multitude de fonctions utiles pour travailler avec différentes structures et types de données.

La fonction operator.mul() peut être utilisée pour multiplier des listes d'entiers lorsque vous la combinez avec la fonction map.

import operator

list1 = [1, 2, 3]
list2 = [4, 5, 6]

result = list(map(operator.mul, list1, list2))

Dans cet exemple, vous importez le module opérateur et utilisez la fonction mul() avec la fonction intégrée map() de Python pour multiplier chaque élément des deux listes.

La variable de résultat contiendra les listes multipliées : [4, 10, 18].

Bibliothèque NumPy : les fonctions de tableau et de multiplication

La bibliothèque NumPy est une puissante bibliothèque externe en Python, largement utilisée pour le calcul numérique et le travail avec des tableaux. Cette bibliothèque est particulièrement efficace lorsqu'il s'agit de grands tableaux ou de tableaux multidimensionnels.

Pour utiliser NumPy, vous pouvez l'installer en utilisant pip :

pip install numpy

Pour effectuer une multiplication élément par élément dans deux listes à l'aide de NumPy, suivez ces étapes générales :

1. Convertissez chaque liste en un tableau NumPy en utilisant numpy.array() .

2. Effectuez la multiplication à l'aide de la fonction de multiplication NumPy.

3. Eventuellement, reconvertissez le résultat en une liste Python à l'aide de la méthode tolist()

Voici un exemple de code :

import numpy as np

list1 = [1, 2, 3]
list2 = [4, 5, 6]
arr1 = np.array(list1)
arr2 = np.array(list2)

res_arr = np.multiply(arr1, arr2)
result = res_arr.tolist()

Cela renverra le même résultat que dans les exemples précédents : [4, 10, 18].

Comment combiner Functools et NumPy en Python

La bibliothèque functools contient une fonction reduce qui applique une fonction spécifique de manière cumulative aux éléments d'une liste, réduisant la liste à une seule valeur.

Pour multiplier deux listes à l'aide de la fonction reduce() , vous pouvez la combiner avec la fonction multiplier de la bibliothèque NumPy.

Voici un exemple:

from functools import reduce
import numpy as np

list1 = [1, 2, 3]
list2 = [4, 5, 6]

result = reduce(np.multiply, [list1, list2])

Ce code importe les bibliothèques nécessaires et utilise la fonction reduce() avec numpy.multiply() pour effectuer la multiplication élément par élément des deux listes.

Travailler avec des listes et d'autres structures de données en Python

La plupart des aspects de l'analyse de données nécessitent de travailler avec des listes, des ensembles et d'autres structures de données. Par exemple, vous mettrez vos connaissances à profit lors de la manipulation de données manquantes avec interpolation.

Regardez cette vidéo pour quelques techniques avancées :

Dernières pensées

Vous avez appris diverses méthodes de multiplication arithmétique de listes en Python. Certains n'utilisent que des modules et des fonctions intégrés, tandis que d'autres s'appuient sur des bibliothèques tierces.

La possibilité d'effectuer une multiplication élément par élément ouvre la porte à une myriade d'applications. De l'analyse des données à l'apprentissage automatique, ces opérations sont une partie essentielle de nombreux algorithmes et tâches de calcul.

Bien que cet article se concentre sur la multiplication, les concepts que vous avez appris s'étendent également à d'autres opérations. L'addition, la soustraction et la division élément par élément peuvent également être accomplies de la même manière.

N'oubliez pas que la meilleure façon de solidifier ces concepts est de les appliquer - alors allez-y, lancez votre environnement Python et commencez à expérimenter. Que vous automatisez des tâches, manipuliez des données ou créiez des logiciels complexes, ces techniques vous seront sans aucun doute utiles.

Bonne Pythonisation !