Sådan multipliceres lister i Python: 7 hurtige måder

Multiplicering af lister i Python er en almindelig operation, når man udfører matematiske beregninger eller løser problemer i datamanipulation. Der er flere måder at udføre denne opgave på, afhængigt af dine krav og de biblioteker, du har til rådighed.

For at multiplicere lister i Python kan du bruge til loops, listeforståelse, zip- og kortfunktioner eller det indbyggede functools-modul. Du kan også bruge funktioner fra et eksternt Python-bibliotek som NumPy.

Denne artikel vil vise dig mange forskellige måder at multiplicere lister på, hver med et kodeeksempel og forklarede resultater.

Lad os komme igang!

Indholdsfortegnelse

• 2 typer numerisk listemultiplikation i Python
  • 1. Multiplikation med værdi
  • 2. Element-Wise List Multiplikation
• Sådan bruges en for loop til flere listeelementer i Python
• Sådan bruges listeforståelser til multiplikation
• Sådan bruger du Zip-funktionen til Element-Wise Multiplikation
  • Arbejde med Tuples og konstruktører
• Sådan bruger du en kort- og lambdafunktion i Python
• Sådan bruger du operatørmodulet i Python
• NumPy Library: Array- og multiplikationsfunktionerne
• Sådan kombinerer du Functools og NumPy i Python
• Arbejde med lister og andre datastrukturer i Python
• Afsluttende tanker

2 typer numerisk listemultiplikation i Python

Før vi dykker ned i de specifikke metoder, bør du forstå, hvilken type listemultiplikation de opnår.

Python har flere forskellige begreber, der er under det brede begreb listemultiplikation. Det inkluderer replikering af lister eller opnåelse af det kartesiske produkt af elementer i en liste.

Denne artikel fokuserer i stedet på to typer aritmetisk multiplikation af elementer på en liste:

1. Multiplikation med værdi

2. Element-vis multiplikation

Lad os tage et hurtigt kig på disse to begreber.

1. Multiplikation med værdi

Når du har en liste over heltal, vil du måske gange hvert element med en bestemt værdi. For eksempel har du en liste [1, 2, 3], og du vil gange hvert element med værdien 3.

Du kan prøve (forkert) at bruge multiplikationsoperatoren som i dette stykke kode:

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

Du kan blive overrasket over, at resultatet er [1, 2, 3, 1, 2, 3, 1, 2, 3]. Dette er kendt som listereplikering .

2. Element-Wise List Multiplikation

Antag, at du har to lister: [1, 2, 3] og [4, 5, 6]

Du ønsker at gange elementerne med det samme indeks på listen for at frembringe [4, 10, 18] som resultat.

Hvis du prøver at gange to sammen ved hjælp af '*'-operatoren, får du en fejlmeddelelse:

TypeError: kan ikke multiplicere sekvens med ikke-int af typen 'list'

Dette skyldes, at multiplikationsoperatoren ikke er designet til at arbejde med lister på den måde, den gør med heltal eller flydende. I stedet kræver multiplikation af lister en operation kendt som elementvis multiplikation.

Element-vis multiplikation parrer de tilsvarende elementer fra to lister og multiplicerer dem sammen og danner en ny liste.

Nu hvor du forstår disse to begreber. lad os arbejde gennem en række teknikker for at opnå de korrekte resultater.

Sådan bruges en for loop til flere listeelementer i Python

Antag, at du vil gange elementer med en værdi. For denne tilgang kan du iterere gennem elementerne med a og gange hver enkelt med en anden værdi.

Her er et eksempel med én liste. Resultatvariablen holder outputlisten.

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

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

I dette tilfælde vil resultatlisten være [3, 6, 9, 12].

Sådan bruges listeforståelser til multiplikation

Listeforståelser giver en kortfattet måde at udføre den numeriske type af listemultiplikationer. Du får det samme resultat som at bruge en for loop, men med en mere kompakt syntaks.

Her er det forrige eksempel, der bruger listeforståelse:

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

Denne kode resulterer i samme output som før: [3, 6, 9, 12].

Sådan bruger du Zip-funktionen til Element-Wise Multiplikation

Hvis du har to lister med heltal, vil du måske gange listerne elementmæssigt. Det betyder, at du gange det første element i den første liste gange det første element i den anden liste og så videre med elementer i samme position.

Zip () -funktionen kan opnå dette, når du kombinerer den med listeforståelse.

