Numpy Prod -metode

I dag skal vi lære hva Prod () -funksjonen er i Numpy. Hvorfor bruker vi denne funksjonen? Vi kommer også til å implementere eksemplene med detaljerte forklaringer.

Prod () -funksjonen er en av de viktige funksjonene til Numpy (numerisk Python). "Prodet" betyr produktet som brukes til å finne produktet av matrisen i Numpy. Verdien av aksen er "ingen" som standard, så resultatet vises i en gitt matrise.

Syntaks:

La oss nå gå videre til skrivemetoden til Numpy Prod () -funksjonen:

Her viser “NP” for Numpy og “Prod” at vi kaller produktfunksjonen til Numpy for å utføre multiplikasjonen på matrisen.

Parameter:

Følgende er de nødvendige og valgfrie parametrene for Numpy Prod () -funksjonen:

Nødvendig parameter:

en: Inngangsarrayen. Den matrisen som vi ønsker å utføre Prod () -funksjonen.

Valgfrie parametere:

akser: Det kan være en int, en forekomst av ints, eller ingen. Dette alternativet definerer hvilke akser produktet skal utføres på.

dtype: Den forteller oss hvilken type data vi får etter produktet av en matrise.

ute: Den forteller den alternative banen der dataene er lagret etter produktet av matrisen.

Keepdims: Hvis det er sant, er de reduserte aksene fremdeles til stede i utgangen som dimensjoner i størrelse 1.

Returverdi:

Numpy Prod () -funksjonen returnerer matriser på samme måte som inngangsarrayen over en gitt akse. Hvis vi legger inn matrisen Blank/Null, returnerer Prod () -funksjonen verdien 1.

Eksempel 1: Implementering av PROD () -funksjon

Vi diskuterte den teoretiske delen av prod () -funksjonen. La oss nå gå videre til implementeringen av prod () -funksjonen gjennom forskjellige eksempler og forklaringer på hver eneste kodeinje. For implementering av det numpy eksemplet, trenger vi en Python -kompilator først for å skrive og utføre programmet vårt. Hvorfor Python Compiler for Numpy? Fordi Numpy er det avanserte biblioteket i Python, er det derfor vi bruker Python -kompilatoren.

1-dimensjonal matrise:

La oss starte vårt aller første enkle eksempel på prod () -funksjonen. For å begynne å implementere koden, må vi først importere Numpy -biblioteket vårt som alias NP. Deretter skriver vi ut meldingen “Her skal vi implementere Prod () -funksjon på 1D -matrise” for at brukeren skal forstå hva vi skal gjøre. Som du kan se på linje 3, bruker vi “\ n” etter å ha skrevet meldingen. Det er fordi vi ønsker å legge til den nye linjen i koden slik at utgangen er i en håndterbar form.

Deretter lager vi en 1-dimensjonal matrise “[5, 0]” kalt “Array”. Og så viser vi matrisen med meldingen “Den 1-dimensjonale matrisen er:” ved hjelp av Print () -metoden. Deretter sender vi matrisen til prod () -funksjonen slik at elementene i matrisen multipliseres. Vi lagrer prod () -funksjonen til en annen matrise som heter “new_array”. Årsaken til å lagre prod () -funksjonen i en annen matrise er at hvis vi vil kalle prod () -funksjonen, trenger vi ikke å skrive hele funksjonen igjen og igjen. Vi kaller bare "new_array" og har den funksjonen. Deretter viser vi New_Array ved hjelp av print () -metoden.

Importer numpy som NP
PRINT ("Her skal vi implementere Prod () -funksjonen på 1D -matrise: \ n")
Array = [5, 0]
Print ("The Array 1 er:", Array)
new_array = np.Prod (Array)
Print ("Returmatrisen er:", new_array)

La oss se på utdataene som ble vist i følgende skall. Som du ser, returnerte vi verdien “0” fordi multiplisering 5 med 0 gir oss 0.

2-dimensjonal matrise:

Her skal vi implementere et enkelt eksempel på en 2D -matrise. Denne forekomsten ligner på forrige eksempel. Den eneste forskjellen er at dette er en 2D -matrise. Her implementerer vi prod () -funksjonen til en 2D -matrise.

