Ebből az oktatóanyagból megtudhatja, hogyan használhatja a NumPy reshape()-t a NumPy tömbök átformálására az eredeti adatok megváltoztatása nélkül.
Amikor Numpy tömbökkel dolgozik, gyakran előfordulhat, hogy egy meglévő tömböt szeretne átformálni különböző méretű tömbökké. Ez különösen akkor lehet hasznos, ha több lépésben alakítja át az adatokat.
És a NumPy reshape() segítségével könnyedén megteheti. A következő néhány percben megtanulja a reshape() használatának szintaxisát, valamint a tömbök különböző méretekre való átformálását.
Tartalomjegyzék
Mi az átformálás a NumPy tömbökben?
Amikor NumPy tömbökkel dolgozik, először érdemes lehet egy egydimenziós számtömböt létrehozni. Ezután alakítsa át a kívánt mérettel rendelkező tömbbé.
Ez különösen akkor hasznos, ha az új tömb méretei kezdetben nem ismertek, vagy a végrehajtás során következtetnek rá. Vagy az is lehetséges, hogy egy bizonyos adatfeldolgozási lépéshez a bemenetnek meghatározott alakúnak kell lennie.
Itt jön jól az átformálás.
Vegyük például a következő ábrát. Van egy vektorunk – egy 6 elemből álló egydimenziós tömb. És átformálhatjuk 2×3, 3×2, 6×1 stb. alakú tömbökké.
▶️ Az oktatóanyag példáinak követéséhez telepítenie kell a Pythont és a NumPy-t. Ha még nem rendelkezik NumPy-val, tekintse meg NumPy telepítési útmutatónkat.
Most már folytathatja és importálhatja a NumPy-t np alias alatt a következő parancs futtatásával: import numpy as np.
Folytassuk a szintaxis megtanulását a következő részben.
A NumPy reshape() szintaxisa
Íme a NumPy reshape() használatának szintaxisa:
np.reshape(arr, newshape, order="C"|'F'|'A')
- Az arr bármely érvényes NumPy tömbobjektum. Itt van a tömb, amelyet át kell alakítani.
- newshape az új tömb alakja. Ez lehet egész szám vagy sor.
- Ha a híralak egy egész szám, a visszaadott tömb egydimenziós.
- A sorrend arra a sorrendre utal, amelyben az átformálandó tömb elemeit szeretné olvasni.
- Az alapértelmezett érték ‘C’, ami azt jelenti, hogy az eredeti tömb elemei C-szerű indexelési sorrendben lesznek beolvasva (0-val kezdődően).
- Az „F” a Fortran-szerű indexelést jelenti (1-gyel kezdődik). Az ‘A’ pedig C-szerű vagy Fortran-szerű sorrendben olvassa be az elemeket a tömb arr memóriaelrendezésétől függően.
Tehát mit ad vissza az np.reshape()?
Ha lehetséges, visszaadja az eredeti tömb átalakított nézetét. Ellenkező esetben a tömb másolatát adja vissza.
A fenti sorban említettük, hogy a NumPy reshape() megpróbál visszaadni egy nézetet, amikor csak lehetséges. Ellenkező esetben egy másolatot ad vissza. Folytassuk a nézet és a másolat közötti különbségek tárgyalását.
Nézet vs. NumPy tömbök másolata
Ahogy a neve is sugallja, a másolat az eredeti tömb másolata. A másolaton végrehajtott változtatások nem lesznek hatással az eredeti tömbre.
Másrészt a nézet egyszerűen az eredeti tömb átformált nézetére utal. Ez azt jelenti, hogy a nézetben végrehajtott bármilyen változtatás hatással lesz az eredeti tömbre is, és fordítva.
Használja a NumPy reshape()-t az 1D tömb 2D tömbökké alakításához
#1. Kezdjük a mintatömb létrehozásával a segítségével np.arange().
Szükségünk van egy 12 számból álló tömbre, 1-től 12-ig, arr1 néven. Mivel a NumPy arange() függvény alapértelmezés szerint kizárja a végpontot, állítsa a stop értéket 13-ra.
Most használjuk a fenti szintaxist, és alakítsuk át az arr1-et 12 elemmel egy 2D alakzatmá (4,3). Nevezzük ezt arr2-nek 4 sorral és 3 oszloppal.
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)
Vessünk egy pillantást az eredeti és átformált tömbökre.
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]]
Ahelyett, hogy np.reshape() argumentumként adja át a tömböt, meghívhatja a .reshape() metódust is az eredeti tömbön.
Futtathatja a dir(arr1) fájlt, és felsorolja az összes lehetséges metódust és attribútumot, amelyet az arr1 tömbobjektumban használhat.
dir(arr1) # Output [ ... ... 'reshape' ... .. ]
A fenti kódcellában láthatja, hogy a .reshape() egy érvényes metódus a meglévő NumPy tömb arr1-en.
▶️ Tehát a következő egyszerűsített szintaxist is használhatja a NumPy tömbök átalakításához.
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
Az oktatóanyag további részében használjuk ezt a szintaxist a példáinkban.
#2. Próbáljuk meg a 12 elemű vektorunkat 12 x 1-es tömbbé alakítani.
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)
Az alábbi kimeneten látható, hogy a tömb szükség szerint át lett alakítva.
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]]
❔ Hogyan ellenőrizhetjük, hogy megszereztük-e a másolatot vagy a nézetet?
Ennek ellenőrzéséhez hívja meg a visszaadott tömb alapattribútumait.
- Ha a tömb egy másolat, akkor az alapattribútum None lesz.
- Ha a tömb egy nézet, akkor az alapattribútum az eredeti tömb lesz.
Gyorsan ellenőrizzük ezt.
arr3.base # Output array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
Mint látható, az arr3 base attribútuma az eredeti tömböt adja vissza. Ez azt jelenti, hogy megkaptuk az eredeti tömb nézetét.
#3. Most próbáljuk meg átformázni a vektort egy másik érvényes 2 x 6-os tömbbe.
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)
És íme a kimenet:
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]]
A következő részben alakítsuk át az arr1-et 3D-s tömbbé.
Használja a NumPy reshape()-t az 1D tömb 3D tömbökké alakításához
Az arr1 3D tömbbé alakításához állítsuk be a kívánt méreteket (1, 4, 3) értékre.
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)
Létrehoztunk egy 3D tömböt, amely ugyanazt a 12 elemet tartalmazza, mint az eredeti arr1 tömb.
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]]]
Értékhibák hibakeresése az újraalakítás során
Ha emlékszik a szintaxisra, az átformálás csak akkor érvényes, ha a dimenziók szorzata megegyezik a tömb elemeinek számával.
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)
Itt egy 12 elemből álló tömböt próbál meg átformálni 4×4-es tömbbé 16 elemből. Az értelmező Értékhibát ad, amint az alább látható.
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)
Az ilyen hibák elkerülése érdekében használhatja a -1-et az egyik méret alakjának automatikus kikövetkeztetéséhez – az elemek teljes száma alapján.
Például, ha előre ismeri az n – 1 dimenziót, akkor a -1 segítségével következtethet az n-edik dimenzióra az átformált tömbben.
Ha van egy 24 elemű tömbje, és szeretné átformálni 3D tömbbé. Tegyük fel, hogy 3 sorra és 4 oszlopra van szüksége. A -1 értéket átadhatja a harmadik dimenzió mentén.
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}")
Ha megvizsgálja az alaktömb alakját, láthatja, hogy az átformált tömb alakja 2 a harmadik dimenzió mentén.
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)
Ez különösen hasznos egy tömb simításánál. Erről pedig a következő részben fogsz tudni.
Használja a NumPy reshape()-t egy tömb egyenítéséhez
Vannak esetek, amikor az N-dimenziós tömbökről vissza kell térnie egy lapított tömbre. Tegyük fel, hogy egy képet egy hosszú pixelvektorba szeretne lapítani.
Kódoljunk egy egyszerű példát a következő lépésekkel:
- Hozzon létre egy 3 x 3-as szürkeárnyalatos képtömböt, img_arr – 0 és 255 közötti pixelekkel.
- Ezután simítsa ki ezt az img_arr-t, és nyomtassa ki a lapos_arr tömböt.
- Az ellenőrzéshez nyomtassa ki az img_arr és flat_arr alakzatait is.
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}")
Íme a kimenet.
[[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,)
A fenti kódcellában látható, hogy a flat_arr pixelértékek 1D-s vektora 9 elemmel.
Összegzés 👩🏫
Ideje gyorsan áttekinteni a tanultakat.
- Az np.reshape(arr, newshape) segítségével alakítsa át az arr-t a híralakban megadott alakzatra. A newshape egy sor, amely megadja az átformált tömb méreteit.
- Alternatív megoldásként használja az arr.reshape(d0, d1, …, dn) függvényt az arr d0 x d1 x … x dn alakúra alakításához.
- Ellenőrizze, hogy d0 * d1 * …* dn = N, az eredeti tömb elemeinek száma, hogy elkerülje az értékhibákat az átalakítás során.
- Használjon -1-et legfeljebb egy mérethez az új alakzatban, ha azt szeretné, hogy a méret automatikusan következtessen.
- Végül az arr.reshape(-1) segítségével simíthatja a tömböt.
Most, hogy tudja, hogyan kell használni a NumPy reshape() funkciót, ismerje meg a NumPy linspace() függvény működését.
Ha szeretné, kipróbálhatja a kódpéldákat a Jupyter notebookban. Ha más fejlesztői környezeteket keres, tekintse meg a Jupyter alternatíváiról szóló útmutatónkat.