Funktionen kombinerer elementerne i to inputlister, så du kan løkke over dem parallelt. Her er et eksempel med lister af samme størrelse:

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

I dette tilfælde vil resultatvariablen indeholde den resulterende liste: [4, 10, 18].

Arbejde med Tuples og konstruktører

Nogle gange skal du måske arbejde med lister, der indeholder tupler i stedet for simple heltal.

For at gange to lister med tupler kan du bruge en kombination af:

• zip() funktion

• tupel konstruktører

• listeforståelser

Her er et eksempel:

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

Dette er resultatet: [(5, 12), (21, 32)].

Sådan bruger du en kort- og lambdafunktion i Python

Kortfunktionen i Python er en praktisk måde at anvende en funktion på hvert element i en iterabel som en liste.

En lambda-funktion i Python er en lille anonym funktion. Det betyder, at det er en funktion uden navn.

For at gange to lister elementmæssigt kan du kombinere kort- og lambda-funktioner:

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

Resultatvariablen vil indeholde de multiplicerede lister: [4, 10, 18].

Sådan bruger du operatørmodulet i Python

Operatørmodulet giver et væld af nyttige funktioner til at arbejde med forskellige datastrukturer og -typer.

Funktionen operator.mul() kan bruges til at multiplicere lister over heltal, når du kombinerer den med kortfunktionen.

import operator

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

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

I dette eksempel importerer du operatormodulet og bruger mul()- funktionen sammen med Pythons indbyggede map()- funktion til at multiplicere hvert element i de to lister.

Resultatvariablen vil indeholde de multiplicerede lister: [4, 10, 18].

NumPy Library: Array- og multiplikationsfunktionerne

NumPy - biblioteket er et kraftfuldt eksternt bibliotek i Python, der er meget brugt til numerisk beregning og arbejde med arrays. Dette bibliotek er særligt effektivt, når det drejer sig om store arrays eller multidimensionale arrays.

For at bruge NumPy kan du installere det ved hjælp af pip:

pip install numpy

For at udføre element-vis multiplikation i to lister ved hjælp af NumPy, følg disse generelle trin:

1. Konverter hver liste til et NumPy-array ved hjælp af numpy.array() .

2. Udfør multiplikationen ved hjælp af NumPy multiplikationsfunktionen.

3. Konverter eventuelt resultatet tilbage til en Python-liste ved hjælp af tolist() -metoden

Her er et kodeeksempel:

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

Dette vil returnere det samme resultat som i de foregående eksempler: [4, 10, 18].

Sådan kombinerer du Functools og NumPy i Python

Functools- biblioteket indeholder en reduktionsfunktion, der anvender en specifik funktion kumulativt på elementerne på en liste, hvilket reducerer listen til en enkelt værdi.

For at gange to lister ved hjælp af reduce() -funktionen, kan du kombinere den med multipliceringsfunktionen fra NumPy-biblioteket.

Her er et eksempel:

from functools import reduce
import numpy as np

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

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

Denne kode importerer de nødvendige biblioteker og bruger reduce()- funktionen sammen med numpy.multiply() til at udføre element-vis multiplikation af de to lister.

Arbejde med lister og andre datastrukturer i Python

De fleste aspekter af dataanalyse kræver arbejde med og andre datastrukturer. For eksempel vil du bruge din viden, når du håndterer manglende data med interpolation.

Se denne video for nogle avancerede teknikker:

Afsluttende tanker

Du har lært forskellige metoder til at multiplicere lister aritmetisk i Python. Nogle bruger kun indbyggede moduler og funktioner, mens andre er afhængige af tredjepartsbiblioteker.

Evnen til at udføre element-vis multiplikation åbner døren til et utal af applikationer. Fra dataanalyse til maskinlæring er disse operationer en væsentlig del af mange algoritmer og beregningsopgaver.

Mens denne artikel fokuserede på multiplikation, udvider de begreber, du lærte, også andre operationer. Elementmæssig addition, subtraktion og division kan også udføres på stort set samme måde.

Husk, at den bedste måde at styrke disse begreber på er ved at anvende dem - så fortsæt, tænd for dit Python-miljø og begynd at eksperimentere. Uanset om du automatiserer opgaver, manipulerer data eller bygger kompleks software, vil disse teknikker uden tvivl være nyttige.

Glædelig Pythoning!