.. index:: Ipython (IDE) .. _ipython: .. _ipython -- eine Python-Entwicklungsumgebung: ``ipython`` -- eine Python-Entwicklungsumgebung =============================================== `Ipython `__ ist ein Interpreter-Frontend, das vielerlei nützliche Features zum interaktiven Entwickeln von Python-Projekten bietet. Er kann durch das gleichnamige Paket installiert werden: .. code-block:: bash sudo aptitude install ipython3 ipython3-qtconsole ipython3-notebook Die beiden letzten Pakete ermöglichen es, Ipython mit einer graphischen Oberfläche oder als Anwendung in einem Webbrowser zu starten. Nach der Installation kann das Programm in einer Shell mittels ``ipython3`` oder als graphische Oberfläche mittels ``ipython3 qtconsole`` aufgerufen werden. Gibt man in Ipython einen Python-Ausdruck ein und drückt ``Enter``, so wird dieser ausgewertet. Besteht der Ausdruck beispielsweise aus einem einzelnen Variablennamen, so wird eine String-Version dieser Variablen ausgegeben. .. _Navigationshilfen: Navigationshilfen ----------------- Ipython bietet gegenüber dem normalen Python-Interpreter für ein interaktives Arbeiten am Quellcode nicht nur ein Syntax-Highlighting, sondern auch folgende Funktionen: .. _Tab-Vervollständigung: .. rubric:: Tab-Vervollständigung Während man einen Python-Ausdruck oder einen Dateinamen schreibt, kann man diesen durch Drücken der ``Tab``-Taste vervollständigen. Gibt es mehrere Möglichkeiten zur Vervollständigung, so werden diese aufgelistet; bei Nutzung der Qt-Konsole kann zwischen den einzelnen Möglichkeiten durch erneutes Drücken von ``Tab`` gewechselt und die Auswahl mit ``Enter`` bestätigt werden. Gibt man einen Modulnamen ein, gefolgt von ``.``, so werden durch Drücken von ``Tab`` alle Funktionen des Moduls aufgelistet; Attributs- und Funktionsnamen, die mit ``_`` oder ``__`` beginnen, werden allerdings als "privat" gewertet und ignoriert. Gibt man zusätzlich den einleitenden Unterstrich ein, so lassen auch diese Attributs- beziehungsweise Funktionsnamen mit ``Tab`` auflisten und vervollständigen. .. _Weitere Tastenkürzel: .. rubric:: Weitere Tastenkürzel In Ipython erleichtern folgende weitere Tastenkürzel das Arbeiten: Navigation: * ``Ctrl u`` Lösche die aktuelle Zeile * ``Ctrl k`` Lösche vom Cursor bis zum Ende der aktuellen Zeile * ``Ctrl a`` Gehe an den Anfang der aktuellen Zeile * ``Ctrl e`` Gehe ans Ende der aktuellen Zeile Code-History: * :math:`\uparrow`: History rückwärts durchsuchen * :math:`\downarrow`: History vorwärts durchsuchen * ``Ctrl`` :math:`\uparrow`: History rückwärts nach Aufruf durchsuchen, der genauso beginnt wie der aktuell eingegebene Text * ``Ctrl`` :math:`\downarrow`: History vorwärts nach Aufruf durchsuchen, der genauso beginnt wie der aktuell eingegebene Text * ``Ctrl r``: History rückwärts nach Aufrufen durchsuchen, die den eingegebenen Text als Muster beinhalten Die letzten drei eingegeben Code-Zeilen können in Ipython zudem über die Variablen ``_``, ``__`` und ``___`` referiert werden. Startet man Ipython mittels ``ipython3`` als Shell-Anwendung, so kann (abhängig von den Einstellungen des jeweiligen Shell-Interpreters) nur begrenzt weit "zurück scrollen". Ruft man in Ipython Funktionen auf, die eigentlich sehr lange Ausgaben auf dem Bildschirm erzeugen würden, so kann man diese unterdrücken, indem man an die Anweisung ein ``;`` anhängt. Dies hat keine Auswirkung auf die Anweisung selbst, hilft aber dabei, die Interpreter-Sitzung übersichtlich zu halten. .. _Informationen zu Objekten: .. rubric:: Informationen zu Objekten Gibt man vor oder nach einem Variablennamen ein ``?`` an, so werden ausführliche Informationen zur jeweiligen Variable angezeigt. Setzt man das Fragezeichen vor oder nach einen Funktions- oder Klassennamen, so wird auch der Docstring der jeweiligen Funktion oder Klasse angezeigt: :: print? .. code-block:: python # Ergebnis: # Type: builtin_function_or_method # String form: # Namespace: Python builtin # Docstring: # print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) # Prints the values to a stream, or to sys.stdout by default. # Optional keyword arguments: # file: a file-like object (stream); defaults to the current sys.stdout. # sep: string inserted between values, default a space. # end: string appended after the last value, default a newline. # flush: whether to forcibly flush the stream. Schreibt man ``??`` anstelle von ``?``, so wird zusätzlich der Quellcode des jeweiligen Objekts angezeigt. .. todo docstring popup-fenster in qtconsole .. _magic-Funktionen: .. _magic: ``magic``-Funktionen -------------------- In Ipython ist es möglich, einige zusätzliche Funktionen aufzurufen; diese nur in Ipython-Sitzungen definierten Funktionen werden als ``magic``-Funktionen bezeichnet und mit ``%`` bzw. ``%%`` eingeleitet. Mittels ``%lsmagic`` werden beispielsweise alle derartigen Funktionen aufgelistet: .. code-block:: python %lsmagic .. code-block:: python # Ergebnis: # Available line magics: # %alias %alias_magic %autocall %autoindent %automagic %bookmark %cd # %colors %config %cpaste %debug %dhist %dirs %doctest_mode %ed %edit # %env %gui %hist %history %install_default_config %install_ext # %install_profiles %killbgscripts %load %load_ext %loadpy %logoff # %logon %logstart %logstate %logstop %lsmagic %macro %magic # %matplotlib %notebook %page %paste %pastebin %pdb %pdef %pdoc %pfile # %pinfo %pinfo2 %popd %pprint %precision %profile %prun %psearch # %psource %pushd %pwd %pycat %pylab %quickref %recall %rehashx # %reload_ext %rep %rerun %reset %reset_selective %run %save %sc # %store %sx %system %tb %time %timeit %unalias %unload_ext %who # %who_ls %whos %xdel %xmode # Available cell magics: # %%! %%HTML %%SVG %%bash %%capture %%debug %%file %%html %%javascript # %%latex %%perl %%prun %%pypy %%python %%python3 %%ruby %%script %%sh # %%svg %%sx %%system %%time %%timeit %%writefile Im folgenden werden einige der ``magic``-Funktionen kurz vorgestellt. .. _Magic-Funktionen automatisch erkennen: .. rubric:: Magic-Funktionen automatisch erkennen Durch eine Eingabe von ``%automagic`` im Ipython-Interpreter werden im Verlauf der Sitzung die Namen der Magic-Funktionen in den globalen Namensraum aufgenommen. Im folgenden kann damit wahlweise ``pwd`` oder ``%pwd`` eingegeben werden, um den Namen des aktuellen Arbeitsverzeichnisses anzuzeigen; das beziehungsweise die ``%``-Zeichen können anschließend also weggelassen werden. .. _Wissenschaftliche Notation von Zahlen: .. rubric:: Wissenschaftliche Notation von Zahlen Mittels der ``%precicion``-Anweisung kann eingestellt werden, in welchem Format Zahlenergebnisse im Ipython-Interpreter ausgegeben werden sollen. Persönlich empfinde ich folgende Einstellung als angenehm: .. code-block:: python %precision %.4g Mit dieser Einstellung erhält man Ergebnisse mit wissenschaftlicher "e-Notation" dargestellt, wobei maximal drei Nachkommastellen ausgegeben werden; beispielsweise liefert auf diese Weise die Eingabe ``5/100000000000000000000`` das Ergebnis ``5e-20``. .. Add (or edit) the line c.InteractiveShellApp.exec_lines = ['%precision %.4g'] .. http://stackoverflow.com/questions/16866761/set-ipythons-default-scientific-notation-threshold .. _Zeilen und Zellen: .. rubric:: Zeilen und Zellen Ipython kennt -- ebenso wie der Standard-Python-Interpreter -- zwei Arten von Anweisungen: Zum einen "simple" einzeilige Anweisungen, zum anderen "zusammengesetzte" Anweisungen, die aus mehreren Zeilen bestehen. In Ipython wird eine solche Block-Anweisung, die stets mit einer leeren Zeile endet, auch als "Zelle" bezeichnet. Die ``line magic``-Funktionen beziehen sich auf eine einzelne, einzeilige Anweisung; den ``cell magic``-Funktionen werden hingegen der jeweiligen Anweisung weitere Zeilen angefügt. Beispielsweise kann mittels ``%% writefile dateiname`` der unmittelbar folgenden Text (ohne Anführungszeichen!) in eine Datei geschrieben werden, bis die Eingabe durch ein zweimaliges Drücken von ``Enter`` beendet wird. :: %%writefile test.txt Hallo Welt! .. code-block:: python #Ergebnis: Writing tmp.txt Mittels ``%%writefile -a`` wird der folgende Text an die angegebene Datei angehängt; eine Eingabe von leeren Zeilen oder von formatiertem Text ist so allerdings nicht möglich, die unmittelbar folgende Texteingabe wird "as it is" geschrieben. .. _cpaste: .. _Code via Copy-und-Paste einfügen: .. rubric:: Code via Copy-und-Paste einfügen Versucht man einen ganzen Code-Block per Copy-und-Paste einzufügen, so kann es zu einer Fehlermeldung kommen, wenn der Block leere Zeilen enthält: Ipython sieht an dieser Stelle die Eingabe der "Zelle" als beendet an und beginnt die nächste (die dann meist eine falsche Einrückung aufweist). Um dieses Problem zu umgehen, kann man die Magic-Funktion ``%cpaste`` aufrufen: Anschließend wird der gesamte (beispielsweise mittels ``Paste``) eingefügte Text als eine einzige Eingabe-Zelle interpretiert -- bis ``Ctrl d`` gedrückt wird, oder eine Textzeile eingegeben wird, die lediglich die Zeichenkette ``--`` enthält. Auf diese Weise kann man beispielsweise :ref:`Vim ` mit dem Plugin :ref:`Vicle ` als Editor verwenden und von dort aus Code an einen Ipython-Shell-Interpreter senden. .. _Python-Skripte aufrufen: .. rubric:: Python-Skripte aufrufen Python-Skripte lassen sich folgendermaßen vom Ipython-Interpreter aus aufrufen: .. code-block:: python %run path/script.py [arguments] Befindet man sich bereits im Pfad der Programmdatei oder wechselt mittels ``os.chdir(path)`` dorthin, so kann die Pfadangabe im obigen Aufruf weggelassen werden. Der obige Aufruf entspricht dem üblichen Aufruf von ``python3 path/script.py`` in einer Shell. Benötigt das Skript gegebenenfalls weitere Argumente, so können diese im Anschluss an die Pfadangabe des Skripts angegeben werden. Ist das aufgerufene Skript fehlerhaft und/oder benötigt es zu lange zur Ausführung, so kann es mit ``Ctrl c`` unterbrochen werden (KeyboardInterrupt). Ein Vorteil der ``%run``-Anweisung liegt darin, dass alle im aufgerufenen Skript definierten Variablen und Funktionen importiert und anschließend in der interaktiven Sitzung genutzt werden können (als wären sie direkt eingeben worden). Ein weiterer Vorteil liegt darin, dass beim Aufruf von ``run`` zusätzliche Optionen angegeben werden können: * Mit ``%run -t`` ("timer") wird die Laufzeit des Python-Skript in Kurzform dargestellt. Der Timer listet auf, wie viel Zeit beim Ausführen des Skripts für System-Aufrufe, wie viel auf benutzerspezifische Rechenschritte und wie viel Gesamt benötigt wurde. * Mit ``%run -t`` ("profiler") wird die Laufzeit der einzelnen im Python-Skript aufgerufenen Anweisungen detailliert dargestellt. Der Profiler listet dabei auf, wie häufig eine Funktion aufgerufen wurde und wie viel Zeit dabei je Ausführung beziehungsweise insgesamt benötigt wurde. * Mit ``%run -d`` ("debugger") wird das Programm im Python-Debugger ``pdb`` gestartet. Der Debugger durchläuft das Programm Anweisung für Anweisung und hält dabei an vorgegebenen Breakpoints oder bei nicht abgefangenen Exceptions; man kann sich dann beispielsweise die Werte von Variablen anzeigen lassen, die für den auftretenden Fehler verantwortlich sein können. .. _Debugging: .. rubric:: Debugging Anstelle ein Python-Skript mittels ``%run -d script.py`` von Anfang an im Debugger zu starten, kann man in Ipython mittels ``%debug`` einen allgemeinen Debug-Modus aktivieren. In diesem Fall wird der Debugger automatisch gestartet, wenn eine nicht abgefangene Exception auftritt. .. _Interaktion mit der Shell: .. rubric:: Interaktion mit der Shell Im Ipython-Interpreter lassen sich Shell-Anweisungen ausführen, indem man diesen ein ``!`` voranstellt; beispielsweise listet ``!ls`` den Inhalt des aktuellen Verzeichnisses auf. Gibt man ``files = !ls`` ein, so wird die Ausgabe der Shell-Anweisung ``ls`` als Liste in der Python-Variablen ``files`` gespeichert. Umgekehrt kann man den Inhalt von Python-Variablen an die Shell-Anweisung übergeben, indem man der Variablen ein ``$``-Zeichen voranstellt. Man könnte also ``!echo "$files`` eingeben, um die in der Variablen ``files`` gespeicherten Inhalte mittels :ref:`echo ` auszugeben. .. _Konfigurationen: Konfigurationen --------------- Eigene Konfigurationen lassen sich in Ipython mittels so genannter "Profile" festlegen. Auf diese Weise kann beispielsweise festgelegt werden, welche Module beim Start von Ipython automatisch geladen oder welche Variablen standardmäßig definiert werden sollen; die Ipython-Profile ermöglichen darüber hinaus weitere Möglichkeiten, das Aussehen und Verhalten des Interpreters zu steuern. Ein neues Profil kann folgendermaßen erstellt werden: .. code-block:: sh # Profil "default" erstellen: ipython3 profile create # Profil "profilname" erstellen: ipython3 profile create profilname Hierdurch wird das Profil mit dem angegebenen Namen im Verzeichnis ``~/.ipython`` neu angelegt; lässt man den Profilnamen weg, so wird das Profil automatisch ``default`` genannt. Bei künftigen Sitzungen wird, sofern vorhanden, das Profil ``default`` automatisch geladen, außer man wählt startet Ipython explizit mit dem angegebenen Profilnamen: .. code-block:: sh # Ipython mit "default"-Profil starten: ipython3 # Ipython mit "profilname"-Profil starten: ipython3 --profile=profilname Durch das Erstellen eines Profils wird im Verzeichnis ``~/.ipython/profile_default`` (oder einem entsprechenden Profilnamen) automatisch ein Satz Konfigurationsdateien erstellt. Die wichtigsten Konfigurationsdateien sind: * ``ipython_qtconsole_config.py``: Diese Datei wird aufgerufen, wenn Ipython mittels ``ipython3 qtconsole``, also mit graphischer QT-Console gestartet wird. * ``ipython_notebook_config.py``: Diese Datei wird aufgerufen, wenn Ipython mittels ``ipython3 notebook``, also als Webanwendung gestartet wird. * ``ipython_config.py``: Diese Datei wird *immer* aufgerufen, wenn Ipython mit dem angegebenen Profil gestartet wird. Alle Konfigurationen enthalten sämtliche Einstellungsoptionen mitsamt der zugehörigen Beschreibungen in Kommentarform; um eine Einstellung vorzunehmen, muss also nur das Kommentarzeichen am Anfange der jeweiligen Zeile entfernt und der Konfig-Variable der gewünschte Wert zugewiesen werden. Abgesehen von vielen zusätzlichen Kommentaren kann eine Konfigurationsdatei somit beispielsweise folgendermaßen aussehen: .. code-block:: python # sample ipython_config.py # Configuration file for ipython. c = get_config() # lines of code to run at IPython startup. c.InteractiveShellApp.exec_lines = [ 'import math as m', 'import numpy as np', 'import matplotlib as mpl', 'import matplotlib.pyplot as plt', 'import sympy as sy', 'import pandas as pd', 'pi = m.pi', 'sq = m.sqrt', 'sin = m.sin', 'cos = m.cos', 'tan = m.tan', 'atan = m.atan', 'rad = m.radians', 'deg = m.degrees', 'g = 9.81', '%precision %.4g', ] # Autoindent IPython code entered interactively. c.InteractiveShell.autoindent = True # Enable magic commands to be called without the leading %. c.TerminalInteractiveShell.automagic = True c.TerminalInteractiveShell.history_length = 10000 # Set the color scheme (NoColor, Linux, or LightBG). c.TerminalInteractiveShell.colors = 'Linux' c.TerminalInteractiveShell.color_info = True Die einzelnen Optionen können bei Bedarf auch innerhalb einer laufenden Sitzung geändert werden; hierzu muss man lediglich eine Anweisung der Form ``%config InteractiveShell.autoindent = True`` eingeben. .. todo DEMO-Funktion https://ipython.org/ipython-doc/2/interactive/reference.html#interactive-demos .. todo EMBEDDING Ipython https://ipython.org/ipython-doc/2/interactive/reference.html .. todo Ipythen Kernel -> Debugging .. https://ipython.readthedocs.io/en/stable/interactive/plotting.html Weitere Infos zu Ipython gibt es in der offiziellen `Dokumentation (en.) `__.