Python lernen

Willkommen bei Python

Python ist eine vielseitige High-Level-Programmiersprache, die für ihre Lesbarkeit und breite Community-Unterstützung bekannt ist. Es wurde Anfang der 1990er Jahre entwickelt und legt Wert auf eine klare, prägnante Syntax, was es zu einer ausgezeichneten Wahl für Anfänger und Profis gleichermaßen macht. Die umfangreiche Standardbibliothek von Python und das florierende Ökosystem an Paketen von Drittanbietern ermöglichen den Einsatz in vielen Bereichen – von der Webentwicklung und Datenanalyse bis hin zu künstlicher Intelligenz und wissenschaftlichem Rechnen. Seine einfache Erlernbarkeit, gepaart mit leistungsstarken Funktionen, machen Python zu einer wertvollen Fähigkeit für jeden, der in die Programmierung eintauchen oder seine technische Karriere vorantreiben möchte.

Einführung in Python

So installieren Sie Python und schreiben Ihr erstes „Hello, World!“ Programm.

Python ist aufgrund seiner Einfachheit und Vielseitigkeit eine der beliebtesten Programmiersprachen. Unabhängig davon, ob Sie Anfänger oder erfahrener Programmierer sind, ist die Installation von Python und die Ausführung Ihres ersten Skripts ein unkomplizierter Vorgang.

Schritt 1: Python herunterladen und installieren

Besuchen Sie die offizielle Website
Gehen Sie zu Python.org und laden Sie die neueste stabile Version von Python für Ihr Betriebssystem (Windows, macOS oder Linux) herunter.
Führen Sie das Installationsprogramm aus

Für Windows: Doppelklicken Sie auf die heruntergeladene Datei .exe und aktivieren Sie „Python zum PATH hinzufügen“, bevor Sie auf „Installieren“ klicken Jetzt".
Für Mac: Laden Sie das macOS-Installationsprogramm herunter und befolgen Sie die Installationsanweisungen.

Für Linux: Verwenden Sie den Paketmanager (z. B. für Ubuntu).

sh
sudo apt install python3

Überprüfen Sie die Installation
Öffnen Sie ein Terminal oder eine Eingabeaufforderung und geben Sie Folgendes ein:

sh
python --version

oder

sh
python3 --version

Hier sollte die installierte Python-Version angezeigt werden.

Schritt 2: Wählen Sie eine IDE oder einen Code-Editor

Python wird mit IDLE geliefert, einer integrierten integrierten Entwicklungsumgebung (IDE), die sich hervorragend für Anfänger eignet. Fortgeschrittenere Benutzer bevorzugen jedoch häufig Editoren wie:

VS-Code – Leicht und leistungsstark, mit Python-Erweiterungen.
PyCharm – Funktionsreiche IDE für professionelle Entwickler.
Jupyter Notebook – Am besten für Datenwissenschaft und interaktive Codierung.

Für Anfänger ist das Starten von IDLE (mit Python installiert) der einfachste Weg, mit dem Codieren zu beginnen.

Schritt 3: Schreiben Sie Ihr erstes Python-Skript und führen Sie es aus

Mit IDLE:
- Öffnen IDLE.
- Klicken Sie auf Datei → Neue Datei.
- Speichern Sie die Datei mit der Erweiterung .py (z. B. hello.py).
- Führen Sie es aus, indem Sie Ausführen → Modul ausführen auswählen oder F5.
  drücken.
Befehlszeile verwenden:
- Öffnen Sie ein Terminal oder eine Eingabeaufforderung.
- Navigieren Sie zu dem Ordner, in dem Sie hello.py.
  gespeichert haben.
- Führen Sie das Skript aus, indem Sie Folgendes eingeben:
- Sie sollten die Ausgabe sehen:

Herzlichen Glückwunsch! Sie haben Python erfolgreich installiert und führen Ihr erstes Skript aus. 🎉

Weitere Informationen finden Sie in der offiziellen Python-Dokumentation unter docs.python.org. Viel Spaß beim Codieren! 🚀

Syntax von Python

1. Python-Einrückung (keine geschweiften Klammern für Blöcke)

Python verwendet indentation (Leerzeichen), um Codeblöcke anstelle der geschweiften Klammern {} wie in anderen Sprachen zu definieren. Dies macht Python-Code besser lesbar, bedeutet aber auch, dass falsche Einrückungen Fehler verursachen.

Richtiges Beispiel:

python
if 5 > 3:
    print("Five is greater than three")  # Proper indentation

Falsches Beispiel (löst Einrückungsfehler aus):

python
if 5 > 3:
print("This will cause an error!")  # No indentation

Python erzwingt Einrückungen für eine bessere Codestruktur und Lesbarkeit. Die empfohlene Einrückung beträgt 4 Leerzeichen pro Ebene.

2. Nullbasierte Indizierung

Python folgt der nullbasierten Indizierung, was bedeutet, dass das erste Element einer Sequenz (wie eine Liste, ein String oder ein Tupel) bei Index 0 beginnt, nicht bei 1.

Beispiel:

python
fruits = ["apple", "banana", "cherry"]
print(fruits[0])  # Outputs: apple
print(fruits[2])  # Outputs: cherry

Falsches Beispiel (IndexError):

python
print(fruits[3])  # IndexError: list index out of range

Da Python mit dem Zählen ab 0 beginnt, führt der Versuch, auf einen Index zuzugreifen, der gleich oder größer als die Länge der Sequenz ist, zu einem Fehler.

3. Kommentare in Python

Kommentare helfen Entwicklern, Code zu verstehen, indem sie Erklärungen hinzufügen. Python unterstützt sowohl einzeilige als auch mehrzeilige Kommentare.

Einzeiliger Kommentar:

python
# This is a single-line comment
print("Hello, World!")  # Inline comment

Mehrzeiliger Kommentar:

python
"""
This is a multi-line comment.
It is often used for documentation.
"""
print("Hello, World!")

Obwohl dreifache Anführungszeichen für mehrzeilige Kommentare verwendet werden können, sind sie hauptsächlich für docstrings gedacht, bei denen es sich um spezielle Kommentare handelt, die innerhalb von Funktionen zur Dokumentation platziert werden.

4. Groß- und Kleinschreibung

Python unterscheidet die Groß- und Kleinschreibung, was bedeutet, dass Groß- und Kleinbuchstaben unterschiedlich behandelt werden. Variablennamen, Funktionsnamen und Schlüsselwörter müssen konsistent verwendet werden.

Beispiel:

python
myVar = 5
MyVar = 10

print(myVar)  # Outputs: 5
print(MyVar)  # Outputs: 10 (different variable)

Hier werden myVar und MyVar aufgrund ihrer Groß- und Kleinschreibung als zwei verschiedene Variablen betrachtet.

Falsches Beispiel:

python
Print("Hello")  # NameError: name 'Print' is not defined

Pythons integrierte Funktionen wie print() müssen in Kleinbuchstaben geschrieben werden.

5. Variablen und dynamische Typisierung

Python ist dynamisch typisiert, was bedeutet, dass Sie den Typ einer Variablen nicht explizit deklarieren müssen. Der Typ wird automatisch anhand des zugewiesenen Werts ermittelt.

Beispiel:

python
x = 10       # Integer
y = 3.14     # Float
z = "Hello"  # String

print(type(x))  # Outputs: <class 'int'>
print(type(y))  # Outputs: <class 'float'>
print(type(z))  # Outputs: <class 'str'>

Verschiedene Datentypen neu zuweisen:

python
a = 5        # Initially an integer
a = "Python" # Now reassigned as a string
print(a)     # Outputs: Python

Da Python dynamische Typisierung zulässt, kann sich der Typ einer Variablen während der Ausführung ändern.

