Detaillierte Einführung in die allgemeine Verwendung von Numpy

Einführung in Numpy

Die Existenz von Numpy sorgt dafür, dass Python über leistungsstarke Matrixberechnungsfunktionen verfügt, nicht weniger als Matlab.
Offizielles Dokument (https://docs.scipy.org/doc/numpy-dev/user/quickstart.html)

Einführung in verschiedene Verwendungsmöglichkeiten

Zuallererst in Numpy Datentyp , ndarray-Typ, unterscheidet sich von array.array in der Standardbibliothek.

Einige Eigenschaften von ndarray

ndarray.ndim
die Anzahl der Achsen (Dimensionen) des Arrays In der Python-Welt. Die Anzahl der Dimensionen wird als Rang bezeichnet.
ndarray.shape
die Dimensionen des Arrays. Dies ist ein Tupel von ganzen Zahlen, die die Größe des Arrays in jeweils Dimension. Für eine Matrix mit n Zeilen und m Spalten beträgt die Form (n,m). Die Länge des Formtupels ist daher der Rang oder die Anzahl der Dimensionen, ndim.
ndarray.sizedie Gesamtzahl der Elemente des Arrays. Dies entspricht dem Produkt der Elemente der Form.

ndarray.dtypeein Objekt, das den Typ der Elemente in beschreibt Das Array. Man kann Dtypes mit Standard-Python-Typen erstellen oder angeben. Numpy.int32, numpy.int16 und numpy sind einige Beispiele.
ndarray.itemsize
die Größe in Bytes jedes Elements des Arrays. Beispielsweise hat ein Array von Elementen vom Typ float64 die Elementgröße 8 (=64/8), während eines davon Typ complex32 hat itemsize 4 (=32/8). Es entspricht ndarray.dtype.itemsize.
ndarray.data
Der Puffer enthält normalerweise die tatsächlichen Elemente des Arrays Dieses Attribut muss nicht verwendet werden, da wir über Indizierungsfunktionen auf die Elemente in einem Array zugreifen. 🎜>Geben Sie den Typ beim Erstellen an

Erstellen Sie einige spezielle Matrizen

>>> import numpy as np>>> a = np.array([2,3,4])>>> a
array([2, 3, 4])>>> a.dtype
dtype('int64')>>> b = np.array([1.2, 3.5, 5.1])>>> b.dtype
dtype('float64')

Erstellen Sie einige Matrizen mit spezifischen Regeln

Einige Grundoperationen

>>> b = np.array([(1.5,2,3), (4,5,6)])>>> b
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])

Addition, Subtraktion, Multiplikation und trigonometrische Division

Funktion

>>> c = np.array( [ [1,2], [3,4] ], dtype=complex )>>> c
array([[ 1.+0.j,  2.+0.j],
       [ 3.+0.j,  4.+0.j]])

Logische Operationen

>>> np.zeros( (3,4) )
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
>>> np.ones( (2,3,4), dtype=np.int16 )                # dtype can also be specified
array([[[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]],
       [[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]]], dtype=int16)
>>> np.empty( (2,3) )                                 # uninitialized, output may vary
array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],
       [  5.30498948e-313,   3.14673309e-307,   1.00000000e+000]])

Matrixoperationen

Es gibt .*,./ usw. in Matlab

Aber in Numpy werden, wenn Sie +, - verwenden, bei der Ausführung von Matrixoperationen zuerst Operationen zwischen Elementen ausgeführt

>>> np.arange( 10, 30, 5 )
array([10, 15, 20, 25])
>>> np.arange( 0, 2, 0.3 )                 # it accepts float arguments
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])

>>> from numpy import pi
>>> np.linspace( 0, 2, 9 )                 # 9 numbers from 0 to 2
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])
>>> x = np.linspace( 0, 2*pi, 100 )        # useful to evaluate function at lots of points
>>> f = np.sin(x)

Wenn Matrixoperationen ausgeführt werden müssen, handelt es sich normalerweise um eine Matrixmultiplikation

Einige häufig verwendete

globale Funktionen

>>> a = np.array( [20,30,40,50] )
>>> b = np.arange( 4 )
>>> b
array([0, 1, 2, 3])
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10*np.sin(a)
array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])
>>> a<35
array([ True, True, False, False], dtype=bool)

Matrix Index-Slice-Traversal

>>> import numpy as np>>> A = np.arange(10,20)>>> B = np.arange(20,30)>>> A + B
array([30, 32, 34, 36, 38, 40, 42, 44, 46, 48])>>> A * B
array([200, 231, 264, 299, 336, 375, 416, 459, 504, 551])>>> A / B
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])>>> B / A
array([2, 1, 1, 1, 1, 1, 1, 1, 1, 1])

Matrix-Traversal

>>> A = np.array([1,1,1,1])
>>> B = np.array([2,2,2,2])
>>> A.reshape(2,2)
array([[1, 1],
       [1, 1]])
>>> B.reshape(2,2)
array([[2, 2],
       [2, 2]])
>>> A * B
array([2, 2, 2, 2])
>>> np.dot(A,B)
8
>>> A.dot(B)
8

Spezielle Operationen der Matrix

Matrixform ändern – umformen

>>> B = np.arange(3)
>>> B
array([0, 1, 2])
>>> np.exp(B)
array([ 1.        ,  2.71828183,  7.3890561 ])
>>> np.sqrt(B)
array([ 0.        ,  1.        ,  1.41421356])
>>> C = np.array([2., -1., 4.])
>>> np.add(B, C)
array([ 2.,  0.,  6.])

Der Unterschied zwischen Größenänderung und Neuformung

Größenänderung ändert die ursprüngliche Matrix, Neuformung führt nicht

>>> a = np.arange(10)**3
>>> a
array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
>>> a[2]
8
>>> a[2:5]
array([ 8, 27, 64])
>>> a[:6:2] = -1000    # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000
>>> a
array([-1000,     1, -1000,    27, -1000,   125,   216,   343,   512,   729])
>>> a[ : :-1]                                 # reversed a
array([  729,   512,   343,   216,   125, -1000,    27, -1000,     1, -1000])
>>> for i in a:
...     print(i**(1/3.))
...
nan
1.0
nan
3.0
nan
5.0
6.0
7.0
8.0
9.0

>>> import numpy as np
>>> b = np.arange(16).reshape(4, 4)
>>> for row in b:
...  print(row)
... 
[0 1 2 3]
[4 5 6 7]
[ 8  9 10 11]
[12 13 14 15]
>>> for node in b.flat:
...  print(node)
... 
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

die Matrizen zusammen

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in die allgemeine Verwendung von Numpy. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!