Principes de base de NumPy

Caractéristiques de NumPy

--Calculer des tableaux multidimensionnels à la fois à grande vitesse.

ndarray: objet de tableau multidimensionnel

import numpy as np

data = np.random.randn(2,3) #Nombres aléatoires avec 2 colonnes et 3 lignes

print(data)
# [[-0.4440664  -0.07889544 -0.84781375]
#  [ 0.59333292 -0.03008522  1.54106015]]

print(data * 10) #Multiplier
# [[-4.44066398 -0.78895438 -8.47813747]
#  [ 5.93332925 -0.3008522  15.41060155]]

print(data + data) #Ajouter
# [[-0.8881328  -0.15779088 -1.69562749]
#  [ 1.18666585 -0.06017044  3.08212031]]

print(data.shape) #Nombre d'éléments verticaux et horizontaux
# (2, 3)

print(data.dtype) #Type d'élément
# float64

Génération de ndarray

--Générer avec np.array (list). --np.zeros (10) `` np.zeros ((3,6))crée un ndarray avec tous les éléments 0.


import numpy as np

data = [[1, 2, 3, 4], [5, 6, 7, 8]]

arr = np.array(data) #Générer ndarray à partir de la liste

print(arr)
# [[1 2 3 4]
#  [5 6 7 8]]

print(arr.ndim) #dimension
# 2

print(arr.shape) #Nombre d'éléments
# (2, 4)

Type de données de ndarray

import numpy as np

arr1 = np.array([-3.7, -1.2, 0.5, 4.5])
print(arr1)
# [-3.7 -1.2  0.5  4.5]

arr2 = arr1.astype(np.int32)  #Pour lancer
print(arr2)
# [-3 -1  0  4]

arr3 = np.array(['-3.7', '-1.2', '0.5', '4.5'], dtype=np.string_)
print(arr3)
# [b'-3.7' b'-1.2' b'0.5' b'4.5']
print(arr3.dtype)
# |S4

arr4 = arr3.astype(np.float64)  #Pour lancer
print(arr4)
# [-3.7 -1.2  0.5  4.5]

Opération arithmétique de ndarray

import numpy as np

arr1 = np.array([[1., 2., 3., 4.], [5., 6., 7., 8.]])
print(arr1 ** 2)
# [[ 1.  4.  9. 16.]
#  [25. 36. 49. 64.]]

print(arr1 - arr1)
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

print(1 / arr1)
# [[1.         0.5        0.33333333 0.25      ]
#  [0.2        0.16666667 0.14285714 0.125     ]]

arr2 = np.array([[0., 4., 1., 5.], [3., 9., 4., 9.]])
print(arr1 < arr2)
# [[False  True False  True]
#  [False  True False  True]]

Référence d'index et principes de base du découpage

import numpy as np

arr1 = np.arange(10)
print(arr1)
# [0 1 2 3 4 5 6 7 8 9]

print(arr1[5:8])
# [5 6 7]

arr1[5:8] = 12
print(arr1)
# [ 0  1  2  3  4 12 12 12  8  9]

arr_slice = arr1[5:8]
arr_slice[1] = 12345

print(arr_slice)
# [   12 12345    12]

print(arr1)
# [    0     1     2     3     4    12 12345    12     8     9]
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])  #2D
print(arr2d)
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

print(arr2d[:2])  #Verticale 0,Sortez le premier
# [[1 2 3]
#  [4 5 6]]

print(arr2d[:2, 1:])  #Verticale 0,1er, 1 sur la rue latérale,Sortez le second
# [[2 3]
#  [5 6]]

print(arr2d[1, :2])  #1er à la verticale, 0 à l'horizontale,Sortez le premier
# [4 5]

print(arr2d[:, :1])  #Tout vertical, horizontal 0,Sortez le premier
# [[1]
#  [4]
#  [7]]

arr2d[:2, 1:] = 0 #Remplacez tout dans cette gamme
print(arr2d)
# [[1 0 0]
#  [4 0 0]
#  [7 8 9]]

Référence d'index booléen

import numpy as np

names = np.array(['Yamada', 'Suzuki', 'Sato', 'Yamada', 'Tanaka', 'Tanaka', 'Sato'])

data = np.random.randn(7, 4) #Créez un tableau avec 7 lignes verticalement et 4 colonnes horizontalement avec des nombres aléatoires
print(data)
# [[-0.92866442 -0.81744986  1.11821763 -0.55440628]
#  [-0.09511771  0.99145963  0.38475434  0.59748055]
#  [ 0.0444708  -0.00381292  0.97888419  1.242504  ]
#  [ 0.89214068 -1.0411466   0.90850611 -2.02933442]
#  [ 0.78789041 -0.84593788 -0.5624772   0.32488453]
#  [ 0.50153002 -0.25411512  0.30855623 -1.31825153]
#  [-0.6596584   1.53735231 -0.37044833  1.93782111]]

print(names == 'Yamada') # 'Yamada'Flux correspondant, 0,4th renvoie True
# [ True False False  True False False False]

print(data[names == 'Yamada']) #données à 0,Sortez le 4e
# [[-0.92866442 -0.81744986  1.11821763 -0.55440628]
#  [ 0.89214068 -1.0411466   0.90850611 -2.02933442]]

mask = (names == 'Yamada') | (names == 'Sato') #Vous pouvez également le retirer avec ou
print(data[(names == 'Yamada') | (names == 'Sato')])
# [[-0.92866442 -0.81744986  1.11821763 -0.55440628]
#  [ 0.0444708  -0.00381292  0.97888419  1.242504  ]
#  [ 0.89214068 -1.0411466   0.90850611 -2.02933442]
#  [-0.6596584   1.53735231 -0.37044833  1.93782111]]

data[names  == 'Yamada'] = 0 # 0,Quatrièmement, mettez 0
print(data)
# [[ 0.          0.          0.          0.        ]
#  [-0.09511771  0.99145963  0.38475434  0.59748055]
#  [ 0.0444708  -0.00381292  0.97888419  1.242504  ]
#  [ 0.          0.          0.          0.        ]
#  [ 0.78789041 -0.84593788 -0.5624772   0.32488453]
#  [ 0.50153002 -0.25411512  0.30855623 -1.31825153]
#  [-0.6596584   1.53735231 -0.37044833  1.93782111]]

Voir l'index de fantaisie

--Fancy index reference est une méthode qui utilise un tableau d'entiers pour la référence d'index.

import numpy as np

arr = np.arange(32).reshape(8, 4)  # 8,Créez un tableau de 4
print(arr)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [12 13 14 15]
#  [16 17 18 19]
#  [20 21 22 23]
#  [24 25 26 27]
#  [28 29 30 31]]

print(arr[[0, 4, 5, -1]])  # 0, 4, 5, -Renvoie une ligne
# [[ 0  1  2  3]
#  [16 17 18 19]
#  [20 21 22 23]
#  [28 29 30 31]]

print(arr[[1, 5, 7, 2], [0, 3, 1, 2]])  # (1,0),(5,3),(7,1),(2,2)rends le
# [ 4 23 29 10]

Matrice de translocation, permutation des lignes et des colonnes

--Transposition de ndarray renvoie une vue spéciale qui reconstruit la matrice d'origine. Ne fait pas de copie. --Il existe une méthode pour appliquer la fonction transpose et une méthode pour faire référence à T qui est l'un des attributs de ndarray.

import numpy as np

arr1 = np.arange(15).reshape(3, 5)  # 3,Créez un tableau de 5
print(arr1)
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]]

print(arr1.T)
# [[ 0  5 10]
#  [ 1  6 11]
#  [ 2  7 12]
#  [ 3  8 13]
#  [ 4  9 14]]

arr2 = np.arange(24).reshape((2, 3, 4))  # (2,3,4)Créez un tableau de
print(arr2)
# [[[ 0  1  2  3]
#   [ 4  5  6  7]
#   [ 8  9 10 11]]
# 
#  [[12 13 14 15]
#   [16 17 18 19]
#   [20 21 22 23]]]

print(arr2.transpose((1, 0, 2)))  #Changer l'ordre des axes,(3,2,4)Fabriqué en une gamme de
# [[[ 0  1  2  3]
#   [12 13 14 15]]
# 
#  [[ 4  5  6  7]
#   [16 17 18 19]]
# 
#  [[ 8  9 10 11]
#   [20 21 22 23]]]

Fonction universelle: application de la fonction à tous les éléments du tableau

