Dies ist eine Ausbildung zum Datenwissenschaftler mit Python. Schließlich werde ich Numpy verwenden. Numpy ist eine Bibliothek zum Bearbeiten großer mehrdimensionaler Arrays und Matrizen. Ohne dies kann Python die Daten nicht analysieren.
** PREV ** → [Python] Weg zur Schlange (3) Python-Klasse ** WEITER ** → [Python] Weg zur Schlange (5) Spiel mit Matplotlib
Importieren Sie zunächst numpy.
>>> import numpy as np
Generieren Sie eindimensionale, zweidimensionale und dreidimensionale Arrays.
>>> a1 = np.array([1, 2, 3], int)
>>> a2 = np.array([[1, 2, 3], [4, 5, 6]])
>>> a3 = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
Untersuchen Sie den Datentyp (dtype) und die Form (shape).
>>> a2.dtype, a1.shape, a2.shape, a3.shape
(dtype('int64'), (3,), (2, 3), (2, 2, 3))
Geben Sie convert array ein.
>>> a1.astype(float), a1.astype(complex)
(array([ 1., 2., 3.]), array([ 1.+0.j, 2.+0.j, 3.+0.j]))
Generieren Sie ein Array mit allen 0.
>>> np.zeros((2, 3), int)
array([[0, 0, 0],
[0, 0, 0]])
Generieren Sie ein Array von allen 1.
>>> np.ones((2, 3),int)
array([[1, 1, 1],
[1, 1, 1]])
Generieren Sie eine 3x3-Einheitenmatrix.
>>> np.identity(3, int)
array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
Generieren Sie eine Diagonalmatrix aus diagonalen Komponenten.
>>> a5 = np.diag([1, 2, 3]); a5
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])
Extrahieren Sie die diagonalen Komponenten aus der quadratischen Matrix.
>>> np.diag(a5)
array([1, 2, 3])
Generieren Sie ein Array mit shape = (2,3).
>>> a1 = np.array([[1, 2, 3], [4, 5, 6]]); a1
array([[1, 2, 3],
[4, 5, 6]])
Geändert in eindimensionale Form der Form = (6,).
>>> a1.reshape(6,)
array([1, 2, 3, 4, 5, 6])
Geändert in eine zweidimensionale Form mit Form = (3,2).
>>> a1.reshape(3, 2)
array([[1, 2],
[3, 4],
[5, 6]])
slice
Ein Slice ist eine Indexliste mit Spaltenanzahl gleicher Anzahl, die an [...] übergeben wird, um ein Teilarray zu erhalten.
>>> a1 = np.array(range(1, 10)).reshape(3, 3); a1
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
Extrahieren Sie Zeilennummern von 1 bis weniger als 3 und Spaltennummern von 1 bis weniger als 3.
>>> a1[1:3, 1:3]
array([[5, 6],
[8, 9]])
Negative Werte für den dritten Parameter der Schicht bedeuten umgekehrte Reihenfolge.
>>> a1[::-1, ::-1]
array([[9, 8, 7],
[6, 5, 4],
[3, 2, 1]])
Auf diese Weise können Sie auch das Slice-Objekt verwenden.
>>> slice1 = slice(0, 3, 2) # 0:3:2
>>> a1[slice1, slice1]
array([[1, 3],
[7, 9]])
fancy indexing
Fancy Indexing ist eine Methode, um ein Teilarray zu erhalten, indem [...] eine beliebige Indexspalte zugewiesen wird.
Extrahieren Sie die 0. Zeile und die 2. Zeile.
>>> a1[[0, 2], :]
array([[1, 2, 3],
[7, 8, 9]])
Extrahieren Sie die 0. Spalte und die 2. Spalte.
>>> a1[:, [0, 2]]
array([[1, 3],
[4, 6],
[7, 9]])
Ausgefallene Indizierung auf beiden Achsen. Extrahieren Sie die Komponenten [0,0] und [2,2].
>>> a1[[0, 2], [0, 2]]
array([1, 9])
Bitte beachten Sie, dass das obige Ergebnis ein 1D-Array ist, das sich von dem folgenden unterscheidet.
>>> a1[[0, 2], :][:, [0, 2]]
array([[1, 3],
[7, 9]])
Auf diese Weise kann die ausgefallene Indizierung auch für Datenpermutationszwecke verwendet werden.
>>> a1[[2, 0, 1], :]
array([[7, 8, 9],
[1, 2, 3],
[4, 5, 6]])
boolean indexing
Die boolesche Indizierung ist eine Methode, um ein Teilarray von nur echten Indizes zu erhalten, indem [...] ein boolesches Array zugewiesen wird.
Erstellen Sie ein boolesches Array, das nur dann True ist, wenn der Wert gerade ist.
>>> a1=np.array(range(1,10)).reshape(3,3); a1
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> a2 = (a1 % 2 == 0); a2
array([[False, True, False],
[ True, False, True],
[False, True, False]], dtype=bool)
Extrahieren Sie nur die Komponenten, deren Index True entspricht, als 1D-Array.
>>> a1[a2]
array([2, 4, 6, 8])
Ein Subarray von Numpy ist eine Referenz, wenn der Index Slice ist. In anderen Fällen (ausgefallener Index usw.) handelt es sich um eine Kopie. Eine Kopie wird auch erstellt, wenn Slice- und Fancy-Indizierung gemischt werden, z. B. "a1 [[0, 2],:]".
Bereiten Sie zunächst zwei zweidimensionale 2x2-Arrays vor.
>>> a1 = np.array(range(1, 5)).reshape(2, 2); a1
array([[1, 2],
[3, 4]])
>>> a2 = np.array(range(5, 9)).reshape(2, 2); a2
array([[5, 6],
[7, 8]])
Verbinden Sie in der Zeilenrichtung. (Linienrichtung: 0. Achse) Form = (4,2).
>>> np.vstack((a1,a2)) # np.concatenate((a1,a2),axis=0)Das gleiche mit
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
In Spaltenrichtung verbinden. (Spaltenrichtung: 1. Achse) Form = (2,4).
>>> np.hstack((a1,a2)) # np.concatenate((a1,a2),axis=1)Das gleiche mit
array([[1, 2, 5, 6],
[3, 4, 7, 8]])
Bereiten Sie ein zweidimensionales Array mit der Form = (2,3) vor.
>>> a1 = np.array(range(2 * 3)).reshape(2, 3); a1
array([[0, 1, 2],
[3, 4, 5]])
Invertieren (vertauschen Sie die 0. Achse (Zeile) und die 1. Achse (Spalte)).
B_{ji} = A_{ij}
>>> a1.T
array([[0, 3],
[1, 4],
[2, 5]])
Bereiten Sie ein 4-dimensionales Array mit der Form = (2,3,4,5) vor.
>>> a2 = np.array(range(2 * 3 * 4 * 5)).reshape(2, 3, 4, 5)
>>> a2.shape
(2, 3, 4, 5)
Tauschen Sie die 1. und 3. Achse aus.
B_{ilkj} = A_{ijkl}
>>> a2.swapaxes(1, 3).shape
(2, 5, 4, 3)
Die 1., 2., 3. und 0. Achse sei die neue 0., 1., 2. und 3. Achse.
B_{jkli} = A_{ijkl}
>>> a3=a2.transpose(1, 2, 3, 0)
Der gleiche Vorgang kann mit einsum auf leicht verständliche Weise visuell ausgedrückt werden.
>>> a4=np.einsum('ijkl->jkli', a2)
>>> a3.shape, a4.shape, (a3 == a4).all()
((3, 4, 5, 2), (3, 4, 5, 2), True)
Bereiten Sie die folgende Matrix vor.
A =
\left(
\begin{matrix}
1 & 2 \\
3 & 4
\end{matrix}
\right)
I =
\left(
\begin{matrix}
1 & 0 \\
0 & 1
\end{matrix}
\right)
>>> A = np.array([[1, 2], [3, 4]]); A
array([[1, 2],
[3, 4]])
>>> I = np.identity(2); I #2x2 Einheitsmatrix
array([[ 1., 0.],
[ 0., 1.]])
Machen Sie I und A eindimensional und berechnen Sie das Tensorprodukt zweier Vektoren.
C =
\left(
\begin{matrix}
1\\
0\\
0\\
1
\end{matrix}
\right)
⊗
\left(
\begin{matrix}
1\\
2\\
3\\
4
\end{matrix}
\right)
=
\left(
\begin{matrix}
1&2&3&4\\
0&0&0&0\\
0&0&0&0\\
1&2&3&4
\end{matrix}
\right)
>>> C = np.outer(I, A); C
array([[ 1., 2., 3., 4.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 1., 2., 3., 4.]])
Berechnen Sie das Kronecker-Tensorprodukt (das sogenannte Tensorprodukt als Operator).
D =
\left(
\begin{matrix}
1&0\\
0&1
\end{matrix}
\right)
⊗
\left(
\begin{matrix}
1&2\\
3&4
\end{matrix}
\right)
=
\left(
\begin{matrix}
1&2&0&0\\
3&4&0&0\\
0&0&1&2\\
0&0&3&4
\end{matrix}
\right)
>>> D = np.kron(I, A); D
array([[ 1., 2., 0., 0.],
[ 3., 4., 0., 0.],
[ 0., 0., 1., 2.],
[ 0., 0., 3., 4.]])
** WEITER ** → [Python] Weg zur Schlange (5) Spiel mit Matplotlib
Recommended Posts