Numpy Array -operasjoner

I dag lærer vi hvilke operasjoner vi utfører på numpy matriser og hvordan vi utfører disse operasjonene. Denne opplæringen vil være nyttig hvis du allerede er kjent med det grunnleggende om Python og vil begynne å bruke Numpy.

Numpy er det avanserte biblioteket for Python -programmering. Hovedfunksjonen ved Numpy er at den tilbyr å jobbe med flerdimensjonale matriser og en enestående hastighet samt evner for å samhandle med disse matriser.

Numpy brukes til å utføre den logiske og matematiske operasjonen. Vi kan utføre flere operasjoner i matriser som er:

• Aritmetiske operasjoner
• Logiske operasjoner
• Sammenligningsoperasjoner

Aritmetiske operasjoner

Vi kan utføre flere operasjoner på numpy matriser der vi kan legge til, trekke, multiplisere og dele de to matriser; Disse operasjonene kalles aritmetiske operasjoner. Minst to matriser er påkrevd for den aritmetiske operasjonen, og de må enten ha samme størrelse eller følge reglene for array kringkasting.

Syntaks:

La oss se syntaks for den aritmetiske operasjonen av Python Library, Numpy. Her skriver vi først navnet på biblioteket som vi bruker som er "numpy". Deretter kaller vi funksjonen til den aritmetiske operasjonen som vi ønsker å utføre som add (), sub (), mul () og div (). Og så overfører vi parametrene til den funksjonen.

Eksempel:

La oss gå videre til eksemplet med aritmetiske operasjoner som legger til, trekker, multipliserer og deler. La oss se hvordan vi kan implementere disse operasjonene på numpy matriser. Åpne Python -kompilatoren din for implementering av det aritmetiske programmet.

Det aller første og grunnleggende trinnet er å importere biblioteket til Python som er numpy. Først skriver vi nøkkelordet "import" som viser at vi skal importere biblioteket. Deretter skriver vi biblioteknavnet som er "numpy". Og så skriver vi Numpy alias, “NP”. I den tredje kodelinjen bruker vi PRINT () uttalelsen slik at vi kan vise meldingen om at vi skal implementere aritmetiske operasjoner. Deretter kaller vi i neste linje Numpy Arange () -funksjonen for opprettelsen av Array1 og passerer argumentene i den.

Det første argumentet er startelementet i Array1. Det andre argumentet er stoppelementet, men husk at vi ikke kan inkludere stoppelementet i Array1. Og det tredje argumentet er hvor stor forskjell vi bør ta for å få det neste elementet i Array1; dtype betyr hvilken type data ønsker vi (som int, float osv.) for Array1.

I denne linjen bruker vi en annen funksjon ved å bruke sammenkobling som er omformet () -funksjonen. Denne funksjonen brukes til å forme array1. Her har vi 2 rader og 4 kolonner i matrisen. Deretter oppretter vi en annen matrise som er Array2 ved å bruke den samme funksjonen som vi bruker for Array1, men vi bruker ikke RESHAPE () -funksjonen i Array 2 fordi vi ikke vil forme matrisen. Etter opprettelsen av begge matriser, skriver vi ut array1 og array2 ved hjelp av setningen () og passerer matriser i den.

Importer numpy som NP
Print ("Implementering av arthimatiske operasjoner: \ n")
Array1 = NP.Arange (40, 96, 7, dtype = int).omforme (2,4)
trykk ("Den første matrisen er", Array1.Ndim, "Dimensional: \ n", Array1)
Array2 = NP.Arange (5, 20, 4, dtype = int)
trykk ("\ n the Second Array er", Array2.Ndim, "Dimensional: \ n", Array2)
Legg til = NP.Legg til (Array1, Array2)
print ("\ nadding de to matriser: \ n", legg til)
sub = np.Trekk (Array1, Array2)
print ("\ nsubracting de to matriser: \ n", sub)
mul = np.Multipliser (Array1, Array2)
PRINT ("\ NMULTIPLYING de to matriser: \ n", mul)
div = np.Del (Array1, Array2)
print ("\ ndeling de to matriser: \ n", div)

Etter å ha opprettet begge matriser, kaller vi de aritmetiske funksjonene en etter en. Først kaller vi add () -funksjonen for tillegg av både Array1 og Array2. Deretter kaller vi sub () -funksjonen slik at vi kan trekke fra Array2 fra Array1. Deretter kaller vi mul () -funksjonen for multiplikasjon av begge matriser. Til slutt har vi div () -funksjonen som deler begge matriser og vi får kvotienten. Vi skriver deretter ut alle funksjonene ved hjelp av PRINT () -uttalelsen og passerer parametrene i den.

