[Python] Verschiedene Möglichkeiten, Daten mit Numpy zu generieren (arange / linspace / logspace / zeros / Einsen / mgrid / ogrid)
Generieren Sie Daten in festgelegten Intervallen
Ich habe zusammengefasst, wie man Daten wie 0,1,2,3 ... oder 1,3,5,7 erstellt.
■ Generieren Sie Daten in Schrittintervallen zwischen Start und Stopp.
arange([start],stop,[step],[dtype])
start, step, dtype kann weggelassen werden, und wenn start weggelassen wird, beginnt es bei 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')
Wenn dtype weggelassen wird, wird es int32, wenn es durch eine Ganzzahl wie 10 angegeben wird, und float64, wenn es durch ein Gleitkomma wie 10 angegeben wird. Wenn Sie dtype = np.float32 angeben, werden die Daten mit dem gewünschten Typ erstellt.
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
Ein Beispiel für die Angabe von Start, Stopp und Schritt lautet wie folgt.
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]
Über Reichweite und Reichweite
Übrigens, wenn Sie anstelle von numpys Arrangement range verwenden, wird es anstelle von numpy array aufgelistet. Wenn Sie möchten, dass Liste Y ein Numpy-Array ist, verwenden Sie np.array (Y). Das Zuweisen der Liste Y zur Variablen X des Numpy-Arrays führt nicht zu einem Numpy-Array ("X = Y").
Wenn xrange verwendet wird, wird auch ein Generator generiert. Wenn Sie den tatsächlichen Wert erhalten möchten, verwenden Sie ihn in der for-Anweisung oder in der Verwendungsliste (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]
Der Unterschied zwischen Bereich und x-Bereich besteht darin, dass der Bereich sofort generiert wird, während x-Bereich einmal pro Schleife generiert wird. Bei der Verarbeitung, die die Schleife in der Mitte der for-Anweisung verlässt, müssen keine unnötigen Werte generiert werden. Wenn die zu generierende Liste groß ist, spart dies Speicher und Zeit.
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
■ Generieren Sie Daten, indem Sie den Start-Stopp-Abschnitt in gleiche Teile teilen
linspace(start,stop,num=50,endpoint=True,retstop=False,dtype=None) Beispielsweise wird es verwendet, wenn Sie beim Abtasten von Daten mit 60 Hz eine Zeit t erstellen möchten.
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
Wenn der Endpunkt auf False gesetzt ist, werden Daten generiert, die keinen Stopp enthalten. Im folgenden Beispiel beträgt das Datenintervall 1/60 = 0,01666 ... Das Intervall beim Einschließen des Endpunkts beträgt 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
Wenn retstep = True ist, wird das Datenintervall zurückgegeben.
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
■ Generieren Sie logarithmische Daten, indem Sie den Start-Stopp-Abschnitt in num gleiche Teile teilen
logspace(start,stop,num=50,endpoint=True,base=10.0,dtype=None) Es gibt auch eine Protokollversion von Linspace namens Logspace. Die Verwendung ist dieselbe, aber der Unterschied besteht darin, dass Sie die Basis angeben können und es keinen Rückschritt gibt. Im folgenden Beispiel ist es dasselbe, als wenn 2 bis 3 durch Linspace in 10 gleiche Teile geteilt werden und der Index die unteren 10 ist.
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]
■ Generieren Sie ein mit 0 initialisiertes Numpy-Array
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.]]
■ Generieren Sie ein in 1 initialisiertes Numpy-Array
ones(shape,dtype=None,order='C') Eine Einheitsmatrix kann durch Kombinieren mit diag erstellt werden.
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.]]
■ Erstellen Sie ein mit 0 oder 1 initialisiertes Numpy-Array, das der Größe des vorhandenen Numpy-Arrays entspricht
zeros_like(a,dtype=None,order='K',subok=True), ones_like(a,dtype=None,order='K',subok=True)
Sie müssen nicht jedes Mal "Nullen (X.shape)" verwenden, aber _like und .shape ändern nicht die Anzahl der eingegebenen Zeichen. Da auch der d-Typ von X verwendet wird, ist die Anzahl der einzugebenden Zeichen kürzer, wenn er enthalten ist.
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]]
■ Erstellen Sie ein Netzgitter
Generieren Sie ein für den Index verwendetes Netzgitter, z. B. die Koordinatenposition von Bildern und die X- und Y-Achsenkoordinaten des 3D-Diagramms. Mit anderen Worten, es dient zum Erstellen von Daten (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]]]
Mit meshgrid können Sie so etwas tun.
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()
Übrigens gibt es auch ogrid, das eindimensionale Daten zurückgibt. Die Unterschiede zwischen Ogrid und Mgrid sind wie folgt.
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