Suche…
Einführung
N-dimensionalen Arrays oder ndarrays sind numpy Kernobjekt verwendet für Elemente desselben Datentyps speichert. Sie bieten eine effiziente Datenstruktur, die herkömmlichen Arrays von Python überlegen ist.
Bemerkungen
Wann immer möglich, Operationen mit Daten in Form von Arrays und Vektoroperationen ausdrücken. Vektoroperationen werden für Schleifen viel schneller als die entsprechenden ausgeführt
Erstellen Sie ein Array
Leeres Array
np.empty((2,3))
Beachten Sie, dass in diesem Fall die Werte in diesem Array nicht festgelegt werden. Diese Art der Array-Erstellung ist daher nur sinnvoll, wenn das Array später im Code gefüllt wird.
Aus einer Liste
np.array([0,1,2,3])
# Out: array([0, 1, 2, 3])
Erstellen Sie einen Bereich
np.arange(4)
# Out: array([0, 1, 2, 3])
Erstellen Sie Nullen
np.zeros((3,2))
# Out:
# array([[ 0., 0.],
# [ 0., 0.],
# [ 0., 0.]])
Erstellen Sie eine
np.ones((3,2))
# Out:
# array([[ 1., 1.],
# [ 1., 1.],
# [ 1., 1.]])
Erstellen Sie linienförmige Array-Elemente
np.linspace(0,1,21)
# Out:
# array([ 0. , 0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 ,
# 0.45, 0.5 , 0.55, 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85,
# 0.9 , 0.95, 1. ])
Erstellen Sie Array-Elemente mit Protokollabstand
np.logspace(-2,2,5)
# Out:
# array([ 1.00000000e-02, 1.00000000e-01, 1.00000000e+00,
# 1.00000000e+01, 1.00000000e+02])
Erstellen Sie ein Array aus einer bestimmten Funktion
np.fromfunction(lambda i: i**2, (5,))
# Out:
# array([ 0., 1., 4., 9., 16.])
np.fromfunction(lambda i,j: i**2, (3,3))
# Out:
# array([[ 0., 0., 0.],
# [ 1., 1., 1.],
# [ 4., 4., 4.]])
Array-Operatoren
x = np.arange(4)
x
#Out:array([0, 1, 2, 3])
Skalaraddition ist elementweise
x+10
#Out: array([10, 11, 12, 13])
Skalarmultiplikation ist elementweise
x*2
#Out: array([0, 2, 4, 6])
Array-Addition ist elementweise
x+x
#Out: array([0, 2, 4, 6])
Array-Multiplikation ist elementweise
x*x
#Out: array([0, 1, 4, 9])
Punktprodukt (oder allgemeiner Matrixmultiplikation) erfolgt mit einer Funktion
x.dot(x)
#Out: 14
In Python 3.5 wurde der Operator @ als Infix-Operator für die Matrixmultiplikation hinzugefügt
x = np.diag(np.arange(4))
print(x)
'''
Out: array([[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 3]])
'''
print(x@x)
print(x)
'''
Out: array([[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 4, 0],
[0, 0, 0, 9]])
'''
Anhängen Gibt eine Kopie mit angehängten Werten zurück. Nicht an Ort und Stelle.
#np.append(array, values_to_append, axis=None)
x = np.array([0,1,2,3,4])
np.append(x, [5,6,7,8,9])
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x
# Out: array([0, 1, 2, 3, 4])
y = np.append(x, [5,6,7,8,9])
y
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
hstack Horizontaler Stapel (Spaltenstapel)
Vstack Vertikaler Stapel. (Reihenstapel)
# np.hstack(tup), np.vstack(tup)
x = np.array([0,0,0])
y = np.array([1,1,1])
z = np.array([2,2,2])
np.hstack(x,y,z)
# Out: array([0, 0, 0, 1, 1, 1, 2, 2, 2])
np.vstack(x,y,z)
# Out: array([[0, 0, 0],
# [1, 1, 1],
# [2, 2, 2]])
Array-Zugriff
Die Slice-Syntax lautet i:j:k wobei i der Startindex (einschließlich) ist, j der Stoppindex (exklusiv) und k die Schrittgröße ist. Wie andere Python-Datenstrukturen hat das erste Element den Index 0:
x = np.arange(10)
x[0]
# Out: 0
x[0:4]
# Out: array([0, 1, 2, 3])
x[0:4:2]
# Out:array([0, 2])
Negative Werte zählen vom Ende des Arrays. -1 greift daher auf das letzte Element in einem Array zu:
x[-1]
# Out: 9
x[-1:0:-1]
# Out: array([9, 8, 7, 6, 5, 4, 3, 2, 1])
Auf mehrdimensionale Arrays kann zugegriffen werden, indem jede durch Kommas getrennte Dimension angegeben wird. Alle vorherigen Regeln gelten.
x = np.arange(16).reshape((4,4))
x
# Out:
# array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11],
# [12, 13, 14, 15]])
x[1,1]
# Out: 5
x[0:3,0]
# Out: array([0, 4, 8])
x[0:3, 0:3]
# Out:
# array([[ 0, 1, 2],
# [ 4, 5, 6],
# [ 8, 9, 10]])
x[0:3:2, 0:3:2]
# Out:
# array([[ 0, 2],
# [ 8, 10]])
Transponieren eines Arrays
arr = np.arange(10).reshape(2, 5)
.transpose Methode verwenden:
arr.transpose()
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
.T Methode:
arr.T
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
Oder np.transpose :
np.transpose(arr)
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
Im Falle eines 2-dimensionalen Arrays entspricht dies einer Standardmatrixtransponierung (wie oben dargestellt). Im n-dimensionalen Fall können Sie eine Permutation der Array-Achsen angeben. Standardmäßig werden array.shape umgekehrt:
a = np.arange(12).reshape((3,2,2))
a.transpose() # equivalent to a.transpose(2,1,0)
# Out:
# array([[[ 0, 4, 8],
# [ 2, 6, 10]],
#
# [[ 1, 5, 9],
# [ 3, 7, 11]]])
Es ist jedoch jede Permutation der Achsindizes möglich:
a.transpose(2,0,1)
# Out:
# array([[[ 0, 2],
# [ 4, 6],
# [ 8, 10]],
#
# [[ 1, 3],
# [ 5, 7],
# [ 9, 11]]])
a = np.arange(24).reshape((2,3,4)) # shape (2,3,4)
a.transpose(2,0,1).shape
# Out:
# (4, 2, 3)
Boolesche Indizierung
arr = np.arange(7)
print(arr)
# Out: array([0, 1, 2, 3, 4, 5, 6])
Ein Vergleich mit einem Skalar gibt ein boolesches Array zurück:
arr > 4
# Out: array([False, False, False, False, False, True, True], dtype=bool)
Dieses Array kann bei der Indizierung verwendet werden, um nur die Zahlen größer als 4 auszuwählen:
arr[arr>4]
# Out: array([5, 6])
Die boolesche Indizierung kann zwischen verschiedenen Arrays (z. B. verwandten parallelen Arrays) verwendet werden:
# Two related arrays of same length, i.e. parallel arrays
idxs = np.arange(10)
sqrs = idxs**2
# Retrieve elements from one array using a condition on the other
my_sqrs = sqrs[idxs % 2 == 0]
print(my_sqrs)
# Out: array([0, 4, 16, 36, 64])
Umformen eines Arrays
Die Methode numpy.reshape (identisch mit numpy.ndarray.reshape ) gibt ein Array derselben Gesamtgröße zurück, aber in einer neuen Form:
print(np.arange(10).reshape((2, 5)))
# [[0 1 2 3 4]
# [5 6 7 8 9]]
Es gibt ein neues Array zurück und funktioniert nicht an Ort und Stelle:
a = np.arange(12)
a.reshape((3, 4))
print(a)
# [ 0 1 2 3 4 5 6 7 8 9 10 11]
Es ist jedoch möglich, das shape Attribut eines ndarray zu überschreiben:
a = np.arange(12)
a.shape = (3, 4)
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
Dieses Verhalten mag zunächst überraschend sein, aber ndarray werden in zusammenhängenden Speicherblöcken gespeichert und ihre shape nur an, wie dieser Datenstrom als mehrdimensionales Objekt interpretiert werden soll.
Bis zu einer Achse in der shape Tupel kann einen Wert von -1 . numpy dann die Länge dieser Achse für Sie:
a = np.arange(12)
print(a.reshape((3, -1)))
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
Oder:
a = np.arange(12)
print(a.reshape((3, 2, -1)))
# [[[ 0 1]
# [ 2 3]]
# [[ 4 5]
# [ 6 7]]
# [[ 8 9]
# [10 11]]]
Mehrere nicht angegebene Dimensionen, z. B. a.reshape((3, -1, -1)) sind nicht zulässig und werfen einen ValueError .
Broadcasting-Array-Operationen
Arithmetische Operationen werden elementweise auf Numpy-Arrays durchgeführt. Für Arrays mit identischer Form bedeutet dies, dass die Operation zwischen Elementen in entsprechenden Indizes ausgeführt wird.
# Create two arrays of the same size
a = np.arange(6).reshape(2, 3)
b = np.ones(6).reshape(2, 3)
a
# array([0, 1, 2],
# [3, 4, 5])
b
# array([1, 1, 1],
# [1, 1, 1])
# a + b: a and b are added elementwise
a + b
# array([1, 2, 3],
# [4, 5, 6])
Arithmetische Operationen können auch auf Arrays verschiedener Formen mittels unkomplizierter Übertragung ausgeführt werden . Im Allgemeinen wird ein Array über das andere "Broadcast", so dass elementweise Operationen an Teilarrays mit kongruenter Form ausgeführt werden.
# Create arrays of shapes (1, 5) and (13, 1) respectively
a = np.arange(5).reshape(1, 5)
a
# array([[0, 1, 2, 3, 4]])
b = np.arange(4).reshape(4, 1)
b
# array([0],
# [1],
# [2],
# [3])
# When multiplying a * b, slices with the same dimensions are multiplied
# elementwise. In the case of a * b, the one and only row of a is multiplied
# with each scalar down the one and only column of b.
a*b
# array([[ 0, 0, 0, 0, 0],
# [ 0, 1, 2, 3, 4],
# [ 0, 2, 4, 6, 8],
# [ 0, 3, 6, 9, 12]])
Um dies weiter zu veranschaulichen, betrachten Sie die Multiplikation von 2D- und 3D-Arrays mit kongruenten Unterdimensionen.
# Create arrays of shapes (2, 2, 3) and (2, 3) respectively
a = np.arange(12).reshape(2, 2, 3)
a
# array([[[ 0 1 2]
# [ 3 4 5]]
#
# [[ 6 7 8]
# [ 9 10 11]]])
b = np.arange(6).reshape(2, 3)
# array([[0, 1, 2],
# [3, 4, 5]])
# Executing a*b broadcasts b to each (2, 3) slice of a,
# multiplying elementwise.
a*b
# array([[[ 0, 1, 4],
# [ 9, 16, 25]],
#
# [[ 0, 7, 16],
# [27, 40, 55]]])
# Executing b*a gives the same result, i.e. the smaller
# array is broadcast over the other.
Wann wird Array Broadcasting angewendet?
Die Übertragung findet statt, wenn zwei Arrays kompatible Formen haben.
Formen werden komponentenweise ausgehend von den nachgestellten verglichen. Zwei Dimensionen sind kompatibel, wenn sie gleich sind oder eine davon 1 . Wenn eine Form eine höhere Dimension als die andere hat, werden die übersteigenden Komponenten nicht verglichen.
Einige Beispiele kompatibler Formen:
(7, 5, 3) # compatible because dimensions are the same
(7, 5, 3)
(7, 5, 3) # compatible because second dimension is 1
(7, 1, 3)
(7, 5, 3, 5) # compatible because exceeding dimensions are not compared
(3, 5)
(3, 4, 5) # incompatible
(5, 5)
(3, 4, 5) # compatible
(1, 5)
Hier ist die offizielle Dokumentation zum Array-Broadcasting .
Füllen Sie ein Array mit dem Inhalt einer CSV-Datei
filePath = "file.csv"
data = np.genfromtxt(filePath)
Viele Optionen werden unterstützt. Die vollständige Liste finden Sie in der offiziellen Dokumentation :
data = np.genfromtxt(filePath, dtype='float', delimiter=';', skip_header=1, usecols=(0,1,3) )
Numpy n-dimensionales Array: das Narray
Die Kerndatenstruktur in numpy ist das ndarray (kurz für n- dimensionales Array). ndarray s sind
- homogen (dh sie enthalten Elemente des gleichen Datentyps)
- enthalten Elemente fester Größen (gegeben durch eine Form , ein Tupel von n positiven ganzen Zahlen, die die Größe jeder Dimension angeben)
Eindimensionale Anordnung:
x = np.arange(15)
# array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
x.shape
# (15,)
Zweidimensionale Anordnung:
x = np.asarray([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])
x
# array([[ 0, 1, 2, 3, 4],
# [ 5, 6, 7, 8, 9],
# [10, 11, 12, 13, 14]])
x.shape
# (3, 5)
Dreidimensional:
np.arange(12).reshape([2,3,2])
So initialisieren Sie ein Array ohne Angabe des Inhalts use:
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
Datentyptypen und automatisches Casting
Der Datentyp ist standardmäßig auf Float gesetzt
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
x.dtype
# dtype('float64')
Wenn einige Daten bereitgestellt werden, wird der Datentyp von numpy erraten:
x = np.asarray([[1, 2], [3, 4]])
x.dtype
# dtype('int32')
Beachten Sie, dass numpy bei Zuweisungen versucht, die Werte automatisch an den Datentyp des ndarray
x[1, 1] = 1.5 # assign a float value
x[1, 1]
# 1
# value has been casted to int
x[1, 1] = 'z' # value cannot be casted, resulting in a ValueError
Array-Übertragung
Siehe auch Broadcasting-Array-Operationen .
x = np.asarray([[1, 2], [3, 4]])
# array([[1, 2],
[3, 4]])
y = np.asarray([[5, 6]])
# array([[5, 6]])
In der Matrixterminologie hätten wir eine 2x2-Matrix und einen 1x2-Zeilenvektor. Trotzdem können wir eine Summe machen
# x + y
array([[ 6, 8],
[ 8, 10]])
Dies liegt daran, dass das Array y " gestreckt " ist:
array([[5, 6],
[5, 6]])
an die Form von x .
Ressourcen:
- Einführung in das ndarray aus der offiziellen Dokumentation: Das N-dimensionale Array (ndarray)
- Klassenreferenz: ndarray .