Liste der Array-Operationen (ndarray) der numerischen Berechnungsbibliothek "Numpy" von Python

Die Operationsmethode des N-dimensionalen Array-Objekts (im Folgenden ndarray), die von Pythons numerischer Berechnungsbibliothek "Numpy" bereitgestellt wird, ist organisiert. Python lässt sich aufgrund mangelnder Datentypunterstützung nur langsam berechnen. Bei der Berechnung mit einer großen Datenmenge wird standardmäßig ndarray verwendet.

Annahme

import numpy as np

A. Sequenzgenerierung

Generieren Sie ein ndarray.

【array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)】

• Erstellen Sie ein ndarray aus der Liste.
• Objekt: Die ursprüngliche Liste (oder etwas, das als solches behandelt werden kann)
• dtype: Der Datentyp des Elements. Wenn nicht angegeben, wird es automatisch basierend auf dem Element ausgewählt. (Referenz: Liste der NumPy-Datentypen dtype und Konvertierung nach Astyp (Besetzung) | note.nkmk.me)

y = np.array([1,2,3])
X = np.array([[1,2,3], [4,5,6]], dtype=np.int64)

【zeros(shape, dtype=float, order='C')】

• Generiere ein ndarray mit jedem Element, das mit 0s aufgefüllt ist.
• Form: Anzahl der Elemente in jeder Dimension (Ganzzahl oder Ganzzahl)

y = np.zeros(3)
# array([0., 0., 0.])

X = np.zeros((2,3))
# array([[0., 0., 0.],
#       [0., 0., 0.]])

【ones(shape, dtype=None, order='C')】

• Generiere ein ndarray, in dem jedes Element mit 1 gefüllt ist.

y = np.ones(3)
# array([1., 1., 1.])

X = np.ones((2,3))
# array([[1., 1., 1.],
#       [1., 1., 1.]])

【empty(shape, dtype=None, order='C')】

• Generieren Sie ein ndarray, in dem nicht jedes Element initialisiert wird.

y = np.empty(3)
# array([0.39215686, 0.70980392, 0.80392157])

X = np.empty((2,3))
# array([[2.6885677e-316, 0.0000000e+000, 0.0000000e+000],
#       [0.0000000e+000, 0.0000000e+000, 0.0000000e+000]])

【identity(n, dtype=None)】

• Generieren Sie ein ndarray, das eine Einheitsmatrix ist.

X = np.identity(3)
# array([[1., 0., 0.],
#       [0., 1., 0.],
#       [0., 0., 1.]])

【arange([start,] stop[, step,], dtype=None)】

• Generieren Sie ein ndarray, das eine Gleichheitssequenz ist.
• start: Startwert der Gleichheitsnummernspalte
• stop: Referenzwert für das Ende der Gleichheitsnummernspalte (Werte über dem angegebenen Wert sind nicht in der Zahlenspalte enthalten)
• Schritt: Unterschied

y = np.arange(5)
# array([0, 1, 2, 3, 4])

y = np.arange(2,5)
# array([2, 3, 4])

y = np.arange(5,2,-1)
# array([5, 4, 3])  

【linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)】

• Generieren Sie ein ndarray, das eine Folge mit gleichen Zahlen ist, die den angegebenen Bereich teilt.
• start: Startwert der Gleichheitsnummernspalte
• stop: Endwert der Gleichheitsnummernspalte
• Schritt: Geteilter Wert (Anzahl der Elemente im Array)

y = np.linspace(2,10,3)
# array([ 2.,  6., 10.])

y = np.linspace(2,10,5)
# array([ 2.,  4.,  6.,  8., 10.])

【unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)】

• Generieren Sie ein ndarray, nachdem Sie Duplikate sortiert und entfernt haben.

y = np.unique(['C', 'E', 'C', 'A', 'B', 'E', 'D', 'C'])
# array(['A', 'B', 'C', 'D', 'E'], dtype='<U1')

B. Holen Sie sich Array-Elemente

Die Elemente von ndarray können auf dieselbe Weise wie Listenelemente in Python abrufen abgerufen werden. Beachten Sie jedoch, dass sich die Spezifikationsmethode für mehrdimensionale Arrays ändert.

X = [[1,2,3],[4,5,6]]
print(X[1][2])
# 6

X_numpy = np.array(X)
print(X_numpy[1,2])
# 6 

Zusätzlich zu der üblichen Erfassungsmethode kann sie auch mit der folgenden Methode erfasst werden.

1. Holen Sie sich ein Array von Indizes.

X = np.array([[1,2,3],[4,5,6]])

print(X[[0,1,-1]])
# [[1 2 3],
#  [4 5 6],
#  [4 5 6]]

print(X[[0,1,-1], 0])
# [1, 4, 4]

