Listojen kertominen Pythonissa: 7 nopeaa tapaa

Listojen kertominen Pythonissa on yleinen toimenpide suoritettaessa matemaattisia laskelmia tai ratkaistaessa tiedonkäsittelyongelmia. Tämä tehtävä voidaan saavuttaa useilla tavoilla riippuen tarpeistasi ja käytettävissä olevista kirjastoista.

Listojen moninkertaistamiseen Pythonissa voit käyttää silmukoita, luettelon ymmärtämistä, zip- ja karttatoimintoja tai sisäänrakennettua functools-moduulia. Voit myös käyttää toimintoja ulkoisesta Python-kirjastosta, kuten NumPysta.

Tämä artikkeli näyttää sinulle monia erilaisia ​​tapoja kertoa luetteloita, joista jokaisessa on koodiesimerkki ja selitetyt tulokset.

Aloitetaan!

Sisällysluettelo

• 2 Pythonin numeerisen luettelon kertolaskutyyppiä
  • 1. Arvolla kertominen
  • 2. Element-Wise List kertolasku
• Kuinka käyttää For-silmukkaa useisiin luetteloelementteihin Pythonissa
• Listan ymmärtämisen käyttäminen kertolaskussa
• Zip-funktion käyttäminen elementtikohtaisessa kertolaskussa
  • Työskentely tuplejen ja konstruktorien kanssa
• Kuinka käyttää karttaa ja lambda-funktiota Pythonissa
• Käyttömoduulin käyttäminen Pythonissa
• NumPy-kirjasto: Array- ja Multiply-funktiot
• Functoolsin ja NumPyn yhdistäminen Pythonissa
• Listojen ja muiden tietorakenteiden työskentely Pythonissa
• Lopulliset ajatukset

2 Pythonin numeerisen luettelon kertolaskutyyppiä

Ennen kuin sukeltaamme tiettyihin menetelmiin, sinun tulisi ymmärtää, minkä tyyppinen luettelokertoin niillä saavutetaan.

Pythonilla on useita erilaisia ​​​​käsitteitä, jotka kuuluvat laajan luettelon kertomisen piiriin. Tämä sisältää luetteloiden replikoinnin tai luettelon elementtien suorakulmaisen tulon saavuttamisen.

Tämä artikkeli keskittyy sen sijaan kahteen luettelon elementtien aritmeettiseen kertolaskutyyppiin:

1. Kertominen arvolla

2. Elementtikohtainen kertolasku

Tarkastellaanpa nopeasti näitä kahta käsitettä.

1. Arvolla kertominen

Kun sinulla on luettelo kokonaisluvuista, saatat haluta kertoa jokaisen elementin tietyllä arvolla. Sinulla on esimerkiksi luettelo [1, 2, 3] ja haluat kertoa jokaisen elementin arvolla 3.

Voit yrittää (väärin) käyttää kerto-operaattoria kuten tässä koodissa:

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

Saatat yllättyä, että tulos on [1, 2, 3, 1, 2, 3, 1, 2, 3]. Tätä kutsutaan luettelon replikaatioksi .

2. Element-Wise List kertolasku

Oletetaan, että sinulla on kaksi luetteloa: [1, 2, 3] ja [4, 5, 6]

Haluat kertoa saman indeksin elementit luettelossa saadaksesi tulokseksi [4, 10, 18].

Jos yrität kertoa kaksi yhdessä käyttämällä '*'-operaattoria, saat virheilmoituksen:

TypeError: sekvenssiä ei voi kertoa ei-int-arvolla, jonka tyyppi on 'list'

Tämä johtuu siitä, että kertolaskuoperaattoria ei ole suunniteltu toimimaan luetteloiden kanssa samalla tavalla kuin se toimii kokonaislukujen tai liukulukujen kanssa. Sen sijaan listojen kertominen vaatii toiminnon, joka tunnetaan nimellä elementtikohtainen kertolasku.

Elementtikohtainen kertolasku yhdistää kahden listan vastaavat alkiot ja kertoo ne yhteen muodostaen uuden listan.

Nyt kun ymmärrät nämä kaksi käsitettä. Käydään läpi erilaisia ​​tekniikoita oikeiden tulosten saavuttamiseksi.

Kuinka käyttää For-silmukkaa useisiin luetteloelementteihin Pythonissa

Oletetaan, että haluat kertoa elementit arvolla. Tässä lähestymistavassa voit iteroida elementtejä a:lla ja kertoa jokainen toisella arvolla.

Tässä on esimerkki yhdellä listalla. Tulosmuuttuja sisältää tulosluettelon.

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

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

Tässä tapauksessa tulosluettelo on [3, 6, 9, 12].

Listan ymmärtämisen käyttäminen kertolaskussa

Listan ymmärtäminen tarjoaa tiiviin tavan suorittaa numeerisia kertolaskuja. Saat saman tuloksen kuin käyttämällä for - silmukkaa, mutta pienemmällä syntaksilla.

Tässä on edellinen esimerkki luettelon ymmärtämisestä:

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

Tämä koodi johtaa samaan ulostuloon kuin ennen: [3, 6, 9, 12].

Zip-funktion käyttäminen elementtikohtaisessa kertolaskussa

Jos sinulla on kaksi kokonaislukuluetteloa, saatat haluta kertoa luettelot elementtikohtaisesti. Tämä tarkoittaa, että kerrot ensimmäisen luettelon ensimmäisen elementin toisen luettelon ensimmäisellä elementillä ja niin edelleen samassa paikassa olevilla elementeillä.

Zip ()- funktio voi saavuttaa tämän, kun yhdistät sen luettelon ymmärtämiseen.

Toiminto yhdistää kahden syöttöluettelon elementit, jolloin voit kiertää niitä rinnakkain. Tässä on esimerkki samankokoisten luetteloiden käyttämisestä:

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

Tässä tapauksessa tulosmuuttuja sisältää tulosluettelon: [4, 10, 18].

Työskentely tuplejen ja konstruktorien kanssa

Joskus saatat joutua käsittelemään luetteloita, jotka sisältävät monikoita yksinkertaisten kokonaislukujen sijaan.

Voit kertoa kaksi monikkoluetteloa käyttämällä yhdistelmää:

• zip()-funktio

• tuple rakentajia

• luettele käsityksiä

Tässä on esimerkki:

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

Tämä on tulos: [(5, 12), (21, 32)].

Kuinka käyttää karttaa ja lambda-funktiota Pythonissa

Pythonin karttatoiminto on kätevä tapa soveltaa funktiota jokaiseen iteroitavissa olevaan kohteeseen, kuten luettelo.

Pythonin lambda-funktio on pieni anonyymi funktio. Tämä tarkoittaa, että se on funktio ilman nimeä.

Voit kertoa kaksi listaa elementtikohtaisesti yhdistämällä kartta- ja lambdafunktiot:

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

Tulosmuuttuja sisältää kerrotut listat: [4, 10, 18].

Käyttömoduulin käyttäminen Pythonissa

Operaattorimoduuli tarjoaa runsaasti hyödyllisiä toimintoja erilaisten tietorakenteiden ja -tyyppien kanssa työskentelyyn.

Operator.mul ()- funktiota voidaan käyttää kokonaislukuluetteloiden kertomiseen, kun yhdistät sen karttafunktioon.

import operator

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

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

Tässä esimerkissä tuot operaattorimoduulin ja käytät mul()- funktiota yhdessä Pythonin sisäänrakennetun map()- funktion kanssa kahden luettelon jokaisen elementin kertomiseen.

Tulosmuuttuja sisältää kerrotut listat: [4, 10, 18].

NumPy-kirjasto: Array- ja Multiply-funktiot

NumPy - kirjasto on Pythonin tehokas ulkoinen kirjasto, jota käytetään laajalti numeeriseen laskemiseen ja taulukoiden kanssa työskentelyyn. Tämä kirjasto on erityisen tehokas käsiteltäessä suuria taulukoita tai moniulotteisia taulukoita.

Voit käyttää NumPyä asentamalla sen pip:llä:

pip install numpy

Suorita elementtikohtainen kertolasku kahdessa luettelossa NumPy:n avulla seuraavasti:

1. Muunna jokainen luettelo NumPy-taulukoksi käyttämällä numpy.array() -funktiota .

2. Suorita kertolasku käyttämällä NumPy-kertotoimintoa.

3. Vaihtoehtoisesti voit muuntaa tuloksen takaisin Python-luetteloksi käyttämällä tolist()- menetelmää

Tässä on esimerkki koodista:

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

Tämä palauttaa saman tuloksen kuin edellisissä esimerkeissä: [4, 10, 18].

Functoolsin ja NumPyn yhdistäminen Pythonissa

Functools - kirjasto sisältää vähennysfunktion, joka käyttää tiettyä funktiota kumulatiivisesti luettelon kohteille, mikä vähentää luettelon yhdeksi arvoksi.

Voit kertoa kaksi listaa vähennysfunktiolla () yhdistämällä sen NumPy-kirjaston kertolaskufunktioon.

Tässä on esimerkki:

from functools import reduce
import numpy as np

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

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

Tämä koodi tuo tarvittavat kirjastot ja käyttää vähennysfunktiota () yhdessä numpy.multiply()- funktion kanssa kahden listan elementtikohtaiseen kertolaskuun.

Listojen ja muiden tietorakenteiden työskentely Pythonissa

Useimmat data-analytiikan osa-alueet vaativat työskentelyä muiden tietorakenteiden kanssa. Voit esimerkiksi hyödyntää tietojasi, kun käsittelet puuttuvaa dataa interpoloinnilla.

Katso tästä videosta edistyneitä tekniikoita:

Lopulliset ajatukset

Olet oppinut erilaisia ​​tapoja kertoa listoja aritmeettisesti Pythonissa. Jotkut käyttävät vain sisäänrakennettuja moduuleja ja toimintoja, kun taas toiset luottavat kolmannen osapuolen kirjastoihin.

Kyky suorittaa elementtikohtaista kertolaskua avaa oven lukemattomille sovelluksille. Data-analyysistä koneoppimiseen nämä toiminnot ovat olennainen osa monia algoritmeja ja laskentatehtäviä.

Vaikka tässä artikkelissa keskityttiin kertomiseen, oppimasi käsitteet ulottuvat myös muihin operaatioihin. Elementtikohtainen yhteen-, vähennys- ja jakolasku voidaan myös suorittaa pitkälti samalla tavalla.

Muista, että paras tapa vahvistaa näitä käsitteitä on soveltaa niitä – joten mene eteenpäin, käynnistä Python-ympäristösi ja aloita kokeilu. Olitpa sitten automatisoimassa tehtäviä, käsittelemässä tietoja tai rakentamassa monimutkaisia ​​ohjelmistoja, nämä tekniikat ovat epäilemättä hyödyllisiä.

Hyvää Pythonointia!