list.append(), sondern man legt sie mit der gewünschten Größe an, z.B. voller Nullen, und modifizert dann die Einträge.import numpy as np
Die array()-Funktion wandelt Listen, Tupeln, ... in numpy-arrays um:
np.array([2,3,4,5])
a = np.array([[1,2,3], [4,5,6]], dtype=np.float64)
a
Wichtige Eigenschaften eines Array-Objektes können abgefragt werden:
print(a.ndim) # Zahl der Indizes
print(a.shape) # Gestalt, z.B. (n,m) für nxm-Matrix
print(a.size) # Gesamtzahl der Elemente
print(a.dtype) # Typ der Elemente
print(a.itemsize) # Größe eines Elements in Bytes
print(type(a)) # Typ von a selbst
numpy hat seine eigene range-Funktion namens arange(), die gleich einen numpy-Array erzeugt:
a = np.arange(1, 16)
print(a)
Die .reshape()-Funktion kann einen array in einen mit anderer Dimension aber der gleichen Gesamtzahl von Elementen umwandeln. Dabei wird eine Matrix zeilenweise gefüllt.
b = a.reshape(3,5)
b
# Hier mal ein Objekt mit 3 Indizes
c = np.arange(12).reshape(2, 3, 2)
c
print( 'c_000=', c[0,0,0], ' c_010=', c[0,1,0], ' c_101=', c[1,0,1])
# array voller Nullen: Das Argument kann eine Zahl, eine Liste [4,3] oder ein Tupel (4,3) sein
np.zeros([3, 5])
np.zeros(5)
# array mit gegebenem Füllwert
np.full([3, 5], 2.01)
# array aus einer mit list comprehension gebildeten Liste
x = np.array([[i-j for i in range(5)] for j in range(6)])
x
# diese Funktion erzeugt eine Nullmatrix derselben Gestalt wie das Argument
x0 = np.zeros_like(x)
x0
# Man kann aus einem numpy-array auch wieder eine Python-Liste machen:
x.tolist()
# 3x3 Einheitsmatrix
np.eye(3)
# Diagonalmatrix aus 1-dim array
np.diag([3,4,5])
Zum Plotten von Funktionen recht nützlich ist linspace. Im Unterschied zu arange gibt man nach Start- und Endwert nicht die Schrittweite sondern die gewünschte Anzahl von Werten im Intervall an. Der Endwert ist hier in der Folge enthalten.
np.linspace(1,2,10)
n:m:k-Syntax kann man Teilfelder ansprechen. Dabei ist der Startindex n enthalten, der Endindex m ist nicht mehr enthalten und k ist eine mögliche Schrittweite. x = np.arange(10)
x
# Ein Element des Feldes
x[5]
# Man kann den Elementen Werte zuweisen
x[5] = 77
x
# Ein Teilfeld
x[2:7]
# Zuweisung eines Teilfeldes
x[2:4] = [-5, -6]
x
# Teilfeld mit Schrittweite
x[0:8:2]
# fehlender Startindex
x[:5]
# fehlender Endindex
x[3:]
# fehlender Start- und Endindex
x[:]
# nochmal, mit Schrittweite
x[::-1]
# Es gibt einen Unterschied zwischen x[7] und x[7:8]. Beides addressiert nur
# ein Element, aber im 2. Fall erhält man trotzdem einen eindimensionalen Vektor
#
print(x[7])
print(x[7:8])
# 2-dimensionale Beispiele
A = np.arange(16).reshape(4,4)
A
B = A[0:2, 1:3]
B
C = A[0:2, :]
C
D = A[::-1, ::2]
D
Numpy ist für den Umgang mit sehr großen Matrizen etc. gedacht. Da ist das Erstellen einer Kopie bereits eine zeit- und vor allem speicherplatzintensive Operation. Numpy vermeidet daher das Erstellen von Kopien, solange es nicht unumgänglich oder explizit angewiesen ist.
Insbesondere erstellen einfache Zuweisungen
B = Aoder Slices
B = A[2:3, 4:6]keine Kopie, sondern nur einen neuen view auf die existierenden Daten.
Modifizierungen von B modifizieren daher auch A:
B = A
C = A[2:4, 1:3]
print(B)
print('\n')
print(C)
B[1,1] = -199
C[1,1] = 999
A
# Explizites erstellen einer Kopie
B = A.copy()
C = A[2:4, 1:3].copy()
B[1,1] = 99999999
A
Ein Index kann auch eine Bedingung sein. Dann werden alle Elemente geliefert, die diese Bedingung erfüllen:
A[A>3]
# Das ist nützlich, weil man so auf genau diese Elemente einwirken kann:
A[A>5] = 5
A
# Noch allgemeiner: der Vergleich A>5 liefert einen Array aus Wahrheitswerten:
A>0
# und einen solchen Array aus Wahrheitswertne kann man als Index verwenden:
B = np.array([1,2,3,4,5,6])
C = np.array([False, False, True, False, False, True])
B[C]
Eine Matriz ist eine Sequenz von Zeilen.
Allgemeiner: for r in A iteriert über den am weitesten links stehenden Index.
for z in A:
print ('Zeile= ', z)
for z in A:
for x in z:
print(x)
# diese Funktion liefert einen Iterator mit Indizes:
for (i,j), x in np.ndenumerate(A):
print(i, j, x)
Vergleichsoperationen liefern einen array aus boolschen Werten:
x = np.arange(4)
x == x[:]
Mit den Operatoren all und any kann man einen array of bools reduzieren:
x == np.array([0,2,2,3])
# Alles wahr?
np.all(x==np.array([0,2,2,3]))
# Irgendwas wahr?
np.any(x==np.array([0,2,2,3]))
a=np.array([[ 1, 2],
[ 3, 4] ])
b=np.array([[ 2, 2],
[ 5, 5]])
a + b
1/a
a * b
a + 1
a += 100
a
# Auch alle üblichen mathematischen Funktionen werden von numpy so
# bereitgestellt, dass sie elementweise auf ein Feld wirken
np.log10(a)
Das innere Produkt von Vektoren und das übliche Matrixprodukt sowie die Wirkung von Matrizen auf Vektoren liefert die Funktion np.matmul().
Ab Python-Version 3.5 kann man für np.matmul(x,y) auch x @ y schreiben.
v = np.array([1,2,3])
w = np.array([3,4,5])
v @ w
A = np.arange(6).reshape(2,3)
A
# 3x2-Matrix mal 2x3-Matrix -> 3x3-Matrix
# ( .T trasnponiert )
A.T @ A
# 2x3-Matrix mal 3x2-Matrix -> 2x2-Matrix
A @ A.T
# 2x3-Matrix mal 3-vektor -> 2-Vektor
A @ v
# 2-Vektor mal 2x3-Matrix -> 3-Vektor
[4,5] @ A
# Es gibt auch ein äußeres (Tensor-) Produkt:
np.outer(v, w)
A = np.array([[1, 18, 7],
[2, 13, 5]])
print( np.sum(A) )
print( np.amax(A) )
# Spaltensumme, größtes Element jeder Spalte
print( np.sum( A, axis=0) )
print('')
print( np.amax(A, axis=0) )
# Zeilensumme, größtes Element jeder Zeile
print( np.sum( A, axis=1) )
print('')
print( np.amax(A, axis=1) )
Eigenwerte, Matrixinverses, Lösen linearer Gleichungssyteme und vieles mehr
from numpy.linalg import eigvals, inv, solve
A = 20*np.eye(5) + np.arange(10,35).reshape(5,5)
A
inv(A)
inv(A) @ A
eigvals(A)
x = [-2, 3 , 4, 8, 10]
solve(A,x)