print(X[[0,1,-1], ::-1])
# [[3 2 1],
#  [6 5 4],
#  [6 5 4]]

print(X[[0,1,-1],[1,0,-1]])
# [2, 4, 6]
"""
* Diese Bezeichnung hat das gleiche Ergebnis wie die folgende.
np.array([X[0,1], X[1,0], X[-1,-1]])
"""

2. Erhalten Sie mit einem bedingten Ausdruck.

X = np.array([[1,2,3],[4,5,6]])

print(X > 4)
#  [[False, False, False],
#  [False,  True,  True]]

print(np.where(X > 4))
# (array([1, 1]), array([1, 2]))

print(X[X > 4])
# [5, 6]

print(X[np.where(X > 4)])
# [5, 6]

C. Sequenzinformationen abrufen

Holen Sie sich ndarray Informationen.

【shape】

• Ermitteln Sie die Anzahl der Elemente in jeder Dimension.

X = np.array([[1,2,3], [4,5,6]])
X.shape
# (2, 3)

【dtype】

• Holen Sie sich den Datentyp.

X = np.array([[1,2,3], [4,5,6]])
X.dtype
# dtype('int64')

【ndim】

• Ermitteln Sie die Anzahl der Dimensionen.

X = np.array([[1,2,3], [4,5,6]])
X.ndim
# 2

【size】

• Holen Sie sich die Anzahl der Elemente.

X = np.array([[1,2,3], [4,5,6]])
X.size
# 6

D. Array-Manipulation

Manipuliere den Ndarray.

【<ndarray>.flatten(order='C')】

• Erstellen Sie ein eindimensionales Array.

X = np.array([[1,2,3], [4,5,6]])
print(X.flatten())
# [1, 2, 3, 4, 5, 6]

【<ndarray>.reshape(shape, order='C')】

• Ändern Sie die Form des Arrays (Anzahl der Dimensionen und Anzahl der Elemente in jeder Dimension).

X = np.array([1,2,3,4,5,6])
print(X.reshape((3,2)))
# [[1, 2],
#  [3, 4],
#  [5, 6]]

【sort(a, axis=-1, kind='quicksort', order=None)】

• Neuanordnungen. (Kopieren Sie das Ziel, sortieren Sie die Kopie und geben Sie sie zurück.)
• Achse: Zu sortierende Bemaßung

X1 = np.array([[5,4,6], [3,1,2]])
X2 = np.sort(X1)
print(X1)
# [[5 4 6]
#  [3 1 2]]
print(X2)
# [[4 5 6]
#  [1 2 3]]

X3 = np.sort(X1, axis=0)
print(X3)
# [[3 1 2]
# [5 4 6]]

【<ndarray>.sort(axis=-1, kind='quicksort', order=None)】

• Neuanordnungen. (Sortiere das Ziel)
• Achse: Zu sortierende Bemaßung

X = np.array([[5,4,6], [3,1,2]])

X.sort()
print(X)
# [4 5 6]
# [1 2 3]]

X.sort(axis=0)
print(X)
# [[3 1 2]
# [5 4 6]]

【<ndarray>.argsort(axis=-1, kind='quicksort', order=None)】

• Holen Sie sich den Index beim Sortieren.

X = np.array([[5,4,6], [3,1,2]])

idxs = X.argsort()
print(idxs)
# [[1 0 2]
#  [1 2 0]]

idxs = X.argsort(axis=0)
print(idxs)
# [[1 1 1]
# [0 0 0]]

【<ndarray>.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)】

• Konvertieren Sie den Datentyp von ndarray.

X = np.array([[1,2,3], [4,5,6]])
print(X.dtype)
# int64
print(X)
# [[1 2 3]
# [4 5 6]]

X2 = X.astype(np.float64)
print(X2.dtype)
# float64
print(X2)
# [[1. 2. 3.]
# [4. 5. 6.]]

E. Matrixbetrieb

Führen Sie Matrixoperationen mit ndarray aus.

【<ndarray>.T】

• Translokation

X = np.array([[1,2,3], [4,5,6]])
print(X.T)
# [[1, 4],
#  [2, 5],
#  [3, 6]]

【numpy.dot】【<ndarray>.dot】

• Innenprodukt

X1 = np.array([[1, 2, 3], [4, 5, 6]])
X2 = np.array([[10, 20], [100, 200], [1000, 2000]])
print(np.dot(X1, X2))
# [[ 3210  6420]
#  [ 6540 13080]]

print(X1.dot(X2))
# [[ 3210  6420]
#  [ 6540 13080]]

【numpy.trace】【<ndarray>.trace】

• Summe der diagonalen Komponenten

X = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(np.trace(X))
# 15

print(X.trace())
# 15

【numpy.linalg.det】

