Numpy logical_and

Som andre rammer og språk, støtter Numpy også logiske operatører og deres virksomhet som og, eller etc. I denne numpy guiden vil vi diskutere den numpy "logical_and" -operasjonen. Logical_and Operator beregner sannhetsverdien til A1 og A2 Elementwise. NP.Logical_and () -metoden er en matematisk array -metode som brukes til å beregne utgangen til XI og YI for hver komponent XI av Array1 angående element Yi av Array2. Det gir oss utgangen i en matriseform. For NP.logical_and () funksjon for å fungere, vi må gi den til inngangsarrayene med samme form

Syntaks

Dette er syntaks for metoden vår.

numpy.logical_and (x1, x2, out = ingen, hvor = sant, dtype = ingen)

Den har følgende parametere

x1, x2 er inngangsarrayene. Disse to må være av samme form, som også vil være den samme som utgangen.

ute er stedet der utgangen er lagret. Vi kan gi formen manuelt ellers vil den tildele et friskt utvalg.

hvor er en tilstand som er en valgfri parameter. Hvis tilstanden er sann, vil resultatet. Ellers vil utdataoppstillingen forbli i sin faktiske form som holder sin faktiske verdi.

dtype Definerer typen utgangsarray.

Eksempel # 01:

Nå vil vi ta to matriser med det samme og noen forskjellige verdier. Og operatøren kommer tilbake når begge verdiene er de samme eller begge forholdene er sanne og returnerer falske i alle de andre tilfellene. Dette er hvordan og operatøren fungerer. I vårt eksempel vil vi også sjekke om vår og operatøren, som bruker denne metoden, fungerer på samme måte eller ikke.

Etter å ha importert vårt Numpy -bibliotek som NP, har vi tildelt verdier “1”, “1”, “0” og “0” til vår første matrise, og “1”, “0”, “1” og “0 ”Til vår andre matrise. Vi vil utføre og operatøren på våre matriser, og vi vil se utdataene ved å skrive ut utdata -matrisen som vi har initialisert av oss selv som vår tredje matrise. Vi vil utføre koden vår:

Importer numpy som NP
arr_x = [1, 1, 0, 0]
arr_y = [1, 0, 1, 0]
arr_z = np.logical_and (arr_x, arr_y)
trykk (arr_z)

Følgende er resultatet vi får fra koden vår. I denne utgangen kan vi se at funksjonen har returnert utgangen som sann og falsk. Det har bare returnert sant der verdiene til begge matriser var de samme. Så ved utgangen kan vi konkludere med at de numpy logiske operatørfunksjonene fungerer på samme måte som alle andre operatører og gir oss den nøyaktige produksjonen.

Eksempel # 02:

Før vi går videre til neste eksempel, la oss gjøre en ting klar: nuller og de er ikke bare verdiene som ble brukt under logiske operasjoner. I noen tilfeller bruker vi også verdier sanne og usant der sant er lik "1" og falsk er lik "0". I eksemplet nedenfor vil vi gi verdiene som er sanne og usant til våre inngangsarrays, og vi vil utføre logical_and -operasjonen på disse matriser og lagre resultatet i den tredje matrisen. Ved å skrive ut den tredje matrisen, vil vi se om operatøren vår fungerer på verdier som sanne og usant eller om den bare fungerer på null og en verdier.

Importer numpy som NP
arr_a = [falsk, falsk, sann, sann]
arr_b = [falsk, sann, falsk, sann]
arr_c = np.logical_and (arr_a, arr_b)
Print (ARR_C)

La oss først importere vårt Numpy Library, grunnen er at vi skal utføre noen operasjoner som er levert av Numpy Library. I neste linje vil vi erklære to matriser som vi lagrer matriseverdiene som sanne og usanne som vi forklarer ovenfor. Etter å ha erklært begge matriser som er "Arr_a" og "ARR_B", vil vi erklære en annen matrise som vil holde resultatet av vår og operasjonen utført mellom matriser som er sendt til vår logiske og operasjon. Til slutt vil vi skrive ut den resulterende matrisen ved hjelp av setningen ().

Her har metoden returnert til oss utdataene, og det er den nøyaktige utgangen vi ventet. Bare sant blir returnert der begge matriser er sanne. Det er slik og operatøren fungerer også i virkeligheten. Så vi kan antyde at det ikke bare fungerer på 0 og 1, men også fungerer på sant og usant også.

Eksempel # 03:

Etter å ha jobbet med Logical_and -operatøren vil det oppstå et spørsmål i tankene dine: Hva skjer hvis vi ikke gir matriser av samme form til operatøren vår? For å svare på spørsmålet ditt, har vi gjort dette eksemplet der vi har gitt to matriser av forskjellige former til vår funksjon for å se hvilken utgang vår funksjon kommer tilbake i så fall vil. Vi har erklært to matriser, den ene med “4” elementer i den og den andre med “5” elementer i den, slik at de ikke har samme form. Vi har lagret utgangen i den tredje matrisen, og vi vil skrive den ut for å sjekke utgangen. Nå vil vi utføre koden vår for å sjekke hva som skjer.

Importer numpy som NP
small_arr = [0, 0, 1, 1]
Large_arr = [1, 0, 1, 0, 1]
out_arr = np.logical_and (small_arr, stor_arr)
trykk (out_arr)

Importer nå det numpy biblioteket først og deretter definere to matriser med forskjellige størrelser som navngir dem “Small_arr” som inneholder “4” elementer og “Large_arr” som inneholder “5” elementer. Deretter vil vi definere et annet utvalg som vil inneholde det resulterende utvalget etter å ha utført logisk og operasjon. Til slutt vil vi skrive ut den resulterende matrisen ved hjelp av setningen ().

Dessverre har koden gitt oss en feil. Men etter dette eksemplet har vi lært at vi bare kan passere matriser med samme form til vår funksjon; Ellers vil det gi en feil. Hvis vi leser den siste feillinjen, kan vi forstå at systemet forteller oss at vi ikke kan kringkaste former 4 og 5 sammen. 4 og 5 er antall elementer som vi har gått til henholdsvis vår små_arr og stor_arr.

Konklusjon

Vi har lært om Numpy NP.logical_and () metode i denne guiden. Vi har diskutert hvor lett vi kan utføre logiske operasjoner på våre matriser ved hjelp av NP.logical_and () funksjon av numpy. Vi viste også hvordan systemet oppfører seg når vi passerer det matriser av forskjellige former. Vi har brukt "hvor" -parameteren vår funksjon i denne guiden som hjelper oss mye med å forstå konseptet.