Cheatsheet Python

Alles Wichtige auf einen Blick: Grundlagen, Ausgabe, Kontrollstrukturen, Listen, Funktionen und Dateien.

Allgemeine Funktionen

`input("Text")`	Benutzereingabe, liefert immer str
`print(a, b, sep=" ", end="\n")`	Ausgabe
`min()`, `max()`	kleinster / größter Wert
`round(x, n)`	auf n Nachkommastellen runden
`abs(x)`	Betrag
`len(x)`	Länge von Text oder Liste
`type(x)`	Datentyp

Operatoren

`+ -` `* /`	Strich- und Punktrechnung
`//`	ganzzahlige Division
`%`	Rest (Modulo)
`**`	Potenz, `x ** 0.5` = Wurzel
`import math`	`math.pi`, `math.sqrt(x)`
`import random`	`random.randint(1, 6)`, `random.choice(l)`
`random.seed(1)`	Zufall wiederholbar machen (gleiche Zahlen bei jedem Start)

Datentypen umwandeln

`int()`	ganze Zahl
`float()`	Kommazahl
`str()`	Text
`bool()`	Wahrheitswert
`list()`	Liste

Vergleiche und Logik

`==` `!=`	gleich, ungleich
`< > <= >=`	kleiner, größer, …
`and` `or` `not`	und, oder, nicht
`x in liste`	enthalten?

Verzweigung

if bedingung:
    ...
elif andere_bedingung:
    ...
else:
    ...

Schleifen

while bedingung:
    ...

for i in range(start, stop, schritt):
    ...

break      # Schleife verlassen
continue   # nächster Durchlauf

Struktogramm

n = int(input("n: "))
for i in range(1, n + 1):
    if i % 2 == 0:
        print(i, "gerade")
    else:
        print(i, "ungerade")
print("fertig")

Eingabe: n

für i von 1 bis n

i % 2 == 0 ?janein

Ausgabe: i, "gerade"

Ausgabe: i, "ungerade"

Ausgabe: "fertig"

Rechteck = Anweisung, Ein- oder Ausgabe · Winkel links = Schleife (der eingerückte Teil wird wiederholt) · Dreieck = Verzweigung mit ja- und nein-Spalte. Gelesen wird von oben nach unten.

PAP (Programmablaufplan)

n = int(input("n: "))
i = 1
while i <= n:
    print(i)
    i = i + 1

Oval = Start/Ende · Parallelogramm = Ein-/Ausgabe · Rechteck = Anweisung · Raute = Bedingung (ja/nein) · Pfeile zeigen den Ablauf. Eine Schleife ist ein Pfeil, der zurück vor die Raute führt.

Formatierte Ausgabe

`f"{x}"`	Wert einsetzen
`f"{x:.2f}"`	2 Nachkommastellen
`f"{x:8.2f}"`	8 Zeichen breit
`f"{t:<10}"` `f"{t:>10}"`	links / rechts
`f"{n:03d}"`	mit Nullen: 007

Beispiel: eine ganze Zeile

name = "Mia"
menge = 2
preis = 3.5
print(f"{name:<8}{menge:>3} x {preis:6.2f} €")

Ausgabe (· = Leerzeichen):

Mia·······2·x···3.50·€

Mia·····	`{name:<8}` 8 Zeichen breit, linksbündig
··2	`{menge:>3}` 3 Zeichen breit, rechtsbündig
·x·	Text aus dem f-String, genau so
··3.50	`{preis:6.2f}` 6 Zeichen breit, 2 Nachkommastellen (Punkt zählt mit)

sep und end

print("A", "B", "C")
print("A", "B", "C", sep=" | ")
print("A", "B", "C", sep="")
print("Lade", end="")
print("...", end=" ")
print("fertig")

Ausgabe (· = Leerzeichen):

A·B·C A·|·B·|·C ABC Lade...·fertig

sep steht zwischen den Werten (Standard: ein Leerzeichen). end steht am Ende (Standard: Zeilenumbruch). Mit end="" geht die nächste Ausgabe in derselben Zeile weiter.

Zeichenketten

`t[0]`, `t[-1]`	erstes, letztes Zeichen
`t[1:4]`, `t[::-1]`	Ausschnitt, rückwärts
`t.upper()` `t.lower()`	groß / klein
`t.strip()` `t.split(";")`	Rand säubern, zerlegen
`t.replace(a, b)` `t.count(a)`	ersetzen, zählen
`t.find("x")`	Position suchen, −1 = nicht gefunden
`t.startswith("ab")` `t.endswith(".de")`	beginnt mit … / endet mit …? True/False
`t.capitalize()` `t.title()`	ersten Buchstaben groß / jedes Wort groß
`t.center(10, "*")`	mittig in fester Breite
`z.isdigit()` `z.isalpha()`	Ziffer? Buchstabe? True/False
`z.isupper()` `z.islower()`	Großbuchstabe? Kleinbuchstabe?
`ord("A")`	Zeichen → Nummer: `65`
`chr(65)`	Nummer → Zeichen: `"A"` (`chr(ord("A") + 1)` = `"B"`)
`"-".join(liste)`	Texte einer Liste mit „-“ zusammenkleben