Importer numpy som NP
Print ("Her skal vi implementere Prod () -funksjonen på 2D -matrise: \ n")
Array = [[5, 1], [10, 1]]
Print ("Den 2-dimensjonale matrisen er:", Array)
new_array = np.Prod (Array)
Print ("Returmatrisen er:", new_array)

Her er utgangen fra 2D -matrisen som ble vist i følgende skall. Etter å ha brukt prod () -funksjonen på matrisen ”[[5, 1], [10, 1]]”, får vi 50.

La oss gjøre et tørt løp av dette eksemplet slik at det ikke er noe forvirringspunkt for brukeren:

Eksempel 2: tom matrise

Nå har vi et annet eksempel på prod () -funksjonen der vi implementerer en tom matrise. Numpy -biblioteket må først importeres som NP. Deretter lager vi et tomt utvalg “[]” kalt “Array”. Deretter sender vi denne tomme matrisen til Prod () -funksjonen og lagrer den i en annen matrise som ble kalt “New_Array”. Deretter kaller vi metoden Print () og skriver ut matrisen.

Importer numpy som NP
Print ("Her skal vi implementere PROD () -funksjonen på tom matrise: \ n")
matrise = []
Print ("Den tomme matrisen er:", matrise)
new_array = np.Prod (Array)
Print ("Returmatrisen er:", new_array)

La oss se utgangen fra den forrige illustrasjonen som ble vist i skallet. Som du kan se i følgende utgang, får vi 1.0 Til gjengjeld. Dette er fordi når vi vil ha produktet av et tomt utvalg, får vi alltid utgangen som nøytralt element 1.

Eksempel 3: Produkt av 2D -matrise når akse = 1

La oss gjøre et annet eksempel på prod () -funksjonen som gir en akse til inngangsarrayen. Først må vi importere biblioteket til Python som er numpy som alias NP. Deretter lager vi en matrise "[8, 7], [4, 5]]" kalt "Array". Etter å ha opprettet matrisen, skriver vi ut input -matrisen ved hjelp av setningen (). Deretter sender vi matrisen til prod () -funksjonen for å finne produktet av inngangsarrayen ved å gi aksen = 1 og lagre den i en annen matrise som heter “new_array”. Deretter skriver vi ut den nye matrisen ved å kalle metoden Print ().

Importer numpy som NP
Print ("Her skal vi implementere Prod () -funksjonen på 2D -matrise: \ n")
Array = [[8,7], [4,5]]
Print ("2D -matrisen er med Axis 1:", Array)
new_array = np.PROD (Array, Axis = 1)
Print ("Returmatrisen er:", new_array)

La oss se utdataene fra den forrige illustrasjonen i skallet. I produktet av inngangen får vi [56 20] med akse = 1.

La oss nå gjøre det tørre kjøringen av det tidligere forklarte eksemplet på hvordan vi får produktet av inngangsarrayen når vi gir aksen = 1.

Når akse = 0:

Nå implementerer vi det samme eksemplet som vi gjorde i forrige eksempel fordi vi vil vise brukeren forskjellen når vi gir de forskjellige aksene.

Importer numpy som NP
Print ("Her skal vi implementere Prod () -funksjonen på 2D -matrise: \ n")
Array = [[8,7], [4,5]]
Print ("2D -matrisen er med Axis 0:", Array)
new_array = np.PROD (Array, Axis = 0)
Print ("Returmatrisen er:", new_array)

Her er utgangen fra det forrige eksemplet. Som du ser, får vi nå en annen utgang som er [32 35].

Her er det tørre kjøringen når vi gir aksen = 0 til forrige eksempel. Nå vil du forstå forskjellen når vi gir de forskjellige aksene.

Konklusjon

Prod () -funksjonens implementering ble dekket i denne artikkelen. For å forstå Prod () -funksjonen tydelig implementerer vi de forskjellige eksemplene med detaljerte forklaringer. Vi gir også de forskjellige aksene til prod () -funksjonen. Jeg håper denne opplæringen vil være nyttig i læringsfasen din.