Numpy-Spickzettel

Umfassende Anleitung zu NumPy: Der ultimative Spickzettel

NumPy (Numerical Python) ist eine grundlegende Bibliothek für wissenschaftliches Rechnen in Python. Es bietet Unterstützung für große mehrdimensionale Arrays und Matrizen sowie eine umfangreiche Sammlung mathematischer Funktionen, um diese Arrays effizient zu bearbeiten. NumPy wird häufig für Datenanalyse, maschinelles Lernen, Deep Learning und numerische Berechnungen verwendet.

1. NumPy importieren

Bevor Sie NumPy verwenden, muss die Bibliothek in Ihre Python-Umgebung importiert werden.

import numpy as np

2. NumPy-Arrays

NumPy-Arrays sind der Kern der Bibliothek. Sie ermöglichen eine schnelle und effiziente Speicherung großer Datensätze und unterstützen vektorisierte Vorgänge.

Arrays erstellen

Es gibt mehrere Möglichkeiten, Arrays in NumPy zu erstellen:

1D-, 2D- und 3D-Array-Erstellung

# 1D array
arr_1d = np.array([1, 2, 3, 4])
# 2D array
arr_2d = np.array([[1, 2], [3, 4], [5, 6]])
# 3D array
arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

Erwartete Ausgabe:

1D array: [1 2 3 4]
2D array: [[1 2]
           [3 4]
           [5 6]]
3D array: [[[1 2]
            [3 4]]
           [[5 6]
            [7 8]]]

3. Array-Initialisierungsfunktionen

Nullen, Einsen, Voll, Leer, Auge, Identität

Diese Funktionen erstellen Arrays mit vordefinierten Werten.

• np.zeros(shape) – Gibt ein neues Array einer bestimmten Form zurück, das mit Nullen gefüllt ist.
• np.ones(shape) – Gibt ein neues Array voller Einsen zurück.
• np.full(shape, fill_value) – Gibt ein neues Array der angegebenen Form zurück, gefüllt mit einem angegebenen Wert.
• np.empty(shape) – Gibt ein nicht initialisiertes Array der angegebenen Form zurück.
• np.eye(N) – Gibt eine 2D-Identitätsmatrix mit 1en auf der Diagonale zurück.
• np.identity(N) – Erstellt eine quadratische Identitätsmatrix der Größe N.

# Creating arrays with initialization functions
zeros_arr = np.zeros((2, 3))
ones_arr = np.ones((2, 2))
full_arr = np.full((3, 3), 7)
eye_arr = np.eye(3)

Erwartete Ausgabe:

Zeros array: [[0. 0. 0.]
              [0. 0. 0.]]
Ones array: [[1. 1.]
             [1. 1.]]
Full array: [[7 7 7]
             [7 7 7]
             [7 7 7]]
Identity matrix: [[1. 0. 0.]
                  [0. 1. 0.]
                  [0. 0. 1.]]

4. Zufällige Array-Generierung

NumPy bietet verschiedene Möglichkeiten, Zufallszahlen zu generieren.

Zufallszahlen mit np.random

• np.random.rand(shape) – Erzeugt Zufallswerte in einer bestimmten Form (zwischen 0 und 1).
• np.random.randint(low, high, size) – Gibt zufällige Ganzzahlen von niedrig (inklusive) bis hoch (exklusiv) zurück.
• np.random.choice(array) – Wählt zufällig ein Element aus einem Array aus.

random_arr = np.random.rand(2, 2)
randint_arr = np.random.randint(1, 10, (2, 3))

Erwartete Ausgabe:

Random array: [[0.234 0.983]
               [0.456 0.654]]
Random integer array: [[5 7 2]
                       [3 9 1]]

5. Arrays prüfen und manipulieren

Array-Attribute

• ndarray.shape – Gibt die Abmessungen des Arrays zurück.
• ndarray.size – Gibt die Anzahl der Elemente im Array zurück.
• ndarray.ndim – Gibt die Anzahl der Dimensionen zurück.
• ndarray.dtype – Gibt den Typ der Elemente im Array zurück.
• ndarray.itemsize – Gibt die Größe jedes Elements im Array zurück (in Bytes).

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("Shape:", arr.shape)
print("Size:", arr.size)
print("Dimensions:", arr.ndim)
print("Data type:", arr.dtype)
print("Item size:", arr.itemsize)

Erwartete Ausgabe:

Shape: (2, 3)
Size: 6
Dimensions: 2
Data type: int32
Item size: 4

Array-Umgestaltung

• reshape(shape) – Formt das Array in eine angegebene Form um, ohne seine Daten zu ändern.
• ravel() – Gibt eine abgeflachte Version des Arrays (1D) zurück.
• transpose() – Transponiert das Array.

reshaped = arr.reshape(3, 2)
flattened = arr.ravel()
transposed = arr.transpose()

Erwartete Ausgabe:

Reshaped array: [[1 2]
                 [3 4]
                 [5 6]]
Flattened array: [1 2 3 4 5 6]
Transposed array: [[1 4]
                   [2 5]
                   [3 6]]

6. Array-Indizierung, Slicing und Modifizieren von Elementen

NumPy-Arrays bieten leistungsstarke Möglichkeiten, auf Daten zuzugreifen, sie aufzuteilen und zu ändern, sodass Sie effizient mit 1D-, 2D- und 3D-Arrays arbeiten können. In diesem Abschnitt erfahren Sie, wie Sie mithilfe von Indizierung und Slicing auf Elemente zugreifen und Arrays ändern.

Grundlegende Indexierung

Sie können auf Elemente eines Arrays zugreifen, indem Sie eckige Klammern [ ] verwenden. Die Indizierung funktioniert für Arrays beliebiger Dimensionalität, einschließlich 1D-, 2D- und 3D-Arrays.

1D-Array-Indizierung

Sie können auf einzelne Elemente eines 1D-Arrays zugreifen, indem Sie deren Index angeben.

arr = np.array([1, 2, 3, 4])
print(arr[1])  # Access second element

Erwartete Ausgabe:

2

2D-Array-Indizierung

In einem 2D-Array können Sie auf Elemente zugreifen, indem Sie die Zeilen- und Spaltenindizes angeben. Das Format ist arr[Zeile, Spalte].

arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr_2d[1, 2])  # Access element at row 1, column 2

Erwartete Ausgabe:

6

3D-Array-Indizierung

Für 3D-Arrays müssen Sie drei Indizes angeben: Tiefe, Zeile und Spalte. Das Format ist arr[Tiefe, Zeile, Spalte].

arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(arr_3d[1, 0, 1])  # Access element at depth 1, row 0, column 1

Erwartete Ausgabe:

6

Schneiden

Slicing wird verwendet, um Subarrays aus größeren Arrays zu extrahieren. Die Syntax für das Slicing lautet start:stop:step. Der Startindex ist inklusiv, während der Stoppindex exklusiv ist.

1D-Array-Slicing

Sie können ein 1D-Array segmentieren, indem Sie die Start-, Stopp- und Schrittindizes angeben.

arr = np.array([10, 20, 30, 40, 50])
print(arr[1:4])  # Slicing from index 1 to 3 (exclusive of index 4)

Expected Output:

[20 30 40]

2D Array Slicing

In a 2D array, you can slice both rows and columns. For example, arr[start_row:end_row, start_col:end_col] will slice rows and columns.

arr_2d = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])
print(arr_2d[1:3, 0:2])  # Rows from index 1 to 2, Columns from index 0 to 1

Expected Output:

[[40 50]
 [70 80]]

3D Array Slicing

For 3D arrays, slicing works similarly by specifying the range for depth, rows, and columns.

arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(arr_3d[1:, 0, :])  # Depth from index 1, Row 0, All columns

Expected Output:

[[5 6]]

Boolean Indexing

Boolean indexing allows you to filter elements based on a condition. The condition returns a boolean array, which is then used to index the original array.

arr = np.array([10, 15, 20, 25, 30])
print(arr[arr > 20])  # Extract elements greater than 20

Expected Output:

[25 30]

Adding, Removing, and Modifying Elements

You can also modify arrays by adding, removing, or altering elements using various functions.

Adding Elements

You can append or insert elements into arrays with the following methods:

• np.append(arr, values) – Appends values to the end of an array.
• np.insert(arr, index, values) – Inserts values at a specified index.
• np.concatenate([arr1, arr2]) – Concatenates two arrays along an existing axis.

arr = np.array([1, 2, 3])
appended = np.append(arr, 4)  # Add 4 at the end
inserted = np.insert(arr, 1, [10, 20])  # Insert 10, 20 at index 1
concatenated = np.concatenate([arr, np.array([4, 5])])  # Concatenate arr with another array

Expected Output:

Appended: [1 2 3 4]
Inserted: [ 1 10 20  2  3]
Concatenated: [1 2 3 4 5]

Removing Elements

To remove elements from an array, you can use np.delete().

• np.delete(arr, index) – Deletes the element at the specified index.
• np.delete(arr, slice) – Deletes elements in a slice of the array.

arr = np.array([1, 2, 3, 4])
deleted = np.delete(arr, 1)  # Remove element at index 1
slice_deleted = np.delete(arr, slice(1, 3))  # Remove elements from index 1 to 2 (exclusive of 3)

Expected Output:

Deleted: [1 3 4]
Slice deleted: [1 4]

7. Mathematical Operations

NumPy supports element-wise operations, broadcasting, and a variety of useful mathematical functions.

Basic Arithmetic

You can perform operations like addition, subtraction, multiplication, and division element-wise:

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
print(arr1 + arr2)  # Element-wise addition
print(arr1 - arr2)  # Element-wise subtraction
print(arr1 * arr2)  # Element-wise multiplication
print(arr1 / arr2)  # Element-wise division

Expected Output:

Addition: [5 7 9]
Subtraction: [-3 -3 -3]
Multiplication: [ 4 10 18]
Division: [0.25 0.4 0.5]

Aggregation Functions

These functions return a single value for an entire array.

• np.sum(arr) – Returns the sum of array elements.
• np.mean(arr) – Returns the mean of array elements.
• np.median(arr) – Returns the median of array elements.
• np.std(arr) – Returns the standard deviation.
• np.var(arr) – Returns the variance.
• np.min(arr) / np.max(arr) – Returns the minimum/maximum element.

arr = np.array([1, 2, 3, 4, 5])
print(np.sum(arr))
print(np.mean(arr))
print(np.median(arr))
print(np.std(arr))
print(np.min(arr), np.max(arr))

Expected Output:

15


3.0
3.0
1.4142135623730951
1 5

8. Broadcasting and Vectorization

NumPy allows operations between arrays of different shapes via broadcasting, a powerful mechanism for element-wise operations.

Example: Broadcasting

arr = np.array([1, 2, 3])
print(arr + 10)  # Broadcasting scalar value 10

Expected Output:

[11 12 13]

9. Linear Algebra in NumPy

NumPy provides many linear algebra functions, such as:

• np.dot() – Dot product of two arrays.
• np.matmul() – Matrix multiplication.
• np.linalg.inv() – Inverse of a matrix.
• np.linalg.det() – Determinant of a matrix.
• np.linalg.eig() – Eigenvalues and eigenvectors.

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
dot_product = np.dot(A, B)
matrix_mult = np.matmul(A, B)
inv_A = np.linalg.inv(A)
det_A = np.linalg.det(A)

Expected Output:

Dot product: [[19 22]
              [43 50]]
Matrix multiplication: [[19 22]
                        [43 50]]
Inverse of A: [[-2.   1. ]
               [ 1.5 -0.5]]
Determinant of A: -2.0

10. Other Useful Functions

Sorting

• np.sort(arr) – Returns a sorted array.

arr = np.array([3, 1, 2])
sorted_arr = np.sort(arr)

Expected Output:

[1 2 3]

Unique Values

• np.unique(arr) – Returns the sorted unique elements of an array.

arr = np.array([1, 2, 2, 3, 3, 3])
unique_vals = np.unique(arr)

Expected Output:

[1 2 3]

Stacking and Splitting

• np.vstack() – Stacks arrays vertically.
• np.hstack() – Stacks arrays horizontally.
• np.split() – Splits arrays into multiple sub-arrays.

arr1 = np.array([1, 2])
arr2 = np.array([3, 4])
vstacked = np.vstack((arr1, arr2))
hstacked = np.hstack((arr1, arr2))
splits = np.split(np.array([1, 2, 3, 4]), 2)

Expected Output:

Vertical stack: [[1 2]
                 [3 4]]
Horizontal stack: [1 2 3 4]
Splits: [array([1, 2]), array([3, 4])]

Conclusion

NumPy is an essential library for any Python user working with large amounts of numerical data. With its efficient handling of arrays and vast range of mathematical operations, it lays the foundation for more advanced topics such as machine learning, data analysis, and scientific computing.

Das obige ist der detaillierte Inhalt vonNumpy-Spickzettel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!