Listen

`l = [3, 1, 2]`	anlegen
`l.append(x)`	anhängen
`l.insert(0, x)`	an Position einfügen
`l.remove(x)` `l.pop()`	entfernen
`l.index(x)`	Position von x
`sum(l)` `sorted(l)` `l.sort()`	Summe, sortieren
`for x in l:`	durchlaufen
`for i, x in enumerate(l):`	Position und Wert zugleich
`for a, b in zip(l1, l2):`	zwei Listen im Gleichschritt

Wörterbücher

`d = {"a": 1}`	anlegen
`d["b"] = 2`	hinzufügen / ändern
`d.get(k, 0)`	Wert oder Standard
`for k, v in d.items():`	durchlaufen
`d.keys()` `d.values()`	alle Schlüssel / alle Werte

Tupel und Mengen

`p = (3, 4)`	Tupel: wie eine Liste, aber unveränderlich
`x, y = p`	entpacken
`m = set(l)`	Menge: jeder Wert nur einmal
`m.add(x)`	Wert zur Menge hinzufügen
`a \| b` `a & b` `a - b`	Vereinigung, Schnitt, Differenz

Funktionen

def flaeche(a, b):
    return a * b

x = flaeche(3, 4)

`def f(x, n=2):`	Parameter mit Standardwert: `f(5)` oder `f(5, 3)`
`return a, b`	zwei Werte zurückgeben: `x, y = f()`
`print` ≠ `return`	ohne `return` liefert die Funktion `None`
lokale Variable	gilt nur innerhalb der Funktion
`def fak(n): if n == 0: return 1 return n * fak(n - 1)`	Rekursion: Funktion ruft sich selbst auf, braucht ein Ende

Dateien

with open("d.txt", encoding="utf-8") as d:
    for zeile in d:
        print(zeile.strip())

with open("d.txt", "w") as d:   # "a" = anhängen
    d.write("Text\n")

`d.read()`	ganze Datei als ein Text
`d.readline()`	nur die nächste Zeile
`d.readlines()`	alle Zeilen als Liste

Fehler abfangen

try:
    x = int(input("Zahl: "))
except ValueError:
    print("keine Zahl")
else:
    print("ok")      # nur ohne Fehler
finally:
    print("immer")

`raise ValueError("Text")`	selbst einen Fehler auslösen
`except Exception as e:`	jeden Fehler abfangen, `e` = Meldung
`ValueError`	falscher Wert, z. B. `int("abc")`
`ZeroDivisionError`	durch 0 geteilt
`IndexError`	Position gibt es nicht: `l[10]`
`KeyError`	Schlüssel fehlt im Wörterbuch
`TypeError`	falscher Typ, z. B. `"5" + 5`
`NameError`	Variable gibt es (noch) nicht
`FileNotFoundError`	Datei nicht gefunden
`AttributeError`	Methode oder Attribut gibt es nicht
`SyntaxError`	Schreibfehler im Code (Doppelpunkt, Klammer …)
`RecursionError`	Rekursion ohne Ende

Testen

`assert f(3) == 6`	Test: stimmt das nicht, kommt `AssertionError`
`assert abs(x - 0.3) < 1e-9`	Kommazahlen fast gleich vergleichen
Testfälle	normal, Grenze (0, leer, gleich), negativ, falsche Eingabe
`print("x =", x)`	Zwischenwerte anzeigen (Debuggen)

Klassen

class Konto:
    def __init__(self, name):
        self.name = name
        self.stand = 0
    def einzahlen(self, betrag):
        self.stand = self.stand + betrag
    def __str__(self):
        return f"{self.name}: {self.stand} €"

k = Konto("Lea")
k.einzahlen(20)
print(k)

`__init__(self, …)`	wird beim Erzeugen aufgerufen, legt Attribute an
`self.x`	Attribut des Objekts
`__str__(self)`	was `print(objekt)` anzeigt
`class Hund(Tier):`	Vererbung: Hund kann alles, was Tier kann
`super().__init__(name)`	Konstruktor der Oberklasse aufrufen

Typische Fehler: Doppelpunkt vergessen · Einrückung falsch · = statt == · input() nicht umgewandelt · Index beginnt bei 0 · range(1, 10) endet bei 9.

