Hvordan multiplisere lister i Python: 7 raske måter

Multiplisering av lister i Python er en vanlig operasjon når man utfører matematiske beregninger eller løser problemer i datamanipulering. Det er flere måter å oppnå denne oppgaven på, avhengig av dine behov og bibliotekene du har tilgjengelig.

For å multiplisere lister i Python kan du bruke for loops, listeforståelse, zip- og kartfunksjoner, eller den innebygde funksjonsverktøymodulen. Du kan også bruke funksjoner fra et eksternt Python-bibliotek som NumPy.

Denne artikkelen vil vise deg mange forskjellige måter å multiplisere lister på, hver med et kodeeksempel og forklarte resultater.

La oss komme i gang!

Innholdsfortegnelse

• 2 typer numerisk listemultiplikasjon i Python
  • 1. Multiplikasjon med verdi
  • 2. Element-Wise List Multiplikasjon
• Hvordan bruke en for loop til flere listeelementer i Python
• Hvordan bruke listeforståelser for multiplikasjon
• Hvordan bruke zip-funksjonen for element-vis multiplikasjon
  • Arbeide med tupler og konstruktører
• Slik bruker du en kart- og lambdafunksjon i Python
• Slik bruker du operatørmodulen i Python
• NumPy Library: Array- og multiplikasjonsfunksjonene
• Hvordan kombinere Functools og NumPy i Python
• Arbeide med lister og andre datastrukturer i Python
• Siste tanker

2 typer numerisk listemultiplikasjon i Python

Før vi dykker ned i de spesifikke metodene, bør du forstå hvilken type listemultiplikasjon de oppnår.

Python har flere forskjellige konsepter som er under det brede begrepet listemultiplikasjon. Dette inkluderer replikering av lister eller oppnåelse av det kartesiske produktet av elementer i en liste.

Denne artikkelen fokuserer i stedet på to typer aritmetisk multiplikasjon av elementer i en liste:

1. Multiplikasjon med verdi

2. Elementvis multiplikasjon

La oss ta en rask titt på disse to konseptene.

1. Multiplikasjon med verdi

Når du har en liste over heltall, kan det være lurt å multiplisere hvert element med en bestemt verdi. For eksempel har du en liste [1, 2, 3] og du vil multiplisere hvert element med verdien 3.

Du kan prøve (feil) å bruke multiplikasjonsoperatoren som i denne kodebiten:

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

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

2. Element-Wise List Multiplikasjon

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

Du vil multiplisere elementene med samme indeks i listen for å produsere [4, 10, 18] som resultat.

Hvis du prøver å multiplisere to sammen med '*'-operatoren, får du en feilmelding:

TypeError: kan ikke multiplisere sekvens med ikke-int av typen 'list'

Dette er fordi multiplikasjonsoperatoren ikke er laget for å fungere med lister på den måten den gjør med heltall eller flyter. I stedet krever multiplisering av lister en operasjon kjent som elementvis multiplikasjon.

Elementvis multiplikasjon parer de tilsvarende elementene fra to lister og multipliserer dem sammen, og danner en ny liste.

Nå som du forstår disse to konseptene. la oss jobbe gjennom en rekke teknikker for å oppnå de riktige resultatene.

Hvordan bruke en for loop til flere listeelementer i Python

Anta at du vil multiplisere elementer med en verdi. For denne tilnærmingen kan du iterere gjennom elementene med a og multiplisere hver med en annen verdi.

Her er et eksempel med én liste. Resultatvariabelen holder utdatalisten.

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

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

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

Hvordan bruke listeforståelser for multiplikasjon

Listeforståelser gir en kortfattet måte å utføre den numeriske typen listemultiplikasjoner. Du får samme resultat som å bruke en for loop, men med en mer kompakt syntaks.

Her er det forrige eksemplet med listeforståelse:

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

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

Hvordan bruke zip-funksjonen for element-vis multiplikasjon

Hvis du har to lister med heltall, kan det være lurt å multiplisere listene elementvis. Dette betyr at du multipliserer det første elementet i den første listen ganger det første elementet i den andre listen og så videre med elementer i samme posisjon.

Zip () -funksjonen kan oppnå dette når du kombinerer den med listeforståelse.

Funksjonen kombinerer elementene i to inndatalister, slik at du kan gå over dem parallelt. Her er et eksempel med lister av 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 tilfellet vil resultatvariabelen inneholde resultatlisten: [4, 10, 18].

Arbeide med tupler og konstruktører

Noen ganger må du kanskje jobbe med lister som inneholder tupler i stedet for enkle heltall.

For å multiplisere to lister med tupler kan du bruke en kombinasjon av:

• zip() funksjon

• tuppelkonstruktø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)].

Slik bruker du en kart- og lambdafunksjon i Python

Kartfunksjonen i Python er en praktisk måte å bruke en funksjon på hvert element i en iterabel som en liste.

En lambda-funksjon i Python er en liten anonym funksjon. Dette betyr at det er en funksjon uten navn.

For å multiplisere to lister elementvis, kan du kombinere kart- og lambdafunksjoner:

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

Resultatvariabelen vil inneholde de multipliserte listene: [4, 10, 18].

Slik bruker du operatørmodulen i Python

Operatørmodulen gir et vell av nyttige funksjoner for å arbeide med ulike datastrukturer og typer.

Operator.mul () -funksjonen kan brukes til å multiplisere lister med heltall når du kombinerer den med kartfunksjonen.

import operator

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

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

I dette eksemplet importerer du operatørmodulen og bruker mul()- funksjonen sammen med Pythons innebygde map()- funksjon for å multiplisere hvert element i de to listene.

Resultatvariabelen vil inneholde de multipliserte listene: [4, 10, 18].

NumPy Library: Array- og multiplikasjonsfunksjonene

NumPy - biblioteket er et kraftig eksternt bibliotek i Python, mye brukt for numerisk beregning og arbeid med arrays. Dette biblioteket er spesielt effektivt når du arbeider med store arrays eller flerdimensjonale arrays.

For å bruke NumPy kan du installere det ved å bruke pip:

pip install numpy

For å utføre elementvis multiplikasjon i to lister ved å bruke NumPy, følg disse generelle trinnene:

1. Konverter hver liste til en NumPy-matrise ved å bruke numpy.array() .

2. Utfør multiplikasjonen ved å bruke NumPy multiplikasjonsfunksjonen.

3. Alternativt kan du konvertere resultatet tilbake til en Python-liste ved å bruke 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 resultatet som i de foregående eksemplene: [4, 10, 18].

Hvordan kombinere Functools og NumPy i Python

Functools - biblioteket inneholder en reduseringsfunksjon som bruker en spesifikk funksjon kumulativt på elementene i en liste, og reduserer listen til en enkelt verdi.

For å multiplisere to lister ved å bruke reduce()- funksjonen, kan du kombinere den med multipliser-funksjonen 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 koden importerer de nødvendige bibliotekene og bruker reduce()- funksjonen sammen med numpy.multiply() for å utføre elementvis multiplikasjon av de to listene.

Arbeide med lister og andre datastrukturer i Python

De fleste aspekter ved dataanalyse krever arbeid med og andre datastrukturer. For eksempel vil du bruke kunnskapen din når du håndterer manglende data med interpolering.

Sjekk ut denne videoen for noen avanserte teknikker:

Siste tanker

Du har lært ulike metoder for å multiplisere lister aritmetisk i Python. Noen bruker kun innebygde moduler og funksjoner, mens andre er avhengige av tredjepartsbiblioteker.

Evnen til å utføre elementvis multiplikasjon åpner døren for et utall av applikasjoner. Fra dataanalyse til maskinlæring er disse operasjonene en viktig del av mange algoritmer og beregningsoppgaver.

Mens denne artikkelen fokuserte på multiplikasjon, strekker konseptene du lærte seg til andre operasjoner også. Elementmessig addisjon, subtraksjon og divisjon kan også utføres på omtrent samme måte.

Husk at den beste måten å styrke disse konseptene på er ved å bruke dem - så fortsett, fyr opp Python-miljøet ditt og begynn å eksperimentere. Enten du automatiserer oppgaver, manipulerer data eller bygger kompleks programvare, vil disse teknikkene utvilsomt komme godt med.

Lykke til med pytoning!