Fazit

Um sauberen und effizienten Code zu schreiben, ist es wichtig, die grundlegende Syntax von Python zu verstehen. Zu den wichtigsten Erkenntnissen gehören:

Python erzwingt Einrückung anstelle von geschweiften Klammern für Codeblöcke.
Nullbasierte Indizierung bedeutet, dass sich das erste Element in einer Sequenz am Index 0.
befindet.
Kommentare verbessern die Lesbarkeit des Codes und können einzeilig (#) oder sein multi-line ("" """).
Python unterscheidet zwischen Groß- und Kleinschreibung, daher werden Var und var als unterschiedlich behandelt Variablen.
Python unterstützt dynamische Typisierung und ermöglicht es Variablen, den Typ zu ändern.

Die Beherrschung dieser Grundlagen bietet eine solide Grundlage für das Erlernen fortgeschrittenerer Python-Konzepte. Viel Spaß beim Codieren! 🚀

print

Die Funktion print() in Python wird verwendet, um die Ausgabe auf dem Bildschirm anzuzeigen. Dies ist eine der am häufigsten verwendeten Funktionen, insbesondere zum Debuggen und zur Benutzerinteraktion. In dieser kurzen Anleitung erkunden wir verschiedene Möglichkeiten zur effektiven Verwendung von print(), einschließlich der Frage, wie mehrere Werte gedruckt, die Ausgabe formatiert und Trennzeichen und Endzeichen gesteuert werden.

1. Grundlegende `print()` Verwendung

Der einfachste Weg, print() zu verwenden, besteht darin, eine Zeichenfolge oder eine Zahl in den Klammern zu übergeben:

python
print("Hello, World!")  # Outputs: Hello, World!
print(42)               # Outputs: 42

Sie können mehrere Werte drucken, indem Sie sie durch ein Komma trennen ,:

python
print("Hello", "Python")  # Outputs: Hello Python

Standardmäßig fügt Python ein Leerzeichen zwischen den Werten ein.

2. Verwendung des Parameters `sep`

Der Parameter sep steuert das Trennzeichen zwischen mehreren Werten in print(). Standardmäßig ist es ein Leerzeichen, aber Sie können es in etwas anderes ändern:

python
print("apple", "banana", "cherry", sep=", ")  
# Outputs: apple, banana, cherry

python
print("Python", "is", "fun", sep="-")  
# Outputs: Python-is-fun
```<h2><span style="font-family: Roboto;">3. Verwendung des Parameters <code inline="">end</code></span></h2>
<p><span style="font-family: Roboto;">Standardmäßig fügt <code inline="">print()</code> am Ende der Ausgabe eine neue Zeile (<code inline="">\n</code>) hinzu. Sie können dieses Verhalten mit dem Parameter <code inline="">end</code> ändern:</span></p>


```python
print("Hello", end=" ")
print("World!")  
# Outputs: Hello World! (on the same line)

Hier ersetzt end=" " den standardmäßigen Zeilenumbruch durch ein Leerzeichen.

4. Drucken von Variablen

Sie können Variablen genau wie String-Literale drucken:

python
name = "Alice"
age = 25
print("Name:", name, "Age:", age)  
# Outputs: Name: Alice Age: 25

Alternativ können Sie f-strings für eine sauberere Ausgabe verwenden:

python
print(f"Name: {name}, Age: {age}")  
# Outputs: Name: Alice, Age: 25

5. Sonderzeichen drucken

Verwenden Sie Escape-Sequenzen, um die Ausgabe zu formatieren:

python
print("Hello\nWorld!")  # \n adds a new line
print("This is a tab:\tPython")  # \t adds a tab space
```<hr />
<h2><span style="font-family: Roboto;">Fazit</span></h2>
<p><span style="font-family: Roboto;">Die Funktion <code inline="">print()</code> ist ein leistungsstarkes Tool in Python, mit dem Sie die Ausgabe auf verschiedene Arten anzeigen können. Wichtige Erkenntnisse:</span></p>
<ul>
<li>
<p><span style="font-family: Roboto;">Verwenden Sie <code inline="">print(value1, value2, …)</code>, um mehrere Werte zu drucken.</span></p>
</li>
<li>
<p><span style="font-family: Roboto;">Ändern Sie das Trennzeichen mit <code inline="">sep="custom_separator"</code>.</span></p>
</li>
<li>
<p><span style="font-family: Roboto;">Kontrollzeilenenden mit <code inline="">end="custom_end"</code>.</span></p>
</li>
<li>
<p><span style="font-family: Roboto;">Verwenden Sie <code inline="">f-strings</code> für eine bessere Formatierung.</span></p>
</li>
</ul>
<p><span style="font-family: Roboto;">Die Beherrschung von <code inline="">print()</code> wird das Debuggen und die Ausgabeverarbeitung in Python viel einfacher machen.</span></p>

Binäre Operationen in Python

1. Arithmetische Operatoren

Arithmetische Operatoren führen mathematische Berechnungen zwischen zwei Operanden durch. Python unterstützt Addition, Subtraktion, Multiplikation, Division, Modulo, Etagendivision und Potenzierung.

Beispiele:

python
a = 15
b = 4

print(a + b)   # 19 (addition)
print(a - b)   # 11 (subtraction)
print(a * b)   # 60 (multiplication)
print(a / b)   # 3.75 (true division)
print(a // b)  # 3 (floor division)
print(a % b)   # 3 (modulus)
print(a ** b)  # 50625 (exponentiation)

Arithmetische Operatoren geben immer einen neuen Wert zurück, ohne die ursprünglichen Variablen zu ändern.

2. Vergleichsoperatoren

Vergleichsoperatoren vergleichen zwei Werte und geben ein boolesches Ergebnis zurück (True oder False). Dazu gehören Gleichheit, Ungleichheit, Größer/Kleiner als und deren Kombinationen.

Beispiele:

python
x = 7
y = 10

print(x == y)   # False (equal to)
print(x != y)   # True (not equal to)
print(x > y)    # False
print(x < y)    # True
print(x >= 7)   # True
print(y <= 7)   # False

Vergleichsergebnisse werden oft in if-Anweisungen oder Schleifen verwendet, um den Programmfluss zu steuern.

3. Logische Operatoren

Logische Operatoren kombinieren boolesche Werte und geben True oder False zurück. Die drei Operatoren sind and, or und not (unär).

Beispiele:

python
is_sunny = True
is_warm = False

print(is_sunny and is_warm)   # False (both must be True)
print(is_sunny or is_warm)    # True  (at least one is True)
print(not is_warm)            # True  (negates the value)

Logische Operatoren werden häufig in Bedingungen verwendet, z. Überprüfen mehrerer Anforderungen gleichzeitig.

4. Bitweise Operatoren

Bitweise Operatoren wirken auf die binäre Darstellung von ganzen Zahlen. Dazu gehören & (AND), | (OR), ^ (XOR), << (Linksverschiebung) und >> (rechts). Schicht).

Beispiele:

python
a = 6   # binary: 110
b = 3   # binary: 011

print(a & b)   # 2 (binary 010)
print(a | b)   # 7 (binary 111)
print(a ^ b)   # 5 (binary 101)
print(a << 1)  # 12 (binary 1100, shifted left by 1)
print(b >> 1)  # 1 (binary 001, shifted right by 1)

Bitweise Operationen werden häufig in der Low-Level-Programmierung, Kryptografie oder Leistungsoptimierung verwendet.

5. Zuweisungsoperatoren

Zuweisungsoperatoren weisen Variablen Werte zu. Sie können Zuweisungen auch mit arithmetischen oder bitweisen Operationen kombinieren.

Beispiele:

python
x = 10   # simple assignment
x += 5   # equivalent to x = x + 5 → 15
x -= 3   # equivalent to x = x - 3 → 12
x *= 2   # equivalent to x = x * 2 → 24
x //= 4  # equivalent to x = x // 4 → 6
x %= 4   # equivalent to x = x % 4 → 2
x **= 3  # equivalent to x = x ** 3 → 8

Zuweisungsoperatoren sind Abkürzungen zum Aktualisieren einer Variablen an Ort und Stelle, wodurch der Code prägnanter wird.

Ganzzahlen

Ganzzahlen sind ganze Zahlen, entweder positiv, negativ oder Null. Sie gehören zu den grundlegenden numerischen Typen von Python und werden für mathematische Operationen verwendet.

1. Ganzzahlen erstellen

Ganzzahlen können durch Zuweisen ganzzahliger Werte zu Variablen erstellt werden:

python
a = 10
b = -5
c = 0
print(a, b, c)

2. Ganzzahlige Operationen

Ganzzahlen unterstützen verschiedene arithmetische Operationen:

python
print(5 + 3)   # Addition
print(5 - 3)   # Subtraction
print(5 * 3)   # Multiplication
print(5 / 3)   # Division (returns float)
print(5 // 3)  # Floor division
print(5 % 3)   # Modulus

3. Typkonvertierung

Konvertieren anderer Typen in Ganzzahlen:

python
num = int("123")
print(num)  # Outputs: 123

num = int(3.1415)
print(num)  # Outputs: 3

Floats

Floats stellen reelle Zahlen dar, die Bruchteile haben können. Sie sind ein weiterer grundlegender numerischer Typ in Python und für Dezimalberechnungen unerlässlich.

1. Floats erstellen

Floats können durch Zuweisen von Dezimalwerten zu Variablen erstellt werden:

python
a = 3.1415
b = -0.5
c = 100.0
print(a, b, c)

2. Float-Operationen

Floats unterstützen verschiedene arithmetische Operationen:

python
print(2.5 + 1.5)  # Addition
print(5.0 / 2)    # Division
print(3.1415 ** 2) # Exponentiation
print(7.3 % 3)    # Modulus

3. Typkonvertierung

Konvertieren anderer Typen in Floats:

python
num = float("123.45")
print(num)  # Outputs: 123.45

num = float(3)
print(num)  # Outputs: 3.0

num = float(5.5)
print(num)  # Outputs: 5.5

Strings

Strings sind Zeichenfolgen, die zur Darstellung von Text verwendet werden. Sie sind unveränderlich und können mit einfachen, doppelten oder dreifachen Anführungszeichen für mehrzeilige Zeichenfolgen definiert werden.

1. Strings erstellen

Strings können mit verschiedenen Arten von Anführungszeichen erstellt werden:

python
a = 'Hello, World!'
b = "Python is great"
c = """This is a
multi-line string"""
print(a, b, c, sep='\n')

2. String-Operationen

Strings unterstützen verschiedene Operationen wie Verkettung und Wiederholung:

python
print("Hello" + " World")  # Concatenation
print("Hello" * 3)        # Repetition
print("Hello"[0])        # Accessing characters
print("Hello"[1:3])      # Slicing

3. String-Methoden

Strings verfügen über verschiedene integrierte Methoden zur Manipulation:

python
text = "hello world"
print(text.upper())      # Outputs: HELLO WORLD
print(text.lower())      # Outputs: hello world
print(text.replace("world", "earth"))  # Outputs: hello earth

String-Funktionen

Strings verfügen über viele nützliche Methoden zum Zuschneiden, Teilen und Ersetzen von Text.

Trimmen mit `.strip()`

python
text = "   hello world   "
print(text.strip())   # "hello world"
print(text.lstrip())  # "hello world   "
print(text.rstrip())  # "   hello world"

Strings aufteilen

python
line = "apple,banana,cherry"
print(line.split(","))   # ['apple', 'banana', 'cherry']

words = "one two three".split()
print(words)             # ['one', 'two', 'three']

Text ersetzen

python
sentence = "I like cats"
print(sentence.replace("cats", "dogs"))
# "I like dogs"

Strings verbinden

python
parts = ["2025", "09", "26"]
date = "-".join(parts)
print(date)   # "2025-09-26"

Häufige Fallstricke

.strip() entfernt standardmäßig Leerzeichen, aber Sie können folgende Zeichen übergeben: "hello!!".strip("!").
.split() ohne Argumente teilt auf alle Leerzeichen, nicht nur Leerzeichen.
.replace() ersetzt alle Vorkommen, es sei denn, Sie übergeben ein drittes Argument (maximale Anzahl).
.join() erfordert, dass alle Elemente Zeichenfolgen (keine Zahlen) sind.

String-Formatierung und Groß-/Kleinschreibungsmethoden

Python bietet mehrere Methoden zum Formatieren von Zeichenfolgen und zum Anpassen der Groß-/Kleinschreibung. Dies hilft bei der Erstellung einer dynamischen Ausgabe und der Steuerung der Textdarstellung.

Formatierung mit `.format()`

python
# Insert values into placeholders {}
template = "The sum of {0} and {1} is {2}"
msg = template.format(2, 4, 2+4)
print(msg)   # The sum of 2 and 4 is 6

# Named placeholders
info = "Name: {name}, Age: {age}".format(name="Alice", age=30)
print(info)

Fallkonvertierung

python
text = "Hello World"
print(text.upper())   # "HELLO WORLD"
print(text.lower())   # "hello world"

Partitionierungszeichenfolgen

python
line = "user:password"
print(line.partition(":"))
# ('user', ':', 'password')

.partition() teilt sich in ein dreiteiliges Tupel auf: Text davor, das Trennzeichen selbst und Text danach.

Häufige Fallstricke

Die Verwendung von .format() mit fehlenden oder falschen Schlüsseln führt zu KeyError oder IndexError.
.upper() / .lower() Erstellen Sie eine neue Zeichenfolge, das Original wird nicht geändert.
.partition() teilt nur beim ersten Auftreten des Trennzeichens.

Listen

Listen sind vielseitige, veränderliche Sequenzen, die zum Speichern von Elementsammlungen verwendet werden. Sie werden mit eckigen Klammern [] definiert und unterstützen eine Vielzahl von Vorgängen für Änderung und Zugriff.

1. Erstellen einer Liste

Definieren Sie eine Liste mit verschiedenen Elementen:

python
my_list = [1, 2, 3, "Python", True]
print(my_list)

2. Zugreifen auf und Ändern von Listen

Listen unterstützen Indizierung, Slicing und Methoden zum Ändern ihres Inhalts:

python
# Accessing an element
print(my_list[3])  # Outputs: Python

# Changing an element
my_list[1] = "changed"
print(my_list)

# Appending a new element
my_list.append("new item")
print(my_list)

3. Listenverständnisse

Listenverständnisse bieten eine prägnante Möglichkeit, Listen durch Iteration über Sequenzen und optionale Anwendung von Bedingungen zu erstellen:

python
# Creating a list of squares for numbers 0 to 9
squares = [x**2 for x in range(10)]
print(squares)

Indexierungslisten

In Python sind Listen geordnete Sammlungen, und Sie können über ihren index auf Elemente zugreifen. Die Indizierung beginnt bei 0 für das erste Element. Negative Indizes zählen ab dem Ende der Liste, wobei -1 das letzte Element ist.

Grundlegende Indexierung

python
fruits = ["apple", "banana", "cherry"]
print(fruits[0])   # Outputs: apple
print(fruits[-1])  # Outputs: cherry

Elemente über Index ändern

python
numbers = [10, 20, 30]
numbers[1] = 25
print(numbers)  # Outputs: [10, 25, 30]

Häufige Fallstricke

IndexError: Zugriff auf einen Index außerhalb des Listenbereichs.
Mutable vs Immutable: Nur veränderbare Listen können durch Indizierung geändert werden; Tupel unterstützen keine Zuweisung.

Slicing-Listen

Slicing ermöglicht es Ihnen, einen Teil einer Liste mithilfe der Syntax list[start:stop:step] zu extrahieren. Der Index start ist inklusiv, stop ist exklusiv und step definiert das Intervall.

Grundlegendes Slicing

python
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4])    # Outputs: [1, 2, 3]
print(numbers[:3])     # Outputs: [0, 1, 2]
print(numbers[3:])     # Outputs: [3, 4, 5]
print(numbers[::2])    # Outputs: [0, 2, 4] - every 2nd element

Eine Liste umkehren

python
print(numbers[::-1])  # Outputs: [5, 4, 3, 2, 1, 0]

Häufige Fallstricke

Stop-Index ist exklusiv; list[start:stop] enthält das Element bei stop.
Negative Indizes können schwierig sein; Stellen Sie sicher, dass sie korrekt mit der Listenlänge verwendet werden.
Slicing gibt eine neue Liste zurück; Es verändert das Original nicht, es sei denn, es wird zurück zugewiesen.

Listenspezifische Funktionen und Methoden

Python bietet viele integrierte Funktionen und Methoden speziell für Listen zur effizienten Bearbeitung, Abfrage und Transformation von Daten.

Gemeinsame Methoden

python
fruits = ["apple", "banana", "cherry"]
fruits.append("date")      # Add element at the end
fruits.insert(1, "blueberry")  # Insert at index 1
fruits.remove("banana")    # Remove element by value
popped = fruits.pop()      # Remove and return last element
print(fruits, popped)

Andere nützliche Methoden

python
numbers = [3, 1, 4, 2]
numbers.sort()     # Sorts in ascending order
numbers.reverse()  # Reverses the list
print(numbers)

Eingebaute Funktionen für Listen

python
nums = [1, 2, 3, 4]
print(len(nums))   # Number of elements
print(sum(nums))   # Sum of elements
print(max(nums))   # Maximum value
print(min(nums))   # Minimum value

Arbeiten mit mehreren Listen

python
# enumerate() gives index + value when looping
animals = ["cat", "dog", "mouse"]
for index, animal in enumerate(animals):
    print(index, animal)

# zip() pairs elements from multiple lists
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(name, "scored", score)

enumerate() ist hilfreich, wenn Sie sowohl die Position als auch den Wert eines Listenelements benötigen. zip() ist nützlich, wenn zwei oder mehr Listen Element für Element kombiniert werden.

Häufige Fallstricke

Methoden wie sort() und reverse() ändern die Liste an Ort und Stelle und geben None.
Das Entfernen nicht vorhandener Elemente löst ValueError.
Seien Sie vorsichtig mit pop() bei leeren Listen; es löst IndexError.
zip() stoppt bei der kürzesten Listenlänge.

Tupel

Tupel sind unveränderliche Sequenzen, die zum Speichern einer Sammlung von Elementen verwendet werden. Sie werden mit Klammern () definiert und sind nützlich, wenn Sie die Datenintegrität sicherstellen möchten.

1. Erstellen eines Tupels

Ein einfaches Tupel mit verschiedenen Datentypen:

python
my_tuple = (10, "hello", 3.14)
print(my_tuple)

2. Auf Tupelelemente zugreifen

Zugriff auf Elemente über ihren Index, ähnlich wie bei Listen:

python
# Accessing the first element
print(my_tuple[0])  # Outputs: 10

# Slicing the tuple
print(my_tuple[1:])  # Outputs: ('hello', 3.14)

Da Tupel unveränderlich sind, können ihre Werte nach der Erstellung nicht geändert werden.

Wörterbücher

Wörterbücher speichern Daten in Schlüssel-Wert-Paaren und ermöglichen so eine effiziente Datensuche. Sie werden mit geschweiften Klammern {} erstellt und können über ihre Schlüssel aufgerufen werden.

1. Erstellen eines Wörterbuchs

Ein einfaches Wörterbuch, das Früchte ihren Farben zuordnet:

python
fruit_colors = {
    "apple": "red",
    "banana": "yellow",
    "cherry": "red"
}

2. Auf Daten zugreifen und sie ändern

Greifen Sie über seinen Schlüssel auf einen Wert zu, fügen Sie ein neues Schlüssel-Wert-Paar hinzu oder aktualisieren Sie ein vorhandenes:

python
# Accessing a value
print(fruit_colors["apple"])  # Outputs: red

# Adding a new entry
fruit_colors["orange"] = "orange"

# Updating an entry
fruit_colors["banana"] = "green"

Durchlaufen Sie Schlüssel und Werte mit der Methode items():

python
for fruit, color in fruit_colors.items():
    print(f"{fruit} is {color}")

Wörterbuchfunktionen

Wörterbücher (dict) speichern Daten als Schlüssel-Wert-Paare. Python bietet Methoden wie .keys() und .values() um separat auf die Schlüssel und Werte zuzugreifen.

Zugriff auf Schlüssel

python
person = {"name": "Alice", "age": 25, "city": "Zurich"}

print(person.keys())   # dict_keys(['name', 'age', 'city'])

# Loop through keys
for key in person.keys():
    print("Key:", key)

Zugriff auf Werte

python
print(person.values())  # dict_values(['Alice', 25, 'Zurich'])

# Loop through values
for value in person.values():
    print("Value:", value)

Schlüssel und Werte gemeinsam verwenden

python
# Often combined with a for-loop
for key in person.keys():
    print(key, "->", person[key])

Häufige Fallstricke

.keys() und .values() geben spezielle Ansichten zurück, keine normalen Listen. Wenn Sie eine Liste benötigen, schließen Sie sie mit list().
Wörterbücher waren vor Python 3.7 ungeordnet. Im modernen Python behalten sie die Einfügereihenfolge bei.

Variablen

Variablen werden zum Speichern von Daten in Python verwendet. Sie fungieren als benannte Container für Werte unterschiedlichen Typs (Zahlen, Zeichenfolgen usw.). Python-Variablen müssen bestimmte Namensregeln befolgen:

Der Name einer Variablen muss mit einem Buchstaben oder einem Unterstrich beginnen (_).
Ein Variablenname darf nicht mit einer Zahl beginnen.
Eine Variable kann keine reservierten Python-Schlüsselwörter verwenden (siehe Modul keyword).

1. Variablen erstellen

In Python werden Variablen automatisch erstellt, wenn Sie ihnen mithilfe des Zuweisungsoperators = einen Wert zuweisen. Es ist keine explizite Deklaration erforderlich.

python
a = 10
b = "Hello"
c = 3.14
print(a, b, c)   # Outputs: 10 Hello 3.14

2. Mehrere Variablen zuweisen

Wenn Sie zwei oder mehr Variablen gleichzeitig ändern und bestimmte Werte für laufende Berechnungen verwenden möchten, ist es hilfreich, dies zu tun ändern Sie es gleichzeitig.

python
a, b = 4, 5
print(a)   # Outputs: 4
print(b)   # Outputs: 5
```<h2><span style="font-family: Roboto;">3. Verwenden von Eingaben zum Erstellen von Variablen</span></h2>
<p><span style="font-family: Roboto;">
Variablen können auch aus Benutzereingaben mithilfe der Funktion <code>input()</code> erstellt werden. 
Standardmäßig gibt <code>input()</code> eine Zeichenfolge zurück, Sie können sie jedoch bei Bedarf in andere Typen konvertieren.
</span></p>


```python
name = input("Enter your name: ")
age = int(input("Enter your age: "))  # type conversion to integer
print("Hello", name, "you are", age, "years old.")

4. Typkonvertierung

Manchmal müssen Sie möglicherweise zwischen Datentypen konvertieren (z. B. von einer Zeichenfolge in eine Ganzzahl). Zu den allgemeinen Funktionen gehören int(), float() und str().

python
num_str = "123"
num = int(num_str)   # convert string to integer
print(num, type(num))  # Outputs: 123 <class 'int'>

pi = 3.1415
print(str(pi))        # convert float to string → "3.1415"

5. Operatoren und Variablen

Variablen können zusammen mit arithmetic verwendet werden, comparison, und andere Zuweisungsoperatoren. Einzelheiten und Beispiele finden Sie in den entsprechenden Abschnitten zu Operatoren.

Bedingungen: if, elif und else

Bedingte Anweisungen in Python ermöglichen es Ihnen, Codeblöcke basierend darauf auszuführen, ob eine Bedingung wahr oder falsch ist. Die Grundstruktur verwendet if, optional gefolgt von elif (sonst wenn) und else als Fallback.

1. Grundlegende if-Anweisung

Verwenden Sie die Anweisung if, um Code nur dann auszuführen, wenn eine Bedingung erfüllt ist:

python
x = 10
if x > 5:
    print("x is greater than 5")  
    # Outputs: x is greater than 5

2. if-else-Anweisung

Fügen Sie einen else-Block ein, um Code auszuführen, wenn die Bedingung nicht erfüllt ist:

python
x = 3
if x > 5:
    print("x is greater than 5")
else:
    print("x is not greater than 5")  
    # Outputs: x is not greater than 5

3. if-elif-else Chain

Für mehrere Bedingungen verwenden Sie elif, um zusätzliche Bedingungen zu überprüfen:

python
x = 5
if x > 5:
    print("x is greater than 5")
elif x == 5:
    print("x is exactly 5")
else:
    print("x is less than 5")
    # Outputs: x is exactly 5

Mit diesen Konstrukten können Sie robuste Entscheidungsstrukturen in Ihren Python-Programmen erstellen.

`for`-Schleife (Grundlagen)

Eine for-Schleife in Python wiederholt Code für jedes Element in einer Sequenz (wie eine Liste, eine Zeichenfolge oder einen Zahlenbereich). Im Gegensatz zu while ist die Anzahl der Wiederholungen normalerweise im Voraus bekannt.

Zählen mit `range()`

python
for i in range(5):
    print("Number:", i)
# Prints 0, 1, 2, 3, 4

range(5) generiert Zahlen von 0 bis (aber nicht einschließlich) 5.

Eine Liste durchlaufen

python
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print("I like", fruit)

Die Schleife besucht jedes Element in der Liste einzeln.

Durchlaufen einer Zeichenfolge

python
word = "hi!"
for char in word:
    print(char)
# Prints h, i, !

Verwenden von `break` und `continue`

python
for num in range(1, 6):
    if num == 3:
        continue   # skip number 3
    if num == 5:
        break      # stop the loop completely
    print(num)
# Prints 1, 2, 4

Häufige Fallstricke

Off-by-One-Fehler: Denken Sie daran, dass range(n) vor n stoppt.
Vergessen, dass in Elemente prüft: für x in der Liste gibt Elemente an, keine Indizes.
Mischen von break und continue: break beendet die Schleife, continue überspringt nur den aktuellen Schritt.

`while`-Schleife (Grundlagen)

Eine while-Schleife wiederholt einen Codeblock, solange seine Bedingung True ist. Im Gegensatz zu for-Schleifen ist die Anzahl der Wiederholungen nicht im Voraus festgelegt. Die Bedingung wird vor jeder Wiederholung überprüft.

Wichtig: Seien Sie vorsichtig mit der Bedingung. Wenn es nie zu False wird, Die Schleife läuft ewig (eine Endlosschleife).

Einfaches Zählbeispiel

python
x = 0
while x < 5:
    print("Counted to:", x)
    x += 1   # Important: update the counter!

Diese Schleife beginnt bei x = 0 und stoppt, sobald x nicht mehr als 5 ist.

Vorzeitiges Stoppen mit `break`

python
x = 10
while True:       # runs "forever" unless stopped
    if x % 7 == 0:
        print("Found a multiple of 7:", x)
        break     # exit the loop
    x += 1

Hier verwenden wir while True, maskieren es jedoch mit break, sobald eine Bedingung erfüllt ist.

Überspringen von Iterationen mit `continue`

python
x = -3
while x <= 3:
    x += 1
    if x == 0:       # skip division by zero
        continue
    print("1/", x, "=", 1/x)

Die Anweisung continue überspringt den aktuellen Schleifenschritt und geht zum nächsten über.

Grundlegende Fallstricke

Vergessen, die Variable zu aktualisieren: Wenn x += 1 fehlt, ändert sich die Bedingung nie. und die Schleife läuft ewig.
Zu weit gefasste Bedingungen: während True nur sicher ist, wenn Sie einen ordnungsgemäßen break.

Schleifenkontrollanweisungen: `break`, `continue` und `pass`

Python bietet spezielle Anweisungen, die den normalen Schleifenfluss ändern. Sie sind nützlich für die differenzierte Steuerung der Iteration, die Behandlung von Ausnahmefällen und die ausdrucksstärkere Gestaltung des Codes.

`break` – Verlassen einer Schleife

break beendet sofort die nächste umschließende Schleife, unabhängig von der Schleifenbedingung. Es wird häufig verwendet, wenn eine Zielbedingung erfüllt wurde und keine weitere Iteration erforderlich ist.

python
nums = [1, 4, 7, 10]
for n in nums:
    if n > 5:
        print(f"Found {n}, stopping loop.")
        break
# Only iterates until 7, then exits

`continue` – Überspringen einer Iteration

continue überspringt den Rest der aktuellen Iteration und springt direkt zur nächsten. Es wird häufig zum Filtern unerwünschter Fälle verwendet.

python
for n in range(5):
    if n % 2 == 0:
        continue
    print(f"Odd: {n}")
# Prints Odd: 1, 3

`pass` – Platzhalteranweisung

pass macht nichts und fungiert als syntaktischer Platzhalter. Dies ist nützlich, wenn ein Codeblock syntaktisch erforderlich ist, aber noch keine Aktion ausgeführt werden soll (z. B. während der Entwicklung oder in abstrakten Klassenmethoden).

python
for n in range(3):
    if n == 1:
        pass  # Placeholder for future logic
    else:
        print(n)
# Prints 0 and 2, does nothing on 1
```<h2 class="error">Häufige Fallstricke</h2>
<ul>
<li><strong>Verwirrung von <code>break</code> mit <code>return</code>:</strong> <code>break</code> beendet nur die Schleife, nicht die Funktion. Verwenden Sie <code>return</code>, um eine Funktion vollständig zu beenden.</li>
<li><strong>Endlosschleifen mit <code>continue</code>:</strong> In <code>while</code>-Schleifen kann das Platzieren von <code>continue</code> vor dem Aktualisieren von Schleifenvariablen dazu führen, dass die Bedingung niemals auftritt ändern.</li>
<li><strong>Die missbräuchliche Verwendung von <code>pass</code>:</strong> Da <code>pass</code> nichts bewirkt, kann das unbeabsichtigte Belassen im Produktionscode fehlende Logik oder Fehler verbergen.</li>
</ul>

<h2>Schnellvergleich</h2>
<ul>
<li><code>break</code>: Schleife vollständig verlassen.</li>
<li><code>continue</code>: Zur nächsten Iteration springen.</li>
<li><code>pass</code>: Nichts tun, nur Platzhalter.</li>
</ul>

Verschachtelte Schleifen

Verschachtelte Schleifen sind Schleifen innerhalb von Schleifen. Die äußere Schleife wird für jede Iteration der inneren Schleife einmal ausgeführt, wodurch die Gesamtzahl der Iterationen multipliziert wird. Sie sind für die Arbeit mit mehrdimensionalen Daten, Kombinatorik und algorithmischen Problemen unerlässlich.

Kartesisches Produkt

python
colors = ["red", "blue"]
sizes = ["S", "M", "L"]
for color in colors:
    for size in sizes:
        print(color, size)

Verschachtelt `while`

python
i = 1
while i <= 3:
    j = 1
    while j <= 2:
        print(i, j)
        j += 1
    i += 1

Fallstricke

Komplexitätsexplosion: Zwei verschachtelte Schleifen über n Elemente führen jeweils zu einer Komplexität von O(n²). Durch das Hinzufügen weiterer Ebenen erhöht sich die Laufzeit erheblich.

Variablenschatten: Die versehentliche Wiederverwendung von Variablennamen in inneren und äußeren Schleifen kann Werte unerwartet überschreiben.

Funktionen und Lambda-Ausdrücke

Funktionen in Python werden mit dem Schlüsselwort def definiert und ermöglichen Ihnen, Code zur Wiederverwendung zu kapseln. Darüber hinaus bieten Lambda-Ausdrücke eine Abkürzung zum Erstellen kleiner anonymer Funktionen.

1. Funktionen definieren

Verwenden Sie def, um eine Funktion zu definieren, optional mit Parametern:

python
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))  
# Outputs: Hello, Alice!

