Numpy Tutorial - NumPy Array neu formen und Größe ändern

  1. numpy.reshape()
  2. ndarray.reshape()
  3. reshape() Funktion/Methode Gemeinsamer Speicher
  4. numpy.resize()

NumPy hat zwei Funktionen (und auch Methoden), um Array-Formen zu verändern - reshape und resize. Sie haben einen signifikanten Unterschied, auf den wir uns in diesem Kapitel konzentrieren werden.

numpy.reshape()

Beginnen wir mit der Funktion zum Ändern der Form des Arrays - reshape().

import numpy as np

arrayA = np.arange(8)
# arrayA = array([0, 1, 2, 3, 4, 5, 6, 7])

np.reshape(arrayA, (2, 4))
#array([[0, 1, 2, 3],
#       [4, 5, 6, 7]])

Sie wandelt einen Vektor mit 8 Elementen in das Array mit der Form von (4, 2) um. Sie konnte erfolgreich ausgeführt werden, da die Anzahl der Elemente vor und nach der Umformung identisch ist. Es erhöht ValueError, wenn die Mengen unterschiedlich sind.

In [1]: np.reshape(arrayA, (3, 4))
    ---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
ValueError: cannot reshape array of size 8 into shape (3,4)

Lassen Sie uns einen genaueren Blick auf das neu geformte Array werfen. Die erste Zeile ist die ersten 4 Daten von arrayA und die zweite Zeile nimmt die letzten 4 und füllt die Daten in der Reihenfolge der Zeilen in dieser Umformung.

Sie müssen den Parameter order ändern, wenn Sie möchten, dass die Reihenfolge der Füllung der Daten spaltenförmig ist.

In [1]: np.reshape(arrayA, (2, 4), order='F')
Out[1]: array([[0, 2, 4, 6],
        	  [1, 3, 5, 7]])

Die Voreinstellung von order ist C, was bedeutet, dass die Daten in C-ähnlicher Indexreihenfolge oder in einfachen Worten in der Reihenfolge der Zeile gelesen oder geschrieben werden. F bedeutet, Daten in Fortan-ähnlicher Index-Reihenfolge zu lesen oder zu schreiben, oder sagen wir, in der Reihenfolge der Spalte. Sie koennen sich auf offizielle NumPy-Dokumentation beziehen, um mehr Details ueber verschiedene Indexierungsmethoden zu erfahren.

ndarray.reshape()

Neben der Funktion reshape hat NumPy auch die Methode reshape im ndarray Objekt. Die Methode hat die gleichen Parameter wie die Funktion, aber ohne gegebenes Array als Parameter.

In [1]: arrayB = arrayA.reshape((2, 4))
    
In [2]: arrayB
Out[2]:	array([[0, 1, 2, 3],
       		[4, 5, 6, 7]])
In [1]: arrayA
Out[2]: array([0, 1, 2, 3, 4, 5, 6, 7])    

Wie man sehen konnte, ist die reshape Methode ähnlich der reshape Funktion. Und Sie sollten sich auch bewusst sein, dass die ndarray.reshape() Methode die Daten und die Form des ursprünglichen Arrays nicht verändert, sondern eine neue ndarray Instanz zurückgibt.

reshape() Funktion/Methode Gemeinsamer Speicher

Das konvertierte Array in der Funktion oder Methode reshape teilt sich den gleichen Speicher wie das ursprüngliche Array. Man könnte es sich als shallow copy in Python vorstellen, wo, wenn man die Daten in einem Array ändert, die entsprechenden Daten im anderen Array ebenfalls geändert werden.

In [1]: arrayA = np.arange(8)
    	arrayB = arrayA.reshape((2, 4))
        arrayB
Out[2]:	array([[0, 1, 2, 3],
       		[4, 5, 6, 7]])
In [2]: arrayA[0] = 10
    	arrayA
Out[2]: array([10, 1, 2, 3, 4, 5, 6, 7]) 
In [3]: arrayB    
Out[3]:	array([[10, 1, 2, 3],
       		[4, 5, 6, 7]])    

numpy.resize()

numpy.resize() ist ein bisschen ähnlich wie reshape im Sinne von Formumwandlung. Aber es hat einige signifikante Unterschiede.

  1. Es hat keinen Order Parameter. Die Reihenfolge von resize ist die gleiche wie order='C' in reshape.
  2. Wenn die Anzahl der Elemente des Ziel-Arrays nicht die gleiche ist wie die des Original-Arrays, wird es eine Größenänderung erzwingen, aber keine Fehler auslösen.

Lass uns auf den zweiten Unterschied konzentrieren.

In [1]: arrayA = np.arange(8)
        arrayB = np.resize(arrayA, (2, 4))
Out[1]: array([[0, 1, 2, 3],
       [4, 5, 6, 7]])

Das Ergebnis ist das gleiche wie das in reshpae, wenn die Elementnummern gleich sind.

In [1]: arrayC = np.resize(arrayA, (3, 4))
    	arrayC
Out[1]: array([[0, 1, 2, 3],
       [4, 5, 6, 7],
       [0, 1, 2, 3]])
In [2]: arrayD = np.resize(arrayA, (4, 4))
    	arrayD
Out[2]: array([[0, 1, 2, 3],
       [4, 5, 6, 7],
       [0, 1, 2, 3],
       [4, 5, 6, 7]])

Wenn das neue Array mehr Zeilen hat, wird es die Daten im ursprünglichen Array wiederholen, aber nicht den Fehler auslösen.

In [1]: arrayE = np.resize(arrayA, (2, 2))
		arrayE
Out[1]: array([[0, 1],
       [2, 3]])    
In [2]: np.resize(arrayA, (1,4))
Out[2]: array([[0, 1, 2, 3]])

Wenn die Anzahl der Elemente in dem neuen Array kleiner ist, holt es die Anzahl der Elemente, die es benötigt, um das neue Array in der Reihenfolge der Zeilen zu füllen.

resize Funktions-/Methodenspeicher

Das neue Array teilt nicht den gleichen Speicher mit dem originalen Array in der resize Funktion/Methode. Die Datenänderung in einem Array wird nicht auf das andere Array abgebildet.

In [1]: arrayA = np.arange(8)
    	arrayB = arrayA.reshape((2, 4))
        arrayB
Out[2]:	array([[0, 1, 2, 3],
       		[4, 5, 6, 7]])
In [2]: arrayA[0] = 10
    	arrayA
Out[2]: array([10, 1, 2, 3, 4, 5, 6, 7]) 
In [3]: arrayB    
Out[3]:	array([[0, 1, 2, 3],
       		[4, 5, 6, 7]])    
comments powered by Disqus