• Matrixausdruck

X1 = np.array([[3., 2.], [5., 4.]])
print(np.linalg.det(X1))
# 2.0000000000000013

【numpy.linalg.eig】

• Eindeutiger Wert / eindeutiger Vektor

X = np.array([[2, 0], [0, 0.25]])
print(np.linalg.eig(X))
# (array([2.  , 0.25]), array([[1., 0.], [0., 1.]]))

【numpy.linalg.svd】

• Singularitätszerlegung

X = np.array([[2, 0], [0, 0.25], [0, 1]])
print(np.linalg.svd(X))
# (array([[ 1.,  0.        ,  0.        ],
#         [ 0., -0.24253563, -0.9701425 ],
#         [ 0., -0.9701425 ,  0.24253563]]), 
#  array([2., 1.03077641]), 
#  array([[ 1.,  0.],
#         [-0., -1.]]))

【numpy.linalg.inv】

• Inverse Matrix

X = np.array([[1, 1], [1, -1]])
print(np.linalg.inv(X))
# [[ 0.5  0.5]
#  [ 0.5 -0.5]]

【numpy.linalg.pinv】

• Moore Penrose's pseudo-inverse Matrix

X = np.array([[1, 1], [1, -1], [1, 0]])
print(np.linalg.pinv(X))
# [[ 0.33333333  0.33333333  0.33333333]
#  [ 0.5        -0.5         0.        ]]

【numpy.linalg.qr】

• QR-Demontage

X = np.array([[1, 2], [3, 4], [5, 6]])
print(np.linalg.qr(X))
# (array([[-0.16903085,  0.89708523],
#         [-0.50709255,  0.27602622],
#         [-0.84515425, -0.34503278]]),
#  array([[-5.91607978, -7.43735744],
#         [ 0.        ,  0.82807867]]))

F. Arithmetik

Arithmetische Operationen werden zwischen zwei ndarrays ausgeführt.

【add】

• Addition (Addition)

a = np.array([[1, 2, 3], [4, 5, 6]])

print(np.add(a, 10))
# [[11 12 13]
#  [14 15 16]]
print(a + 10)
# [[11 12 13]
#  [14 15 16]]

print(np.add(a, [10, 20, 30]))
# [[11 22 33]
#  [14 25 36]]
print(a + [10, 20, 30])
# [[11 22 33]
#  [14 25 36]]

print(np.add(a, np.array([[10, 20, 30], [40, 50, 60]])))
# [[11 22 33]
#  [44 55 66]]
print(a + np.array([[10, 20, 30], [40, 50, 60]]))
# [[11 22 33]
#  [44 55 66]]

【subtract】

• Subtraktion (Subtraktion)

a = np.array([[11, 22, 33], [44, 55, 66]])

print(np.subtract(a, 10))
# [[ 1 12 23]
#  [34 45 56]]
print(a - 10)
# [[ 1 12 23]
#  [34 45 56]]

print(np.subtract(a, [10, 20, 30]))
# [[ 1  2  3]
#  [34 35 36]]
print(a - [10, 20, 30])
# [[ 1  2  3]
#  [34 35 36]]

print(np.subtract(a, np.array([[10, 20, 30], [40, 50, 60]])))
# [[1 2 3]
#  [4 5 6]] 
print(a - np.array([[10, 20, 30], [40, 50, 60]]))
# [[1 2 3]
#  [4 5 6]]

【multiply】

• Multiplikation

a = np.array([[1, 2, 3], [4, 5, 6]])

print(np.multiply(a, 10))
# [[10 20 30]
#  [40 50 60]]
print(a * 10)
# [[10 20 30]
#  [40 50 60]]

print(np.multiply(a, [10, 20, 30]))
# [[ 10  40  90]
#  [ 40 100 180]]
print(a * [10, 20, 30])
# [[ 10  40  90]
#  [ 40 100 180]]

print(np.multiply(a, np.array([[10, 20, 30], [40, 50, 60]])))
# [[ 10  40  90]
#  [160 250 360]]
print(a * np.array([[10, 20, 30], [40, 50, 60]]))
# [[ 10  40  90]
#  [160 250 360]]

【divide】

• Abteilung (Abteilung)

a = np.array([[10, 20, 30], [40, 50, 60]])

print(np.divide(a, 10))
# [[1. 2. 3.]
#  [4. 5. 6.]]
print(a / 10)
# [[1. 2. 3.]
#  [4. 5. 6.]]

print(np.divide(a, [10, 20, 30]))
# [[1.  1.  1. ]
#  [4.  2.5 2. ]]
print(a / [10, 20, 30])
# [[1.  1.  1. ]
#  [4.  2.5 2. ]]

