Funktionen und Module in Python

Eigene Funktionen, Gültigkeitsbereiche, Import und Modulstruktur.

Kernideen

• Parameter werden über die Position oder den Namen zugeordnet; Defaultwerte machen sie optional.
• Ein Defaultwert wird einmal bei der Definition ausgewertet. Ein veränderlicher Default wird deshalb von allen Aufrufen geteilt.
• *args und **kwargs sammeln beliebig viele Argumente ein und packen sie beim Aufruf wieder aus. Das Gegenstück in R ist ....
• Gelesen wird von innen nach aussen, geschrieben wird immer lokal, ausser mit global oder nonlocal.
• Funktionen sind Objekte: Man kann sie übergeben, speichern und aus anderen Funktionen zurückgeben.
• Jede .py-Datei ist ein Modul. if __name__ == "__main__": trennt den ausführbaren Teil vom importierbaren.

Erklärung

Vorwissen: Python-Grundlagen, insbesondere der Unterschied zwischen veränderlichen und unveränderlichen Objekten und die Tatsache, dass ein Name nur ein Verweis ist. Beides erklärt die wichtigste Falle dieses Themas. Weiter geht es mit Objektorientierung in Python.

Wann eine Funktion fällig ist

Die Faustregel: Sobald dieselbe Folge von Schritten ein zweites Mal auftaucht, gehört sie in eine Funktion. Der Grund ist weniger das Tippen als die Korrektur. Steht eine Berechnung dreimal im Skript und stellt sich als falsch heraus, muss man alle drei Stellen finden. Steht sie einmal, genügt eine Änderung. Der zweite Grund ist die Benennung: Eine Funktion mit einem guten Namen macht aus fünf Zeilen eine, die sagt, was passiert.

Aufbau einer Funktion

def kennzahlen(werte, runden=2, einheit="mm"):
    """Mittelwert als Text mit Einheit."""
    mittel = sum(werte) / len(werte)
    return f"{round(mittel, runden)} {einheit}"

Teil	Bedeutung
def	leitet die Definition ein
werte	Pflichtparameter, muss beim Aufruf angegeben werden
runden=2	Parameter mit Defaultwert, darf fehlen
Docstring	die Zeichenkette direkt unter def, erscheint in help(kennzahlen)
return	gibt den Wert zurück; fehlt es, liefert die Funktion None

In R entspricht das kennzahlen <- function(werte, runden = 2, einheit = "mm"). Dort ist der letzte ausgewertete Ausdruck der Rückgabewert, ein return() braucht es nur für einen vorzeitigen Ausstieg.

Wie Argumente zugeordnet werden

Python ordnet zuerst nach Position, dann nach Namen zu. Nach dem ersten benannten Argument darf kein unbenanntes mehr folgen. Ein Name, der in der Definition nicht vorkommt, ist ein Fehler. R ist hier grosszügiger: Es akzeptiert abgekürzte Namen, solange sie eindeutig sind (partial matching). Das spart Tipparbeit und ist eine Fehlerquelle, sobald eine Funktion einen zweiten Parameter mit demselben Anfang bekommt.

Die Falle mit veränderlichen Defaultwerten

Der Defaultwert wird beim Ausführen der def-Zeile erzeugt und an die Funktion gehängt, nicht bei jedem Aufruf neu. Solange er unveränderlich ist (Zahl, Text, Tupel, None), merkt man davon nichts. Ist er eine Liste oder ein Dictionary, teilen sich alle Aufrufe dasselbe Objekt. Der richtige Weg verwendet None als Signal und legt das Objekt im Funktionsrumpf an. R kennt die Falle nicht, weil dort Defaults bei jedem Aufruf neu ausgewertet werden.

Namensräume

Python sucht einen Namen in vier Schichten, von innen nach aussen: Lokal, Einschliessende Funktion, Global (Modul), Built-in. Das heisst LEGB-Regel; R nennt dasselbe Prinzip lexical scoping.

Lesen folgt dieser Kette. Schreiben legt ohne ausdrückliche Erklärung immer einen lokalen Namen an. Wer einen äusseren Namen verändern will, erklärt ihn mit global (Modulebene) oder nonlocal (einschliessende Funktion). In R übernimmt <<- beide Rollen.

Funktionen sind Objekte