2. Lambda-Funktionen

Lambda-Ausdrücke erstellen kleine anonyme Funktionen. Sie sind nützlich für kurze, einfache Funktionen:

python
# A lambda that adds two numbers
add = lambda a, b: a + b
print(add(3, 4))  # Outputs: 7

Sowohl reguläre Funktionen als auch Lambda-Ausdrücke sind wesentliche Werkzeuge zum Organisieren und Vereinfachen Ihres Codes.

Module in Python importieren

Mit Python können Sie die Funktionalität erweitern, indem Sie modules (Dateien, die Python-Code, Funktionen und Klassen enthalten) importieren. Module können integriert, maßgeschneidert oder aus externen Quellen (wie PyPI) installiert werden.

1. Grundlegende Importsyntax

Verwenden Sie die Anweisung import, um ein Modul in Ihr Programm einzufügen.

python
import math
print(math.sqrt(16))   # Outputs: 4.0

2. Importieren bestimmter Funktionen oder Aliase

Sie können der Einfachheit halber bestimmte Funktionen importieren oder Module umbenennen.

python
from math import pi, sin
print(pi)        # Outputs: 3.141592653589793
print(sin(90))   # Uses radians by default

import numpy as np
arr = np.array([1, 2, 3])
print(arr)
```<h2><span style="font-family: Roboto;">3. Häufig verwendete integrierte Module</span></h2>
<p><span style="font-family: Roboto;">Zu den nützlichsten integrierten Modulen gehören:</span></p>
<ul>
<li><span style="font-family: Roboto;"><code>math</code> → Mathematische Funktionen (Quadrat, Pi, Sin, Cos...)</span></li>
<li><span style="font-family: Roboto;"><code>random</code> → Zufallszahlen, Mischen, Auswahl</span></li>
<li><span style="font-family: Roboto;"><code>datetime</code> → Datum und Uhrzeit</span></li>
<li><span style="font-family: Roboto;"><code>os</code> → Betriebssysteminteraktionen (Dateien, Verzeichnisse)</span></li>
<li><span style="font-family: Roboto;"><code>sys</code> → Systemspezifische Parameter und Funktionen</span></li>
<li><span style="font-family: Roboto;"><code>json</code> → Arbeiten mit JSON-Daten</span></li>
</ul>

<h2><span style="font-family: Roboto;">4. Externe Module installieren</span></h2>
<p><span style="font-family: Roboto;">
Viele beliebte Module sind nicht integriert und müssen über <code>pip</code> (Pythons Paketmanager) installiert werden.
</span></p>


```bash
pip install numpy
pip install requests

python
import requests
response = requests.get("https://api.github.com")
print(response.status_code)
```<h2><span style="font-family: Roboto;">5. Beheben von Importfehlern</span></h2>
<p><span style="font-family: Roboto;">
Häufige Probleme beim Importieren von Modulen:
</span></p>
<ul>
<li><span style="font-family: Roboto;"><strong>ModuleNotFoundError</strong>: Das Modul ist nicht installiert.  
➝ Fix: Führen Sie <code>pip install modulename</code>.</span></li> aus.
<li><span style="font-family: Roboto;"><strong>ImportError</strong>: Eine bestimmte Funktion/Klasse kann nicht importiert werden.  
➝ Fix: Überprüfen Sie die Dokumentation des Moduls auf korrekte Funktionsnamen.</span></li>
<li><span style="font-family: Roboto;"><strong>Versionskonflikte</strong>: Eine Modulversion unterstützt möglicherweise nicht Ihre Python-Version.  
➝ Fix: Upgrade mit <code>pip install --upgrade modulename</code>.</span></li>
<li><span style="font-family: Roboto;"><strong>Probleme mit der virtuellen Umgebung</strong>: Das Modul ist in einer anderen Umgebung installiert.  
➝ Fix: Aktivieren Sie die richtige Umgebung, bevor Sie das Skript ausführen.</span></li>
</ul>

<h2><span style="font-family: Roboto;">6. Überprüfen installierter Module</span></h2>


```bash
pip list        # Shows installed modules
pip show numpy  # Details about a specific module

