Décrit comment utiliser Numpy.
La structure de données de base dans Numpy est ndarray. Représente un tableau à N dimensions.
Décrit comment créer un ndarray.
>>> from numpy import *
# range()Créez un tableau unidimensionnel avec la même sensation que.
>>> a = arange(10);a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#Tableau bidimensionnel avec remodelage(2 lignes 5 colonnes)À
>>> a = arange(10).reshape(2,5);a
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
#Matrice 3D(Deux matrices 3 par 4)
>>> a = arange(24).reshape(2,3,4);a
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
#Créez un tableau à une dimension. Spécifiez des données spécifiques.
>>> a = array([1,2,3]);a
array([1, 2, 3])
#Créez un tableau à deux dimensions.
>>> a = array([(1,2,3), (4,5,6)]);a
array([[1, 2, 3],
[4, 5, 6]])
zeros crée un tableau avec tous les éléments nuls. ones crée un tableau avec les 1 éléments. eye crée un tableau avec 1 élément diagonal. empty crée un tableau non initialisé.
>>> a = zeros((2,3));a
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
>>> a = ones((2,3));a
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
>>> a = eye(3,3);a
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
#La valeur de l'élément n'est pas définie car il n'est pas initialisé.
>>> a = empty((2,3));a
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
Créez un tableau unidimensionnel en spécifiant la valeur de début, la valeur de fin et le nombre de données. Utile lors de la création de graphiques de fonctions.
>>> x = linspace(0, 2*pi, 10);x
array([ 0. , 0.6981317 , 1.3962634 , 2.0943951 , 2.7925268 ,
3.4906585 , 4.1887902 , 4.88692191, 5.58505361, 6.28318531])
>>> sin(x)
array([ 0.00000000e+00, 6.42787610e-01, 9.84807753e-01,
8.66025404e-01, 3.42020143e-01, -3.42020143e-01,
-8.66025404e-01, -9.84807753e-01, -6.42787610e-01,
-2.44929360e-16])
Créez un tableau avec des nombres aléatoires uniformes et des nombres aléatoires normaux comme éléments.
# [0,1)Créez un nombre aléatoire uniforme pour.
>>> a = random.random(10);a
array([ 0.55089503, 0.45425945, 0.57639104, 0.65731385, 0.06515141,
0.75809653, 0.98538432, 0.14194245, 0.81874444, 0.77024755])
#Valeur moyenne mu,Créez un nombre aléatoire normal avec un écart type de sigma.
>>> mu = 100; sigma=10
>>> a = random.normal(mu, sigma, 10).reshape(2,5);a
array([[ 83.5821915 , 82.34512541, 102.4633897 , 72.53721859,
96.21639407],
[ 91.54337302, 96.03740307, 82.04488924, 109.00803432,
101.72208762]])
>>> a = random.random(6).reshape(2,3);a
array([[ 0.52638479, 0.39144147, 0.75575996],
[ 0.1557081 , 0.11812827, 0.84377568]])
>>> b = random.random(6).reshape(2,3);b
array([[ 0.28797541, 0.60331924, 0.81078013],
[ 0.83825199, 0.41031302, 0.64098045]])
>>> a + b
array([[ 0.8143602 , 0.9947607 , 1.56654009],
[ 0.9939601 , 0.52844128, 1.48475613]])
>>> a - b
array([[ 0.23840938, -0.21187777, -0.05502018],
[-0.68254389, -0.29218475, 0.20279523]])
>>> a * b
array([[ 0.15158588, 0.23616417, 0.61275516],
[ 0.13052263, 0.04846957, 0.54084371]])
>>> a / b
array([[ 1.82788103, 0.64881317, 0.93213921],
[ 0.18575334, 0.28789793, 1.31638287]])
>>> a = random.random(6).reshape(2,3);a
array([[ 0.26511097, 0.7092039 , 0.78596957],
[ 0.52916934, 0.00993958, 0.30160079]])
>>> b = random.random(6).reshape(3,2);b
array([[ 0.68708518, 0.77809895],
[ 0.32463964, 0.35987488],
[ 0.13998871, 0.65494372]])
#Produit matriciel(dot)
>>> dot(a,b)
array([[ 0.52241638, 0.97627307],
[ 0.4090319 , 0.61285465]])
#Matrice de translocation(T)
>>> a.T
array([[ 0.26511097, 0.52916934],
[ 0.7092039 , 0.00993958],
[ 0.78596957, 0.30160079]])
#Matrice inverse(linalg.inv)
>>> linalg.inv(dot(a,b))
array([[ -7.74182569, 12.33267281],
[ 5.16705495, -6.59937322]])
#Formule matricielle(linalg.det)
>>> linalg.det(dot(a,b))
-0.079161515267537994
#valeur propre(w), Vecteur unique(v) linalg.eig
>>> w, v = linalg.eig(dot(a,b))
>>> w
array([-0.06590343, 1.20117446])
>>> v
array([[-0.85650205, -0.8210583 ],
[ 0.51614363, -0.57084434]])
>>> a = random.random(3);a
array([ 0.52541688, 0.12396039, 0.31534285])
>>> b = random.random(3);b
array([ 0.62372191, 0.00251833, 0.41029588])
#produit intérieur
>>> inner(a,b)
0.45741006789576372
#Produit extérieur(Produit croisé)
>>> cross(a,b)
array([ 0.0500663 , -0.01889014, -0.07599364])
#Produit direct
>>> outer(a,b)
array([[ 3.27714024e-01, 1.32317300e-03, 2.15576381e-01],
[ 7.73168097e-02, 3.12173138e-04, 5.08604357e-02],
[ 1.96686245e-01, 7.94137296e-04, 1.29383871e-01]])
Détermine si les éléments du tableau répondent aux critères.
>>> a = random.random(9).reshape(3,3);a
array([[ 0.07562832, 0.37995414, 0.80141031],
[ 0.31946711, 0.54688344, 0.27916878],
[ 0.64425661, 0.50601982, 0.55279281]])
#Pour chaque élément un< 0.Juger 5.
>>> a < 0.5
array([[ True, True, False],
[ True, False, True],
[False, False, False]], dtype=bool)
#Élément par élément(0.2 < a) & (a < 0.4)Est jugé.
>>> (0.2 < a) & (a < 0.4)
array([[False, True, False],
[ True, False, True],
[False, False, False]], dtype=bool)
# any():Est au moins un vrai?
>>> a = [True,False]
>>> any(a)
True
>>> a = [False,False]
>>> any(a)
False
# all():Sont tous vrais?
>>> a = [True,False]
>>> all(a)
False
>>> a = [True,True]
>>> all(a)
True
>>> a = random.random(5);a
array([ 0.81006955, 0.54988884, 0.3000227 , 0.68326733, 0.01710223])
#total
>>> a.sum()
2.3603506492918598
#moyenne
>>> a.mean()
0.47207012985837193
#maximum
>>> a.max()
0.81006955003900494
#le minimum
>>> a.min()
0.017102231221299058
#maximum-le minimum
>>> a.ptp()
0.79296731881770588
#Le diviseur de l'écart type est N
>>> a.std()
0.28337244927937266
#Le diviseur de l'écart type est N-1
>>> a.std(ddof=1)
0.31682002976226714
#Le diviseur distribué est N
>>> a.var()
0.080299945006851087
#Index du tableau de valeurs maximales
>>> a.argmax()
0
#Index du tableau de valeurs minimales
>>> a.argmin()
4
#Valeur cumulée
>>> a.cumsum()
array([ 0.81006955, 1.35995839, 1.65998109, 2.34324842, 2.36035065])
Effectue des calculs statistiques le long d'un axe pour un tableau à N dimensions. Il s'agit d'une image calculée en se déplaçant uniquement dans la direction de l'axe spécifié. L'axe est spécifié par l'axe des arguments.
#3 lignes 4 colonnes*Créez un tableau de 2.
>>> a = random.random(24).reshape(2,3,4);a
array([[[ 0.70106649, 0.84600927, 0.96988224, 0.06242455],
[ 0.90827331, 0.65320237, 0.41143149, 0.73883318],
[ 0.03434408, 0.40834032, 0.16037719, 0.66273333]],
[[ 0.33596355, 0.77672752, 0.26468854, 0.83723116],
[ 0.9966073 , 0.29452339, 0.26186954, 0.33732824],
[ 0.76577634, 0.20663298, 0.33442575, 0.3477926 ]]])
#J'expliquerai en utilisant la somme comme exemple, mais d'autres statistiques peuvent être calculées de la même manière.
# axis=Somme le long de 0.
>>> a.sum(axis=0)
array([[ 1.03703004, 1.62273679, 1.23457077, 0.89965571],
[ 1.90488061, 0.94772576, 0.67330104, 1.07616143],
[ 0.80012042, 0.6149733 , 0.49480294, 1.01052593]])
# axis=Additionnez 1.
>>> a.sum(axis=1)
array([[ 1.64368387, 1.90755197, 1.54169092, 1.46399106],
[ 2.09834719, 1.27788389, 0.86098384, 1.52235201]])
# axis=Additionnez 2.
>>> a.sum(axis=2)
array([[ 2.57938255, 2.71174035, 1.26579492],
[ 2.21461077, 1.89032848, 1.65462767]])
>>> a
array([[[ 0.69633633, 0.60467738, 0.46174455, 0.24528887],
[ 0.03127559, 0.66646753, 0.93620592, 0.39435246],
[ 0.59428005, 0.05191262, 0.94079899, 0.1217417 ]],
[[ 0.6436789 , 0.41509296, 0.38650686, 0.41877047],
[ 0.87710361, 0.34266031, 0.58358085, 0.72265266],
[ 0.57560748, 0.2277301 , 0.12321634, 0.49292207]]])
#Enregistrez en tant que fichier binaire.
>>> a.tofile("test.dat")
#Lire à partir d'un fichier binaire. Les informations d'axe telles que les lignes et les colonnes ont disparu.
>>> fromfile("test.dat")
array([ 0.69633633, 0.60467738, 0.46174455, 0.24528887, 0.03127559,
0.66646753, 0.93620592, 0.39435246, 0.59428005, 0.05191262,
0.94079899, 0.1217417 , 0.6436789 , 0.41509296, 0.38650686,
0.41877047, 0.87710361, 0.34266031, 0.58358085, 0.72265266,
0.57560748, 0.2277301 , 0.12321634, 0.49292207])
#Enregistrez au format npy.
>>> save("test", a)
#Les informations d'axe restent également.
>>> load("test.npy")
array([[[ 0.69633633, 0.60467738, 0.46174455, 0.24528887],
[ 0.03127559, 0.66646753, 0.93620592, 0.39435246],
[ 0.59428005, 0.05191262, 0.94079899, 0.1217417 ]],
[[ 0.6436789 , 0.41509296, 0.38650686, 0.41877047],
[ 0.87710361, 0.34266031, 0.58358085, 0.72265266],
[ 0.57560748, 0.2277301 , 0.12321634, 0.49292207]]])
#Enregistrez au format npz.
>>> savez("test", a=a)
#Parcourez le tableau avec des mots-clés.
>>> npz = load("test.npz")
>>> npz["a"]
array([[[ 0.69633633, 0.60467738, 0.46174455, 0.24528887],
[ 0.03127559, 0.66646753, 0.93620592, 0.39435246],
[ 0.59428005, 0.05191262, 0.94079899, 0.1217417 ]],
[[ 0.6436789 , 0.41509296, 0.38650686, 0.41877047],
[ 0.87710361, 0.34266031, 0.58358085, 0.72265266],
[ 0.57560748, 0.2277301 , 0.12321634, 0.49292207]]])
#Version compressée de Savez_Il est également compressé. Même usage que savez.
#Si vous ne le fermez pas, le fichier restera ouvert.
>>> npz.close()
>>> x = random.random(6).reshape(2,3);x
array([[ 0.56246598, 0.19331716, 0.2826291 ],
[ 0.81149981, 0.32680372, 0.90326888]])
#Savetxt est utile pour les tableaux à 2 dimensions. C'est du texte donc c'est facile à lire.
>>> savetxt("x.txt", x, delimiter="\t")
>>> loadtxt("x.txt")
array([[ 0.56246598, 0.19331716, 0.2826291 ],
[ 0.81149981, 0.32680372, 0.90326888]])
#Une erreur se produira s'il s'agit de 3D.
>>> savetxt("a.txt", a) #Une erreur se produira.
Recommended Posts