Share
numerisk er en pakke som opprinnelig ble utviklet av Jim Hugunin. Det regnes som forfader til NumPy, et Python-bibliotek og et åpen kildekode-prosjekt opprettet av Travis Oliphant som står for Numerisk Python. Travis opprettet NumPy ved å inkorporere funksjoner av Numarray pakke inn i Numerisk.
Den grunnleggende ideen til NumPy er støtte for flerdimensjonale arrays. Så NumPy kan betraktes som grunnlaget for numerisk databehandling i Python, og er opprettet for å aktivere Python til å brukes til å løse matematiske og vitenskapelige problemer. NumPy-modulen gir oss hundrevis av nyttige matematiske funksjoner i tillegg til konstanter som grunnlaget for naturlige logaritmer (e) og pi (π).
Denne opplæringen viser hvordan vi kan bruke NumPy til å arbeide med flerdimensjonale arrays, og beskriver ndarray-objektet, et grunnleggende objekt for biblioteket.
Siden Python ikke kommer med NumPy, er det første trinnet å bruke dette biblioteket å gå videre og installere det. Dette kan enkelt gjøres ved å kjøre følgende kommando i kommandoprompten din:
pip installere numpy
For å sikre at NumPy ble installert, kjør følgende kommandoer i Pythons IDLE:
Hvis importere erklæringen går i hvert fall vellykket, så er du klar!
De ndarray er et grunnleggende formål med NumPy. Dette objektet er en N-dimensjonal array, noe som betyr at den inneholder en samling av elementer av samme type indeksert ved hjelp av N (dimensjoner av arrayet) heltall.
De viktigste egenskapene til ndarray er datatype (dtype), form, størrelse, itemsize, data, og ndim. La oss lære hva hvert attributt betyr gjennom et eksempel.
I dette eksemplet skal vi bruke NumPy til å lage en matrise. Jeg vil ikke gi dimensjonene til arrayet og annen informasjon, som vi vil se at ved hjelp av ovenstående attributter.
Legg merke til at vi brukte matrise funksjon for å lage en matrise. Utgangen av det ovennevnte skriptet er som følger:
La oss nå gå tilbake til våre attributter.
De dtype Attributtet kan kjøres som vist i følgende setning:
data_type = my_array.dtype
Ovennevnte utsagn vil returnere int32 som datatype. Dette betyr at elementene i arrayet er av typen int32. jeg får 32 som jeg bruker en 32-bit Python. Hvis du bruker en 64-bit Python, får du det int64, men vi har å gjøre med heltall på slutten.
Siden NumPy brukes i vitenskapelig databehandling, har den mange datatyper, som vist i dokumentasjonen. Legg merke til at flertallet av NumPy datatyper slutter med et tall, hvilket indikerer antall biter som er knyttet til den typen (dette ble nevnt kort i avsnittet ovenfor).
Følgende eksempler viser hvordan vi kan konvertere fra en type til en annen:
bool (35) bool (0) bool (-1) float (True) int (67.7) float (87)
Ovennevnte utsagn returnerer følgende:
True False True 1.0 67 87.0
Selv om vi kan konvertere fra en type til en annen, er det viktig å merke seg at vi ikke kan konvertere et komplekst tall til et heltall eller en flyt.
Formattributtet returnerer en tuple av array dimensjonene. Så følgende erklæring:
array_shape = my_array.shape
vil returnere (4,4), noe som betyr at vårt utvalg består av 4 rader og 4 kolonner.
De størrelse attributt returnerer antall elementer i arrayet. Dermed, hvis vi skriver:
array_size = my_array.size
vi vil få 16 som resultat, noe som betyr at vi har 16 elementer i vårt utvalg.
De itemsize Attributt returnerer størrelsen på ett arrayelement i byte. Følgende uttalelse:
array_item_size = my_array.itemsize
vil returnere 4. Dette betyr at hvert array element har størrelse 4-byte.
De data Attributt er en Python-bufferobjekt som peker på starten av arrayets data. Hvis vi skriver inn følgende:
array_location = my_array.data
vi får følgende:
Attributtet ndim vil returnere nummeret på array dimensjonene. Så skriver du følgende setning:
array_dimension = my_array.ndim
vil returnere 2, Det er arrayet består av to dimensjoner.
Etter å ha forstått hva de forskjellige ndarray attributter betyr, la oss ta en titt på noen flere eksempler på bruk ndarray.
Si at vi vil lage et nytt utvalg med en rad og fem kolonner. Vi ville gjøre det som følger:
my_array = np.array ((1, 2, 3, 4, 5))
Utgangen av ovennevnte utsagn er: [1 2 3 4 5].
I dette eksemplet skal jeg omskrive det første eksemplet i denne opplæringen, men bruke [] i stedet for (), som følger:
Dette eksemplet viser hvordan vi bruker en strukturert datatype, der vi erklærer feltnavnet og tilhørende datatype:
Accentsconagua
importer numpy som np height_type = np.dtype ([('høyde', np.float)])Hvis vi print (DATA_TYPE), vi får følgende:
[('høyde', 'Vi kan søke på height_type til en ndarray objekt, som følger:
import numpy som np height_type = np.dtype ([('høyde', np.float)]) my_array = np.array ([(1,78,), (1,69,), (1,88,)], dtype = height_type) tilgang innhold i høyde kolonne utskrift (my_array ['høyde'])Velger elementer
I denne delen skal jeg vise deg hvordan du velger bestemte elementer i matrisen. For vårt utvalg vist under avsnittet "Ndarry Object", la oss si at vi vil velge elementet som ligger i tredje rad og fjerde kolonne. Vi vil gjøre det som følger:
my_array [2,3]
Husk at indeksering her starter på 0, og det er derfor vi skrev [2,3] i stedet for [3,4].
Mer om NumPy Arrays
I denne delen skal vi dype dypere inn i NumPy-arrays.
Tom (Uninitialized) Arrays
Vi kan lage et tomt array ved hjelp av numpy.empty med følgende syntaks:
numpy.empty (form, dype, rekkefølge)
Betydningen av parametrene i konstruksjonen ovenfor er som følger
- Form: formen (dimensjonene) av den tomme arrayen.
- dtype: ønsket utskriftstype, som er valgfri.
- Rekkefølge: Hvis du vil ha en C-style (row-major) -gruppe, skriver du inn
C; Hvis du vil ha en FORTRAN-stil (kolonne-major) -gruppe, ville du skrive F.
Så la oss lage en tom [2,2] utvalg av type int. Det kan vi gjøre som følger:
importer numpy som np empty_array = np.empty ([2,2], dtype = int) print (empty_array)
Ovennevnte skript returnerer følgende tilfeldige verdier ettersom arrayet ikke ble initialisert:
[[1852795252 111218] [7500288 53018624]]
Array fylt med nuller
For å lage en matrise der elementene er alle nuller, bruker vi numpy.zeros. Konstruktøren her har samme syntaks og parametre som i numpy.empty. Så, hvis vi vil lage en [2,2] nuller utvalg av type int, det kan vi gjøre som følger:
importer numpy som np zeros_array = np.zeros ([2,2], dtype = int) print (zeros_array)
Ovennevnte skript vil returnere følgende:
[[0 0] [0 0]]
En matrise med alle elementer som har verdien 1 kan enkelt opprettes på samme måte som ovenfor, men med numpy.ones.
Arrayer med jevnt fordelte verdier innenfor et gitt område
Vi kan bruke numpy.arange å opprette en matrise med jevnt fordelte verdier innenfor et spesifisert område. Konstruktøren har følgende format:
numpy.arange (start, stopp, trinn, dype)
Nedenfor er betydningen av hver parameter:
- Start: Dette er hvor intervallet begynner. Standardverdien er
0. - Stoppe: slutten av intervallet, forutsatt at dette nummeret ikke er inkludert.
- Skritt: avstanden mellom verdiene. Standardverdien er
1. - dtype: datatypen for utgangen. Hvis ikke spesifisert, vil datatypen være den samme som for inngangen.
La oss ta et eksempel på numpy.arange.
importer numpy som np my_array = np.arange (1,10) print (my_array)
Resultatet av det ovennevnte skriptet er:
[1 2 3 4 5 6 7 8 9]
Omforming av en array
For å omforme en matrise bruker vi numpy.reshape funksjon. Denne funksjonen gir en ny form til en matrise uten å endre dataene. Som vist i dokumentasjonen har funksjonen følgende egenskaper: numpy.reshape (a, newshape, order = "C"), hvor en er gruppen vi ønsker å omforme, newshape er den nye ønskede formen forutsatt at den nye formen skal være kompatibel med opprinnelsesformen, og rekkefølge er et valgfritt argument som refererer til indeksrekkefølgen vi vil bruke til å lese begge tabellene en og hvordan vi ønsker å plassere elementene i den omformede gruppen.
C betyr lesing / skriving av elementene ved hjelp av C-lignende indeksrekkefølge; F betyr å lese / skrive elementene ved hjelp av Fortran-lignende indeksrekkefølge, og EN betyr å lese / skrive elementene i Fortran-lignende indeksrekkefølgen hvis en er Fortran tilstede i minnet, C-lignende rekkefølge ellers.
Jeg vet at jeg har dekket mye i avsnittet ovenfor, men konseptet er veldig enkelt. La oss ta vår originale matrise my_array og prøv å omforme den. Husk at det nye arrayet (omformet array) må være kompatibelt med den opprinnelige gruppen. For eksempel, my_array har formen (4,4), det er vi har 16 elementer i arrayet, og den nye arrayen må ha det antall elementer.
Vi kan omforme my_array ved å sette den til å ha åtte rader og to kolonner, som følger:
import numpy som np my_array = np.array ((6, 12, 93, 2), (5, 26, 78, 90), (3, 12, 16, 22), (5, 3, 1, 16) )) my_array_reshaped = np.reshape (my_array, (8,2))
I så fall vil vi ha følgende utgang, hvor vi også har 16 elementer.
[[6 12] [93 2] [5 26] [78 90] [3 12] [16 22] [5 3] [1 16]]
Hva om vi skriver reshape-setningen som følger?
my_array_reshaped = np.reshape (my_array, (8,3))
I dette tilfellet vil du få følgende feil:
ValueError: kan ikke omforme rekkevidde 16 i form (8,3)
Sammenkobling Arrays
Hvis vi ønsker å bli med to eller flere arrays av samme form langs en bestemt akse, kan vi bruke numpy.concatenate funksjon. Syntaxen til denne funksjonen er: numnumpy.concatenate ((a1, a2, ...), akse = 0) y.concatenate. a1 og a2 er arrays med samme form, og akser er aksen langs hvilken arrays vil bli slått sammen, forutsatt at standard er 0.
Igjen, la oss ta et eksempel for å forenkle konseptet. I dette eksemplet vil vi bli med (sammenkjørende) tre arrays.
import numpy som np array_1 = np.array ((1, 2), (3, 4)) array_2 = np.array (((5, 6), (7, 8)) array_3 = np.array ( ((9, 10), (11, 12))) contacted_array = np.concatenate ((array_1, array_2, array_3)) print ('Første Array:') print (array_1) print ('Second Array:') array_2) print ('Third Array:') print (array_3) print ('Concatenated Array:') print (contacted_array)Utgangen av den ovennevnte koden er som følger:
Første Array: [[1 2] [3 4]] Andre Array: [[5 6] [7 8]] Tredje Array: [[9 10] [11 12]] Konkludert Array: [[1 2] [3 4 ] [5 6] [7 8] [9 10] [11 12]]
Splitting Arrays
I motsetning til sammenføyningsarrayer som vist i avsnittet ovenfor, kan vi se hvordan vi kan dele (dele) en matrise i flere underarrayer. Dette kan gjøres ved å bruke følgende funksjon:
numpy.split (ary, indices_or_sections, axis = 0)
ær er arrayet delt inn i sub-arrays. Angående indices_or_sections, hvis det er et heltall N, arrayet vil bli delt inn i N like arrays langs akser. Hvis det er en 1-D rekke sorterte heltall, angir oppføringene hvor langs akser arrayet er delt. akser er aksen langs hvilken å splitte.
Følgende eksempel vil reversere det vi har gjort i det forrige eksempelet, det vil si å returnere sammenkoblet array til sine tre gruppekomponenter:
import numpy som np concatenated_array = np.array ((1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, 12))) split_array = np.split (concatenated_array, 3) print ('Original Array:') print (concatenated_array) print ('Split sub-arrayer') print ('First Sub array') utskrift (split_array [0]) print Sub-array ') utskrift (split_array [1]) utskrift (' Tredje sub-array ') utskrift (split_array [2])Utgangen av det ovennevnte skriptet er:
Opprinnelige Array: [[1 2] [3 4] [5 6] [7 8] [9 10] [11 12]] Delte delrader: Første underarrangement [[1 2] [3 4]] Andre del -array [[5 6] [7 8]] Tredje underarrangement [[9 10] [11 12]]
Konklusjon
Som vi så i denne opplæringen, gjør NumPy det svært fleksibelt for å jobbe med arrays. Opplæringen var bare en skrap på overflaten av dette interessante Python-biblioteket. NumPy har fortsatt mange flere funksjoner å se på for å få mest mulig ut av dette biblioteket. En omfattende bok om emnet av NumPy-skaperen selv er Guide to NumPy.
Videre se hva vi har tilgjengelig for salg og for studier på markedet, og ikke nøl med å stille spørsmål og gi din verdifulle tilbakemelding ved å bruke feedet under.