print(np.divide(a, np.array([[10, 20, 30], [40, 50, 60]])))
# [[1. 1. 1.]
#  [1. 1. 1.]]
print(a / np.array([[10, 20, 30], [40, 50, 60]]))
# [[1. 1. 1.]
#  [1. 1. 1.]]

【floor_divide】

• Teilungsquotient

a = np.array([[22, 33, 44], [45, 67, 89]])

print(np.floor_divide(a, 2))
# [[11 16 22]
#  [22 33 44]]
print(a // 2)
# [[11 16 22]
#  [22 33 44]]

print(np.floor_divide(a, [2, 3, 4]))
# [[11 11 11]
#  [22 22 22]]
print(a // [2, 3, 4])
# [[11 11 11]
#  [22 22 22]]

print(np.floor_divide(a, np.array([[2, 3, 4], [4, 6, 8]])))
# [[11 11 11]
#  [11 11 11]]
print(a // np.array([[[2, 3, 4], [4, 6, 8]]]))
# [[11 11 11]
#  [11 11 11]]

【mod】

• Rest der Teilung

a = np.array([[22, 33, 44], [45, 67, 89]])

print(np.mod(a, 2))
# [[0 1 0]
#  [1 1 1]]
print(a % 2)
# [[0 1 0]
#  [1 1 1]]

print(np.mod(a, [2, 3, 4]))
# [[0 0 0]
#  [1 1 1]]
print(a % [2, 3, 4])
# [[0 0 0]
#  [1 1 1]]

print(np.mod(a, np.array([[2, 3, 4], [4, 6, 8]])))
# [[0 0 0]
#  [1 1 1]]
print(a % np.array([[[2, 3, 4], [4, 6, 8]]]))
# [[0 0 0]
#  [1 1 1]]

【power】

• Leistung

a = np.array([[1, 2, 3], [4, 5, 6]])

print(np.power(a, 2))
# [[ 1  4  9]
#  [16 25 36]]
print(a ** 2)
# [[ 1  4  9]
#  [16 25 36]]

print(np.power(a, [2, 3, 4]))
# [[   1    8   81]
#  [  16  125 1296]]
print(a ** [2, 3, 4])
# [[   1    8   81]
#  [  16  125 1296]]

print(np.power(a, np.array([[2, 3, 4], [1/2, 1/3, 1/4]])))
# [[ 1.          8.         81.        ]
#  [ 2.          1.70997595  1.56508458]]
print(a ** np.array([[2, 3, 4], [1/2, 1/3, 1/4]]))
# [[ 1.          8.         81.        ]
#  [ 2.          1.70997595  1.56508458]]

G. Vergleichsberechnung

Vergleichen Sie zwei ndarrays.

【greater】

• Größer als

a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.greater(a1, a2))
# [ True  True False False False]
print(a1 > a2)
# [ True  True False False False]

【greater_equal】

• das ist alles

a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.greater_equal(a1, a2))
# [ True  True True False False]
print(a1 >= a2)
# [ True  True True False False]

【less】

• Weniger als

a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.less(a1, a2))
# [False False False  True  True]
print(a1 < a2)
# [False False False  True  True]

【less_equal】

• Weniger als

a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.less_equal(a1, a2))
# [False False  True  True  True]
print(a1 <= a2)
# [False False  True  True  True]

【equal】

• Gleich

a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.equal(a1, a2))
# [False False  True False False]
print(a1 == a2)
# [False False  True False False]

【not_equal】

• Nicht gleich

a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.not_equal(a1, a2))
# [ True  True False  True  True]
print(a1 != a2)
# [ True  True False  True  True]

H. Logische Operation

Führen Sie logische Operationen an zwei ndarrays aus.

【logical_and】

• AND

a1 = np.array([True, False, True, False])
a2 = np.array([True, False, False, True])

print(np.logical_and(a1, a2))
# [ True False False False]

【logical_or】

• OR

a1 = np.array([True, False, True, False])
a2 = np.array([True, False, False, True])

print(np.logical_or(a1, a2))
# [ True False  True  True]

【logical_xor】

• XOR

a1 = np.array([True, False, True, False])
a2 = np.array([True, False, False, True])

print(np.logical_xor(a1, a2))
# [False False  True  True]

【logical_not】

• NOT

a = np.array([True, False, True, False])

print(np.logical_not(a))
# [False  True False  True]

【<ndarray>.any()】

• Eines der Elemente ist True

a1 = np.array([0, 1, 0, 0])
print(a1.any())
# True

a2 = np.array([1, 1, 1, 1])
print(a2.any())
# True

a3 = np.array([0, 0, 0, 0])
print(a3.any())
# False

【<ndarray>.all()】

• Alle Elemente sind wahr

a1 = np.array([0, 1, 0, 0])
print(a1.all())
# False

a2 = np.array([1, 1, 1, 1])
print(a2.all())
# True

a3 = np.array([0, 0, 0, 0])
print(a3.all())
# False

I. Betrieb einstellen

Führen Sie eine Set-Operation mit ndarray durch.

• Die Set-Operation selbst kann auch mit einem Python-Set ausgeführt werden. Referenz: Python-Set-Operation

【union1d(ar1, ar2)】

• Summensatz (ODER)

X = np.unique([1,2,3,4,5,6])
Y = np.unique([4,5,6,7,8,9])

Z = np.union1d(X,Y)
print(Z)
# [1 2 3 4 5 6 7 8 9]

【intersect1d(ar1, ar2)】

• Produktsatz (UND)

X = np.unique([1,2,3,4,5,6])
Y = np.unique([4,5,6,7,8,9])

Z = np.intersect1d(X,Y)
print(Z)
# [4 5 6]

【setxor1d(ar1, ar2)】

• Symmetriedifferenz (XOR)

X = np.unique([1,2,3,4,5,6])
Y = np.unique([4,5,6,7,8,9])

Z = np.setxor1d(X,Y)
print(Z)
# [1 2 3 7 8 9]

【setdiff1d(ar1, ar2)】

• Differenz eingestellt

X = np.unique([1,2,3,4,5,6])
Y = np.unique([4,5,6,7,8,9])

Z = np.setdiff1d(X,Y)
print(Z)
# [1 2 3]

【in1d(ar1, ar2)】

• Bestimmen, ob jedes Element der ersteren Menge in der letzteren enthalten ist

X = np.unique([1,2,3,4,5])
Y = np.unique([1,2,3])

Z = np.in1d(X,Y)
print(Z)
# [ True  True  True False False]

J. Maximum / Minimum / Code-Extraktion

Extrahieren Sie den Maximalwert, den Minimalwert und den Code von ndarray.

【maximum】

• Maximaler Wert (vergleiche zwei ndarrays und erhalte den größeren)
• Wenn ein Element NaN ist, erhalten Sie NaN.

a1 = np.array([4, 2, np.nan])
a2 = np.array([3, 6, 5])

print(np.maximum(a1, a2))
# [ 4.  6. nan]

【fmax】

• Maximaler Wert (vergleiche zwei ndarrays und erhalte den größeren)
• Wenn ein Element NaN ist, holen Sie sich das andere.

a1 = np.array([4, 2, np.nan])
a2 = np.array([3, 6, 5])

print(np.fmax(a1, a2))
# [4. 6. 5.]

【minimum】

• Minimaler Wert (vergleiche zwei ndarrays und erhalte den kleineren)
• Wenn ein Element NaN ist, erhalten Sie NaN.

a1 = np.array([4, 2, np.nan])
a2 = np.array([3, 6, 5])

print(np.minimum(a1, a2))
# [ 3.  2. nan]

【fmin】

• Minimaler Wert (vergleiche zwei ndarrays und erhalte den kleineren)
• Wenn ein Element NaN ist, holen Sie sich das andere.

a1 = np.array([4, 2, np.nan])
a2 = np.array([3, 6, 5])

print(np.fmin(a1, a2))
# [3. 2. 5.]

【copysign】

• Wenden Sie das Vorzeichen des entsprechenden Elements im zweiten ndarray auf das erste ndarray an.

a1 = np.array([1, 2, 3, 4, 5])
a2 = np.array([0, -1, 1, 2, -2])

print(np.copysign(a1, a2))
# [ 1. -2.  3.  4. -5.]

K. Aufrunden / Abrunden / Runden

Verarbeiten Sie für jeden Wert von ndarray den Wert nach dem Dezimalpunkt.

【ceil(ndarray)】

• Zusammenfassen

y = np.array([-5.6, -5.5, -5.4, 0, 5.4, 5.5, 5.6])

z = np.ceil(y)
print(z)
# [-5. -5. -5.  0.  6.  6.  6.]

【floor(ndarray)】

• Abschneiden

y = np.array([-5.6, -5.5, -5.4, 0, 5.4, 5.5, 5.6])

z = np.floor(y)
print(z)
# [-6. -6. -6.  0.  5.  5.  5.]

【rint(ndarray)】

• Rundung

y = np.array([-5.6, -5.5, -5.4, 0, 5.4, 5.5, 5.6])

z = np.rint(y)
print(z)
# [-6. -6. -5.  0.  5.  6.  6.]

【modf(ndarray)】

• Aufteilen des ganzzahligen Teils und des gebrochenen Teils

y = np.array([-3.6, -2.5, -1.4, 0, 1.4, 2.5, 3.6])

z = np.modf(y)
print(z)
# (array([-0.6, -0.5, -0.4,  0. ,  0.4,  0.5,  0.6]), array([-3., -2., -1.,  0.,  1.,  2.,  3.]))

L. Quadrat, Quadratwurzel, absoluter Wert

Berechnen Sie das Quadrat, die Quadratwurzel und den absoluten Wert für jeden Wert von ndarray.

【square(ndarray)】

• Quadrat

y = np.arange(1,6)

z = np.square(y)
print(z)
# [ 1  4  9 16 25]

z = y ** 2
print(z)
# [ 1  4  9 16 25]

【sqrt(ndarray)】

• Quadratwurzel

y = np.array([1,4,9,16,25])

z = np.sqrt(y)
print(z)
# [1. 2. 3. 4. 5.]

z = y ** 0.5
print(z)
# [1. 2. 3. 4. 5.]

【abs(ndarray)】

• Absolutwert

y = np.array([-1,-2,3,4,5j])

z = np.abs(y)
print(z)
# [1, 2, 3, 4, 5]

【fabs(ndarray)】

• Absolutwert (kann nicht imaginär oder komplex sein, aber schneller als abs)

y = np.array([-1,-2,3,4,-5])

z = np.fabs(y)
print(z)
# [1, 2, 3, 4, 5]

M. Exponenten- / Logarithmusfunktion

Berechnen Sie den Exponenten und den logarithmischen Wert für jeden Wert von ndarray.

【exp(ndarray)】

• Index

y = np.arange(1,6)

z = np.exp(y)
print(z)
# [  2.71828183   7.3890561   20.08553692  54.59815003 148.4131591 ]

print(np.e)
# 2.718281828459045

【log(ndarray)】

• Natürlicher Logarithmus

y = np.e ** np.array([1, 2, 3, 4, 5])

z = np.log(y)
print(z)
# [1. 2. 3. 4. 5.]

【log10(ndarray)】

• Gemeinsamer Logarithmus

y = 10 ** np.array([1, 2, 3, 4, 5])

z = np.log10(y)
print(z)
# [1. 2. 3. 4. 5.]

【log2(ndarray)】

• Binäres Protokoll

y = 2 ** np.array([1, 2, 3, 4, 5])

z = np.log2(y)
print(z)
# [1. 2. 3. 4. 5.]

N. Dreiecksfunktion

Wenden Sie auf jeden Wert von ndarray eine Dreiecksfunktion an.

【sin(ndarray)】

• Sinus

y = np.linspace(-1, 1, 5)  * np.pi

print(np.sin(y))
# [-1.2246468e-16 -1.0000000e+00  0.0000000e+00  1.0000000e+00 1.2246468e-16]

【cos(ndarray)】

• Cosinus

y = np.linspace(-1, 1, 5)  * np.pi

print(np.cos(y))
# [-1.000000e+00  6.123234e-17  1.000000e+00  6.123234e-17 -1.000000e+00]

【tan(ndarray)】

• Direkte Verbindung

y = np.linspace(-1, 1, 5)  * np.pi

print(np.tan(y))
# [ 1.22464680e-16 -1.63312394e+16  0.00000000e+00  1.63312394e+16 -1.22464680e-16]

O. Bikurvenfunktion

Wenden Sie auf jeden Wert von ndarray eine Bikurvenfunktion an.

【sinh(ndarray)】

• Doppelkurvensinus

y = np.array([-np.inf, -2, -1, 0, 1, 2, np.inf])

print(np.sinh(y))
# [-inf -3.62686041 -1.17520119  0. 1.17520119  3.62686041 inf]

【cosh(ndarray)】

• Doppelkurven-Cosinus

y = np.array([-np.inf, -2, -1, 0, 1, 2, np.inf])

print(np.cosh(y))
# [inf 3.76219569 1.54308063 1. 1.54308063 3.76219569 inf]

【tanh(ndarray)】

• Doppelte Kurventangente

y = np.array([-np.inf, -2, -1, 0, 1, 2, np.inf])

print(np.tanh(y))
# [-1. -0.96402758 -0.76159416  0. 0.76159416  0.96402758 1.]

P. Inverse Dreiecksfunktion

Wenden Sie die Funktion des umgekehrten Dreiecks auf jeden Wert von ndarray an.

【arcsin(ndarray)】

• Inverser Sinus

y = np.linspace(-1, 1, 5)

print(np.arcsin(y))
# [-1.57079633 -0.52359878  0. 0.52359878  1.57079633]

【arccos(ndarray)】

• Kosinus umkehren

y = np.linspace(-1, 1, 5)

print(np.arccos(y))
# [3.14159265 2.0943951  1.57079633 1.04719755 0.]

【arctan(ndarray)】

• Vorwärtsverbindung umkehren

y = np.linspace(-1, 1, 5)

print(np.arctan(y))
# [-0.78539816 -0.46364761  0. 0.46364761  0.78539816]

