Phenquestions
- Hva er Python NumPy-pakke?
- NumPy arrays
- Ulike operasjoner som kan gjøres over NumPy-matriser
- Noen flere spesielle funksjoner
Hva er Python NumPy-pakke?
Enkelt sagt står NumPy for 'Numerical Python', og det er det den har som mål å oppfylle, for å tillate komplekse numeriske operasjoner utført på N-dimensjonale array-objekter veldig enkelt og på en intuitiv måte. Det er kjernebiblioteket som brukes i vitenskapelig databehandling, med funksjoner til stede for å utføre lineære algebraiske operasjoner og statistiske operasjoner.
Et av de mest grunnleggende (og attraktive) konseptene for NumPy er bruken av N-dimensjonale matriseobjekter. Vi kan ta denne matrisen som bare en samling av rader og kolonne, akkurat som en MS-Excel-fil. Det er mulig å konvertere en Python-liste til et NumPy-array og betjene funksjoner over den.
NumPy Array-representasjon
Bare et notat før du starter, bruker vi et virtuelt miljø for denne leksjonen som vi laget med følgende kommando:
python -m virtualenv nummenkilde numpy / bin / aktivere
Når det virtuelle miljøet er aktivt, kan vi installere numpy-biblioteket i det virtuelle miljøet slik at eksempler vi oppretter neste kan utføres:
pip install nummenVi ser noe slikt når vi utfører kommandoen ovenfor:
La oss raskt teste om NumPy-pakken er installert riktig med følgende korte kodebit:
importer nummen som npa = np.matrise ([1,2,3])
skriv ut (a)
Når du har kjørt programmet ovenfor, bør du se følgende utdata:
Vi kan også ha flerdimensjonale matriser med NumPy:
multi_dimension = np.matrise ([(1, 2, 3), (4, 5, 6)])skriv ut (multidimensjon)
Dette vil gi en produksjon som:
[[1 2 3][4 5 6]]
Du kan også bruke Anaconda til å kjøre disse eksemplene, noe som er lettere og det er det vi har brukt ovenfor. Hvis du vil installere den på maskinen din, kan du se på leksjonen som beskriver “Slik installerer du Anaconda Python på Ubuntu 18.04 LTS ”og del din tilbakemelding. La oss nå gå videre til forskjellige typer operasjoner som kan utføres med Python NumPy-matriser.
Bruke NumPy-matriser over Python-lister
Det er viktig å spørre at når Python allerede har en sofistikert datastruktur for å inneholde flere elementer enn hvorfor trenger vi i det hele tatt NumPy-matriser? NumPy-matriser er foretrukket fremfor Python-lister på grunn av følgende årsaker:
- Praktisk å bruke til matematiske og beregningsintensive operasjoner på grunn av tilstedeværelsen av kompatible NumPy-funksjoner
- De går mye raskere på grunn av måten de lagrer data internt på
- Mindre minne
La oss bevis at NumPy arrays okkuperer mindre minne. Dette kan gjøres ved å skrive et veldig enkelt Python-program:
importer nummen som npimporttid
importer sys
python_list = rekkevidde (500)
trykk (sys.getsizeof (1) * len (python_list))
numpy_arr = np.arange (500)
skriv ut (numpy_arr.størrelse * numpy_arr.elementstørrelse)
Når vi kjører programmet ovenfor, får vi følgende utdata:
140004000
Dette viser at samme størrelsesliste er mer enn 3 ganger i størrelse sammenlignet med samme størrelse NumPy-matrise.
Utfører NumPy-operasjoner
I denne delen, la oss raskt se på operasjonene som kan utføres på NumPy-matriser.
Finne dimensjoner i matrisen
Ettersom NumPy-matrisen kan brukes i et hvilket som helst dimensjonalt rom for å holde data, kan vi finne dimensjonen til en matrise med følgende kodebit:
importer nummen som npnumpy_arr = np.matrise ([(1,2,3), (4,5,6)])
skriv ut (numpy_arr.ndim)
Vi vil se utdata som "2", da dette er en to-dimensjonal matrise.
Finne datatype for elementer i matrisen
Vi kan bruke NumPy-matrisen til å ha en hvilken som helst datatype. La oss nå finne ut datatypen til dataene en matrise inneholder:
other_arr = np.array ([('ærefrykt', 'b', 'cat')])skriv ut (annet_arr.dtype)
numpy_arr = np.matrise ([(1,2,3), (4,5,6)])
skriv ut (numpy_arr.dtype)
Vi brukte forskjellige typer elementer i kodebiten ovenfor. Her er utgangen dette skriptet viser:
Dette skjer når tegn tolkes som unicode-tegn og andre er åpenbar.
Omform elementene i en matrise
Hvis en NumPy-matrise består av 2 rader og 4 kolonner, kan den omformes til å inneholde 4 rader og 2 kolonner. La oss skrive en enkel kodebit for det samme:
original = np.matrise ([('1', 'b', 'c', '4'), ('5', 'f', 'g', '8')])trykk (original)
omformet = original.omforme (4, 2)
trykk (omformet)
Når vi har kjørt kodebiten ovenfor, får vi følgende utdata med begge matriser skrevet ut på skjermen:
[['1' 'b' 'c' '4']['5' 'f' 'g' '8']]
[['1' 'b']
['c' '4']
['5' 'f']
['g' '8']]
Legg merke til hvordan NumPy tok seg av å skifte og knytte elementene til nye rader.
Matematiske operasjoner på elementer i en matrise
Å utføre matematiske operasjoner på elementer i en matrise er veldig enkelt. Vi begynner med å skrive en enkel kodebit for å finne ut maksimum, minimum og tillegg av alle elementene i matrisen. Her er kodebiten:
numpy_arr = np.matrise ([(1, 2, 3, 4, 5)])skriv ut (numpy_arr.maks ())
skriv ut (numpy_arr.min ()
skriv ut (numpy_arr.sum())
skriv ut (numpy_arr.mener())
utskrift (np.sqrt (numpy_arr))
utskrift (np.std (numpy_arr))
I de to siste operasjonene ovenfor beregnet vi også kvadratroten og standardavviket til hver matriseelement. Ovennevnte utdrag vil gi følgende utdata:
51
15
3.0
[[1. 1.41421356 1.73205081 2. 2.23606798]]
1.4142135623730951
Konvertering av Python-lister til NumPy-matriser
Selv om du har brukt Python-lister i de eksisterende programmene dine, og du ikke vil endre all den koden, men likevel vil bruke NumPy-matriser i den nye koden din, er det godt å vite at vi enkelt kan konvertere en Python liste til en NumPy-matrise. Her er et eksempel:
# Lag to nye lister høyde og vekthøyde = [2.37, 2.87, 1.52, 1.51, 1.70, 2.05]
vekt = [91.65, 97.52, 68.25, 88.98, 86.18, 88.45]
# Lag to numpe ordninger fra høyde og vekt
np_height = np.array (høyde)
np_vekt = np.matrise (vekt)
Bare for å sjekke, kan vi nå skrive ut typen av en av variablene:
skriv ut (type (np_height))Og dette vil vise:
Vi kan nå utføre en matematisk operasjon over alle elementene samtidig. La oss se hvordan vi kan beregne BMI for folket:
# Beregn bmibmi = np_vekt / np_høyde ** 2
# Skriv ut resultatet
skrive ut (bmi)
Dette viser BMI for alle mennesker beregnet elementmessig:
[16.31682957 11.8394056 29.54033934 39.02460418 29.8200692 21.04699584]Er ikke det enkelt og hendig? Vi kan til og med filtrere data enkelt med en tilstand i stedet for en indeks innenfor firkantede parenteser:
bmi [bmi> 25]Dette vil gi:
matrise ([29.54033934, 39.02460418, 29.8200692])Lag tilfeldige sekvenser og repetisjoner med NumPy
Med mange funksjoner til stede i NumPy for å lage tilfeldige data og ordne dem i ønsket form, brukes NumPy-matriser mange ganger til å generere testdatasett mange steder, inkludert feilsøkings- og testformål. Hvis du for eksempel vil opprette en matrise fra 0 til n, kan vi bruke arange (merk singelen 'r') som den gitte utdraget:
utskrift (np.arange (5)Dette vil returnere utdataene som:
[0 1 2 3 4]Den samme funksjonen kan brukes til å gi en lavere verdi slik at matrisen starter fra andre tall enn 0:
utskrift (np.arange (4, 12))Dette vil returnere utdataene som:
[4 5 6 7 8 9 10 11]Tallene trenger ikke være kontinuerlige, de kan hoppe over et fiksetrinn som:
utskrift (np.arange (4, 14, 2))Dette vil returnere utdataene som:
[4 6 8 10 12]Vi kan også få tallene i avtagende rekkefølge med en negativ hoppverdi:
utskrift (np.arange (14, 4, -1))Dette vil returnere utdataene som:
[14 13 12 11 10 9 8 7 6 5]Det er mulig å finansiere n tall mellom x og y med lik mellomrom med linspace-metoden, her er kodebiten for det samme:
np.linspace (start = 10, stop = 70, num = 10, dtype = int)Dette vil returnere utdataene som:
array ([10, 16, 23, 30, 36, 43, 50, 56, 63, 70])Vær oppmerksom på at utgangselementene ikke er like fordelt. NumPy gjør sitt beste for å gjøre det, men du trenger ikke å stole på det da det gjør avrundingen.
Til slutt, la oss se på hvordan vi kan generere et sett med tilfeldig sekvens med NumPy, som er en av de mest brukte funksjonene for testformål. Vi vil overføre en rekke tall til NumPy som vil bli brukt som et første og siste punkt for tilfeldige tall:
utskrift (np.tilfeldig.randint (0, 10, størrelse = [2,2]))Ovennevnte tekstutdrag oppretter en 2 av 2 dimensjonal NumPy-matrise som vil inneholde tilfeldige tall mellom 0 og 10. Her er prøveutgangen:
[[0 4][8 3]]
Vær oppmerksom på at når tallene er tilfeldige, kan utdataene variere selv mellom de to løpene på samme maskin.
Konklusjon
I denne leksjonen så vi på forskjellige aspekter av dette databiblioteket som vi kan bruke med Python for å beregne enkle så vel som komplekse matematiske problemer som kan oppstå i forskjellige brukssaker. NumPy er et av de viktigste beregningsbiblioteket når det gjelder datateknikk og beregning av numerisk dat, definitivt en ferdighet vi trenger å ha under beltet.
Del din tilbakemelding på leksjonen på Twitter med @sbmaggarwal og @LinuxHint.