Wenn Sie wissen, wie man Module importiert und verwaltet, können Sie die Funktionalität von Python weit über die Kernfunktionen hinaus erweitern.

Grundlegende Dateimethoden

Die integrierte Funktion open() gibt ein Dateiobjekt zurück, das Sie zum Lesen oder Schreiben von Dateien auf der Festplatte verwenden können. Der Modus bestimmt die zulässigen Aktionen: 'r' (Lesen, Standard), 'w' (Schreiben, Überschreiben), 'a' (Anhängen). Durch das Öffnen einer Datei werden selbst keine Daten gelesen oder geschrieben – Sie müssen die unten gezeigten Dateimethoden aufrufen. Schließen Sie Dateien immer, wenn Sie fertig sind (oder verwenden Sie vorzugsweise einen Kontextmanager).

Modi – kurze Beispiele

python
# implicit read mode (same as 'r')
f = open("example.txt")
f.close()

# explicit read
f = open("example.txt", "r")
f.close()

# open for writing (will overwrite)
f = open("output.txt", "w")
f.write("line 1\n")
f.close()

# open for appending (adds to end)
f = open("output.txt", "a")
f.write("another line\n")
f.close()

.read() – gesamten Inhalt lesen

read() gibt den Rest der Datei als einzelne Zeichenfolge zurück. Bei erneutem Aufruf bereits am Ende wird ein leerer String zurückgegeben.