Eine Funktion lässt sich einer Variablen zuweisen, an eine andere Funktion übergeben und aus einer zurückgeben. Darauf beruhen map, filter und das Argument key beim Sortieren. lambda ist eine Kurzschreibweise für eine namenlose Funktion mit einem einzigen Ausdruck; für alles Längere ist eine benannte Funktion lesbarer, und für die meisten map-Aufrufe ist eine Comprehension die klarere Wahl.

Vom Skript zum Modul

Sobald eine Datei wächst, lohnt die Aufteilung. Jede .py-Datei ist ein Modul und kann importiert werden. Beim Import wird die Datei einmal von oben nach unten ausgeführt; Definitionen entstehen, aber auch jeder Aufruf auf oberster Ebene läuft. Der Block

if __name__ == "__main__":
    main()

schützt davor: __name__ ist "__main__", wenn die Datei direkt gestartet wird, und der Modulname, wenn sie importiert wird.

Für die Datenarbeit hat sich diese Aufteilung bewährt: Funktionen in ein Modul, das versioniert und getestet wird, und ein Notebook oder Quarto-Dokument, das diese Funktionen aufruft und die Erzählung liefert. So bleibt die Logik prüfbar und das Dokument lesbar.

Kurz nachgeschlagen

Aufgabe	R	Python
Funktion mit Default	f <- function(x, k = 2) x * k	def f(x, k=2): return x * k
beliebig viele Argumente	function(...)	def f(*args, **kwargs):
Argumente aus einer Liste übergeben	do.call(f, liste)	f(*liste), f(**dictionary)
namenlose Funktion	function(x) x^2, kurz \(x) x^2	lambda x: x ** 2
auf jedes Element anwenden	sapply(x, f)	[f(v) for v in x], map(f, x)
äusseren Namen ändern	<<-	global, nonlocal
eigenen Code laden	source("werkzeuge.R")	from werkzeuge import f

Beispiele

Beispiel 1: Position, Name und Default

Frage und Datenlage

Drei Messwerte 12.34, 15.67, 11.02 sollen als Mittelwert mit Einheit ausgegeben werden, einmal mit allen Defaults, dann mit geänderter Rundung, geänderter Einheit, vertauschter Reihenfolge und einem abgekürzten Namen.

Rechnung

R

kennzahlen <- function(werte, runden = 2, einheit = "mm") {
  paste(round(mean(werte), runden), einheit)
}
w <- c(12.34, 15.67, 11.02)

kennzahlen(w)

[1] "13.01 mm"

kennzahlen(w, 1)

[1] "13 mm"

kennzahlen(w, einheit = "cm")

[1] "13.01 cm"

kennzahlen(einheit = "cm", werte = w, runden = 0)

[1] "13 cm"

kennzahlen(w, ein = "cm")      # abgekuerzter Name wird akzeptiert

[1] "13.01 cm"

Python

def kennzahlen(werte, runden=2, einheit="mm"):
    mittel = sum(werte) / len(werte)
    return f"{round(mittel, runden)} {einheit}"

w = [12.34, 15.67, 11.02]

print(kennzahlen(w))

13.01 mm

print(kennzahlen(w, 1))

13.0 mm

print(kennzahlen(w, einheit="cm"))

13.01 cm

print(kennzahlen(einheit="cm", werte=w, runden=0))

13.0 cm

try:
    kennzahlen(w, ein="cm")
except TypeError as fehler:
    print(type(fehler).__name__)

TypeError

Output Zeile für Zeile

Aufruf	Python	R	Erklärung
alle Defaults	13.01 mm	13.01 mm	Mittelwert 13.01, zwei Stellen, Einheit mm.
runden als zweite Position	13.0 mm	13 mm	Nach Position zugeordnet. Python schreibt eine gerundete Gleitkommazahl als 13.0, R lässt die Null weg.
einheit nach Name	13.01 cm	13.01 cm	runden bleibt beim Default, obwohl es in der Definition davor steht.
alles benannt, Reihenfolge vertauscht	13.0 cm	13 cm	Mit Namen spielt die Reihenfolge keine Rolle.
ein="cm"	TypeError	13.01 cm	Python kennt keinen Parameter ein. R ergänzt den eindeutigen Anfang zu einheit.

Interpretation und Ergebnissatz

Benannte Argumente machen einen Aufruf ohne Blick auf die Definition lesbar und unabhängig von der Reihenfolge. Bei mehr als zwei Argumenten sind sie fast immer die bessere Wahl. Das partial matching in R ist bequem, aber zerbrechlich: Bekäme die Funktion einen Parameter einzeln, wäre ein mehrdeutig und der Aufruf bräche ab.

