Commit 9c2a0d9b authored by Jochen Schulz's avatar Jochen Schulz
Browse files

scope

parent ef028cfa
......@@ -3,8 +3,10 @@ jupytext:
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.10.3
kernelspec:
display_name: Python 3
display_name: Python 3 (ipykernel)
language: python
name: python3
---
......@@ -16,7 +18,7 @@ kernelspec:
Beispiel:
```{code-cell}
```{code-cell} ipython3
y = 0
def f(x):
......@@ -54,7 +56,7 @@ Außerdem haben *Module* jeweils einen eigenen globalen Scope, d.h. ein Module k
Hier ist `x` global:
```{code-cell}
```{code-cell} ipython3
x = 0
def f():
print(x)
......@@ -63,7 +65,7 @@ f()
Hier ist `x` lokal:
```{code-cell}
```{code-cell} ipython3
x = 0
def f():
x = 1
......@@ -74,7 +76,7 @@ print(x)
Hier wird `x` explizit als global deklariert:
```{code-cell}
```{code-cell} ipython3
x = 0
def f():
global x
......@@ -86,8 +88,9 @@ print(x)
Hier ist `x` ebenfalls lokal, auch wenn die Zuweisung erst am Ende steht:
```{code-cell}
:tags: ["raises-exception"]
```{code-cell} ipython3
:tags: [raises-exception]
x = 0
def f():
print(x)
......@@ -99,7 +102,7 @@ Da zum Zeitpunkt des `print`-Befehls die lokale Variable `x` noch nicht zugewies
Variablen sind nur lokal, wenn sie **zugewiesen** werden. *Mutable* Objekte können ohne Zuweisung verändert werden; in diesem Fall wird das *globale* Objekt verändert:
```{code-cell}
```{code-cell} ipython3
a = [1, 2]
def f():
a.append(10)
......@@ -115,7 +118,7 @@ Es ist ein Hauptgrund von Funktionen, Funktionalität abzukapseln, um diese sowo
Funktionen können auch innerhalb anderer Funktionen definiert werden. Die verschachtelten Funktionen haben dabei einen eigenen Scope, der nach den gleichen Regeln wie oben funktioniert:
```{code-cell}
```{code-cell} ipython3
x = 0
y = 10
z = 100
......@@ -140,7 +143,7 @@ Nutzen verschachtelter Funktionen:
(3.) und (4.) sind insofern interessant, als dass verschachtelte Funktionen Zugriff auf den Scope der äußeren Funktion haben und dieser so eventuell weiter existiert, nachdem die äußere Funktion beendet wurde:
```{code-cell}
```{code-cell} ipython3
def make_appender():
lst = []
def append(x):
......@@ -164,8 +167,9 @@ Dieses "Einschließen" lokaler Variablen in Funktions-Objekte nennt man **Closur
Betrachten wir nochmal das Beispiel mit einer Zuweisung, jetzt innerhalb einer verschachtelten Funktion.
```{code-cell}
:tags: ["raises-exception"]
```{code-cell} ipython3
:tags: [raises-exception]
def g():
x = 0
def f():
......@@ -177,7 +181,7 @@ g()
Durch die Verwendung von `nonlocal` können wir die Variable im darüberliegenden Scope verfügbar machen.
```{code-cell}
```{code-cell} ipython3
def g():
x = 0
def f():
......@@ -193,7 +197,7 @@ g()
Funktionsargumente verhalten sich wie Zuweisungen: sie referenzieren dasselbe Objekt, das vom Aufrufer übergeben wurde. Insbesondere können Funktionen veränderliche Objekte des Aufrufers modifizieren (man nennt das auch *call by reference*).
```{code-cell}
```{code-cell} ipython3
def append_something(x):
x.append(42)
......@@ -201,3 +205,4 @@ a = [1, 2, 3]
append_something(a)
a
```
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment