• Aktuelle Version: Python 3.7
• Interpretierte Programmiersprache
  • Kein Kompilieren
  • Programme werden mit dem python-Programm ausgeführt
• Eignet sich sehr gut zum Erlernen der Programmierung!
• Hat viele Pakete, die für wissenschaftliches Arbeiten verwendet werden können.

Hier soll es hingehen: Auswertung von Praktikumsversuchen:

Versuch aus dem Fortgeschrittenen-Praktikum: Lebensdauer kosmischer Myonen

%%javascript
$.getScript('https://kmahelona.github.io/ipython_notebook_goodies/ipython_notebook_toc.js')

Inhalt

Grundlagen

Eine Programmiersprache wie Python lässt sich nicht an einem Tag lernen.

Hier geben wir einen kurzen Überblick über die wichtigsten Konzepte.

Keine Angst: Zum Erstellen von Plots und für einfache Auswertungen muss man nicht viel Python können!

Die folgenden Beispiele kann man auf der Kommandozeile durch ausführen von

ipython

ausprobieren.

Einfachstes Beispiel

print('Hello, World!')

Hello, World!

Kommentare

• Sehr wichtig für die Leute, die mit euch Arbeiten.
• Auch für euch selbst zwei Wochen später

Alles was in Python hinter einem # steht, wird nicht als Code betrachtet und dient als Kommentar.

# This just prints the traditional greeting to the console
print("Hello, World!")

Hello, World!

Kommentare sollten nicht erklären, was der Code tut, sondern warum.

Kommentare, wie jeder andere Code, sollten auf englisch sein.

Variablen

Man kann einem Objekt einen Namen geben:

a = 2
b = 3

Variablennamen können auch überschrieben werden:

a = 42
b = a

a = 0
b

42

• Namen verweisen auf Objekte
• Mehrere Namen können auf das gleiche Objekt zeigen

Datentypen

Einfache Datentypen

Booleans

True und False

Logische Operatoren: and, or, not

True and False

False

True or False

True

not True

False

None oder leere Objekte verhalten sich wie False, andere wie True

'' or True

True

'Hallo' and True

True

Zahlen

Ganze Zahlen: 42
Kommazahlen: 3.14
Komplexe Zahlen: 3 + 2j

Rechenoperatoren:

• +, -, *
• ** (Potenzieren: 2**3 → 8)
• / (3 / 2 → 1.5)
• // (Ganzzahldivision: 3 // 2 → 1)
• % (Modulo-Operation, Divisionsrest: 7 % 4 → 3)

x = 5
y = 3
x + y

8

Rechenoperationen können geklammert werden

a = 2 + 4 / 5 + 1
b = (2 + 4) / 5 + 1
c = (2 + 4) / (5 + 1)

print(a, b, c)

3.8 2.2 1.0

a = 3 + 2j
b = 1 + 1j

print(a + b, a*b, abs(b))

(4+3j) (1+5j) 1.4142135623730951

Vergleichsoperatoren geben True oder False zurück

• ==, !=
• >, <, >=, <=

x < y

False

a = 2 + 4 / 5 + 1
b = (2 + 4) / 5 + 1
c = (2 + 4) / (5 + 1)

print(a, b, c)

3.8 2.2 1.0

Mehrere Vergleichsoperatoren können in einem Ausdruck stehen:

c < b < a

True

c < a < b

False

Strings

Stehen in ' oder ". (Für eins entscheiden)

foo = 'foo'
bar = "bar"

Strings können mit + konkateniert werden:

foo + " " + bar

'foo bar'

Strings können mit * vervielfacht werden

foo * 4

'foofoofoofoo'

Strings können mit [] indiziert werden

foo[0]

'f'

Können beliebige Unicode Symbole enthalten

print('π ist genau 3, Erwin Schrödinger')

π ist genau 3, Erwin Schrödinger

None

Stellt das Fehlen eines Wertes dar.

Wird häufig für Standardwerte von Funktionen verwendet.

print(None)

None

Funktionen, die 'nichts' zurückgeben, geben None zurück:

print('test')

test

a = print('test')

test

print(a)

None

Sammlungen (Collections)

Speichern mehrere Objekte

Listen

• Veränderbar
• Gedacht für mehrere Werte vom selben Typ

names = ['foo', 'bar']

Listen können mit [] indiziert werdern

names[1]

'bar'

Man kann Werte an Listen anhängen:

names.append('baz')
names

['foo', 'bar', 'baz']

Negative Indizes (beginnend mit -1), indizieren die Liste rückwärts

names[-1]

'baz'

Man kann auch Teillisten indizieren.
names[Anfang:Ende] liefert eine Teilliste mit den Werten von names[Anfang] bis names[Ende-1]:

names[1:3]

['bar', 'baz']

Listen werden mit + zusammengeführt:

names + ['thing']

['foo', 'bar', 'baz', 'thing']

Listen können mit * vervielfacht werden:

names * 3

['foo', 'bar', 'baz', 'foo', 'bar', 'baz', 'foo', 'bar', 'baz']

Die Liste kann auch erweitert werden:

names.extend(['quux'])
names

['foo', 'bar', 'baz', 'quux']

Listen sind veränderbar, man kann ihnen Werte zuweisen:

names[1] = 'new'
names

['foo', 'new', 'baz', 'quux']

Mit in wird überprüft ob ein Wert in der Liste ist:

weekdays = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So']
'Mo' in weekdays

True

Tupel

• Gedacht für Werte mit unterschiedlichen Typen.
• Unveränderbar nach Erzeugung.
• Werden an allen möglichen Stellen von python erzeugt

tup = (5, 3)
tup

(5, 3)

Können wahlweise auch ohne Klammern geschrieben werden (wenn es eindeutig ist).

tup = 5, 3
tup

(5, 3)

a = 5
b = 3
a, b = b, a

print("a =", a)
print("b =", b)

a = 3
b = 5

tup[0]

5

tup[1] = 7

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-44-0dc366c7c319> in <module>
----> 1 tup[1] = 7

TypeError: 'tuple' object does not support item assignment

Dictionaries

numbers = { 'one': 1, 'two': 2, 'three': 3 }

numbers['two']

2

Dictionaries sind extrem hilfreich, zum Beispiel um die verschiedene Datensätze der gleichen Messung zusammenzufassen. So wird es einfacher dieselbe Analyse auf die einzelnen Datensätze anzuwenden.

data = {'Cu': [1.1, 1.2, 1.3, 1.4], 'Fe': [0.7, 0.8, 0.9, 1.0]}
data['Cu']

[1.1, 1.2, 1.3, 1.4]

Leere Dictionaries werden z.B. mit der Funktion dict()erstellt

data = dict()
data

{}

data["Fe"] = [1.1, 1.2, 1.3, 1.4]
data

{'Fe': [1.1, 1.2, 1.3, 1.4]}

data["Cu"] = [0.7, 0.8, 0.9, 1.0]
data

{'Fe': [1.1, 1.2, 1.3, 1.4], 'Cu': [0.7, 0.8, 0.9, 1.0]}

data["Au"] = [0.2, 0.3, 0.1, 0.5]
data

{'Fe': [1.1, 1.2, 1.3, 1.4],
 'Cu': [0.7, 0.8, 0.9, 1.0],
 'Au': [0.2, 0.3, 0.1, 0.5]}

In der aktuellen Python-Version 3.7 entspricht die Reihenfolge der Einträge in Dictionaries der
Zuweisungsreihenfolge! In allen älteren Versionen war dies nicht der Fall $\Rightarrow$ Nicht auf die Reihenfolge der Dictionary-Einträge verlassen.

Kontrollstrukturen

Die Zeilen eines Python-Programms werden nacheinander ausgeführt.

Sogennante Kontrollstrukturen erlauben es, den Ablauf zu steuern.

if / elif / else

a = 3

if a == 1:
    # muss eingerückt werden, 4 spaces:
    print('foo')
elif a == 2:
    print('bar')
else:
    print('baz')

baz

while

Wiederholen, solange eine Bedingung erfüllt ist.

i = 0
while i < 5:
    print(i)
    i += 1

# there has to be a better way!

0
1
2
3
4

for

Wiederholen für jedes Elements (z.B. einer Liste)

data = [10, 42, -1]

for x in data:
    # Wir können auf das jetzige Element als "x" zugreifen
    print(2 * x)

20
84
-2

klassische for-Schleife mit range:

for i in range(5):
    print(i)

0
1
2
3
4

for i in range(2, 5):
    print(i)

2
3
4

for i in range(2, 10, 2):
    print(i)

2
4
6
8

for i in range(10, 3, -1):
    print(i)