Q. Inverse Kurvenfunktion

Wenden Sie die inverse Bikurvenfunktion auf jeden Wert von ndarray an.

【arcsinh(ndarray)】

• Inverser Doppelkurvensinus

y = np.array([-np.inf, -3.62686041, -1.17520119,  0., 1.17520119,  3.62686041, np.inf])

print(np.arcsinh(y))
# [-inf  -2.  -1.   0.   1.   2.  inf]

【arccosh(ndarray)】

• Invertierter Doppelkurven-Cosinus

y = np.array([1., 1.54308063, 3.76219569, np.inf])

print(np.arccosh(y))
# [ 0.  1.  2. inf]

【arctanh(ndarray)】

• Inverse Doppelkurventangente

y = np.array([-1., -0.96402758, -0.76159416,  0., 0.76159416,  0.96402758, 1.])

print(np.arctanh(y))
# [-inf -2. -1.00000001 0. 1.00000001 2. inf]

R. Zufällige Generation

Generieren Sie Zufallszahlen mit Numpy.

【numpy.random.rand(d0, d1, ..., dn)】

• Gleichmäßige Verteilung
• Erzeugt ein zufälliges Array mit der angegebenen Anzahl von Elementen / Dimensionen. (Zufälliger Bereich: 0 oder mehr und weniger als 1)

print(np.random.rand())
# 0.5504876218756463

print(np.random.rand(2))
# [0.70029403 0.48969378]

print(np.random.rand(2, 2))
# [[0.98181874 0.47001957]
#  [0.79277853 0.12536121]]

【numpy.random.randint(low, high=None, size=None, dtype='l')】

• Gleichmäßige Verteilung
• Generieren Sie eine Zufallszahl mit einem bestimmten Bereich von Ganzzahlen.
• niedrig: Mindestwert (oder mehr, im Bereich der Zufallszahlen enthalten)
• hoch: Maximalwert (kleiner als, nicht im Zufallsbereich enthalten)
• Größe: Anzahl der Elemente / Anzahl der Dimensionen
• dtype: Datentyp

print(np.random.randint(1,4))
# 2

print(np.random.randint(1,4, 2))
# [2 2]

print(np.random.randint(1,4, (2, 2)))
# [[3 2]
#  [3 1]]

【numpy.random.uniform(low=0.0, high=1.0, size=None)】

• Gleichmäßige Verteilung
• Generieren Sie einen bestimmten Bereich von Zufallszahlen.
• niedrig: Mindestwert (oder mehr, im Bereich der Zufallszahlen enthalten)
• hoch: Maximalwert (kleiner als, nicht im Zufallsbereich enthalten)
• Größe: Anzahl der Elemente / Anzahl der Dimensionen

print(np.random.uniform(1,4))
# 3.5515484791542056

print(np.random.uniform(1,4, 2))
# [1.51270014 3.02435494]

print(np.random.uniform(1,4, (2, 2)))
# [[3.47188029 1.17177563]
#  [3.87198389 3.91458379]]

【numpy.random.randn(d0, d1, ..., dn)】

• Normalverteilung
• Erzeugt ein zufälliges Array mit der angegebenen Anzahl von Elementen / Dimensionen. (Durchschnitt: 0, Standardabweichung: 1)

print(np.random.randn())
# -0.5775065521096695

print(np.random.randn(2))
# [-1.50501689  1.46743032]

print(np.random.randn(2, 2))
# [[ 1.16357112 -0.24601519]
#  [ 2.07269576 -0.39272309]]

【numpy.random.normal(loc=0.0, scale=1.0, size=None)】

• Normalverteilung
• Generieren Sie eine Zufallszahl mit der angegebenen Durchschnitts- / Standardabweichung.
• loc: Durchschnitt
• Skala: Standardabweichung
• Größe: Anzahl der Elemente / Anzahl der Dimensionen

print(np.random.normal(50, 10))
# 63.47995333571061

print(np.random.normal(50, 10, (2, 2)))
# [[56.02364177 55.25423891]
#  [45.44840171 29.8303964 ]]

print(np.random.normal((50, 0), (10, 1), (5, 2)))
# [[45.48754234 -0.74792452]
#  [60.84696747  1.01209036]
#  [42.38844146 -0.10453915]
#  [39.77544056  1.22264549]
#  [41.60250782  1.64150462]]

【numpy.random.binomial(n, p, size=None)】

• Binäre Verteilung
• Generieren Sie eine Zufallszahl der angegebenen Anzahl von Versuchen und Wahrscheinlichkeiten.
• n: Anzahl der Versuche
• p: Wahrscheinlichkeit
• Größe: Anzahl der Elemente / Anzahl der Dimensionen

