Datavitenskap

Python NumPy-veiledning

Python NumPy-veiledning
I denne leksjonen om Python NumPy-biblioteket vil vi se på hvordan dette biblioteket lar oss administrere kraftige N-dimensjonale matriseobjekter med sofistikerte funksjoner til stede for å manipulere og operere over disse matriser. For å gjøre denne leksjonen komplett, vil vi dekke følgende seksjoner:

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 nummen
kilde 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 nummen

Vi 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 np
a = 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:

La oss bevis at NumPy arrays okkuperer mindre minne. Dette kan gjøres ved å skrive et veldig enkelt Python-program:

importer nummen som np
importtid
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:

14000
4000

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 np
numpy_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:

int64

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:

5
1
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 vekt
hø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 bmi
bmi = 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.

5 beste arkadespill for Linux
I dag er datamaskiner seriøse maskiner som brukes til spill. Hvis du ikke kan få den nye høye poengsummen, vil du vite hva jeg mener. I dette innlegge...
Kamp for Wesnoth 1.1. 3.6 Utvikling utgitt
Kamp for Wesnoth 1.1. 3.6 utgitt i forrige måned, er den sjette utgivelsen i 1.1. 3.x-serien, og den leverer en rekke forbedringer, spesielt til bruke...
Slik installerer du League Of Legends på Ubuntu 14.04
Hvis du er fan av League of Legends, er dette en mulighet for deg å prøvekjør League of Legends. Merk at LOL støttes på PlayOnLinux hvis du er en linu...