I denne opplæringen lærer du hvordan du bruker NumPy reshape() til å omforme NumPy-matriser uten å endre de originale dataene.
Når du arbeider med Numpy-matriser, vil du kanskje ofte omforme en eksisterende matrise til en matrise med forskjellige dimensjoner. Dette kan være spesielt nyttig når du transformerer data i flere trinn.
Og NumPy reshape() hjelper deg å gjøre det enkelt. I løpet av de neste minuttene vil du lære syntaksen for å bruke reshape(), og også omforme arrays til forskjellige dimensjoner.
Innholdsfortegnelse
Hva er omforming i NumPy-matriser?
Når du arbeider med NumPy-matriser, vil du kanskje først lage en 1-dimensjonal matrise med tall. Og deretter omforme den til en matrise med ønsket dimensjon.
Dette er spesielt nyttig når dimensjonene til den nye matrisen ikke er kjent i utgangspunktet eller antas under utførelse. Eller det kan også være mulig at et bestemt databehandlingstrinn krever at inngangen har en bestemt form.
Det er her omforming kommer godt med.
Tenk for eksempel på følgende illustrasjon. Vi har en vektor – en endimensjonal matrise med 6 elementer. Og vi kan omforme den til matriser med former 2×3, 3×2, 6×1, og så videre.
▶️ For å følge med eksemplene i denne opplæringen, må du ha Python og NumPy installert. Hvis du ikke har NumPy ennå, sjekk ut vår NumPy-installasjonsveiledning.
Du kan nå gå videre og importere NumPy under aliaset np, ved å kjøre: import numpy som np.
La oss fortsette å lære syntaksen i neste avsnitt.
Syntaks for NumPy omforming()
Her er syntaksen for å bruke NumPy omforming():
np.reshape(arr, newshape, order="C"|'F'|'A')
- arr er et hvilket som helst gyldig NumPy matriseobjekt. Her er det matrisen som skal omformes.
- newshape er formen til den nye matrisen. Det kan enten være et heltall eller en tuppel.
- Når newshape er et heltall, er den returnerte matrisen endimensjonal.
- rekkefølge refererer til rekkefølgen du ønsker å lese i elementene i matrisen som skal omformes.
- Standardverdien er «C», som betyr at elementene i den opprinnelige matrisen vil bli lest i en C-lignende indekseringsrekkefølge (starter med 0)
- «F» står for Fortran-lignende indeksering (starter med 1). Og «A» leser inn elementene i enten C-lignende eller Fortran-lignende rekkefølge avhengig av minneoppsettet til array arr.
Så hva returnerer np.reshape()?
Den returnerer en omformet visning av den opprinnelige matrisen hvis mulig. Ellers returnerer den en kopi av matrisen.
I linjen ovenfor nevnte vi at NumPy reshape() ville prøve å returnere en visning når det er mulig. Ellers returnerer den en kopi. La oss fortsette å diskutere forskjellene mellom en visning og en kopi.
Vis vs. kopi av NumPy-matriser
Som navnet antyder, er kopi en kopi av den originale matrisen. Og eventuelle endringer i kopien vil ikke påvirke den originale matrisen.
På den annen side refererer visning ganske enkelt til omformet visning av den originale matrisen. Dette betyr at enhver endring som gjøres i visningen også vil påvirke den opprinnelige matrisen og omvendt.
Bruk NumPy reshape() for å omforme 1D Array til 2D Arrays
#1. La oss starte med å lage prøvematrisen ved å bruke np.arange().
Vi trenger en matrise med 12 tall, fra 1 til 12, kalt arr1. Siden NumPy arange()-funksjonen ekskluderer endepunktet som standard, setter du stoppverdien til 13.
La oss nå bruke syntaksen ovenfor, og omforme arr1 med 12 elementer til en 2D-array av form (4,3). La oss kalle dette arr2 med 4 rader og 3 kolonner.
import numpy as np
arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr2 = np.reshape(arr1,(4,3))
print("nReshaped array:")
print(arr2)
La oss ta en titt på de originale og omformede matrisene.
Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]]
I stedet for å sende inn matrisen som et argument np.reshape(), kan du også kalle .reshape()-metoden på den opprinnelige matrisen.
Du kan kjøre dir(arr1), og den vil liste ned alle mulige metoder og attributter som du kan bruke på matriseobjektet arr1.
dir(arr1) # Output [ ... ... 'reshape' ... .. ]
I kodecellen ovenfor kan du se at .reshape() er en gyldig metode å bruke på den eksisterende NumPy-matrisen arr1.
▶️ Så du kan også bruke følgende forenklede syntaks for å omforme NumPy-matriser.
arr.reshape(d0,d1,...,dn) # where: # d0, d1,..,dn are the dimensions of the reshaped array # d0 * d1 * ...* dn = N, the number of elements in arr
For resten av denne opplæringen, la oss bruke denne syntaksen i eksemplene våre.
#2. La oss prøve å omforme vår 12-element vektor til en 12 x 1 matrise.
import numpy as np
arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr3 = arr1.reshape(12,1)
print("nReshaped array:")
print(arr3)
I utdataene nedenfor kan du se at matrisen har blitt omformet etter behov.
Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[ 1] [ 2] [ 3] [ 4] [ 5] [ 6] [ 7] [ 8] [ 9] [10] [11] [12]]
❔ Så, hvordan sjekker vi om vi har fått en kopi eller en visning?
For å sjekke dette kan du kalle opp baseattributtet på den returnerte matrisen.
- Hvis matrisen er en kopi, vil basisattributtet være Ingen.
- Hvis matrisen er en visning, vil baseattributtet være den opprinnelige matrisen.
La oss raskt bekrefte dette.
arr3.base # Output array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
Som du kan se, returnerer baseattributtet til arr3 den opprinnelige matrisen. Dette betyr at vi har mottatt en visning av den opprinnelige matrisen.
#3. La oss nå prøve å omforme vektoren til en annen gyldig 2 x 6 matrise.
import numpy as np
arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr4 = arr1.reshape(2,6)
print("nReshaped array:")
print(arr4)
Og her er utgangen:
Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[ 1 2 3 4 5 6] [ 7 8 9 10 11 12]]
I neste avsnitt, la oss omforme arr1 til en 3D-array.
Bruk NumPy reshape() for å omforme 1D Array til 3D Arrays
For å omforme arr1 til en 3D-matrise, la oss sette de ønskede dimensjonene til (1, 4, 3).
import numpy as np
arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr3D = arr1.reshape(1,4,3)
print("nReshaped array:")
print(arr3D)
Vi har nå laget en 3D-matrise med de samme 12 elementene som den originale matrisen arr1.
Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]]]
Slik feilsøker du verdifeil under omforming
Hvis du husker syntaksen, er omforming bare gyldig når produktet av dimensjonene er lik antall elementer i matrisen.
import numpy as np
arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr2D = arr1.reshape(4,4)
print("nReshaped array:")
print(arr2D)
Her prøver du å omforme en 12-elements array til en 4×4 array med 16 elementer. Tolken kaster en verdifeil, som vist nedenfor.
Original array, before reshaping:
[ 1 2 3 4 5 6 7 8 9 10 11 12]
-----------------------------------------------------------
ValueError
Traceback (most recent call last)
<ipython-input-11-63552bcc8c37> in <module>()
6
7 # Reshape array
----> 8 arr2 = arr1.reshape(4,4)
9 print("nReshaped array:")
10 print(arr2)
ValueError: cannot reshape array of size 12 into shape (4,4)
For å unngå slike feil kan du bruke -1 for automatisk å utlede formen for en av dimensjonene – basert på det totale antallet elementer.
For eksempel, hvis du kjenner n – 1 dimensjoner på forhånd, kan du bruke -1 for å utlede den n-te dimensjonen i den omformede matrisen.
Hvis du har en 24-elements matrise og du ønsker å omforme den til en 3D-matrise. Anta at du trenger 3 rader og 4 kolonner. Du kan sende inn verdien på -1 langs den tredje dimensjonen.
import numpy as np
arr1 = np.arange(1,25)
print("Original array, before reshaping:n")
print(arr1)
# Reshape array
arr_res = arr1.reshape(4,3,-1)
print("nReshaped array:")
print(arr_res)
print(f"Shape of arr_res:{arr_res.shape}")
Når du undersøker formen på formmatrisen, kan du se at den omformede matrisen har formen 2 langs den tredje dimensjonen.
Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24] Reshaped array: [[[ 1 2] [ 3 4] [ 5 6]] [[ 7 8] [ 9 10] [11 12]] [[13 14] [15 16] [17 18]] [[19 20] [21 22] [23 24]]] Shape of arr_res:(4, 3, 2)
Dette er spesielt nyttig for å flate ut en matrise. Og du vil lære om det i neste avsnitt.
Bruk NumPy reshape() for å flate ut en matrise
Det er tider når du trenger å gå tilbake fra N-dimensjonale arrays til en flatet array. Anta at du vil flate ut et bilde til en lang vektor av piksler.
La oss kode et enkelt eksempel ved å bruke følgende trinn:
- Generer en 3 x 3 gråtonebildematrise, img_arr – med piksler i området 0 til 255.
- Deretter flater du ut denne img_arr og skriver ut den flattede matrisen, flat_arr.
- Skriv også ut formene til img_arr og flat_arr for å bekrefte.
img_arr = np.random.randint(0, 255, (3,3))
print(img_arr)
print(f"Shape of img_arr: {img_arr.shape}")
flat_arr = img_arr.reshape(-1)
print(flat_arr)
print(f"Shape of flat_arr: {flat_arr.shape}")
Her er utgangen.
[[195 145 77] [ 63 193 223] [215 43 36]] Shape of img_arr: (3, 3) [195 145 77 63 193 223 215 43 36] Shape of flat_arr: (9,)
I kodecellen ovenfor kan du se at flat_arr er en 1D-vektor med pikselverdier med 9 elementer.
Oppsummering👩🏫
Det er på tide å raskt gjennomgå det vi har lært.
- Bruk np.reshape(arr, newshape) for å omforme arr til formen spesifisert i newshape. newshape er en tuppel som spesifiserer dimensjonene til den omformede matrisen.
- Alternativt kan du bruke arr.reshape(d0, d1, …, dn) for å omforme arr til å ha formen d0 x d1 x … x dn
- Sjekk om d0 * d1 * …* dn = N, antall elementer i den opprinnelige matrisen, for å unngå verdifeil under omforming.
- Bruk -1 for maksimalt én dimensjon i den nye formen hvis du vil at dimensjonen skal utledes automatisk.
- Til slutt kan du bruke arr.reshape(-1) for å flate ut matrisen.
Nå som du vet hvordan du bruker NumPy reshape(), lær hvordan NumPy linspace()-funksjonen fungerer.
Du kan prøve kodeeksemplene i Jupyter notatbok hvis du vil. Hvis du leter etter andre utviklingsmiljøer, sjekk ut vår guide om Jupyter-alternativer.