Python Tutorial für Data Science: Grundlagen: Syntax-Essentials

Lernziele

• Du verstehst die wichtigsten Bausteine einer Programmiersprache (Anweisungen, Ausdrücke, Variablen).
• Du kannst einfache Bedingungen (if/elif/else) und Schleifen (for/while) schreiben.
• Du weißt, wie man Funktionen definiert und aufruft (inkl. *args/**kwargs als Vorgeschmack).
• Du kennst grundlegende Datentypen (Zahlen, Text, Wahrheitswerte) und Operatoren.

0) Grundbegriffe (kurz & klar)

• Programm: Eine Folge von Anweisungen, die der Computer nacheinander ausführt.
• Interpreter: Das Programm (hier: Python), das deinen Code Zeile für Zeile ausführt.
• Anweisung (Statement): Eine vollständige „Handlungsanweisung“, z. B. print("Hi").
• Ausdruck (Expression): Ein Stück Code, das zu einem Wert ausgewertet wird, z. B. 2 + 3.
• Variable: Ein „benannter Speicherplatz“ für Werte, z. B. alter = 30.
• Datentyp: Die „Art“ eines Werts, z. B. Zahl, Text, Wahrheitswert.
• Kommentar: Text, den Menschen lesen, den Python ignoriert. Beginnt mit #.
• Einrückung: Leerzeichen am Zeilenanfang. In Python markieren Einrückungen Codeblöcke – sehr wichtig!
• Block: Zusammengehöriger Code, z. B. der Teil unter einer if-Zeile.
• Funktion: Benannter, wiederverwendbarer Code-Block, den du aufrufen kannst.
• Parameter/Argumente: Platzhalter im Funktionskopf / konkrete Werte beim Aufruf.
• Return-Wert: Der Wert, den eine Funktion „zurückgibt“ (mit return).
• Boolean (Wahrheitswert): Entweder True oder False.
• Operator: Symbol/Schlüsselwort für eine Operation, z. B. +, -, ==, and.
• Vergleichsoperator: Prüft Beziehungen, z. B. >, <, ==, !=.

1) Erste Zeilen Code: Ausgeben & Kommentieren

• Text ausgeben: Mit print(...) schreibst du etwas in die Konsole.
• Kommentar: Alles hinter # wird nicht ausgeführt (nur für Menschen).

# Das hier ist ein Kommentar – Python ignoriert ihn.
print("Hallo Data Science!")  # Gibt Text aus

2) Werte & Datentypen

• Zahlen: Ganzzahlen (int) wie 42 und Kommazahlen (float) wie 3.14.
• Text (String): Zeichenketten in Anführungszeichen, z. B. "Berlin" oder 'DS'.
• Wahrheitswerte (Boolean): True oder False.

ganzzahl = 42            # int
kommazahl = 3.14         # float
text = "Data Science"    # str
ist_gross = True         # bool

Tipp – f-Strings: Eine bequeme Art, Texte mit Werten zu verbinden.

name = "Alex"
punkte = 95
print(f"{name} hat {punkte} Punkte.")  # Alex hat 95 Punkte.

3) Variablen & Zuweisung

• Zuweisung: = speichert rechtsstehenden Wert in der linken Variable.
• Benennung: Kleinbuchstaben_und_unterstriche sind üblich, z. B. gesamt_summe.

gesamt_summe = 10 + 5
stadt = "Köln"
print(gesamt_summe, stadt)

4) Rechnen & Vergleiche

• Arithmetik: + - * / // % **
  • //: Ganzzahl-Division, %: Rest, **: Potenz.
• Vergleiche: == != > < >= <= → liefern True/False.

a, b = 7, 3
print(a + b)     # 10
print(a ** b)    # 343
print(a > b)     # True
print(a == 7)    # True

5) Logik mit Booleans

• Logische Operatoren: and, or, not
  • A and B ist nur True, wenn beide True sind.
  • A or B ist True, wenn mindestens eins True ist.

alter = 19
hat_ticket = True
darf_rein = (alter >= 18) and hat_ticket
print(darf_rein)  # True

6) Bedingungen: if, elif, else

• Bedingung: Steuert, ob ein Block ausgeführt wird.
• Doppelpunkt : und Einrückung sind Pflicht.

punktzahl = 72

if punktzahl >= 90:
    print("Note: Sehr gut")
elif punktzahl >= 75:
    print("Note: Gut")
else:
    print("Note: Ausreichend")

Merke: Jeder Block (der eingerückte Teil) gehört zur jeweiligen Zeile mit Doppelpunkt.

7) Schleifen: Wiederholen leicht gemacht

7.1 for mit range

• Schleife: Führt einen Block mehrfach aus.
• range(n) erzeugt die Zahlen 0 bis n-1.

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

7.2 while

• Läuft, solange die Bedingung True ist.
• Vorsicht: Achte, dass die Bedingung irgendwann False wird (sonst Endlosschleife).

count = 3
while count > 0:
    print("Tick")
    count = count - 1
print("Boom!")

8) Sequenzen: Listen & Tupel (Basics)

• Liste: Verändertbar, eckige Klammern [].
• Tupel: Unveränderbar, runde Klammern ().

zahlen = [10, 20, 30]     # Liste
punkte = (3, 6, 9)        # Tupel

print(zahlen[0])          # 10 (Index beginnt bei 0)
zahlen.append(40)         # [10, 20, 30, 40]

# Slicing: Teilstücke herausschneiden
print(zahlen[1:3])        # [20, 30]

9) Kurz & elegant: List Comprehension

• List Comprehension: Kompakte Schreibweise, um Listen zu erzeugen.

quadrate = [i ** 2 for i in range(6)]
print(quadrate)  # [0, 1, 4, 9, 16, 25]

Begriff: Comprehension bedeutet „zusammengefasste Schreibweise“ für „Schleife + Anfügen“.

10) Funktionen definieren & aufrufen

• Funktion: Kapselt Logik, vermeidet Wiederholungen.
• Parameter: Namen im Funktionskopf.
• Argumente: Werte beim Aufruf.
• return: Liefert einen Wert an die Aufruferstelle zurück.

def addiere(a, b):
    # a und b sind Parameter
    ergebnis = a + b
    return ergebnis  # gibt ergebnis zurück

summe = addiere(2, 3)     # 2 und 3 sind Argumente
print(summe)              # 5

10.1 Vorgeschmack: *args und **kwargs

• *args sammelt beliebig viele positionale Argumente als Tupel.
• **kwargs sammelt benannte Argumente als Dictionary (Schlüssel-Wert-Paare).

def zeige_args(*args):
    print(args)

def zeige_kwargs(**kwargs):
    for k, v in kwargs.items():
        print(k, "→", v)

zeige_args(1, 2, 3)                   # (1, 2, 3)
zeige_kwargs(name="Mia", punkte=88)   # name → Mia \n punkte → 88

Keine Sorge: Wir vertiefen *args/**kwargs später im Kurs, hier nur als „Vokabel“.

11) Fehler verstehen: Tracebacks

• Fehler (Exception): Tritt auf, wenn etwas Unerlaubtes passiert (z. B. Teilen durch 0).
• Traceback: Die Fehlermeldung zeigt wo es krachte und warum – sehr hilfreich!

# print(10 / 0)  # ZeroDivisionError: division by zero

12) Stil & gute Gewohnheiten (kurz)

• Einrückung: 4 Leerzeichen pro Ebene.
• Klar benennen: anzahl_kunden statt ak.
• Kleine Funktionen: Lieber mehrere kurze als eine riesige.
• Kommentare sparsam & klar: „Warum“ erklären, nicht „was“ der Code ohnehin zeigt.

Mini-Checkliste (Selbsttest ohne Code)

• Weißt du, was Variablen, Datentypen, Operatoren sind?
• Kannst du eine if/elif/else-Struktur erklären?
• Kannst du mit for + range zählen?
• Weißt du, wie man eine Funktion mit return schreibt?

Praxisübungen (leicht → mittel)

1. Vergleich & Ausgabe
   • Lege x = 12 an.
   • Wenn x > 10, gib "Groß" aus, sonst "Klein".
2. Zählen mit for
   • Gib die Zahlen 0 bis 4 Zeile für Zeile aus.
3. Quadratliste
   • Erzeuge mit List Comprehension die Quadrate von 0 bis 5 und gib die Liste aus.
4. Funktion schreiben
   • Definiere addiere(a, b) und gib die Summe von 2 und 3 aus.
5. *args kurz probieren
   • Definiere summiere(*args), die alle Zahlen addiert und zurückgibt.
   • Teste summiere(1, 2, 3, 4).
6. **kwargs kurz probieren
   • Definiere zeige(**kwargs), die alle Paare key: value ausgibt.
   • Rufe auf mit zeige(stadt="Berlin", jahr=2025).