python
f = open("notes.txt", "r", encoding="utf-8")
all_text = f.read()
print(len(all_text))   # number of characters read
more = f.read()        # already at EOF → returns ''
print(repr(more))      # shows ''
f.close()

.readline() – liest die nächste Zeile

readline() gibt die nächste Zeile zurück (einschließlich der abschließenden neuen Zeile, falls vorhanden). Durch wiederholtes Aufrufen wird die Datei durchlaufen. Ein size-Argument (z. B. readline(50)) begrenzt die Anzahl der zurückgegebenen Zeichen – es wählt nicht die „n-te Zeile“ aus.

python
f = open("notes.txt", "r", encoding="utf-8")
first = f.readline()
second = f.readline()
print("First:", first)
print("Second:", second)
# to get the 3rd line specifically, iterate 3 times or use itertools.islice
f.close()
```<h2><span style="font-family: Roboto;">.readlines() – alle Zeilen als Liste abrufen</span></h2>
<p><span style="font-family: Roboto;">
<code>readlines()</code> gibt eine Liste zurück, in der jedes Element eine Zeile aus der Datei ist (einschließlich Zeilenumbruchzeichen). Bei sehr großen Dateien mit Vorsicht verwenden.
</span></p>


```python
f = open("notes.txt", "r", encoding="utf-8")
lines = f.readlines()
print("Number of lines:", len(lines))
print("Line 0:", lines[0])
f.close()