Der Mittelwert der drei Messwerte beträgt 13.01 mm. Ein unbekannter Argumentname wie ein löst in Python einen TypeError aus, während R ihn stillschweigend zu einheit ergänzt.

Beispiel 2: Der geteilte Defaultwert

Frage und Datenlage

Eine Funktion soll einen Wert an eine Liste anhängen und die Liste zurückgeben. Fehlt die Liste, soll eine neue beginnen. Was geschieht bei drei Aufrufen hintereinander?

Rechnung

R

sammeln <- function(wert, bisher = c()) c(bisher, wert)

sammeln(1)

[1] 1

sammeln(2)

[1] 2

sammeln(3)

[1] 3

Python

def sammeln_falsch(wert, bisher=[]):
    bisher.append(wert)
    return bisher

print(sammeln_falsch(1))

[1]

print(sammeln_falsch(2))

[1, 2]

print(sammeln_falsch(3))

[1, 2, 3]

print(sammeln_falsch.__defaults__)     # dort haengt die geteilte Liste

([1, 2, 3],)

def sammeln(wert, bisher=None):
    if bisher is None:
        bisher = []
    bisher.append(wert)
    return bisher

print(sammeln(1))

[1]

print(sammeln(2))

[2]

Output Zeile für Zeile

Aufruf	erwartet	Python falsch	Python richtig	R
erster	[1]	[1]	[1]	1
zweiter	[2]	[1, 2]	[2]	2
dritter	[3]	[1, 2, 3]		3
__defaults__		([1, 2, 3],)

__defaults__ ist das Tupel der Defaultwerte, das an der Funktion hängt. Nach drei Aufrufen steht darin die gefüllte Liste: Der Default ist kein Rezept für eine neue Liste, sondern eine Liste, die bei jedem Aufruf weiterwächst.

Interpretation und Ergebnissatz

Der Fehler ist tückisch, weil der erste Aufruf richtig aussieht und Tests mit einem einzigen Aufruf ihn nie finden. Die Merkregel lautet: Als Defaultwert taugen nur unveränderliche Objekte; alles andere entsteht im Rumpf nach dem Muster if bisher is None: bisher = []. Dieselbe Falle gibt es bei veränderlichen Klassenattributen, siehe Objektorientierung.

Mit dem Default bisher=[] liefert der dritte Aufruf [1, 2, 3] statt [3], weil die Liste bei der Definition einmal erzeugt und dann geteilt wird. Mit None als Default und einer neuen Liste im Rumpf liefert jeder Aufruf eine eigene Liste; in R tritt das Problem nicht auf.

Beispiel 3: Beliebig viele Argumente

Frage und Datenlage

Eine Hilfsfunktion soll eine beliebige andere Funktion aufrufen und vorher protokollieren, womit. Dazu eine Summe über beliebig viele Zahlen und der umgekehrte Weg: Argumente aus einer Liste und einem Dictionary übergeben.

Rechnung

R

protokolliert <- function(funktion, ...) {
  argumente <- list(...)
  cat("rufe mit", length(argumente), "Argumenten:", names(argumente), "\n")
  funktion(...)
}
protokolliert(kennzahlen, c(1, 2, 3), einheit = "kg")

rufe mit 2 Argumenten:  einheit 

[1] "2 kg"

summe_aller <- function(...) sum(...)
c(summe_aller(1, 2, 3), summe_aller())

[1] 6 0

optionen <- list(runden = 0, einheit = "g")
do.call(kennzahlen, c(list(c(1.26, 2.5)), optionen))

[1] "2 g"

Python

def protokolliert(funktion, *args, **kwargs):
    print(f"rufe {funktion.__name__} mit {args} und {kwargs}")
    return funktion(*args, **kwargs)

print(protokolliert(kennzahlen, [1.0, 2.0, 3.0], einheit="kg"))

rufe kennzahlen mit ([1.0, 2.0, 3.0],) und {'einheit': 'kg'}
2.0 kg

def summe_aller(*zahlen):
    return sum(zahlen)

print(summe_aller(1, 2, 3), summe_aller())

6 0

teile = [4, 5]
print(summe_aller(*teile))            # Liste auspacken

9

optionen = {"runden": 0, "einheit": "g"}
print(kennzahlen([1.26, 2.5], **optionen))   # Dictionary auspacken