10
9
8
7
6
5
4

# Hatten wir weiter oben bei den Listen erstellt
weekdays

['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So']

for day in weekdays:
    print("Heute ist", day)

Heute ist Mo
Heute ist Di
Heute ist Mi
Heute ist Do
Heute ist Fr
Heute ist Sa
Heute ist So

Zwei sehr nützliche Funktionen sind enumerate und zip

for i, day in enumerate(weekdays):
    print(day, " ist der ", i+1, ". Tag der Woche", sep="")

Mo ist der 1. Tag der Woche
Di ist der 2. Tag der Woche
Mi ist der 3. Tag der Woche
Do ist der 4. Tag der Woche
Fr ist der 5. Tag der Woche
Sa ist der 6. Tag der Woche
So ist der 7. Tag der Woche

Was enumerate() macht:

list(enumerate(weekdays))

[(0, 'Mo'), (1, 'Di'), (2, 'Mi'), (3, 'Do'), (4, 'Fr'), (5, 'Sa'), (6, 'So')]

voltages = [1, 3, 5]
currents = [1, 5, 1]

for voltage, current in zip(voltages, currents):
    print('R =', voltage / current)

R = 1.0
R = 0.6
R = 5.0

Was zip() macht:

list(zip(voltages, currents))

[(1, 1), (3, 5), (5, 1)]

Iterieren über die Einträge von dict

translations = {
    'foot': 'Fuß',
    'ball': 'Ball',
    'goal': 'Tor',
}

for e, g in translations.items():
    print(e, g)

foot Fuß
ball Ball
goal Tor

Funktionen

Mit Funktionen lässt sich Code leicht wiederverwenden. Eine Funktion nimmt Parameter, verarbeitet sie und gibt Ergebnisse zurück.

print('Hello!')

Hello!

len([1, 2, 3, 4, 5])

5

Viele Funktionen haben mehrere Parameter, einige können sogar beliebig viele haben:

print(1, 2, 3, 4, 5)

1 2 3 4 5

Viele Funktionen haben optionale Parameter mit eigenem Namen, sogenannte "keyword arguments":

print(1, 2, 3, 4, 5, sep=', ')

1, 2, 3, 4, 5

Objekte haben auch Funktionen (diese nennt man Methoden):

s = 'test'
s.upper()

'TEST'

'foo bar baz'.split()

['foo', 'bar', 'baz']

In IPython kann man wie folgt auf die Dokumentation einer Funktion zugreifen:

print?

Ansonsten findet man ausführliche Erklärungen in der offiziellen Dokumentation.

Eigene Funktionen definieren mit def

Um immer wieder benötigten Code einfacher zu nutzen, können Funktionen definiert werden.

Vorteile:

• Weniger Code
• Änderungen nur an einer Stelle notwending

def add(x, y):
    z = x + y
    return z

add(2, 2)

4

Mit dem return Statement wird die Funktion beendet und Ergebnisse zurückgeben.

Es können auch mehrere Werte zurückgeben werden:

def divide(x, y):
    return x // y, x % y

n, rest = divide(5, 3)
n, rest

(1, 2)

Funktionen können sich selbst aufrufen (Rekursion)

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

factorial(4)

24

Module und import

In Python kann man Code in einzelne Module portionieren.

Es stehen bereits unglaublich viele Module für Python zur Verfügung.

Gerade für das wissenschaftliche Arbeiten ist eigentlich alles da was gebraucht wird und noch viel mehr.

Wird etwas aus einem anderen Modul gebraucht, importiert man es.

Zahlreiche Module sind Teil jeder Python Installation, die sogenannte "standard library": https://docs.python.org/3/library/

Viele weitere Module habt ihr mit Anaconda installiert

import os

os.path.join('plots', 'fig1.pdf')

'plots/fig1.pdf'

Für das Importieren einzelner Funktionen gibt es den Befehl:

from time import sleep

print('hello')
sleep(1)
print('world')

hello
world

Den Modulen können mit as neue Namen gegeben werden

Viele Module haben Konventionen für den Kurznamen

import numpy as np

np.sum([1, 2]) # siehe numpy Kurs

3

Auslagern in Python-Dateien

• Python-Dateien haben die Endung .py
• Ausführen mit python programm.py
• Einzelne Python-Dateien (Endung .py) kann man als Module benutzen.
  Liegt eine Datei test.py im selben Ordner, so kann der Inhalt mit import test in einer weiteren Datei verwendet werden.
• Die Datei muss mit dem Encoding UTF-8 abgespeichert werden. (Standard in modernen Editoren / Betriebssystemen)

Es folgt ein fertiges Python-Programm.

Speichert es als primes.py ab und startet es aus dem Terminal mit python primes.py.

def primes(max_num):
    # Only primes smaller than max_num are calculated
    is_prime = max_num * [True]
    is_prime[0] = False
    is_prime[1] = False

    primes = []

    # Sieve of Erathosthenes:
    for i in range(2, max_num):
        if is_prime[i]:
            for j in range(2 * i, max_num, i):
                # Multiples are not primes
                is_prime[j] = False
            primes.append(i)
    
    return primes

print(primes(100))

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

Formatieren von Strings

f-strings

https://docs.python.org/3/reference/lexical_analysis.html#f-strings https://docs.python.org/3/library/string.html#formatspec

Oft will man Werte oder andere Strings in einen String einsetzen.

Seit der Python Version 3.6 gibt es sogenannte f-strings (formatted strings) für String-Formatierung:

U = 42
R = 7

print(f"Spannung U = {U}, R = {R}, I = {U / R}")

Spannung U = 42, R = 7, I = 6.0

Der Ausdruck in den {}-Markierungen wird ausgewertet und das Ergebnis anstelle der geschweiften Klammern gesetzt.
Variablen ersetzt.

f-strings haben viele fortgeschrittene Funktionen.

Beispielsweise kann die gewünschte Genauigkeit für floats angeben werden:

result = 3.2291421

print(f'Das Ergebnis ist {result:.2f}')

Das Ergebnis ist 3.23

Alle Formateinstellungen werden nach einem Doppelpunkt angegeben.
Für die Genauigkeit sieht die Angabe allgemein so aus: :.Nf
N ist dabei die gewünschte Anzahl an Nachkommastellen.

.format funktioniert sehr ähnlich, siehe https://docs.python.org/3/library/string.html#format-string-syntax

Sonderzeichen

Mit \ kann man in Strings besondere Anweisungen setzen:

• '\n' -> Zeilenumbruch
• '\t' -> Tab
• '\\' -> normales '\'

Wenn viele '\' geschrieben werden müssen (z.B. in LaTeX-Code), lohnt es sich diese Funktion mit dem Prefix r auszuschalten:

print(r'\Huge\texttt{Python}')

\Huge\texttt{Python}

Will man { oder } im Text stehen haben (für LaTeX benötigt) geht das mit doppelten {{ oder }}.

LaTeX sieht dann leider so aus:

energy = 1.23456
print(rf'\SI{{{energy:.4f}}}{{\kilo\joule}}')

\SI{1.2346}{\kilo\joule}

Nur zur Demonstration einmal mit mehr Lücken (funktioniert so nicht in LaTeX wegen den Leerzeichen!):

print(fr'\SI {{ {energy:.4f} }} {{ \kilo\joule }}')

\SI { 1.2346 } { \kilo\joule }

Comprehensions

Sind nützlich, um Listen oder Dictionaries umzuwandeln oder zu erzeugen:

# Ursprüngliche Liste
list(range(5))

[0, 1, 2, 3, 4]

# List-Comprehension
[2 * x for x in range(5)]

[0, 2, 4, 6, 8]

# List-Comprehension mit Bedingung
[2 * x for x in range(5) if x % 2 == 0]

[0, 4, 8]

# Ursprüngliche Liste
weekdays = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So']

# Dict-Comprehension
{num + 1: name for num, name in enumerate(weekdays)}

{1: 'Mo', 2: 'Di', 3: 'Mi', 4: 'Do', 5: 'Fr', 6: 'Sa', 7: 'So'}

# Ursprüngliche Listen
print(list(range(3)))
print(list(range(4)))

[0, 1, 2]
[0, 1, 2, 3]

# List-Comprehension mit verschachtelten Schleifen
[x + y for y in range(3) for x in range(4)]

[0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5]

# List-Comprehension mit verschachtelten Schleifen und Bedingung
[x + y for y in range(3) for x in range(4) if x % 2 == 0]

[0, 2, 1, 3, 2, 4]

Häufig auftretende Fehler