.write() – Zeichenfolgen in eine Datei schreiben

write() erfordert eine Zeichenfolge. Konvertieren Sie andere Typen mit str(). Das Verhalten (Überschreiben oder Anhängen) hängt vom Modus ab, der beim Öffnen der Datei verwendet wird.

python
# overwrite file
f = open("results.txt", "w", encoding="utf-8")
f.write("score: " + str(42) + "\n")
f.close()

# append
f = open("results.txt", "a", encoding="utf-8")
f.write("score: " + str(100) + "\n")
f.close()

.close() und Best Practice

close() gibt das Dateihandle frei und stellt sicher, dass gepufferte Daten auf die Festplatte geschrieben werden. Wenn Sie vergessen, das Programm zu schließen, können andere Programme blockiert werden oder Daten verloren gehen. Das empfohlene Muster ist der Kontextmanager, der automatisch geschlossen wird.

python
# manual close (works but easy to forget on errors)
f = open("data.txt", "r", encoding="utf-8")
try:
    content = f.read()
finally:
    f.close()

# preferred: context manager (automatic close)
with open("data.txt", "r", encoding="utf-8") as f:
    for line in f:
        process(line.rstrip("\n"))
# file is closed here automatically

Kleine Praxisbeispiele

python
# Example: copy a file line-by-line (memory-friendly)
with open("source.txt", "r", encoding="utf-8") as src, \
     open("copy.txt", "w", encoding="utf-8") as dst:
    for line in src:
        dst.write(line)

# Example: read the 3rd line safely
from itertools import islice
with open("notes.txt", "r", encoding="utf-8") as f:
    third_line = next(islice(f, 2, 3), "")  # returns "" if missing
