Hoe lijsten in Python te vermenigvuldigen: 7 snelle manieren

Het vermenigvuldigen van lijsten in Python is een gebruikelijke bewerking bij het uitvoeren van wiskundige berekeningen of het oplossen van problemen bij gegevensmanipulatie. Er zijn meerdere manieren om deze taak uit te voeren, afhankelijk van uw vereisten en de beschikbare bibliotheken.

Om lijsten in Python te vermenigvuldigen, kun je for loops, list comprehension, zip en map-functies gebruiken, of de ingebouwde functools-module. U kunt ook functies gebruiken uit een externe Python-bibliotheek zoals NumPy.

Dit artikel laat je veel verschillende manieren zien om lijsten te vermenigvuldigen, elk met een codevoorbeeld en uitgelegde resultaten.

Laten we beginnen!

Inhoudsopgave

• 2 soorten numerieke lijstvermenigvuldiging in Python
  • 1. Vermenigvuldiging met waarde
  • 2. Elementgewijze lijstvermenigvuldiging
• Hoe een For-lus te gebruiken om meerdere lijstelementen in Python te gebruiken
• Hoe lijstbegrippen te gebruiken voor vermenigvuldiging
• Hoe de Zip-functie te gebruiken voor elementgewijze vermenigvuldiging
  • Werken met tuples en constructors
• Hoe een kaart- en lambdafunctie in Python te gebruiken
• Hoe de operatormodule in Python te gebruiken
• NumPy-bibliotheek: de array- en vermenigvuldigfuncties
• Hoe Functools en NumPy in Python te combineren
• Werken met lijsten en andere gegevensstructuren in Python
• Laatste gedachten

2 soorten numerieke lijstvermenigvuldiging in Python

Voordat we ingaan op de specifieke methoden, moet u begrijpen welk type lijstvermenigvuldiging ze bereiken.

Python heeft verschillende concepten die onder de brede term van lijstvermenigvuldiging vallen. Dat omvat het repliceren van lijsten of het bereiken van het Cartesiaanse product van elementen binnen een lijst.

Dit artikel richt zich in plaats daarvan op twee soorten rekenkundige vermenigvuldiging van elementen in een lijst:

1. Vermenigvuldiging met waarde

2. Elementgewijze vermenigvuldiging

Laten we deze twee concepten even bekijken.

1. Vermenigvuldiging met waarde

Als u een lijst met gehele getallen heeft, wilt u misschien elk element met een specifieke waarde vermenigvuldigen. U hebt bijvoorbeeld een lijst [1, 2, 3] en u wilt elk element vermenigvuldigen met de waarde 3.

Je zou kunnen proberen (ten onrechte) de vermenigvuldigingsoperator te gebruiken zoals in dit stuk code:

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

Het zal je misschien verbazen dat het resultaat [1, 2, 3, 1, 2, 3, 1, 2, 3] is. Dit staat bekend als lijstreplicatie .

2. Elementgewijze lijstvermenigvuldiging

Stel dat je twee lijsten hebt: [1, 2, 3] en [4, 5, 6]

U wilt de elementen met dezelfde index in de lijst vermenigvuldigen om [4, 10, 18] als resultaat te produceren.

Als je twee Python-lijsten probeert te vermenigvuldigen met de '*'-operator, krijg je een foutmelding:

TypeError: kan reeks niet vermenigvuldigen met niet-int van type 'lijst'

Dit komt omdat de vermenigvuldigingsoperator niet is ontworpen om met lijsten te werken zoals met gehele getallen of zwevende getallen. In plaats daarvan vereist het vermenigvuldigen van lijsten een bewerking die bekend staat als elementgewijze vermenigvuldiging.

Elementgewijze vermenigvuldiging koppelt de overeenkomstige elementen uit twee lijsten en vermenigvuldigt ze met elkaar, waardoor een nieuwe lijst ontstaat.

Nu je deze twee concepten begrijpt. laten we een reeks technieken doorlopen om de juiste resultaten te bereiken.

Hoe een For-lus te gebruiken om meerdere lijstelementen in Python te gebruiken

Stel dat u lijstelementen wilt vermenigvuldigen met een waarde. Voor deze benadering kunt u de elementen doorlopen met een for-lus en elk element vermenigvuldigen met een tweede waarde.

Hier is een voorbeeld met één lijst. De resultaatvariabele bevat de uitvoerlijst.

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

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

In dit geval is de resultatenlijst [3, 6, 9, 12].

Hoe lijstbegrippen te gebruiken voor vermenigvuldiging

Lijstbegrip biedt een beknopte manier om het numerieke type lijstvermenigvuldigingen uit te voeren. U krijgt hetzelfde resultaat als het gebruik van een for- lus, maar met een compactere syntaxis.

Hier is het vorige voorbeeld met behulp van lijstbegrip:

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

Deze code resulteert in dezelfde uitvoer als hiervoor: [3, 6, 9, 12].

Hoe de Zip-functie te gebruiken voor elementgewijze vermenigvuldiging