2.0 g

Output Zeile für Zeile

Zeile	Python	R	Erklärung
Protokoll	([1.0, 2.0, 3.0],) und {'einheit': 'kg'}	2 Argumente, Namen "" und einheit	Python trennt in ein Tupel der unbenannten und ein Dictionary der benannten Argumente. R hält beides in einer Liste, unbenannte haben einen leeren Namen.
Ergebnis	2.0 kg	2 kg	Die Argumente kommen unverändert bei kennzahlen an.
Summe von 1, 2, 3	6	6
Summe ohne Argumente	0	0	Leeres Tupel beziehungsweise leere Argumentliste; die Summe von nichts ist 0.
summe_aller(*teile)	9		Der Stern im Aufruf packt die Liste in einzelne Argumente aus.
**optionen	2.0 g	2 g (über do.call)	Mittelwert 1.88, auf null Stellen gerundet. R braucht do.call, um eine Liste als Argumente zu übergeben.

Interpretation und Ergebnissatz

Der Stern hat zwei Rollen: In der Definition sammelt er ein, im Aufruf packt er aus. Gerechtfertigt ist *args beim Durchreichen an eine andere Funktion, deren Signatur man nicht wiederholen will, und bei beliebig vielen gleichartigen Werten. Verdächtig wird es, wenn damit verdeckt wird, dass eine Funktion zu viele verschiedene Dinge tut.

protokolliert erhält ein unbenanntes Argument im Tupel args und die Einheit im Dictionary kwargs und reicht beide unverändert weiter; das Ergebnis ist 2.0 kg. Mit * und ** im Aufruf lassen sich umgekehrt Listen und Dictionaries als Argumente übergeben.

Beispiel 4: Namensräume und Closures

Frage und Datenlage

Ein globaler Zähler steht auf 0. Welche Funktionen können ihn lesen, welche verändern? Und wie baut man einen Zähler, der seinen Stand zwischen zwei Aufrufen behält, ohne einen globalen Namen zu benutzen?

Rechnung

R

zaehler <- 0
liest_nur <- function() zaehler + 1
schreibt_lokal <- function() { zaehler <- 99; zaehler }
erhoehe_lokal <- function() { zaehler <- zaehler + 1; zaehler }
c(liest_nur(), schreibt_lokal(), erhoehe_lokal(), zaehler)

[1]  1 99  1  0

erhoehe_global <- function() zaehler <<- zaehler + 1
erhoehe_global()
zaehler

[1] 1

zaehler_fabrik <- function() {
  stand <- 0
  function() { stand <<- stand + 1; stand }
}
z <- zaehler_fabrik()
c(z(), z(), z())

[1] 1 2 3

z2 <- zaehler_fabrik()
z2()

[1] 1

Python

zaehler = 0

def liest_nur():
    return zaehler + 1

def schreibt_lokal():
    zaehler = 99
    return zaehler

print([liest_nur(), schreibt_lokal(), zaehler])

[1, 99, 0]

def erhoehe_falsch():
    zaehler += 1          # liest und schreibt: Python haelt zaehler fuer lokal
    return zaehler

try:
    erhoehe_falsch()
except UnboundLocalError as fehler:
    print(type(fehler).__name__)

UnboundLocalError

def erhoehe_global():
    global zaehler
    zaehler += 1

erhoehe_global()
print(zaehler)

1

def zaehler_fabrik():
    stand = 0
    def weiter():
        nonlocal stand
        stand += 1
        return stand
    return weiter

z = zaehler_fabrik()
print([z(), z(), z()])

[1, 2, 3]

z2 = zaehler_fabrik()
print(z2())

1

Output Zeile für Zeile

Funktion	Python	R	Erklärung
liest_nur()	1	1	Der äussere Zähler wird gelesen.
schreibt_lokal()	99	99	Die Zuweisung legt einen neuen lokalen Namen an.
zaehler danach	0	0	Der äussere Zähler ist unverändert.
zaehler += 1 ohne Erklärung	UnboundLocalError	1, äusserer bleibt 0	Python entscheidet beim Übersetzen: Wird ein Name in der Funktion zugewiesen, ist er dort lokal, auch beim Lesen davor. R liest den äusseren Wert und legt dann einen lokalen an.
mit global bzw. <<-	1	1	Jetzt wird der äussere Zähler verändert.
z() dreimal	[1, 2, 3]	1 2 3	Die innere Funktion behält stand aus ihrer Entstehungsumgebung.
neuer Zähler z2()	1	1	Jeder Aufruf der Fabrik erzeugt einen eigenen Stand.