-La fonction universelle est une fonction qui renvoie les résultats de la recherche pour chaque élément de ndarray. -Un seul terme ufunc Prendre un ndarray -Abs, fabs, sqrt, square, exp, log, log10, log2, log1p, sign, cell, floor, rint modf, isnan, isfinite, isinf, cos, sin, tan, etc. -Deux termes ufunc Prend deux ndarrays -Ajouter, soustraire, multiplier, diviser, floor_dvide, puissance, maximum, fmax, minimum, fmin, mod, copysign, râpe, moins, égal, logique_and, etc.

Programmation orientée Array avec ndarray

--Affiche le résultat de sqrt (x ^ 2 + y ^ 2) pour les données de point de grille --np.meshgrid prend deux fonctions unidimensionnelles et énumère toutes les combinaisons de chaque élément.

import numpy as np
import matplotlib.pyplot as plt

points = np.arange(-5, 5, 0.01)  #1000 points de grille
xs, ys = np.meshgrid(points, points)  #Renvoie toutes les combinaisons

z = np.sqrt(xs ** 2 + ys ** 2)

print(z)

plt.imshow(z, cmap=plt.cm.gray)
plt.colorbar()
plt.title("Image plot of $\\sqrt{x^2 + x^2}$ for a grid of values")
plt.show()
スクリーンショット 2020-01-27 9.07.30.png

Représentation du contrôle conditionnel dans ndarray

--np.where () renvoie le deuxième argument lorsque le premier argument est Vrai et le troisième lorsque le premier argument ne l'est pas.

import numpy as np
import matplotlib.pyplot as plt

xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])
#Prend x quand cond est vrai, y sinon
#Notation d'inclusion (lente)
reult1 = [(x if c else y) for x, y, c in zip(xarr, yarr, cond)]
#utiliser où
result2 = np.where(cond, xarr,yarr)
print(result2)
# [1.1 2.2 1.3 1.4 2.5]

Fonction mathématique, fonction statistique

Spécifiez l’axe à traiter avec «axe» --Total et moyenne de ʻarr.sum () , ʻarr.mean () --ʻArr.sum (axis = 1) , ʻarr.mean (axis = 0) En deux dimensions, la somme des lignes et la moyenne des colonnes, respectivement

Fonction de tableau booléen

--Lorsque ʻarrestnp.array, (arr> 0) .sum () ʻest le nombre de nombres positifs (True). --Lorsque bool = tableau booléen --S'il y a True même dans bools.any () 1, alors True --bools.all () Vrai si tout est Vrai

Trier

--Lorsque ʻarrestnp.array, trier lui-même avec ʻarr.sort (). (Destructeur) --Pour les tableaux multidimensionnels, spécifiez n'importe quel axe, tel que ʻarr.sort (1) `.

Fonction d'agrégation: unique, etc.

--np.unique (arr) supprime les doublons et renvoie le résultat trié. --np.inld (arr, [2, 3, 6]) est True si la liste de arr contient 2,3,6, sinon False est une liste de même longueur que arr. revenir.

Fichier d'entrée / sortie de ndarray

--Beaucoup utilisent pandas pour lire des fichiers texte et des données tabulaires.

Calcul matriciel


import numpy as np

x = np.array([[1., 2., 3.], [4., 5., 6., ]])
y = np.array([[6., 23.], [-1., 7.], [8., 9.]])

print(x.dot(y))  #produit intérieur
# [[ 28.  64.]
#  [ 67. 181.]]

print(np.dot(x, y))  #Une autre façon d'écrire
# [[ 28.  64.]
#  [ 67. 181.]]

print(x @ y)  # @Peut également être utilisé.
# [[ 28.  64.]
#  [ 67. 181.]]

Génération de nombres pseudo aléatoires

--Utilisez normal pour une matrice 4x4 avec np.random.normal (size = (4,4)) pour générer des nombres aléatoires basés sur une distribution normale. --randint Renvoie un nombre aléatoire entier dans la plage d'entiers donnée.

import numpy as np
import matplotlib.pyplot as plt

samples = np.random.normal(size=(4,4))
print(samples)
# [[ 1.45907882  1.78873804 -0.52480754  0.20770224]
#  [-1.55474475 -1.67045483 -1.3589208   1.25584424]
#  [ 0.90562937 -1.50742692  1.48579887  1.48081589]
#  [ 1.3478]5606 -0.20653648  0.13308665 -0.24455952]

Exemple: marche aléatoire

Marche aléatoire multiple

--Dans une marche aléatoire, après 5000 essais, trouvez l'indice qui a d'abord atteint 30 ou -30 à la fois.

