Il s'agit d'une formation pour devenir un data scientist en utilisant Python. Enfin, j'utiliserai Numpy. Numpy est une bibliothèque pour manipuler de grands tableaux et matrices multidimensionnels. Sans cela, Python ne peut pas analyser les données.
** PREV ** → [Python] Road to the Serpent (3) Python Class ** SUIVANT ** → [Python] Road to the Serpent (5) Jouez avec Matplotlib
Tout d'abord, importez numpy.
>>> import numpy as np
Générez des tableaux à 1 dimension, 2 dimensions et 3 dimensions.
>>> 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]]])
Examinez le type de données (dtype) et la forme (forme).
>>> a2.dtype, a1.shape, a2.shape, a3.shape
(dtype('int64'), (3,), (2, 3), (2, 2, 3))
Tapez le tableau de conversion.
>>> a1.astype(float), a1.astype(complex)
(array([ 1., 2., 3.]), array([ 1.+0.j, 2.+0.j, 3.+0.j]))
Générez un tableau de tous les 0.
>>> np.zeros((2, 3), int)
array([[0, 0, 0],
[0, 0, 0]])
Générez un tableau de tous les 1.
>>> np.ones((2, 3),int)
array([[1, 1, 1],
[1, 1, 1]])
Générez une matrice d'unité 3x3.
>>> np.identity(3, int)
array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
Générez une matrice diagonale à partir de composants diagonaux.
>>> a5 = np.diag([1, 2, 3]); a5
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])
Extraire les composantes diagonales de la matrice carrée.
>>> np.diag(a5)
array([1, 2, 3])
Générez un tableau avec shape = (2,3).
>>> a1 = np.array([[1, 2, 3], [4, 5, 6]]); a1
array([[1, 2, 3],
[4, 5, 6]])
Changé en forme unidimensionnelle de forme = (6,).
>>> a1.reshape(6,)
array([1, 2, 3, 4, 5, 6])
Changé en une forme bidimensionnelle avec shape = (3,2).
>>> a1.reshape(3, 2)
array([[1, 2],
[3, 4],
[5, 6]])
slice
Une tranche est une liste d'index de type colonne à nombre égal, et ceci est [...] donné pour obtenir un tableau partiel.
>>> a1 = np.array(range(1, 10)).reshape(3, 3); a1
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
Extrayez les numéros de ligne de 1 à moins de 3 et les numéros de colonne de 1 à moins de 3.
>>> a1[1:3, 1:3]
array([[5, 6],
[8, 9]])
Les valeurs négatives pour le troisième paramètre de la tranche indiquent l'ordre inverse.
>>> a1[::-1, ::-1]
array([[9, 8, 7],
[6, 5, 4],
[3, 2, 1]])
Vous pouvez également utiliser l'objet slice de cette manière.
>>> slice1 = slice(0, 3, 2) # 0:3:2
>>> a1[slice1, slice1]
array([[1, 3],
[7, 9]])
fancy indexing
L'indexation fantaisie est une méthode pour obtenir un tableau partiel en donnant une colonne d'index arbitraire à [...].
Extrayez la 0ème ligne et la 2ème ligne.
>>> a1[[0, 2], :]
array([[1, 2, 3],
[7, 8, 9]])
Extrayez la 0ème colonne et la 2ème colonne.
>>> a1[:, [0, 2]]
array([[1, 3],
[4, 6],
[7, 9]])
Indexation fantaisie sur les deux axes. Extraire les composants [0,0] et [2,2].
>>> a1[[0, 2], [0, 2]]
array([1, 9])
Veuillez noter que le résultat ci-dessus est un tableau 1D, qui est différent de ce qui suit.
>>> a1[[0, 2], :][:, [0, 2]]
array([[1, 3],
[7, 9]])
L'indexation fantaisie peut également être utilisée à des fins de permutation de données de cette manière.
>>> a1[[2, 0, 1], :]
array([[7, 8, 9],
[1, 2, 3],
[4, 5, 6]])
boolean indexing
L'indexation booléenne est une méthode pour obtenir un tableau partiel de seuls vrais index en donnant un tableau booléen à [...].
Créez un tableau booléen qui a la valeur True uniquement si la valeur est paire.
>>> 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)
Extrayez uniquement les composants dont l'index correspond à True en tant que tableau 1D.
>>> a1[a2]
array([2, 4, 6, 8])
Un sous-tableau de Numpy est une référence si l'index est slice. Dans d'autres cas (index fantaisie, etc.), il s'agit d'une copie. Même si l'indexation par tranches et fantaisie est mélangée comme ʻa1 [[0, 2] ,:] `, ce sera une copie.
Tout d'abord, préparez deux tableaux bidimensionnels 2x2.
>>> 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]])
Rejoignez dans le sens de la ligne. (Direction de la ligne: 0ème axe) forme = (4,2).
>>> np.vstack((a1,a2)) # np.concatenate((a1,a2),axis=0)Même avec
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
Rejoignez dans le sens de la colonne. (Direction de la colonne: 1er axe) forme = (2,4).
>>> np.hstack((a1,a2)) # np.concatenate((a1,a2),axis=1)Même avec
array([[1, 2, 5, 6],
[3, 4, 7, 8]])
Préparez un tableau à deux dimensions avec shape = (2,3).
>>> a1 = np.array(range(2 * 3)).reshape(2, 3); a1
array([[0, 1, 2],
[3, 4, 5]])
Inverser (permuter le 0e axe (ligne) et le 1er axe (colonne)).
B_{ji} = A_{ij}
>>> a1.T
array([[0, 3],
[1, 4],
[2, 5]])
Préparez un tableau à 4 dimensions avec shape = (2,3,4,5).
>>> a2 = np.array(range(2 * 3 * 4 * 5)).reshape(2, 3, 4, 5)
>>> a2.shape
(2, 3, 4, 5)
Permutez les 1er et 3ème axes.
B_{ilkj} = A_{ijkl}
>>> a2.swapaxes(1, 3).shape
(2, 5, 4, 3)
Soit les 1er, 2ème, 3ème et 0ème axes les nouveaux 0ème, 1er, 2ème et 3ème axes.
B_{jkli} = A_{ijkl}
>>> a3=a2.transpose(1, 2, 3, 0)
Le même processus peut être exprimé visuellement de manière facile à comprendre en utilisant einsum.
>>> a4=np.einsum('ijkl->jkli', a2)
>>> a3.shape, a4.shape, (a3 == a4).all()
((3, 4, 5, 2), (3, 4, 5, 2), True)
Préparez la matrice suivante.
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 #Matrice d'unité 2x2
array([[ 1., 0.],
[ 0., 1.]])
Rendre I et A unidimensionnels et calculer le produit tensoriel de deux vecteurs.
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.]])
Calculez le produit tenseur de Kronecker (le produit tenseur en tant qu'opérateur)
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.]])
** SUIVANT ** → [Python] Road to the Serpent (5) Jouez avec Matplotlib
Recommended Posts