print(np.random.binomial(100, 0.5))
# 53

print(np.random.binomial(100, 0.5, (2, 2)))
# [[53 53]
#  [48 50]]

print(np.random.binomial((100, 1000), (0.3, 0.7), (5, 2)))
# [[ 33 699]
#  [ 30 660]
#  [ 34 698]
#  [ 26 688]
#  [ 25 683]]

【numpy.random.beta(a, b, size=None)】

• Beta-Verteilung

print(np.random.beta(3, 5))
# 0.09838262724430759
 
print(np.random.beta(8, 2, (2, 2)))
# [[0.92800788 0.86391443]
#  [0.67249524 0.97299346]]
 
print(np.random.beta((3, 8), (5, 2), (5, 2)))
# [[0.11825463 0.74320634]
#  [0.24992266 0.79029969]
#  [0.13345269 0.57807883]
#  [0.32374525 0.92666103]
#  [0.64669681 0.84867388]]

【numpy.random.chisquare(df, size=None)

• Chi-Quadrat-Verteilung

print(np.random.chisquare(1))
# 0.05074259859574817
 
print(np.random.chisquare(5, (2, 2)))
# [[ 6.15617206  5.54859677]
#  [ 2.60704305 10.35079434]]
 
print(np.random.chisquare((1, 5), (5, 2)))
# [[2.3942405  6.43803251]
#  [1.97544231 2.73456762]
#  [0.63389405 7.81526263]
#  [0.05035459 7.8224598 ]
#  [1.01597309 1.46098368]]

【numpy.random.gamma(shape, scale=1.0, size=None)】

• Gammaverteilung
• Form: Formparameter k
• scale: Skalierungsparameter θ

print(np.random.gamma(1, 2))
# 0.48471788864900295
 
print(np.random.gamma(9, 1, (2, 2)))
# [[10.71101589 16.68686166]
#  [ 5.22150652  5.87160223]]
 
print(np.random.gamma((1, 9), (2, 1), (5, 2)))
# [[ 3.4102224   6.31938602]
#  [ 0.03882968  7.71108072]
#  [ 2.62781738 10.70853193]
#  [ 5.07929584  5.83489052]
#  [ 1.50577929 11.21572879]]

S. Grundlegende Statistiken

Berechnen Sie die Basisstatistik aus dem Wert von ndarray.

【max】

• Maximalwert

a = np.array([10, 20, 30, 40, 50])
print(np.max(a))
# 50

【argmax】

• Maximaler Index

a = np.array([10, 20, 30, 40, 50])
print(np.argmax(a))
# 4

【min】

• Mindestwert

a = np.array([10, 20, 30, 40, 50])
print(np.min(a))
# 10

【argmin】

• Mindestindex

a = np.array([10, 20, 30, 40, 50])
print(np.argmin(a))
# 0

【sum】

• insgesamt

a = np.array([10, 20, 30, 40, 50])
print(np.sum(a))
# 150

【mean】

• Durchschnittswert

a = np.array([10, 20, 30, 40, 50])
print(np.mean(a))
# 30.0

【var】

• Verteilt

a = np.array([10, 20, 30, 40, 50])
print(np.var(a))
# 200.0

【std】

• Standardabweichung

a = np.array([10, 20, 30, 40, 50])
print(np.std(a))
# 14.142135623730951

【cumsum】

• Kumulative Summe

a = np.array([10, 20, 30, 40, 50])
print(np.cumsum(a))
# [ 10  30  60 100 150]

【cumsum】

• Kumulatives Produkt

a = np.array([10, 20, 30, 40, 50])
print(np.cumprod(a))
# [      10      200     6000   240000 12000000]

T. Überprüfungsprozess

Führt eine Wertüberprüfungsverarbeitung durch.

【isnan(ndarray)】

• Urteil von NaN (keine Zahl)

y = np.array([np.nan, np.inf, 0, 1])

print(np.isnan(y))
# [ True False False False]

【isfinite(ndarray)】

• Beurteilung, ob es endlich ist (weder unendlich noch NaN)

y = np.array([np.nan, np.inf, -np.inf, 0, 1])

print(np.isfinite(y))
# [False False False  True  True]

【isfin(ndarray)】

• Beurteilung der Unendlichkeit (weder endlich noch NaN)

y = np.array([np.nan, np.inf, -np.inf, 0, 1])

print(np.isinf(y))
# [False  True  True False False]

【sign(ndarray)】

• Urteil des Zeichens

y = np.array([-np.inf, -5, 0, 5, np.inf])

print(np.sign(y))
# [-1. -1.  0.  1.  1.]

Bemerkungen

Dieser Artikel ist ein Migrationsartikel aus dem Blog "Technische Hinweise für Hausingenieure". Der vorherige Blog wird gelöscht.