```<h2><span style="font-family: Roboto;">Häufige Fehler und schnelle Lösungen</span></h2>
<ul>
<li><span style="font-family: Roboto;"><strong>FileNotFoundError</strong>: Überprüfen Sie den Pfad oder verwenden Sie einen absoluten Pfad.</span></li>
<li><span style="font-family: Roboto;"><strong>PermissionError</strong>: Stellen Sie sicher, dass Sie über Schreib-/Leseberechtigungen für den Zielordner verfügen.</span></li>
<li><span style="font-family: Roboto;"><strong>UnicodeDecodeError</strong>: Geben Sie die richtige <code>Kodierung</code> an (z. B. <code>"utf-8"</code>, <code>"latin-1"</code>) oder im Binärmodus öffnen <code>"rb"</code> für Rohbytes.</span></li>
</ul>

NumPy – Installieren und Importieren

NumPy ist das Kernpaket für numerische Berechnungen in Python (Arrays, schnelle Mathematik, lineare Algebra). Installieren Sie es mit pip oder Ihrem Paketmanager und importieren Sie es dann (herkömmlich als np).

Installieren

shell
# with pip
pip install numpy

# or with conda
conda install numpy

Import

python
import numpy as np
# now use np.array, np.linspace, np.zeros, ...

Häufige Fallstricke

Stellen Sie sicher, dass Sie in derselben Python-Umgebung installieren, die Sie ausführen (Probleme mit Virtualenv/Conda Env).
Der Import als etwas anderes als np ist erlaubt, aber ungewöhnlich – andere Leute erwarten np.

NumPy-Arrays – Erstellen, Indizieren, Slice

NumPy-Arrays sind wie Listen, jedoch mit festen numerischen Typen und schnellen vektorisierten Operationen. Sie können Listen konvertieren, verschachtelte (2D-)Arrays erstellen und diese indizieren/slicen.

Aus Listen erstellen

python
import numpy as np

a = np.array([1, 2, 3, 4])            # 1D array
b = np.array([[1, 2, 3], [4, 5, 6]])  # 2D array
print(a.shape)   # (4,)
print(b.shape)   # (2, 3)

Indizierung (1D und 2D)

python
print(a[0])      # first element -> 1
print(b[1, 2])   # second row, third column -> 6
print(b[0][1])   # alternative syntax -> 2

Slicing

python
c = np.arange(10)       # array([0,1,2,...,9])
print(c[1:5])             # [1 2 3 4]
print(b[0:2, 1:3])        # rows 0..1 and cols 1..2 (2x2 subarray)

Häufige Fallstricke

NumPy-Arrays erfordern einen einheitlichen dtype – gemischte Python-Objekte führen zu dtype=object.
Slices sind **Ansichten**, keine Kopien – das Ändern eines Slice kann das ursprüngliche Array ändern.

Array-Form und die Eigenschaft `.shape`

.shape gibt ein Tupel mit der Größe jeder Dimension zurück. Es handelt sich um eine Eigenschaft (keine Klammern).

Beispiele

python
import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array([[1,2,3],[4,5,6]])

print(a.shape)   # (4,)
print(b.shape)   # (2, 3)

# reshape if needed
c = a.reshape((2,2))
print(c.shape)   # (2, 2)

Häufige Fallstricke

Der Aufruf von .shape() mit Klammern ist falsch – es ist eine Eigenschaft, keine Funktion.
reshape erfordert Größen, die sich mit der gleichen Anzahl von Elementen multiplizieren (oder verwenden Sie -1 für automatische Schlussfolgerung).

NumPy – Grundfunktionen (Linspace, Nullen, Zufall, ...)

NumPy bietet praktische Konstruktoren und Helfer für häufig verwendete Arrays und Sequenzen.

Gemeinsame Konstruktoren

python
import numpy as np

# even spacing: start, stop, num-values
x = np.linspace(0, 1, num=5)    # [0.  0.25 0.5  0.75 1. ]

# zeros with shape / dtype
Z = np.zeros((2,3), dtype=float)  # 2x3 array of zeros

# arange like Python range -> integers
r = np.arange(0, 10, 2)           # [0 2 4 6 8]

Zufallszahlen

python
# modern usage (numpy >= 1.17) prefers Generator, but simple forms below:
rand = np.random.rand(3)       # 3 uniform floats in [0,1)
rnorm = np.random.randn(3)     # 3 standard normal samples
rint = np.random.randint(0, 10, size=4)  # 4 ints in [0,10)

Datentypverhalten

python
a = np.array([1, 2, 3], dtype=int)
a[0] += 0.2
print(a)  # still integer array; fractional part lost (a[0] remains 1)

Wenn ein Array einen ganzzahligen D-Typ hat, werden direkte Vorgänge in diesen D-Typ umgewandelt (mögliche Kürzung).
Um Floats zuzulassen, erstellen Sie das Array mit dtype=float oder konvertieren Sie es mit .astype().

Matplotlib – Installieren und Importieren

Matplotlib ist die Standard-Plotbibliothek für Python. Installieren Sie es mit Ihrem Paketmanager und importieren Sie das Pyplot-Modul (üblicherweise als plt).

Installieren

shell
# with pip
pip install matplotlib

# or with conda
conda install matplotlib

Import

python
import matplotlib.pyplot as plt
# optionally import numpy for data
import numpy as np

Häufige Fallstricke

Installation in der aktiven Umgebung (virtualenv/conda), die von Ihrem Skript oder Notebook verwendet wird.
In einigen Umgebungen (z. B. Headless-Servern) benötigen Sie möglicherweise ein nicht interaktives Backend, um Zahlen zu speichern.

Matplotlib – Grundlegende Verwendung (plt.plot, plt.show, speichern)

Einfacher Plot-Workflow: Daten erstellen, Plotfunktionen aufrufen und dann die Abbildung anzeigen oder speichern.

Einfaches Liniendiagramm

python
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)

plt.plot(x, y)       # plot the line
plt.show()           # display the plot window (or inline in notebooks)

Mehrere Serien und Speichern

python
plt.plot(x, np.sin(x), label='sin')
plt.plot(x, np.cos(x), label='cos')
plt.legend()
plt.savefig('sincos.png')  # save to file
plt.show()

Häufige Fallstricke

Rufen Sie plt.show() auf, nachdem Sie den Plot konfiguriert haben – andernfalls rendern einige Backends möglicherweise nicht den vollständigen Stil.
Wenn Sie mehrere Figuren zeichnen, verwenden Sie plt.figure() oder fig, ax = plt.subplots(), um sie getrennt zu halten.

Matplotlib – Modifikatoren und Stil (Titel, Legende, Achsen, Aspekt)

Verwenden Sie Beschriftungen, Grenzwerte, Legenden und Achsenmethoden, um das Erscheinungsbild und Layout von Diagrammen anzupassen.

Beschriftungen, Titel, Legende

python
plt.plot(x, np.sin(x), label='sin')
plt.plot(x, np.cos(x), label='cos')
plt.xlabel('x (rad)')
plt.ylabel('value')
plt.title('Sine & Cosine')
plt.legend()  # show labels in top-right by default
plt.show()

Achsengrenzen und -aspekt

python
plt.plot([0,1,2], [0,1,4])
plt.xlim(0, 2)        # set x limits
plt.ylim(0, 5)        # set y limits

ax = plt.gca()        # get current Axes
ax.set_aspect('equal')   # equal scaling for x and y units
plt.show()

Achsen oder Häkchen ausblenden

python
ax = plt.gca()
ax.xaxis.set_visible(False)   # hide x-axis
ax.yaxis.set_visible(False)   # hide y-axis

Häufige Fallstricke

Das Ändern der Achseneigenschaften erfordert ein Axes-Objekt (von plt.gca() oder die Rückgabe von plt.subplots()).
Viele Stiloptionen gelten für die aktuelle Figur/Achsen – rufen Sie sie in der richtigen Reihenfolge auf oder erstellen Sie eine neue Figur für separate Diagramme.

Erweiterte Python-Konzepte

Über die Grundlagen hinaus bietet Python viele erweiterte Funktionen zum Schreiben prägnanter, effizienter und robuster Codes. Themen wie Listenverständnis, Generatoren und Ausnahmebehandlung können Ihnen dabei helfen, Ihre Programmierkenntnisse auf die nächste Stufe zu heben.

1. Listenverständnisse

Listenverständnisse bieten eine prägnante Möglichkeit, Listen zu erstellen. Sie können in vielen Fällen Schleifen ersetzen:

python
# Traditional loop
squares = []
for i in range(10):
    squares.append(i ** 2)

# Using list comprehension
squares = [i ** 2 for i in range(10)]
print(squares)

2. Ausnahmebehandlung

Verwenden Sie Try-Except-Blöcke, um Fehler und Ausnahmen ordnungsgemäß zu behandeln:

python
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")
else:
    # is executed if try did not work
    # and the exception is not the same as in except
    print("Not execute but no ZeroDivisionError.")
finally:
    # is always executed
    print("Execution complete.")
    # Outputs an error message 
    # and a final execution statement

3. Generatoren

Generatoren ermöglichen Ihnen eine effiziente Iteration über große Datensätze, ohne die gesamte Sequenz im Speicher zu speichern:

python
def count_up_to(n):
    count = 1
    while count <= n:
        yield count
        count += 1

for number in count_up_to(5):
    print(number)
    # Outputs: 1 2 3 4 5

Das Erkunden dieser fortgeschrittenen Themen kann Ihre Python-Programmierfähigkeiten erheblich verbessern.

Willkommen bei Python

Einführung in Python

Schritt 1: Python herunterladen und installieren

Schritt 2: Wählen Sie eine IDE oder einen Code-Editor

Schritt 3: Schreiben Sie Ihr erstes Python-Skript und führen Sie es aus

Syntax von Python

1. Python-Einrückung (keine geschweiften Klammern für Blöcke)

Richtiges Beispiel:

Falsches Beispiel (löst Einrückungsfehler aus):

2. Nullbasierte Indizierung

Beispiel:

Falsches Beispiel (IndexError):

3. Kommentare in Python

Einzeiliger Kommentar:

Mehrzeiliger Kommentar:

4. Groß- und Kleinschreibung

Beispiel:

Falsches Beispiel:

5. Variablen und dynamische Typisierung

Beispiel:

Verschiedene Datentypen neu zuweisen:

Fazit

print

1. Grundlegende print() Verwendung

2. Verwendung des Parameters sep

4. Drucken von Variablen

5. Sonderzeichen drucken

Binäre Operationen in Python

1. Arithmetische Operatoren

Beispiele:

2. Vergleichsoperatoren

Beispiele:

3. Logische Operatoren

Beispiele:

4. Bitweise Operatoren

Beispiele:

5. Zuweisungsoperatoren

Beispiele:

Ganzzahlen

1. Ganzzahlen erstellen

2. Ganzzahlige Operationen

3. Typkonvertierung

Floats

1. Floats erstellen

2. Float-Operationen

3. Typkonvertierung

Strings

1. Strings erstellen

2. String-Operationen

3. String-Methoden

String-Funktionen

Trimmen mit .strip()

Strings aufteilen

Text ersetzen

Strings verbinden

Häufige Fallstricke

String-Formatierung und Groß-/Kleinschreibungsmethoden

Formatierung mit .format()

Fallkonvertierung

Partitionierungszeichenfolgen

Häufige Fallstricke

Listen

1. Erstellen einer Liste

2. Zugreifen auf und Ändern von Listen

3. Listenverständnisse

Indexierungslisten

Grundlegende Indexierung

Elemente über Index ändern

Häufige Fallstricke

Slicing-Listen

Grundlegendes Slicing

Eine Liste umkehren

Häufige Fallstricke

Listenspezifische Funktionen und Methoden

Gemeinsame Methoden

Andere nützliche Methoden

Eingebaute Funktionen für Listen

Arbeiten mit mehreren Listen

Häufige Fallstricke

1. Grundlegende `print()` Verwendung

2. Verwendung des Parameters `sep`

Trimmen mit `.strip()`

Formatierung mit `.format()`

`for`-Schleife (Grundlagen)

Zählen mit `range()`

Verwenden von `break` und `continue`

`while`-Schleife (Grundlagen)

Vorzeitiges Stoppen mit `break`

Überspringen von Iterationen mit `continue`

Schleifenkontrollanweisungen: `break`, `continue` und `pass`

`break` – Verlassen einer Schleife

`continue` – Überspringen einer Iteration

`pass` – Platzhalteranweisung

Verschachtelt `while`

Array-Form und die Eigenschaft `.shape`