python
-Programm ausgeführtHier 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')
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.
print('Hello, World!')
Hello, World!
Alles was in Python hinter einem #
steht, wird nicht als Code betrachtet und dient als Kommentar.
# This 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.
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
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
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 = 5
y = 3
x < y
False
Mehrere Vergleichsoperatoren können in einem Ausdruck stehen:
a = 3.8
b = 2.2
c = 1
c < b < a
True
c < a < b
False
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
print(None)
None
Funktionen, die 'nichts' zurückgeben, geben None
zurück:
print('test')
test
a = print('test')
test
print(a)
None
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
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
Einträge nach Erzeugung unveränderbar:
tup[1] = 7
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Input In [42], in <cell line: 1>() ----> 1 tup[1] = 7 TypeError: 'tuple' object does not support item assignment
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]}
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
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
Übungen 1, 2, und 3 können bearbeitet werden.
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.
def
¶Um mehrfach benötigten Code einfacher zu nutzen, können Funktionen definiert werden.
Vorteile:
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
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.listdir('.')
['plot.pdf', 'uncertainties.ipynb', 'README.md', 'python.ipynb', 'numeric-python.ipynb', 'data', 'matplotlib.ipynb', 'Makefile', 'plot_2.pdf', 'images', 'muon_plot.py', 'header-matplotlib.tex', '.gitignore', 'matplotlibrc_muon', 'scientific-python.ipynb', 'build', 'plot_1.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, die ihr verwenden solltet
import numpy as np
np.sum([1, 2]) # siehe numpy Kurs
3
.py
python programm.py
.py
) kann man als Module benutzen.test.py
im selben Ordner, so kann der Inhalt mit import test
in einer weiteren Datei verwendet werden.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]
Übung 4, 5 und 6 können bearbeitet werden.
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.
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'\qty{{{energy:.4f}}}{{\kilo\joule}}')
\qty{1.2346}{\kilo\joule}
Nur zur Demonstration einmal mit mehr Lücken (funktioniert so nicht in LaTeX wegen den Leerzeichen!):
print(fr'\qty {{ {energy:.4f} }} {{ \kilo\joule }}')
\qty { 1.2346 } { \kilo\joule }
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]
Übung 7 kann jetzt bearbeitet werden.
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!
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 c >= b")
else:
print("a <= b und b > c")
else:
print("a > b")
Input In [90] print("a <= b und c >= b") ^ IndentationError: expected an indented block after 'if' statement on line 6
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 c >= b")
else:
print("a <= b und b > c")
else:
print("a > b")
Input In [91] if a <= b ^ SyntaxError: expected ':'
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 c >= b")
else:
print("a <= b und b > c")
else:
print("a > b")
Input In [92] d = ((a + b) / (a + c)/((a + b) / (a + c)) ^ SyntaxError: '(' was never closed
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 c >= b")
else:
print("a <= b und b > c")
else:
print("a > b")
a > b
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) Input In [94], in <cell line: 4>() 1 names = ["Anna","Jan","Marie","Tim"] 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
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) Input In [95], in <cell line: 4>() 1 numbers = {"one": 1 ,"two": 2,"three": 3,"four": 4} 2 # Analog zum Beispiel mit der Listen Index 3 # Der key "five" ist nicht in dem Dictionary vorhanden ----> 4 numbers["five"] KeyError: 'five'
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) Input In [96], in <cell line: 13>() 10 x = 2 11 y = 2 ---> 13 add_one_to_inverse_difference(x,y) Input In [96], in add_one_to_inverse_difference(a, b) 4 def add_one_to_inverse_difference(a, b): ----> 5 return 1 + inverse_difference(a, b) Input In [96], in inverse_difference(a, b) 1 def inverse_difference(a, b): ----> 2 return 1/(a - b) ZeroDivisionError: division by zero
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 1020 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 + 1020
step_5 = step_4 - birth_year
return step_5
Mit der Schuhgröße 45 und dem Geburtsjahr 1993, kriege ich die Zahl 4527
raus.
Ich habe (wie erwähnt die Schuhgröße 45) und bin 27 Jahre alt.
Wie funktioniert dieser Trick?!
shoesize_and_age(45, 1993)
4527
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 + 1020
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: 6520 step_5: 4527
4527
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 + 1020
step_5 = step_4 - birth_year
IPython.embed()
return step_5
shoesize_and_age(45, 1993)
Python 3.10.4 (main, Mar 31 2022, 08:41:55) [GCC 7.5.0] Type 'copyright', 'credits' or 'license' for more information IPython 8.4.0 -- An enhanced Interactive Python. Type '?' for help.
--------------------------------------------------------------------------- StdinNotImplementedError Traceback (most recent call last) File /tmp/ipykernel_23561/2333610718.py:1, in <cell line: 1>() ----> 1 shoesize_and_age(45, 1993) File /tmp/ipykernel_23561/4086330078.py:10, in shoesize_and_age(shoesize, birth_year) 7 step_4 = step_3 + 1020 8 step_5 = step_4 - birth_year ---> 10 IPython.embed() 12 return step_5 File ~/.local/anaconda3/envs/toolbox/lib/python3.10/site-packages/IPython/terminal/embed.py:399, in embed(header, compile_flags, **kwargs) 396 frame = sys._getframe(1) 397 shell = InteractiveShellEmbed.instance(_init_location_id='%s:%s' % ( 398 frame.f_code.co_filename, frame.f_lineno), **kwargs) --> 399 shell(header=header, stack_depth=2, compile_flags=compile_flags, 400 _call_location_id='%s:%s' % (frame.f_code.co_filename, frame.f_lineno)) 401 InteractiveShellEmbed.clear_instance() 402 #restore previous instance File ~/.local/anaconda3/envs/toolbox/lib/python3.10/site-packages/IPython/terminal/embed.py:245, in InteractiveShellEmbed.__call__(self, header, local_ns, module, dummy, stack_depth, compile_flags, **kw) 241 self.show_banner() 243 # Call the embedding code with a stack depth of 1 so it can skip over 244 # our call and get the original caller's namespaces. --> 245 self.mainloop( 246 local_ns, module, stack_depth=stack_depth, compile_flags=compile_flags 247 ) 249 self.banner2 = self.old_banner2 251 if self.exit_msg is not None: File ~/.local/anaconda3/envs/toolbox/lib/python3.10/site-packages/IPython/terminal/embed.py:337, in InteractiveShellEmbed.mainloop(self, local_ns, module, stack_depth, compile_flags) 334 self.set_completer_frame() 336 with self.builtin_trap, self.display_trap: --> 337 self.interact() 339 # now, purge out the local namespace of IPython's hidden variables. 340 if local_ns is not None: File ~/.local/anaconda3/envs/toolbox/lib/python3.10/site-packages/IPython/terminal/interactiveshell.py:665, in TerminalInteractiveShell.interact(self) 662 print(self.separate_in, end='') 664 try: --> 665 code = self.prompt_for_code() 666 except EOFError: 667 if (not self.confirm_exit) \ 668 or self.ask_yes_no('Do you really want to exit ([y]/n)?','y','n'): File ~/.local/anaconda3/envs/toolbox/lib/python3.10/site-packages/IPython/terminal/interactiveshell.py:424, in TerminalInteractiveShell.init_prompt_toolkit_cli.<locals>.prompt() 422 def prompt(): 423 prompt_text = "".join(x[1] for x in self.prompts.in_prompt_tokens()) --> 424 lines = [input(prompt_text)] 425 prompt_continuation = "".join(x[1] for x in self.prompts.continuation_prompt_tokens()) 426 while self.check_complete('\n'.join(lines))[0] == 'incomplete': File ~/.local/anaconda3/envs/toolbox/lib/python3.10/site-packages/IPython/utils/py3compat.py:48, in input(prompt) 47 def input(prompt=""): ---> 48 return builtin_mod.input(prompt) File ~/.local/anaconda3/envs/toolbox/lib/python3.10/site-packages/ipykernel/kernelbase.py:1174, in Kernel.raw_input(self, prompt) 1167 """Forward raw_input to frontends 1168 1169 Raises 1170 ------ 1171 StdinNotImplementedError if active frontend doesn't support stdin. 1172 """ 1173 if not self._allow_stdin: -> 1174 raise StdinNotImplementedError( 1175 "raw_input was called, but this frontend does not support input requests." 1176 ) 1177 return self._input_request( 1178 str(prompt), 1179 self._parent_ident["shell"], 1180 self.get_parent("shell"), 1181 password=False, 1182 ) 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.