Die innere Funktion samt der Umgebung, aus der sie ihre Namen bezieht, heisst Closure. Sie ist die saubere Alternative zum globalen Zähler: Der Zustand ist gekapselt, und zwei Zähler kommen sich nicht in die Quere.

Interpretation und Ergebnissatz

Beide Sprachen lesen von innen nach aussen und schreiben lokal. Der Unterschied liegt im Mischfall: R erlaubt, einen äusseren Wert zu lesen und unter demselben Namen lokal abzulegen, Python verbietet es mit einem UnboundLocalError. Versteckte Seiteneffekte sind die häufigste Ursache schwer auffindbarer Fehler; beide Sprachen machen sie zum Sonderfall, der ausdrücklich erklärt werden muss.

Ohne global legt eine Zuweisung in der Funktion einen lokalen Namen an, und der äussere Zähler bleibt bei 0; zaehler += 1 scheitert in Python mit einem UnboundLocalError. Eine Closure mit nonlocal zählt 1, 2, 3 und hält ihren Stand getrennt von jedem weiteren Zähler.

Beispiel 5: Funktionen als Argumente

Frage und Datenlage

Drei Messreihen (Drossel 2, 4, 6, Ventil 1.6, 1.7, 9.3, Pumpe 5). Gesucht sind je Reihe Mittelwert und Anzahl, die Reihen sortiert nach Mittelwert, nur die Reihen mit mehr als einem Wert, und für das Ventil Minimum, Maximum und Mittelwert in einem Durchgang.

Rechnung

R

messungen <- list(Drossel = c(2, 4, 6), Ventil = c(1.6, 1.7, 9.3), Pumpe = 5)

sapply(messungen, mean)

Drossel  Ventil   Pumpe 
    4.0     4.2     5.0 

sapply(messungen, length)

Drossel  Ventil   Pumpe 
      3       3       1 

names(sort(sapply(messungen, mean)))

[1] "Drossel" "Ventil"  "Pumpe"  

names(Filter(function(w) length(w) > 1, messungen))

[1] "Drossel" "Ventil" 

sapply(list(min = min, max = max, mittel = mean),
       function(f) f(messungen$Ventil))

   min    max mittel 
   1.6    9.3    4.2 

Python

messungen = {"Drossel": [2.0, 4.0, 6.0], "Ventil": [1.6, 1.7, 9.3],
             "Pumpe": [5.0]}

def mittel(werte):
    return sum(werte) / len(werte)

print({name: round(mittel(werte), 2) for name, werte in messungen.items()})

{'Drossel': 4.0, 'Ventil': 4.2, 'Pumpe': 5.0}

print(list(map(len, messungen.values())))

[3, 3, 1]

print(sorted(messungen, key=lambda name: mittel(messungen[name])))

['Drossel', 'Ventil', 'Pumpe']

print(list(filter(lambda name: len(messungen[name]) > 1, messungen)))

['Drossel', 'Ventil']

print([round(f(messungen["Ventil"]), 2) for f in (min, max, mittel)])

[1.6, 9.3, 4.2]

Output Zeile für Zeile

Aufgabe	Python	R	Ergebnis
Mittelwert je Reihe	Dictionary-Comprehension	sapply(messungen, mean)	Drossel 4.0, Ventil 4.2, Pumpe 5.0
Anzahl je Reihe	map(len, ...)	sapply(messungen, length)	3, 3, 1
nach Mittelwert sortiert	sorted(..., key=...)	sort() und names()	Drossel, Ventil, Pumpe
mehr als ein Wert	filter(lambda ...)	Filter(function ...)	Drossel, Ventil
drei Funktionen auf eine Reihe	Schleife über (min, max, mittel)	sapply über eine Liste von Funktionen	1.6, 9.3, 4.2

key= erwartet eine Funktion, die aus jedem Element den Sortierwert macht. Hier ist das Element der Name der Reihe, und die Lambda-Funktion schlägt dazu den Mittelwert nach. map und filter liefern in Python keine Liste, sondern einen Iterator; erst list() holt die Werte ab.

Interpretation und Ergebnissatz

