[Python] Différentes façons de générer des données avec Numpy (arange / linspace / logspace / zeros / ones / mgrid / ogrid)
Générer des données à des intervalles spécifiés
J'ai résumé comment créer des données telles que 0,1,2,3 ... ou 1,3,5,7.
■ Générez des données à intervalles réguliers entre le démarrage et l'arrêt.
arange([start],stop,[step],[dtype])
start, step, dtype peuvent être omis, et si start est omis, il commence à 0.
In [1]: import numpy as np
In [2]: X = np.arange(10)
In [3]: print X
[0 1 2 3 4 5 6 7 8 9]
In [4]: type(X)
Out[4]: numpy.ndarray
In [5]: X.dtype
Out[5]: dtype('int32')
Si dtype est omis, il devient int32 lorsqu'il est spécifié par un entier tel que 10 et float64 lorsqu'il est spécifié par une virgule flottante telle que 10. Si vous spécifiez dtype = np.float32, les données seront créées avec le type souhaité.
In [15]: X = np.arange(10)
In [16]: print X.dtype
int32
In [17]: X = np.arange(10.)
In [18]: print X.dtype
float64
In [19]: X = np.arange(10.,dtype=np.float32)
In [20]: print X.dtype
float32
Voici un exemple de début, d'arrêt, d'étape.
In [22]: X = np.arange(1,10)
In [23]: print X
[1 2 3 4 5 6 7 8 9]
In [24]: X = np.arange(1,10,2)
In [25]: print X
[1 3 5 7 9]
In [26]: X = np.arange(9,0,-2)
In [27]: print X
[9 7 5 3 1]
À propos de la gamme et de la gamme X
Au fait, si vous utilisez range au lieu de numpy, ce sera une liste au lieu d'un tableau numpy. Si vous voulez que la liste Y soit un tableau numpy, utilisez np.array (Y). L'affectation de la liste Y à la variable X du tableau numpy ne produit pas un tableau numpy («X = Y»).
De plus, lorsque xrange est utilisé, un générateur est généré. Si vous souhaitez obtenir la valeur réelle, utilisez-la dans l'instruction for ou utilisez la liste (Z).
In [6]: Y = range(10)
In [7]: print Y
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [8]: type(Y)
Out[8]: list
In [9]: Z = xrange(10)
In [10]: print Z
xrange(10)
In [11]: type(Z)
Out[11]: xrange
In [12]: list(Z)
Out[12]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
La différence entre range et xrange est que la plage est générée en même temps, tandis que xrange est générée une fois par boucle. Il n'est pas nécessaire de générer des valeurs inutiles dans le cas d'un traitement qui quitte la boucle au milieu de l'instruction for. Si la liste à générer est volumineuse, cela économise de la mémoire et du temps.
In [13]: timeit for i in range(1000000): pass
10 loops, best of 3: 36.3 ms per loop
In [14]: timeit for i in xrange(1000000): pass
100 loops, best of 3: 16.4 ms per loop
■ Générez des données en divisant la section start-stop en nombre de parties égales
linspace(start,stop,num=50,endpoint=True,retstop=False,dtype=None) Par exemple, il est utilisé lorsque vous souhaitez créer un temps t lors de l'échantillonnage de données à 60 Hz.
In [28]: t = np.linspace(0,1,60)
In [29]: print t
[ 0. 0.01694915 0.03389831 0.05084746 0.06779661 0.08474576
0.10169492 0.11864407 0.13559322 0.15254237 0.16949153 0.18644068
0.20338983 0.22033898 0.23728814 0.25423729 0.27118644 0.28813559
0.30508475 0.3220339 0.33898305 0.3559322 0.37288136 0.38983051
0.40677966 0.42372881 0.44067797 0.45762712 0.47457627 0.49152542
0.50847458 0.52542373 0.54237288 0.55932203 0.57627119 0.59322034
0.61016949 0.62711864 0.6440678 0.66101695 0.6779661 0.69491525
0.71186441 0.72881356 0.74576271 0.76271186 0.77966102 0.79661017
0.81355932 0.83050847 0.84745763 0.86440678 0.88135593 0.89830508
0.91525424 0.93220339 0.94915254 0.96610169 0.98305085 1. ]
In [30]: len(t)
Out[30]: 60
Si le point de terminaison est défini sur False, les données qui n'incluent pas d'arrêt seront générées. Dans l'exemple ci-dessous, l'intervalle de données est 1/60 = 0,01666 ... L'intervalle lors de l'inclusion du point final est 1/59 = 0,001694.
In [31]: t = np.linspace(0,1,60,endpoint=False)
In [32]: print t
[ 0. 0.01666667 0.03333333 0.05 0.06666667 0.08333333
0.1 0.11666667 0.13333333 0.15 0.16666667 0.18333333
0.2 0.21666667 0.23333333 0.25 0.26666667 0.28333333
0.3 0.31666667 0.33333333 0.35 0.36666667 0.38333333
0.4 0.41666667 0.43333333 0.45 0.46666667 0.48333333
0.5 0.51666667 0.53333333 0.55 0.56666667 0.58333333
0.6 0.61666667 0.63333333 0.65 0.66666667 0.68333333
0.7 0.71666667 0.73333333 0.75 0.76666667 0.78333333
0.8 0.81666667 0.83333333 0.85 0.86666667 0.88333333
0.9 0.91666667 0.93333333 0.95 0.96666667 0.98333333]
In [33]: len(t)
Out[33]: 60
Si retstep = True, il renverra l'intervalle de données.
In [34]: t = np.linspace(0,1,60,retstep=True)
In [35]: print t
(array([ 0. , 0.01694915, 0.03389831, 0.05084746, 0.06779661,
0.08474576, 0.10169492, 0.11864407, 0.13559322, 0.15254237,
0.16949153, 0.18644068, 0.20338983, 0.22033898, 0.23728814,
0.25423729, 0.27118644, 0.28813559, 0.30508475, 0.3220339 ,
0.33898305, 0.3559322 , 0.37288136, 0.38983051, 0.40677966,
0.42372881, 0.44067797, 0.45762712, 0.47457627, 0.49152542,
0.50847458, 0.52542373, 0.54237288, 0.55932203, 0.57627119,
0.59322034, 0.61016949, 0.62711864, 0.6440678 , 0.66101695,
0.6779661 , 0.69491525, 0.71186441, 0.72881356, 0.74576271,
0.76271186, 0.77966102, 0.79661017, 0.81355932, 0.83050847,
0.84745763, 0.86440678, 0.88135593, 0.89830508, 0.91525424,
0.93220339, 0.94915254, 0.96610169, 0.98305085, 1. ]), 0.01694915254237288)
In [36]: print t[1]
0.0169491525424
■ Générez des données logarithmiques en divisant la section start-stop en nombre de parties égales
logspace(start,stop,num=50,endpoint=True,base=10.0,dtype=None) Il existe également une version journal de linspace appelée logspace. L'utilisation est la même, mais la différence est que vous pouvez spécifier la base et qu'il n'y a pas de nouvelle étape. Dans l'exemple ci-dessous, c'est la même chose que lorsque 2 à 3 sont divisés en 10 parties égales par linspace et que l'indice est le 10 du bas.
In [45]: t1 = np.logspace(2,3,10)
In [46]: print t1
[ 100. 129.1549665 166.81005372 215.443469 278.25594022
359.38136638 464.15888336 599.48425032 774.26368268 1000. ]
In [47]: n = np.linspace(2,3,10)
In [48]: t2 = 10**n
In [49]: print t2
[ 100. 129.1549665 166.81005372 215.443469 278.25594022
359.38136638 464.15888336 599.48425032 774.26368268 1000. ]
In [50]: t1 = np.logspace(2,3,10,base=np.e)
In [51]: print t1
[ 7.3890561 8.25741109 9.22781435 10.3122585 11.52414552
12.87845237 14.3919161 16.08324067 17.97332814 20.08553692]
■ Générer un tableau numpy initialisé avec 0
zeros(shape,dtype=float,order='C')
In [52]: X = np.zeros(10)
In [53]: print X
[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
In [54]: X = np.zeros((3,2))
In [55]: print X
[[ 0. 0.]
[ 0. 0.]
[ 0. 0.]]
■ Générer un tableau numpy initialisé en 1
ones(shape,dtype=None,order='C') Une matrice unitaire peut être créée en combinant avec diag.
In [56]: X = np.ones(10)
In [57]: print X
[ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
In [58]: X = np.ones((3,2))
In [59]: print X
[[ 1. 1.]
[ 1. 1.]
[ 1. 1.]]
In [60]: X = np.diag(np.ones(3))
In [61]: print X
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
■ Créez un tableau numpy initialisé avec 0 ou 1 de la même taille que le tableau numpy existant
zeros_like(a,dtype=None,order='K',subok=True), ones_like(a,dtype=None,order='K',subok=True)
Vous n'êtes pas obligé d'utiliser zeros (X.shape) à chaque fois, mais _like et .shape ne changent pas le nombre de caractères que vous entrez.
Comme le dtype de X est également utilisé, le nombre de caractères à saisir sera plus court s'il est inclus.
In [62]: X = np.arange(9).reshape(3,3)
In [63]: print X
[[0 1 2]
[3 4 5]
[6 7 8]]
In [64]: Y = np.zeros_like(X)
In [65]: print Y
[[0 0 0]
[0 0 0]
[0 0 0]]
■ Créer une grille maillée
Générez la grille de maillage utilisée pour l'index, comme la position des coordonnées des images et les coordonnées des axes X et Y du graphique 3D. En d'autres termes, c'est pour créer des données (0,0), (0,1) .... (1,0), (1,1) ....
In [68]: X = np.mgrid[0:10:2]
In [69]: print X
[0 2 4 6 8]
In [70]: XY = np.mgrid[0:10:2,1:10:2]
In [71]: print XY
[[[0 0 0 0 0]
[2 2 2 2 2]
[4 4 4 4 4]
[6 6 6 6 6]
[8 8 8 8 8]]
[[1 3 5 7 9]
[1 3 5 7 9]
[1 3 5 7 9]
[1 3 5 7 9]
[1 3 5 7 9]]]
Vous pouvez faire quelque chose comme ça avec meshgrid.
In [84]: X,Y = np.mgrid[-2:2:0.2,-2:2:0.2]
In [85]: Z = X * np.exp(-X**2-Y**2)
In [86]: import matplotlib.pyplot as plt
In [87]: from mpl_toolkits.mplot3d import Axes3D
In [88]: from matplotlib import cm
In [89]: fig = plt.figure()
In [90]: ax = fig.gca(projection='3d')
In [91]: surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.jet,linewidth=0.1, antialiased=False)
In [92]: plt.show()
À propos, il y a aussi ogrid, qui renvoie des données unidimensionnelles. Les différences entre ogrid et mgrid sont les suivantes.
ipython
In [93]: np.ogrid[0:10:2,1:10:2]
Out[93]:
[array([[0],
[2],
[4],
[6],
[8]]), array([[1, 3, 5, 7, 9]])]
In [94]: np.mgrid[0:10:2,1:10:2]
Out[94]:
array([[[0, 0, 0, 0, 0],
[2, 2, 2, 2, 2],
[4, 4, 4, 4, 4],
[6, 6, 6, 6, 6],
[8, 8, 8, 8, 8]],
[[1, 3, 5, 7, 9],
[1, 3, 5, 7, 9],
[1, 3, 5, 7, 9],
[1, 3, 5, 7, 9],
[1, 3, 5, 7, 9]]])
Recommended Posts