I den här handledningen kommer du att lära dig hur du använder NumPy reshape() för att omforma NumPy-matriser utan att ändra originaldata.
När du arbetar med Numpy-arrayer kanske du ofta vill omforma en befintlig array till en array med olika dimensioner. Detta kan vara särskilt användbart när du transformerar data i flera steg.
Och NumPy reshape() hjälper dig att göra det enkelt. Under de närmaste minuterna kommer du att lära dig syntaxen för att använda reshape(), och även omforma arrayer till olika dimensioner.
Innehållsförteckning
Vad är omformning i NumPy-arrayer?
När du arbetar med NumPy-matriser kanske du först vill skapa en 1-dimensionell matris med tal. Och sedan omforma den till en array med önskad dimension.
Detta är särskilt användbart när dimensionerna för den nya arrayen inte är kända från början eller antas under exekvering. Eller så kan det också vara möjligt att ett visst databearbetningssteg kräver att inmatningen är av en specifik form.
Här kommer omformning väl till pass.
Tänk till exempel på följande illustration. Vi har en vektor – en endimensionell matris med 6 element. Och vi kan omforma det till arrayer av former 2×3, 3×2, 6×1, och så vidare.
▶️ För att följa exemplen i denna handledning måste du ha Python och NumPy installerade. Om du inte har NumPy ännu, kolla in vår NumPy installationsguide.
Du kan nu gå vidare och importera NumPy under aliaset np, genom att köra: import numpy som np.
Låt oss fortsätta att lära oss syntaxen i nästa avsnitt.
Syntax för NumPy reshape()
Här är syntaxen för att använda NumPy omformning():
np.reshape(arr, newshape, order="C"|'F'|'A')
- arr är vilket giltigt NumPy-arrayobjekt som helst. Här är det arrayen som ska omformas.
- newshape är formen på den nya arrayen. Det kan vara antingen ett heltal eller en tupel.
- När newshape är ett heltal är den returnerade arrayen endimensionell.
- ordning hänvisar till den ordning som du vill läsa i elementen i arrayen som ska omformas.
- Standardvärdet är ’C’, vilket innebär att elementen i den ursprungliga arrayen kommer att läsas i en C-liknande indexeringsordning (börjar med 0)
- ’F’ står för Fortran-liknande indexering (börjar med 1). Och ’A’ läser in elementen i antingen C-liknande eller Fortran-liknande ordning beroende på minneslayouten för arrayen.
Så vad returnerar np.reshape()?
Den returnerar en omformad vy av den ursprungliga arrayen om möjligt. Annars returnerar den en kopia av arrayen.
I raden ovan nämnde vi att NumPy reshape() skulle försöka returnera en vy när det var möjligt. Annars returnerar den en kopia. Låt oss fortsätta att diskutera skillnaderna mellan en vy och en kopia.
Visa kontra kopia av NumPy-arrayer
Som namnet antyder är kopia en kopia av den ursprungliga arrayen. Och eventuella ändringar som görs i kopian kommer inte att påverka den ursprungliga arrayen.
Å andra sidan hänvisar vy helt enkelt till en omformad vy av den ursprungliga arrayen. Detta innebär att alla ändringar som görs i vyn också kommer att påverka den ursprungliga arrayen och vice versa.
Använd NumPy reshape() för att omforma 1D Array till 2D Arrays
#1. Låt oss börja med att skapa provmatrisen med hjälp av np.arange().
Vi behöver en matris med 12 nummer, från 1 till 12, kallad arr1. Eftersom funktionen NumPy arange() exkluderar slutpunkten som standard, ställ in stoppvärdet till 13.
Låt oss nu använda ovanstående syntax och omforma arr1 med 12 element till en 2D-array av form (4,3). Låt oss kalla detta arr2 med 4 rader och 3 kolumner.
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)
Låt oss ta en titt på de ursprungliga och omformade arrayerna.
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]]
Istället för att skicka in arrayen som ett argument np.reshape(), kan du också anropa metoden .reshape() på den ursprungliga arrayen.
Du kan köra dir(arr1), och det kommer att lista ner alla möjliga metoder och attribut som du kan använda på arrayobjektet arr1.
dir(arr1) # Output [ ... ... 'reshape' ... .. ]
I ovanstående kodcell kan du se att .reshape() är en giltig metod att använda på den befintliga NumPy-matrisen arr1.
▶️ Så du kan också använda följande förenklade syntax för att omforma 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
För resten av denna handledning, låt oss använda den här syntaxen i våra exempel.
#2. Låt oss försöka omforma vår 12-element vektor till en 12 x 1 array.
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 utgången nedan kan du se att arrayen har omformats efter 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å, hur kontrollerar vi om vi har fått en kopia eller en vy?
För att kontrollera detta kan du anropa basattributet på den returnerade arrayen.
- Om arrayen är en kopia kommer basattributet att vara None.
- Om arrayen är en vy kommer basattributet att vara den ursprungliga arrayen.
Låt oss snabbt verifiera detta.
arr3.base # Output array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
Som du kan se, returnerar basattributet för arr3 den ursprungliga matrisen. Det betyder att vi har fått en bild av den ursprungliga arrayen.
#3. Låt oss nu försöka omforma vektorn till en annan giltig 2 x 6 array.
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)
Och här är resultatet:
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 nästa avsnitt, låt oss omforma arr1 till en 3D-array.
Använd NumPy reshape() för att omforma 1D Array till 3D Arrays
För att omforma arr1 till en 3D-array, låt oss ställa in önskade dimensioner till (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 nu skapat en 3D-array med samma 12 element som den ursprungliga arrayen 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]]]
Hur man felsöker värdefel under omformning
Om du kommer ihåg syntaxen är omformning endast giltig när produkten av dimensionerna är lika med antalet element i arrayen.
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)
Här försöker du omforma en 12-elements array till en 4×4 array med 16 element. Tolken kastar ett värdefel, som visas nedan.
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)
För att undvika sådana fel kan du använda -1 för att automatiskt härleda formen för en av dimensionerna – baserat på det totala antalet element.
Till exempel, om du känner till n – 1 dimensioner i förväg, kan du använda -1 för att härleda den n:te dimensionen i den omformade matrisen.
Om du har en array med 24 element och du vill omforma den till en 3D-array. Anta att du behöver 3 rader och 4 kolumner. Du kan skicka in värdet -1 längs den tredje dimensionen.
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 att den omformade matrisen har formen 2 längs den tredje dimensionen.
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)
Detta är särskilt användbart för att platta till en array. Och du kommer att lära dig om det i nästa avsnitt.
Använd NumPy reshape() för att platta till en array
Det finns tillfällen då du skulle behöva gå tillbaka från N-dimensionella arrayer till en tillplattad array. Anta att du vill platta till en bild till en lång vektor av pixlar.
Låt oss koda ett enkelt exempel med följande steg:
- Generera en 3 x 3 gråskalebildmatris, img_arr—med pixlar i intervallet 0 till 255.
- Platta sedan ut denna img_arr och skriv ut den tillplattade arrayen, flat_arr.
- Skriv också ut formerna av img_arr och flat_arr för att verifiera.
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}")
Här är utgången.
[[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 ovanstående kodcell kan du se att flat_arr är en 1D-vektor med pixelvärden med 9 element.
Sammanfattning👩🏫
Det är dags att snabbt se över vad vi har lärt oss.
- Använd np.reshape(arr, newshape) för att omforma arr till den form som anges i newshape. newshape är en tuppel som anger dimensionerna för den omformade arrayen.
- Alternativt kan du använda arr.reshape(d0, d1, …, dn) för att omforma arr till att ha formen d0 x d1 x … x dn
- Kontrollera om d0 * d1 * …* dn = N, antalet element i den ursprungliga arrayen, för att undvika värdefel under omformning.
- Använd -1 för högst en dimension i den nya formen om du vill att dimensionen ska härledas automatiskt.
- Slutligen kan du använda arr.reshape(-1) för att platta till arrayen.
Nu när du vet hur du använder NumPy reshape(), lär dig hur funktionen NumPy linspace() fungerar.
Du kan prova kodexemplen i Jupyter anteckningsbok om du vill. Om du letar efter andra utvecklingsmiljöer, kolla in vår guide om Jupyter-alternativ.