NumPy-Grundlagen: Arrays und mathematische Operationen
Erstellen und bearbeiten Sie NumPy-Arrays, führen Sie vektorisierte Arithmetik durch und verstehen Sie Broadcasting, um numerische Daten effizient zu verarbeiten.
NumPy-Grundlagen: Arrays und mathematische Operationen ist eine kostenlose Machine Learning Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Machine Learning Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Machine Learning Academy-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
Why NumPy Is the Foundation of ML
NumPy is the foundation under every ML library. Its superpower is vectorized math: it works on whole arrays at once in fast C code, leaving Python loops in the dust.
import numpy as np
import time
# Speed comparison: NumPy vs Python list
n = 1_000_000
python_list = list(range(n))
np_array = np.arange(n)
# Python loop (slow)
start = time.time()
result = [x * 2 for x in python_list]
print(f'Python loop: {time.time() - start:.3f}s')
# NumPy vectorised (fast)
start = time.time()
result = np_array * 2
print(f'NumPy vectorised: {time.time() - start:.4f}s')Creating NumPy Arrays
The core NumPy object is the array. Its most important trait is shape — a tuple giving the size of each dimension, like (rows, cols). The code shows how to make them.
import numpy as np
# From Python list
a = np.array([1, 2, 3, 4, 5])
print('1D array:', a, '| shape:', a.shape) # (5,)
# 2D matrix from nested list
M = np.array([[1, 2, 3], [4, 5, 6]])
print('2D matrix shape:', M.shape) # (2, 3)
# Built-in generators
zeros = np.zeros((3, 4)) # 3x4 matrix of zeros
ones = np.ones((2, 5)) # 2x5 matrix of ones
range_arr = np.arange(0, 10, 2) # [0 2 4 6 8]
linspace = np.linspace(0, 1, 5) # 5 evenly spaced points
random = np.random.randn(3, 3) # 3x3 standard normalArray Indexing and Slicing
You index arrays with [row, col] and slice with start:stop:step. One gotcha: a slice is a view, not a copy — change it and you change the original. Use .copy() to be safe.
import numpy as np
M = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
# Single element
print(M[1, 2]) # 7 (row 1, column 2)
# Slice rows and columns
print(M[0:2, 1:3]) # rows 0-1, columns 1-2 -> [[2,3],[6,7]]
# All rows, last column
print(M[:, -1]) # [4, 8, 12]
# Boolean indexing
print(M[M > 6]) # [7, 8, 9, 10, 11, 12]Vectorised Arithmetic Operations
NumPy math is element-wise by default: a + b adds matching elements with no loop. It runs in compiled C, which is why it flies on millions of numbers. See the code.
import numpy as np
a = np.array([1.0, 2.0, 3.0, 4.0])
b = np.array([10.0, 20.0, 30.0, 40.0])
print('Addition:', a + b) # [11. 22. 33. 44.]
print('Multiply:', a * b) # [10. 40. 90. 160.]
print('Power:', a ** 2) # [ 1. 4. 9. 16.]
print('Divide:', b / a) # [10. 10. 10. 10.]
# Scalar operations apply to all elements
print('Add scalar:', a + 100) # [101. 102. 103. 104.]
print('Square root:', np.sqrt(a)) # [1. 1.41 1.73 2.]Broadcasting: Operating on Different Shapes
Broadcasting lets NumPy combine different shapes by stretching the smaller one to fit. It's how you add a bias vector to a whole batch without writing any loops.
import numpy as np
# Matrix + vector (broadcasting)
matrix = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]) # shape (3, 3)
bias = np.array([10, 20, 30]) # shape (3,) -> broadcasts to (3, 3)
result = matrix + bias
print(result)
# [[11 22 33]
# [14 25 36]
# [17 28 39]]
# Normalize each column to zero mean (ML preprocessing)
mean = matrix.mean(axis=0) # shape (3,)
centered = matrix - mean # broadcasts across rowsAggregation Functions
Aggregations like mean and sum collapse an array down. The axis picks the direction: axis=0 goes down columns, axis=1 goes across rows. The code shows both.
import numpy as np
X = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]], dtype=float)
print('Global mean:', X.mean()) # 5.0
print('Column means:', X.mean(axis=0)) # [4. 5. 6.]
print('Row means:', X.mean(axis=1)) # [2. 5. 8.]
print('Global std:', X.std()) # ~2.58
print('Column max:', X.max(axis=0)) # [7. 8. 9.]
print('Row sum:', X.sum(axis=1)) # [ 6. 15. 24.]Matrix Multiplication: The Heart of ML
Matrix multiplication is the heart of ML — every neural net layer and prediction is one. Use @ (not *, which is element-wise). Inner shapes must match: (m,k) by (k,n).
import numpy as np
# Linear regression prediction: y_hat = X @ weights + bias
X = np.random.randn(100, 5) # 100 samples, 5 features
weights = np.random.randn(5) # one weight per feature
bias = 0.5
y_hat = X @ weights + bias # shape: (100,)
print('Predictions shape:', y_hat.shape)
# Matrix-matrix multiplication (e.g., two weight layers)
A = np.random.randn(4, 3) # (4, 3)
B = np.random.randn(3, 5) # (3, 5)
C = A @ B # (4, 5)
print('A @ B shape:', C.shape)Reshaping and Stacking Arrays
Reshaping changes an array's shape without touching its data — like flattening a 28x28 image into 784 numbers. Stacking with vstack or hstack joins arrays together.
import numpy as np
# Reshape: 1D to 2D
a = np.arange(12) # [0, 1, ..., 11]
matrix = a.reshape(3, 4) # shape (3, 4)
print('Reshaped:', matrix.shape)
# Use -1 to infer one dimension automatically
flat = matrix.reshape(-1) # back to 1D (12,)
row = matrix.reshape(1, -1) # shape (1, 12)
col = matrix.reshape(-1, 1) # shape (12, 1)
# Stack two arrays row-wise
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
stacked = np.vstack([A, B]) # shape (4, 2)Random Number Generation for ML
Random numbers drive weight init, shuffling, and train-test splits. Always set a seed so results repeat — without it, every run differs and debugging gets painful.
import numpy as np
# Set seed for reproducibility
rng = np.random.default_rng(seed=42)
# Common distributions used in ML
uniform = rng.uniform(0, 1, size=(3, 3)) # Uniform [0, 1)
normal = rng.normal(0, 1, size=(3, 3)) # Standard normal
integers = rng.integers(0, 10, size=5) # Random integers
# Shuffle an array
data = np.arange(10)
rng.shuffle(data)
print('Shuffled:', data)
# Random sampling without replacement
idxs = rng.choice(100, size=20, replace=False) # 20 unique indicesBoolean Masks and Fancy Indexing
Boolean masking filters arrays in one clean line: compare to a condition, then select the matches. Fancy indexing picks elements by an explicit list of positions.
import numpy as np
scores = np.array([85, 42, 91, 67, 55, 78, 33, 95])
# Boolean mask: select scores above 70
mask = scores > 70
print('Mask:', mask) # [T F T F F T F T]
print('High scores:', scores[mask]) # [85 91 78 95]
# Count how many passed
print('Passed:', mask.sum()) # 4
# Fancy indexing: select by explicit indices
indices = np.array([0, 2, 7])
print('Selected:', scores[indices]) # [85 91 95]
# Replace outliers
scores[scores < 50] = 50 # clip low scores to 50NumPy in scikit-learn Workflows
scikit-learn wants shapes right: X as 2D (samples, features), y as 1D (samples). A shape like (100,) instead of (100, 1) is a classic error — reshape(-1, 1) fixes it.
import numpy as np
from sklearn.linear_model import LinearRegression
# X must be 2D: (n_samples, n_features)
X = np.array([1, 2, 3, 4, 5]) # shape (5,) -- WRONG
# Fix:
X = X.reshape(-1, 1) # shape (5, 1) -- CORRECT
y = np.array([2.1, 4.0, 5.9, 8.1, 10.0]) # shape (5,) -- correct
model = LinearRegression()
model.fit(X, y)
print('Learned slope:', round(model.coef_[0], 2)) # ~2.0Quick Check
Test your understanding of Machine Learning with Python concepts from this lesson.
Lesson Recap
You learned the core of NumPy: arrays underpin all ML, vectorized math and broadcasting kill slow loops, and the @ operator runs every model. Next up: Pandas. 🐼
Häufig gestellte Fragen
Ist die Lektion „NumPy-Grundlagen: Arrays und mathematische Operationen“ kostenlos?
Ja — der vollständige Text von „NumPy-Grundlagen: Arrays und mathematische Operationen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Machine Learning Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Machine Learning Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „NumPy-Grundlagen: Arrays und mathematische Operationen“?
Erstellen und bearbeiten Sie NumPy-Arrays, führen Sie vektorisierte Arithmetik durch und verstehen Sie Broadcasting, um numerische Daten effizient zu verarbeiten. Du übst Machine Learning Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Machine Learning Academy zu starten?
Keine Vorkenntnisse erforderlich. Machine Learning Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „NumPy-Grundlagen: Arrays und mathematische Operationen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Machine Learning Academy-Lektion Code schreiben und ausführen?
Ja. Jede Machine Learning Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Anaconda und Jupyter Notebook installieren
- NumPy-Grundlagen: Arrays und mathematische Operationen
- Datenbearbeitung mit Pandas
- Datenvisualisierung mit Matplotlib und Seaborn