Die letzte Zeile zeigt den Kern: min, max und mittel stehen in einem Tupel wie gewöhnliche Werte, und die Schleife ruft jede davon auf. Das Ventil hat mit 1.6 bis 9.3 die grösste Spannweite, aber mit 4.2 nur den mittleren Mittelwert, ein Hinweis auf einen Ausreisser, den ein einzelner Mittelwert verbergen würde.

Nach Mittelwert sortiert stehen die Reihen in der Folge Drossel (4.0), Ventil (4.2), Pumpe (5.0); nur Drossel und Ventil haben mehr als einen Wert. Weil Funktionen Objekte sind, lassen sich Minimum (1.6), Maximum (9.3) und Mittelwert (4.2) des Ventils in einem Durchgang berechnen.

Beispiel 6: Ein eigenes Modul importieren

Frage und Datenlage

Eine Datei kennzahlen_modul.py enthält eine Funktion, eine Ausgabe auf oberster Ebene und einen Testaufruf im __main__-Block. Was läuft beim Import, was beim zweiten Import, was beim direkten Start? Die Datei wird in einem temporären Ordner angelegt, damit das Beispiel ohne Vorbereitung läuft.

Rechnung

R

datei <- tempfile(fileext = ".R")
writeLines(c("mittel_modul <- function(werte) sum(werte) / length(werte)",
             "cat('Datei wird ausgefuehrt\\n')"), datei)

modul <- new.env()
sys.source(datei, envir = modul)

Datei wird ausgefuehrt

modul$mittel_modul(c(2, 4, 6))

[1] 4

exists("mittel_modul")       # nicht im globalen Namensraum gelandet

[1] FALSE

Python

ordner = pathlib.Path(tempfile.mkdtemp())
pfad = ordner / "kennzahlen_modul.py"
_ = pfad.write_text(
    "def mittel(werte):\n"
    "    return sum(werte) / len(werte)\n\n"
    "print('Modul wird ausgefuehrt, __name__ =', __name__)\n\n"
    "if __name__ == '__main__':\n"
    "    print('Testaufruf:', mittel([1, 2, 3]))\n",
    encoding="utf-8")
sys.path.insert(0, str(ordner))

import kennzahlen_modul                  # erster Import

Modul wird ausgefuehrt, __name__ = kennzahlen_modul

print(kennzahlen_modul.mittel([2, 4, 6]))

4.0

import kennzahlen_modul                  # zweiter Import
print("zweiter Import ohne Ausgabe")

zweiter Import ohne Ausgabe

_ = runpy.run_path(str(pfad), run_name="__main__")   # wie ein direkter Start

Modul wird ausgefuehrt, __name__ = __main__
Testaufruf: 2.0

print(__name__)

__main__

Output Zeile für Zeile

Zeile	Ausgabe	Erklärung
erster Import	Modul wird ausgefuehrt, __name__ = kennzahlen_modul	Die Datei läuft einmal ganz durch. __name__ ist der Modulname, der Testaufruf im __main__-Block bleibt aus.
Funktion aus dem Modul	4.0	Zugriff über modul.funktion.
zweiter Import	nichts	Python merkt sich geladene Module in sys.modules und führt die Datei nicht erneut aus. Wer eine geänderte Datei neu laden will, braucht importlib.reload.
direkter Start	__name__ = __main__ und Testaufruf: 2.0	Jetzt ist die Datei das Hauptprogramm, und der geschützte Block läuft.
__name__ im Dokument	__main__	Auch der Code dieser Seite läuft als Hauptprogramm, deshalb steht hier __main__.
R: sys.source	Datei wird ausgefuehrt	Auch in R läuft die Datei beim Laden ganz durch.
R: Funktion aus der Umgebung	4	sys.source führt die Datei in einer eigenen Umgebung aus, die als Modul dient.
R: exists("mittel_modul")	FALSE	Die Funktion ist nicht in den globalen Namensraum gelangt. Ein schlichtes source() hätte sie dort abgelegt.

Interpretation und Ergebnissatz

Der Import ist kein reines “Definitionen holen”: Er führt die Datei aus. Alles, was auf oberster Ebene steht, läuft mit, einmal je Sitzung. Genau deshalb gehören Testaufrufe, Dateizugriffe und Ausgaben in den __main__-Block oder in eine Funktion main(). R hat keinen solchen Mechanismus; dort trennt man Funktionsdateien und Auswertungsskripte, oder man schreibt ein Paket.