Einige Fehler werden zu Anfang sehr häufig gemacht (und immer mal wieder).
Wenn man die Fehlermeldungen richtig zu lesen weiß, kann einem das viel Arbeit/Frust ersparen.
Das Wichtigste ist: Lest die Fehlermeldung und versucht sie zu verstehen!

Gerade am Anfang beliebt: IndentationError:

Die Fehlermeldung gibt die Zeile an in der Fehler auftritt (hier: line 8)
und den Grund für den Fehler, häufig mit Erklärung (hier: IndentationError: expected an indented block)

a = 5
b = 7
c = 9

if a <= b:
    if c >= b:
    # Zeile 8 müsste in dem if-Block eingerückt werden
    print("a <= b und b >= c")
    else:
        print("a <= b und b >= c")
else:
    print("a > b")    

  File "<ipython-input-93-0a5350255358>", line 8
    print("a <= b und b >= c")
        ^
IndentationError: expected an indented block

Allgemeiner Syntax-Fehler: SyntaxError

Zeile in der der Fehler auftritt: line 6
Grund für den Fehler: SyntaxError: invalid syntax
Hier sogar mit Hinweis auf das fehlerhafte/fehlende Zeichen.

a = 5
b = 7
c = 9

# In Zeile 6 fehlte der Doppelpunkt ':' nach der Bedingung, um den If-Block einzuleiten
if a <= b
    if c >= b:
        print("a <= b und b >= c")
    else:
        print("a <= b und b >= c")
else:
    print("a > b")

  File "<ipython-input-94-326c449f263e>", line 6
    if a <= b
             ^
SyntaxError: invalid syntax

Ein zu Anfang verwirrender Fehler

Die Fehlermeldung ist hier im ersten Moment nicht besonders hilfreich:
Zeile in der der Fehler auftritt: line 11
Grund für den Fehler: SyntaxError: invalid syntax

Stimmt nur zum Teil, denn in Zeile 11 ist alles in Ordnung und der eigentliche Fehler ist in Zeile 10.
In komplexeren Programmen ist das nicht mehr so einfach zu sehen wie hier,
deswegen ist es gut, wenn man dieses Verhalten schon mal gesehen hat.

a = 5
b = 7
c = 9


if a <= b:
    if c >= b:
        # In Zeile 10 fehlt eine Klammer, zum Vergleich:
#       d = ((a + b) / (a + c))/((a + b) / (a + c)) 
        d = ((a + b) / (a + c)/((a + b) / (a + c))
        print("a <= b und b >= c")
    else:
        print("a <= b und b >= c")
else:
    print("a > b") 

  File "<ipython-input-95-04b0166b2e09>", line 11
    print("a <= b und b >= c")
        ^
SyntaxError: invalid syntax

Auch sehr einfach auszulösen: NameError:

Zeile in der der Fehler auftritt: ----> 7 if a <= n:
Grund für den Fehler: NameError: name 'n' is not defined
Fehlermeldung sieht etwas anders aus, liefert aber immer noch die gleichen Informationen.

a = 5
b = 7
c = 9

# Beim Schreiben des Codes vertippt (n anstelle von b),
# sodass a <= n statt a <= b ausgewertet wird, n ist jedoch nicht definiert
if a <= n:
    if c >= b:
        print("a <= b und b >= c")
    else:
        print("a <= b und b >= c")
else:
    print("a > b")    

a > b

Fehler bei Zugriffen auf Listen: IndexError

Zeile in der der Fehler auftritt: ----> 4 names[4]
Grund für den Fehler: IndexError: list index out of range
Fehlermeldung sieht etwas anders aus, liefert aber immer noch die gleichen Informationen.

names = ["Anna","Jan","Marie","Tim"]
# Die Liste hat vier Einträge, da der erste Index aber 0 ist ist der letzte Index 3
# der Index 4 der in Zeile 4 abgerufen wird überschreitet diesen Bereich
names[4]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-97-da525c7959b7> in <module>
      2 # Die Liste hat vier Einträge, da der erste Index aber 0 ist ist der letzte Index 3
      3 # der Index 4 der in Zeile 4 abgerufen wird überschreitet diesen Bereich
----> 4 names[4]

IndexError: list index out of range

Fehler bei Zugriffen auf Dictionaries: KeyError

Zeile in der der Fehler auftritt: ----> 4 numbers["five"]
Grund für den Fehler: KeyError: 'five'
Fehlermeldung sieht etwas anders aus, liefert aber immer noch die gleichen Informationen.

numbers = {"one": 1 ,"two": 2,"three": 3,"four": 4}
# Analog zum Beispiel mit der Listen Index
# Der key "five" ist nicht in dem Dictionary vorhanden
numbers["five"]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-98-2308ed8a16fa> in <module>
      2 # Analog zum Beispiel mit der Listen Index
      3 # Der key "five" ist nicht in dem Dictionary vorhanden
----> 4 numbers["five"]

KeyError: 'five'

Komplexer Fehler mit Traceback:

Wenn an einem Fehler mehrere Funktionen beteiligt sind,
gibt die Fehlermeldung einen Traceback aus.
Dieser Fall ist eher die Regel, vorallem, wenn Module verwendet werden.
Der Traceback zeigt die Reihenfolge aller Funktionsaufrufe, die
am Ende zu dem Fehler geführt haben mit dem letzten Aufruf ganz unten (most recent call last).

Zeilen die zum Auftreten des Fehlers führen:
Funktionsaufruf in Zeile 10:
---> 10 add_one_to_inverse_difference(x,y)
Ergebnis des Funktionsaufrufs ist das return in Zeile 5 mit neuem Funktionsaufruf:
----> 5 return 1 + inverse_difference(a, b)
Ergebnis des 2. Funktionsaufrufs ist das return in Zeile 2:
----> 2 return 1/(a - b)
Hier tritt der Fehler auf, da durch Null geteilt wird, wenn a und b gleich sind!

Grund für den Fehler: ZeroDivisionError: division by zero

def inverse_difference(a, b):
    return 1/(a - b)

def add_one_to_inverse_difference(a, b):
    return 1 + inverse_difference(a, b) 

def add_2_to_inverse_difference(a, b):
    return add_one_to_inverse_difference(a, b) + 2

x = 2
y = 2

add_one_to_inverse_difference(x,y)

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
<ipython-input-99-c6e4b41c5f62> in <module>
     11 y = 2
     12 
---> 13 add_one_to_inverse_difference(x,y)

<ipython-input-99-c6e4b41c5f62> in add_one_to_inverse_difference(a, b)
      3 
      4 def add_one_to_inverse_difference(a, b):
----> 5     return 1 + inverse_difference(a, b)
      6 
      7 def add_2_to_inverse_difference(a, b):

<ipython-input-99-c6e4b41c5f62> in inverse_difference(a, b)
      1 def inverse_difference(a, b):
----> 2     return 1/(a - b)
      3 
      4 def add_one_to_inverse_difference(a, b):
      5     return 1 + inverse_difference(a, b)

ZeroDivisionError: division by zero

Debugging leicht gemacht

Es kann vorkommen, dass man mal überhaupt nicht weiß, warum etwas nicht funktioniert.

In diesem Fall sollte man zunächst mal Ruhe bewahren
und sich dann auf systematische Fehlersuche begeben.
Ein einfacher Ansatz ist das print()-debugging.

Kleiner Trick, um Schuhgröße und Alter einer weiteren Person zu berechnen. Die zweite Person muss folgende Anweisungen befolgen:

1. Multipliziere deine Schuhgröße mit 5         
2. Addiere 50 zum Ergebnis                      
3. Multipliziere das Ergebnis mit 20            
4. Addiere 1018 zum Ergebnis                    
5. Ziehe dein Geburtsjahr vom Ergebnis ab
6. Nenne das Ergebnis

def shoesize_and_age(shoesize, birth_year):
    step_1 = shoesize * 5
    step_2 = step_1 + 50
    step_3 = step_2 * 20
    step_4 = step_3 + 1018
    step_5 = step_4 - birth_year
 
    return step_5

Beispiel:

Mit der Schuhgröße 45 und dem Geburtsjahr 1993, kriege ich die Zahl 4525 raus.
Ich habe (wie erwähnt die Schuhgröße 45) und bin 25 Jahre alt.
Wie funktioniert dieser Trick?!

shoesize_and_age(45, 1993)

4525

Die print()-Debugguing Methode:

def shoesize_and_age(shoesize, birth_year):
    print("shoesize:", shoesize)
    step_1 = shoesize * 5
    print("step_1:", step_1)
    step_2 = step_1 + 50
    print("step_2:", step_2)
    step_3 = step_2 * 20
    print("step_3:", step_3)
    step_4 = step_3 + 1018
    print("step_4:", step_4)
    step_5 = step_4 - birth_year
    print("step_5:", step_5)
    
    return step_5

shoesize_and_age(45, 1993)

shoesize: 45
step_1: 225
step_2: 275
step_3: 5500
step_4: 6518
step_5: 4525

4525

Die coolere IPython.embed()-Methode:

import IPython

def shoesize_and_age(shoesize, birth_year):
    step_1 = shoesize * 5
    step_2 = step_1 + 50
    step_3 = step_2 * 20
    step_4 = step_3 + 1017
    step_5 = step_4 - birth_year
    
    IPython.embed()
 
    return step_5

shoesize_and_age(45, 1993)

Python 3.7.3 (default, Mar 27 2019, 22:11:17) 
Type 'copyright', 'credits' or 'license' for more information
IPython 7.6.1 -- An enhanced Interactive Python. Type '?' for help.

---------------------------------------------------------------------------
StdinNotImplementedError                  Traceback (most recent call last)
<ipython-input-105-1ed1f1f17aac> in <module>
----> 1 shoesize_and_age(45, 1993)

<ipython-input-104-b1314e5d8d99> in shoesize_and_age(shoesize, birth_year)
      8     step_5 = step_4 - birth_year
      9 
---> 10     IPython.embed()
     11 
     12     return step_5

~/.local/anaconda/lib/python3.7/site-packages/IPython/terminal/embed.py in embed(**kwargs)
    387         frame.f_code.co_filename, frame.f_lineno), **kwargs)
    388     shell(header=header, stack_depth=2, compile_flags=compile_flags,
--> 389         _call_location_id='%s:%s' % (frame.f_code.co_filename, frame.f_lineno))
    390     InteractiveShellEmbed.clear_instance()
    391     #restore previous instance