`==` `!=`	equal, not equal
`< > <= >=`	less than, greater than, …
`and` `or` `not`	and, or, not
`x in items`	contained?

`t[0]`, `t[-1]`	first, last character
`t[1:4]`, `t[::-1]`	slice, reversed
`t.upper()` `t.lower()`	uppercase / lowercase
`t.strip()` `t.split(";")`	trim the edges, split
`t.replace(a, b)` `t.count(a)`	replace, count
`t.find("x")`	find position, −1 = not found
`t.startswith("ab")` `t.endswith(".org")`	starts with … / ends with …? True/False
`t.capitalize()` `t.title()`	first letter uppercase / every word uppercase
`t.center(10, "*")`	centered in a fixed width
`z.isdigit()` `z.isalpha()`	digit? letter? True/False
`z.isupper()` `z.islower()`	uppercase letter? lowercase letter?
`ord("A")`	character → number: `65`
`chr(65)`	number → character: `"A"` (`chr(ord("A") + 1)` = `"B"`)
`"-".join(items)`	glue the strings of a list together with “-”

`p = (3, 4)`	tuple: like a list, but can't be changed
`x, y = p`	unpack
`m = set(l)`	set: each value only once
`m.add(x)`	add a value to the set
`a \| b` `a & b` `a - b`	union, intersection, difference

`def f(x, n=2):`	parameter with a default value: `f(5)` or `f(5, 3)`
`return a, b`	return two values: `x, y = f()`
`print` ≠ `return`	without `return` the function returns `None`
local variable	only exists inside the function
`def fact(n): if n == 0: return 1 return n * fact(n - 1)`	recursion: a function calls itself, needs a stopping point

`assert f(3) == 6`	test: if it's false, you get `AssertionError`
`assert abs(x - 0.3) < 1e-9`	compare decimal numbers as almost equal
test cases	normal, edge (0, empty, equal), negative, wrong input
`print("x =", x)`	show values along the way (debugging)

`input("Text")`	user input, always returns str
`print(a, b, sep=" ", end="\n")`	output
`min()`, `max()`	smallest / largest value
`round(x, n)`	round to n decimal places
`abs(x)`	absolute value
`len(x)`	length of a string or list
`type(x)`	data type

`+ -` `* /`	add/subtract, multiply/divide
`//`	integer division
`%`	remainder (modulo)
`**`	power, `x ** 0.5` = square root
`import math`	`math.pi`, `math.sqrt(x)`
`import random`	`random.randint(1, 6)`, `random.choice(l)`
`random.seed(1)`	make randomness repeatable (same numbers every run)

`int()`	integer
`float()`	decimal number
`str()`	string
`bool()`	Boolean
`list()`	list

`f"{x}"`	insert a value
`f"{x:.2f}"`	2 decimal places
`f"{x:8.2f}"`	8 characters wide
`f"{t:<10}"` `f"{t:>10}"`	left / right
`f"{n:03d}"`	with zeros: 007

Mia·····	`{name:<8}` 8 characters wide, left-aligned
··2	`{amount:>3}` 3 characters wide, right-aligned
·x·	text from the f-string, exactly as written
··3.50	`{price:6.2f}` 6 characters wide, 2 decimal places (the point counts too)

`l = [3, 1, 2]`	create
`l.append(x)`	append
`l.insert(0, x)`	insert at a position
`l.remove(x)` `l.pop()`	remove
`l.index(x)`	position of x
`sum(l)` `sorted(l)` `l.sort()`	sum, sort
`for x in l:`	loop through
`for i, x in enumerate(l):`	position and value at the same time
`for a, b in zip(l1, l2):`	two lists in step

`d.read()`	whole file as one string
`d.readline()`	only the next line
`d.readlines()`	all lines as a list

`raise ValueError("Text")`	raise an error yourself
`except Exception as e:`	catch any error, `e` = message
`ValueError`	wrong value, e.g. `int("abc")`
`ZeroDivisionError`	divided by 0
`IndexError`	position doesn't exist: `l[10]`
`KeyError`	key missing from the dictionary
`TypeError`	wrong type, e.g. `"5" + 5`
`NameError`	variable doesn't exist (yet)
`FileNotFoundError`	file not found
`AttributeError`	method or attribute doesn't exist
`SyntaxError`	typo in the code (colon, parenthesis …)
`RecursionError`	recursion without an end

`__init__(self, …)`	called when the object is created, sets up attributes
`self.x`	attribute of the object
`__str__(self)`	what `print(obj)` shows
`class Dog(Animal):`	inheritance: Dog can do everything Animal can
`super().__init__(name)`	call the constructor of the parent class