Als u twee lijsten met gehele getallen hebt, kunt u de lijsten elementsgewijs vermenigvuldigen. Dit betekent dat je het eerste element in de eerste lijst vermenigvuldigt met het eerste element in de tweede lijst, enzovoort, met elementen op dezelfde positie.

De functie zip() kan dit bereiken wanneer u deze combineert met lijstbegrip.

De functie combineert de elementen van twee invoerlijsten, zodat u ze parallel kunt doorlopen. Hier is een voorbeeld met lijsten van dezelfde grootte:

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

In dit geval bevat de resultaatvariabele de resulterende lijst: [4, 10, 18].

Werken met tuples en constructors

Soms moet u werken met lijsten die tupels bevatten in plaats van eenvoudige gehele getallen.

Om twee lijsten met tupels te vermenigvuldigen , kunt u een combinatie gebruiken van:

• zip() functie

• tuple-constructeurs

• lijst begrippen

Hier is een voorbeeld:

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)]

Dit is het resultaat: [(5, 12), (21, 32)].

Hoe een kaart- en lambdafunctie in Python te gebruiken

De kaartfunctie in Python is een handige manier om een ​​functie toe te passen op elk item in een iterabele zoals een lijst.

Een lambda-functie in Python is een kleine anonieme functie. Dit betekent dat het een functie zonder naam is.

Om twee lijsten elementsgewijs te vermenigvuldigen, kun je map- en lambda-functies combineren:

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

De resultaatvariabele bevat de vermenigvuldigde lijsten: [4, 10, 18].

Hoe de operatormodule in Python te gebruiken

De operatormodule biedt een schat aan handige functies voor het werken met verschillende datastructuren en -typen.

De functie operator.mul() kan worden gebruikt om lijsten met gehele getallen te vermenigvuldigen wanneer u deze combineert met de kaartfunctie.

import operator

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

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

In dit voorbeeld importeert u de operatormodule en gebruikt u de functie mul() samen met de ingebouwde map() -functie van Python om elk element van de twee lijsten te vermenigvuldigen.

De resultaatvariabele bevat de vermenigvuldigde lijsten: [4, 10, 18].

NumPy-bibliotheek: de array- en vermenigvuldigfuncties

De NumPy- bibliotheek is een krachtige externe bibliotheek in Python, die veel wordt gebruikt voor numerieke berekeningen en het werken met arrays. Deze bibliotheek is vooral efficiënt bij grote arrays of multidimensionale arrays.

Om NumPy te gebruiken, kunt u het installeren met pip:

pip install numpy

Volg deze algemene stappen om elementgewijze vermenigvuldiging in twee lijsten uit te voeren met behulp van NumPy:

1. Converteer elke lijst naar een NumPy-array met behulp van numpy.array() .

2. Voer de vermenigvuldiging uit met behulp van de NumPy-vermenigvuldigingsfunctie.

3. Converteer het resultaat optioneel terug naar een Python-lijst met behulp van de methode tolist().

Hier is een codevoorbeeld:

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()

Dit geeft hetzelfde resultaat als in de vorige voorbeelden: [4, 10, 18].

Hoe Functools en NumPy in Python te combineren

De functools- bibliotheek bevat een reduce-functie die een specifieke functie cumulatief toepast op de items in een lijst, waardoor de lijst wordt teruggebracht tot een enkele waarde.

Om twee lijsten te vermenigvuldigen met behulp van de functie reduce() , kunt u deze combineren met de functie vermenigvuldigen uit de NumPy-bibliotheek.

Hier is een voorbeeld:

from functools import reduce
import numpy as np

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

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

Deze code importeert de benodigde bibliotheken en gebruikt de functie reduce() samen met numpy.multiply() om elementgewijze vermenigvuldiging van de twee lijsten uit te voeren.

Werken met lijsten en andere gegevensstructuren in Python

De meeste aspecten van gegevensanalyse vereisen het werken met lijsten, sets en andere gegevensstructuren. Je zet je kennis bijvoorbeeld in bij het afhandelen van ontbrekende gegevens met interpolatie.

Bekijk deze video voor enkele geavanceerde technieken:

Laatste gedachten

Je hebt verschillende methoden geleerd om lijsten rekenkundig te vermenigvuldigen in Python. Sommige gebruiken alleen ingebouwde modules en functies, terwijl andere afhankelijk zijn van bibliotheken van derden.

De mogelijkheid om elementgewijze vermenigvuldiging uit te voeren, opent de deur naar een groot aantal toepassingen. Van gegevensanalyse tot machine learning, deze bewerkingen vormen een essentieel onderdeel van veel algoritmen en rekentaken.

Hoewel dit artikel zich richtte op vermenigvuldiging, zijn de concepten die je hebt geleerd ook van toepassing op andere bewerkingen. Elementsgewijs optellen, aftrekken en delen kan ook op vrijwel dezelfde manier worden bereikt.

Onthoud dat de beste manier om deze concepten te verstevigen, is door ze toe te passen. Dus ga je gang, activeer je Python-omgeving en begin met experimenteren. Of je nu taken automatiseert, gegevens manipuleert of complexe software bouwt, deze technieken zullen ongetwijfeld van pas komen.

Gelukkig pythonen!