Beim ersten Import lief die Datei einmal durch und meldete __name__ = kennzahlen_modul, der Testaufruf blieb aus; der zweite Import blieb stumm. Erst beim direkten Start war __name__ gleich __main__, und der geschützte Block gab Testaufruf: 2.0 aus.

Verständnisfragen

Eine Funktion ist als def sammeln(wert, bisher=[]) definiert. Der erste Aufruf liefert [1], der zweite [1, 2]. Warum?

Der Defaultwert wurde einmal bei der Definition erzeugt und wird geteilt

Richtig. Die leere Liste hängt seither an der Funktion, sichtbar in __defaults__, und jeder Aufruf ohne zweites Argument hängt daran an.

Python merkt sich die vorherigen Aufrufe

Einen solchen Mechanismus gibt es nicht. Es liegt allein am geteilten Objekt.

Die Funktion ruft sich selbst auf

Jeder Aufruf ist unabhängig, nur das Defaultobjekt ist es nicht.

Wann ist *args gerechtfertigt und wann ein Zeichen für unklares Design?

Gerechtfertigt beim Durchreichen an eine andere Funktion

Richtig, etwa wenn man deren Signatur nicht wiederholen will, oder bei beliebig vielen gleichartigen Werten. Verdächtig wird es, wenn damit verdeckt wird, dass eine Funktion zu viele verschiedene Dinge tut.

Immer gerechtfertigt, es macht Funktionen flexibel

Flexibilität ohne erkennbare Signatur macht den Aufruf unlesbar.

Nie, benannte Parameter sind immer besser

Beim Weiterreichen wären sie eine Verdopplung, die bei jeder Änderung nachgezogen werden müsste.

In einer Funktion steht zaehler += 1, und zaehler ist nur global definiert. Python meldet UnboundLocalError. Warum?

Weil zaehler in der Funktion zugewiesen wird und damit lokal ist, auch beim Lesen davor

Richtig. Python entscheidet für die ganze Funktion, ob ein Name lokal ist. Abhilfe: global zaehler, oder besser den Wert als Argument übergeben und zurückgeben.

Weil globale Namen in Funktionen nicht lesbar sind

Lesen geht, wie liest_nur() in Beispiel 4 zeigt.

Weil += für ganze Zahlen nicht definiert ist

Ist es; das Problem ist der Gültigkeitsbereich.

Ein Skript enthält Testaufrufe am Dateiende und wird von einer anderen Datei importiert. Was passiert ohne if __name__ == "__main__"?

Die Testaufrufe laufen beim Import mit

Richtig. Beim Import wird der gesamte Dateiinhalt ausgeführt, wie die Ausgabe in Beispiel 6 zeigt. Das kostet Zeit, erzeugt unerwünschte Ausgaben und kann im schlimmsten Fall Dateien überschreiben.

Nichts, Funktionen werden beim Import nur definiert

Definitionen ja, aber Aufrufe auf oberster Ebene werden ausgeführt.

Der Import schlägt fehl

Er gelingt, nur eben mit Nebenwirkungen.

Eine Moduldatei wird geändert und im laufenden Notebook erneut mit import geladen. Die Änderung wirkt nicht. Warum?

Die Datei wurde nicht gespeichert

Möglich, aber nicht der typische Grund.

Ein zweiter import lädt aus dem Zwischenspeicher sys.modules und liest die Datei nicht neu

Richtig. Abhilfe ist importlib.reload(modul) oder ein Neustart des Kernels, der ohnehin der sicherere Weg ist.

Python erlaubt nur einen Import pro Sitzung

Weitere Importe sind erlaubt, sie tun nur nichts.

Warum ist sorted(leute, key=lambda p: p["jahr"]) einer eigenen Sortierschleife vorzuziehen?

Weil Lambda-Ausdrücke schneller sind

Der Gewinn liegt nicht am Lambda, sondern an der geprüften Sortierfunktion dahinter.

Weil die Absicht in einer Zeile steht und der Sortiercode geprüft ist

Richtig. Eine eigene Schleife müsste Stabilität, Sonderfälle und Effizienz nachbilden, ohne dass daraus etwas gewonnen wäre.

Weil eigene Schleifen in Python verboten sind

Sie sind erlaubt, nur hier unnötig.

Verlinkte Ressourcen

• Funktionen im Python-Tutorial
• Module im Python-Tutorial
• Gültigkeitsbereiche und Namensräume