import numpy as np
import matplotlib.pyplot as plt

nwalks = 5000
nsteps = 1000

#Générer au hasard 0 ou 1
draws = np.random.randint(0, 2, size=(nwalks, nsteps))
print(draws)
# [[1 1 1 ... 0 1 1]
#  [1 1 0 ... 0 0 1]
#  [0 0 1 ... 1 1 0]
#  ...
#  [0 0 1 ... 0 0 0]
#  [0 0 1 ... 1 0 0]
#  [1 0 1 ... 1 1 0]]

#0 et 1-Diviser en 1 et 1
steps = np.where(draws > 0, 1, -1)
print(steps)
# [[ 1  1  1 ... -1  1  1]
#  [ 1  1 -1 ... -1 -1  1]
#  [-1 -1  1 ...  1  1 -1]
#  ...
#  [-1 -1  1 ... -1 -1 -1]
#  [-1 -1  1 ...  1 -1 -1]
#  [ 1 -1  1 ...  1  1 -1]]


#Ajouter dans le sens horizontal
walks = steps.cumsum(1)
print(walks)
# [[  1   2   3 ...  10  11  12]
#  [  1   2   1 ... -44 -45 -44]
#  [ -1  -2  -1 ... -28 -27 -28]
#  ...
#  [ -1  -2  -1 ...   6   5   4]
#  [ -1  -2  -1 ...  -6  -7  -8]
#  [  1   0   1 ...  28  29  28]]

print(walks.max())
# 128

print(walks.min())
# -123

#Avez-vous atteint 30 ans? Vrai dans les lignes/Revenir avec faux
hits30 = (np.abs(walks) >= 30).any(1)
print(hits30)
# [False False  True ...  True  True  True]

#30-Nombre atteint 30
print(hits30.sum())
# 3377

# 30/-Sortez la ligne qui a atteint 30 et trouvez le tout premier index
crossing_times = (np.abs(walks[hits30]) >= 30).argmax(1)
print(crossing_times)
# [671 313 161 ... 307 289  89]

#moyenne
print(crossing_times.mean())
# 500.09327805744744

#Affichage sur le graphique
max_row = walks[(walks == walks.max()).any(1)][0]
min_row = walks[(walks == walks.min()).any(1)][0]

plt.plot(max_row)
plt.plot(min_row)
plt.show()

--Graphique maximum et minimum de marche aléatoire

スクリーンショット 2020-01-30 12.53.18.png

référence

--Introduction à l'analyse de données avec Python 2nd Edition

Recommended Posts

Principes de base de NumPy
Les bases de #Python (#Numpy 1/2)
Les bases de #Python (#Numpy 2/2)
Principes de base de Python #Numpy
Test numpy Python Basic 8
Les bases de Python ⑤
Numpy [basique]
numpy partie 1
Bases de Linux
Les bases de Python
Les bases de Python ④
Mémorandum Numpy _ Matrice
astuces numpy
Notions de base sur les pandas
Les bases de Git
Les bases de Python ③
Les bases de Python
Les bases de Django
À propos de numpy
Bases de Linux
Axe NumPy
Notions de base sur les pandas
Utilisez Numpy
Les bases de Python
numpy partie 2
Les bases de Python
Les bases de Python ③
Les bases de Python ②
Les bases de Python ②
Accélérer les calculs numériques avec NumPy: principes de base
bases de python: liste
Mémorandum de base Python
Principes de base du script Shell # 2
Les bases de #Python (#matplotlib)
Principes de base de Python CGI
bases de python: dictionnaire
test unitaire numpy
Fonctionnement du tableau NumPy (3)
list et numpy
Les bases de Python ①
Fonction universelle NumPy
Bases de python ①
mémorandum numpy 1 / np.pad
bases de la tranche de python
# Principes de base de Python (portée)
Aller aux bases de la classe
Apprendre sans enseignant 1 Principes de base
# Bases de Python (fonctions)
recherche d'index numpy
Fonctionnement du tableau NumPy (1)
principes de base des tableaux python
[Numpy] Shuffle ndarray
Principes de base du profilage Python
Principes de base des commandes Linux
technique non basique de numpy
À propos de la diffusion Numpy
[PyTorch] Exemple ① ~ NUMPY ~
bases de python: fonctions
Les bases de #Python (classe)
Installation de Numpy + Atlas
Résumé des bases de Python