Her er resultatet av dette forklarte eksemplet der vi får resultatet av aritmetiske operasjoner:

Logiske operasjoner

La oss nå gå videre til den andre driften av Numpy Library som er den logiske operasjonen. Vi bruker den logiske operasjonen for å få den sanne verdien av numpy matriser som de boolske sannhetsverdiene. Vi implementerer de logiske operasjonene gjennom Numpy -funksjoner som er logical_and (), logical_or () og logical_not () funksjoner.

Syntaks:

La oss se på skrivestilen til den logiske driften av Python -biblioteket, Numpy. Først skriver vi biblioteknavnet som vi bruker i dette programmet som er numpy. Deretter skriver vi funksjonsnavnet til den logiske operatøren som vi bruker, og passerer deretter argumentene i den.

Eksempel:

La oss begynne å implementere eksemplet på de logiske operasjonene av Python-Numpy som er logical_and (), logical_or og logical_not.

Vi importerer biblioteket til Python som vi bruker i dette programmet som er numpy. Deretter lager vi den 1-dimensjonale tilfeldige matrisen ved hjelp av Numpy Randn () -funksjonen og passerer to parametere i den. Den første parameteren viser antall rader med matrisen. Den andre parameteren viser antall kolonner i matrisen. I den sjette kodelinjen kaller vi PRINT () uttalelsen og passerer logical_and () -funksjonen i den. Deretter passerer vi i neste linje logical_or () -funksjonen og deretter logical_not () -funksjonene i den.

Importer numpy som NP
arr = np.tilfeldig.Randn (2, 2)
Print ("The Random Array er: \ n", ARR)
trykk ('\ n resultatet av og er: \ n', np.logical_and (arr> 0, arr < 0.5))
trykk ('\ n resultatet av eller er: \ n', np.logical_or (arr < 0, arr > 0.5))
trykk ('\ n resultatet av ikke er: \ n', np.logical_not (arr> 0))

Her er utdataene fra det tidligere nevnte kodebiten. Som du kan se, får vi den tilfeldige matrisen ved hjelp av RANDN () -funksjonen og anvendte flere logiske operasjoner på den:

Sammenligningsoperasjoner

Nå har vi den tredje driften av Numpy Arrays, som er sammenligningsoperasjonen. I denne operasjonen sammenligner vi matrisen med et hvilket som helst nummer og sjekk om det er sant eller usant. Vi utfører flere sammenligningsoperasjoner i numpy matriser som er>, =, <=, =, != etc.

Syntaks:

Her er syntaks for sammenligningsoperasjoner i numpy matriser:

Eksempel:

La oss nå gå videre til eksemplet på sammenligningsoperasjoner. Først importerer vi Python -biblioteket som er numpy. Deretter lager vi en tilfeldig numpy matrise ved hjelp av Randint () -funksjonen for å lage heltall tilfeldige matriser fra 1 til 20. Størrelsen på matrisen er 1 rad og 3 kolonner. Deretter kaller vi PRINT () uttalelsen og passerer sammenligningsoperasjonene i den. Funksjonene som vi utfører i dette eksemplet er større (), Greater_equal (), Less (), Less_equal (), like () og not_equal ().

Importer numpy som NP
arr = np.tilfeldig.Randint (1, 8, størrelse = (1, 3))
Print ("Inngangsarrayen er: \ n", ARR)
print ("\ ngaterer enn det er: \ n", np.større (arr, 5))
print ("\ ngreater enn eller lik 5: \ n", np.Greater_equal (arr, 5))
trykk ("\ nless enn 5: \ n", np.Less (arr, 5))
trykk ("\ nless enn eller lik 5: \ n", np.Less_equal (arr, 5))
trykk ("\ nequal til 5: \ n", np.Lik (arr, 5))
print ("\ nnot lik 5: \ n", np.not_equal (arr, 5))

Her er produksjonen fra sammenligningsoperasjonene:

Konklusjon

I denne artikkelen lærte vi hvilke operasjoner vi kan utføre i Numpy -matriser, hvordan vi implementerer disse operasjonene i Numpy -matriser, og hvilke funksjoner bruker vi for å implementere disse operasjonene av Numpy. Vi implementerte eksempler på hver operasjon av numpy matriser og brukte de forskjellige funksjonene for å lage matrisen i disse eksemplene.