~/.local/anaconda/lib/python3.7/site-packages/IPython/terminal/embed.py in __call__(self, header, local_ns, module, dummy, stack_depth, global_ns, compile_flags, **kw)
    227         # our call and get the original caller's namespaces.
    228         self.mainloop(local_ns, module, stack_depth=stack_depth,
--> 229                       global_ns=global_ns, compile_flags=compile_flags)
    230 
    231         self.banner2 = self.old_banner2

~/.local/anaconda/lib/python3.7/site-packages/IPython/terminal/embed.py in mainloop(self, local_ns, module, stack_depth, display_banner, global_ns, compile_flags)
    322 
    323         with self.builtin_trap, self.display_trap:
--> 324             self.interact()
    325 
    326         # now, purge out the local namespace of IPython's hidden variables.

~/.local/anaconda/lib/python3.7/site-packages/IPython/terminal/interactiveshell.py in interact(self, display_banner)
    479 
    480             try:
--> 481                 code = self.prompt_for_code()
    482             except EOFError:
    483                 if (not self.confirm_exit) \

~/.local/anaconda/lib/python3.7/site-packages/IPython/terminal/interactiveshell.py in prompt()
    252             def prompt():
    253                 prompt_text = "".join(x[1] for x in self.prompts.in_prompt_tokens())
--> 254                 lines = [input(prompt_text)]
    255                 prompt_continuation = "".join(x[1] for x in self.prompts.continuation_prompt_tokens())
    256                 while self.check_complete('\n'.join(lines))[0] == 'incomplete':

~/.local/anaconda/lib/python3.7/site-packages/IPython/utils/py3compat.py in input(prompt)
    152 # to forward requests to a frontend.
    153 def input(prompt=''):
--> 154     return builtin_mod.input(prompt)
    155 
    156 builtin_mod_name = "builtins"

~/.local/anaconda/lib/python3.7/site-packages/ipykernel/kernelbase.py in raw_input(self, prompt)
    853         if not self._allow_stdin:
    854             raise StdinNotImplementedError(
--> 855                 "raw_input was called, but this frontend does not support input requests."
    856             )
    857         return self._input_request(str(prompt),

StdinNotImplementedError: raw_input was called, but this frontend does not support input requests.

Das funktioniert auch in normalen Python .py Dateien.
IPython.embed() öffnet ein IPython-Terminalfenster mit allen Variablennamen,
die vorher definiert wurden. Man kann dann interaktiv nach Problemen im Code suchen
oder wie hier herrausfinden wie Code funktioniert.