Computer Setup OLD

In diesem kurzen Tutorial geht es darum, ein professionelles Setup für die Entwicklung von Python Programmen zu errichten. Das Tutorial ist für Windows User gedacht, das Meiste sollte aber auch für Unix-Systeme (MacOS und Linux) zutreffen. An einigen Orten gibt es aber mit Sicherheit Abweichungen.

Dieses Tutorial wird laufend weiterentwickelt. Falls du Verbesserungsvorschläge oder Anmerkungen zu diesem hast, so melde dich bitte bei mir (persönlich oder per Mail).

Es lohnt sich, sich mit dem Terminal (Konsole, Eingabeaufforderung) etwas vertraut zu machen.

Hier die wichtigsten Befehle:

• dir (Windows), ll und ls (Unix): Zeigt alle Dateien und Unterordner im jetzigen Ordner an
• mkdir meinOrdner erstellt einen neuen Ordner mit Namen meinOrdner
• cd meinOrdner: navigiere in den Ordner meinOrdner hinein. cd steht für change directory, also wechsle Ordner
• cd ..: navigiere zum übergeordneten Ordner
• Tippe die ersten Buchstaben eines Befehls, nutze dann die TAB-Taste zur Autovervollständigung. Mehrmaliges drücken geht durch alle Möglichkeiten hindurch.
• tree /F: Zeige Baumstruktur des aktuellen Ordners mitsamt allen Unterordnern

Gehe auf https://www.python.org/downloads/, lade die neuste Version von Python 3 hinunter und installiere diese.

Wichtig: Füge Python zu deinem Pfad hinzu. Dazu musst du bei der Installation die Option Add Python 3… to PATH anwählen.

Dieser Schritt ist auch empfohlen, wenn du bereits Anaconda bereits installiert hast.

Bist du mit der Installation fertig, überprüfe ob alles klappt: Öffne den Terminal und tippe python. Python sollte nun im Terminal geöffnet werden. Um diesen Modus wieder zu schliessen, tippe exit().

Möchtest du eine neue Version von Python installieren, so musst du diese von der Website https://www.python.org/ herunterladen und installieren. Diese Version wird dann parallel zu den alten Versionen installiert. Per Default, also wenn du ein Programm in der Konsole ausführst mit python myprog.py, sollte dann aber die neuste Version ausgeführt werden.

Falls du nun mehrere Versionen parallel installiert (sagen wir v3.7 und v3.8) hast und eine bestimmte Version verwenden möchtest, kannst du dies wie folgt tun:

snippet.bash

py -VERSION myprog.py

also z.B.

snippet.bash

py -3.7 myprog.py

Um sicherzustellen, dass Python läuft, tippe einfach python. Du siehst dann, welche Version von Python genau installiert wurde und du kannst gleich im Terminal in Python Programmieren. Möchtest du Python wieder schliessen, tippe exit().

Bisher hast du nur die Grundinstallation von Python gemacht, es gibt aber noch eine Vielzahl von Modulen, die einem viele weitere Möglichkeiten bieten. Diese können dann separat installiert werden.

pip ist ein Paketverwaltungsprogramm und steht für pip installs packages (Achtung Informatikerhumor!). Um Module wie z.B. numpy zu Installieren, tippe im Terminal einfach

snippet.bash

pip install numpy

Möchtest du alle installierten Module, sowie deren Version einsehen, tippe

snippet.bash

pip **freeze**

Schreibe diese Information in eine Datei:

snippet.bash

pip freeze > requirements.txt

Mit pip kannst du nun alle Module herunterladen, die du für dein Projekt benötigst. Indem du nur genau diejenigen herunterlädst, die du auch wirklich benötigst, kannst du die Installation schön schlank halten.

Um ein Modul, z.B. numpy zu deinstallieren, tippe

snippet.bash

pip uninstall numpy

Falls du mehrere Versionen von Python installiert hast und für eine bestimmte ein Modul (de)installieren möchtest, kannst du dies wie folgt tun:

snippet.bas

python -VERSION -m pip install PACKAGE # allgemeiner Befehl
python -3.7 -m pip install numpy # konkretes Programm

Alternativ kannst du auch die entsprechende exe-Datei angeben:

snippet.bash

PATH\python.exe -m pip install numpy

Falls du z.B. alle für v3.7 installierten Module auch für v3.8 installieren möchtest, kannst du dies wie folgt machen:

python -3.7 -m pip freeze > requirements.txt
python -3.8 -m pip install -r requirements.txt

Erstelle eine kleine Testdatei mit dem Namen helloworld.py mit Inhalt:

snippet.python

print("Hello World")

Verwende dazu einen Beliebigen Editor. Navigiere nun im Terminal in den Ordner, in dem die Datei gespeichert ist. Führe das Programm nun wie folgt aus:

snippet.bash

python helloworld.py

Mit einem Virtual Environment ist eine isolierte Python Umgebung gemeint, die man z.B. für ein gewisses Projekt erstellt. Wenn man an unterschiedlichen Projekten arbeitet, die unterschiedliche Python-Versionen benötigen oder für die Abhängigkeiten unterschiedlicher Versionen erforderlich sind, dann macht es Sinn eine Möglichkeit zu haben, diese Projekte voneinander zu separieren. Mit virtuellen Umgebungen wird genau dies realisiert.

Erstelle einen neuen Ordner für dein Projekt und navigiere im Terminal in diesen.

Erstelle ein neues VE mit Namen env (oder welchen Namen auch immer) mit

snippet.bash

python -m venv env

In deinem Projektordner wurde ein Ordner env erstellt, der das VE beinhaltet. Überprüfe dies mit dem dir Befehl.

Aktiviere das VE env mit:

snippet.bash

env\Script\activate

Beachte: Hast du dem VE einen anderen Namen gegeben, so musst du den Befehl entsprechend anpassen.

Im Prompt wird nun angezeigt, dass das VE env ausgewählt wurde:

snippet.bash

(env) C:\Users\...

Möchtest du nun im gewählten VE ein Python Programm ausführen, tippe einfach

snippet.bash

python mein_programm.py

Deaktiviere das VE mit

snippet.bash

deactivate

Du kannst nun mit pip Module installieren (siehe Installation von Python Modulen)

Stelle dir folgende Situation vor: Ein Kollege von dir hat ein cooles Python Programm geschrieben und hat es dir geschickt, damit du es selbst ausführen und weiterentwickeln kannst. Vielleicht hat er Module installiert, die du nicht installiert hast. Weiter hat er vielleicht einige Module in einer älteren oder neueren Version installiert wie du. Schliesslich werden Module wir numpy werden ständig weiterentwickelt und es werden neue Versionen veröffentlicht. Es kann deshalb sein, dass dein Programm nicht sauber oder gar nicht sein.

Fehlende Module zu installieren ist weniger ein Problem. Auf keinen Fall aber möchtest du Module mit deren älteren Versionen ersetzen, da dann deine eigenen Programme eventuell nicht mehr funktionieren.

Die Lösung ist einfach: Erstelle ein VE für dieses Projekt, in dem du die genau gleichen Programme in genau der gleichen Version installierst wie dein Kollege. Ganz einfach geht dies, falls dein Kollege selbst in einem VE gearbeitet hat. Er kann ganz einfach ein requirements.txt File erstellen und dir schicken. Erstelle nun selbst ein VE. Mit dem folgenden Befehl kannst du dann genau die gleichen Module in der genau gleichen Version wie sie vom Kollegen verwendet wurden installieren:

snippet.bash

pip install -r requirements.txt

Die oben besprochenen virtual Environments venv eignen sich besonders, wenn man für ein einzelnes Projekt eine eigene solche Umgebung haben möchte. Möchte man aber ein virtuelle Environment schaffen, welches für verschiedene Projekte genutzt werden soll, bietet sich virtualenvwrapper an.

Installiere virtualenvwrapper für eine Python Installation:

python -m pip install virtualenvwrapper

Das erste Argument Python muss jenachdem durch den genauen Pfad der Python-Executable ersetzt werden.

TODO:

• Rest
• Wie funktioniert unter Windows?

Die Python-Installation, die mit Anaconda installiert wird, ist ebenfalls ein VE. Du kannst dieses über den Anaconda Prompt im Terminal öffnen. Du kannst dort auch weitere Anaconda-VE erstellen. Ich empfehle aber eher, dies getrennt von Anaconda wie hier beschrieben zu machen.

Dies hat nichts mit Python direkt zu tun, sondern mit Programmieren im Allgemeinen.

Git ist ein einfaches aber sehr mächtiges Versionierungstool, welches von sehr vielen Programmieren verwendet wird.

Das folgende Tutorial begleitet dich durch die Installation und die wichtigsten Schritte: https://rogerdudler.github.io/git-guide/index.de.html

Das Wichtigste wird hier doch noch kurz erläutert.

Auf MacOS und Linux sollte git bereits installiert sein. Falls du auf Windows arbeitest, lade git hier herunter und installiere es https://gitforwindows.org/.

Bei der Installation wirst du einige Entscheidungen treffen müssen. Wähle die folgenden Option:

• „Use Git from Git Bash only“
• „Use the OpenSSL library“
• „Checkout Windows-style, commit Unix-style line endings“
• „Use MinTTY“
• Wähle bei den „Configuring extra options“ alle Optionen an

Git ist nur für einfache Textdateien (z.B. .txt, .md, .tex) oder Programmiercode (z.B. .py) geeignet, da man dort Änderungen gut tracken kann und damit verschiedene Versionen gut vergleichen kann.

Git ist absolut ungeeignet für Bilder, Videos, Musik, zip-Files, Office-Dateien (.docx,…) oder PDF. Arbeitest du an einem Projekt, in welchem aus Programmiercode oder Textdateien PDFs erzeugt werden, solltest du diese PDFs von git ausschliessen. In einem Git-Repository kann man eine Datei .gitignore hinzufügen, in welchem festgelegt wird, welche Dateien oder Dateiformate ausgeschlossen, also von Git ignoriert werden.

Öffne die Git Bash und navigiere in den Ordner, der als Git Repository dienen soll. Dieser kann bereits Dateien und Unterordner beinhalten. Unter MacOS und Linux kannst du den normalen Terminal nutzen. Um ein neues Git Repository zu initialisieren, tippe

snippet.bash

git init

Der wichtigste Befehl unter Git ist

snippet.bash

git status

Er zeigt dir den aktuellen Status eines Repositories an.

Tipps:

• Tippe immer git status, wenn du dir unsicher bist, was du machen sollst.
• Gerade am Anfang bietet es sich an, nach jedem Schritt den Status zu überprüfen.

Dein lokales Repository besteht aus drei Instanzen, die von git verwaltet werden. Die erste ist deine Arbeitskopie, welche die echten Dateien enthält. Die zweite ist der Index, welcher als Zwischenstufe agiert und zu guter Letzt noch der HEAD, der auf deinen letzten Commit zeigt.

{width=300}

Hast du gerade ein Repository initialisiert, werden bereits vorhandene Dateien in rot angezeigt: Diese Files befinden sich erst im working dir und sind deshalb untracked, sie werden also von Git ignoriert.

Um ein einzelnes File zum Index hinzuzufügen, tippe

snippet.bash

git add <filename>

Mit

snippet.bash

git add *

werden alle Dokumente (auch in Unterordnern) getracked. Tippst du wieder git status werden diese Dateien jetzt in Grün dargestellt.

Nun musst du deine Änderungen noch bestätigen, also committen:

snippet.bash

git commit -am "initial commit"

Mit diesem ersten Commit hast du eine erste Version erstellt, quasi einen ersten Snapshot.

Tippst du nun git status, so erscheint die Nachricht nothing to commit, working tree clean.

Nun kannst du wie gehabt an deinem Projekt arbeiten:

• bestehende Files verändern
• bestehende Files löschen
• neue Ordner und Files hinzufügen

Tippst du git status, so wird angezeigt, welche Files modified oder deleted wurden oder noch untracked.

Mit

snippet.bash

git add <filename>

fügst du wieder ein gezieltes File dem Index hinzu, mit

snippet.bash

git add *

fügst du alle ungetrackten Files hinzu.

Committe deine Änderungen nun mit

snippet.bash

git commit -am "my commit message"

Wichtig:

• Commit-Nachrichten sollten auf Englisch geschrieben werden.
• Sie sollen zwar kurz aber auch …
• möglichst aussagekräftig sein.

Beispiel für eine ordentliche Commit-Nachricht: some bugs in myapp.py fixed, runs well now

Datei/Ordner von Git entfernen ohne es von lokalem Dateisystem zu löschen

snippet.bash

git rm --cached fileName
git rm -r --cached folderName

Zeige alle von Git getrackten Dateien

snippet.bash

git ls-files # oder:
git ls-tree -r master

GitHub ist eine Onlinedienst, auf welchen man seine Projekte, die mit Git versioniert werden, hochladen kann. Ein Projekt wird in einem sogenannten Repository gespeichert. Dabei unterscheidet man zwischen private Repositories (nur für Author zugänglich und Leute, die explizit dazu berechtigt werden) und public Repositories (für alle zugänglich).

Verwendungszwecke für GitHub:

• Backup (privat)
• Kollaborationen in Projekten (privat)
• Open Source Code veröffentlichen (public)
• Ausbildung: Abgabe von Aufträgen (privat)

{width=300}

Erstelle einen Account auf GitHub: https://github.com/. Du kannst auch einen Studenten Account beantragen, welcher mit irgendwelchen Vorteilen daher kommt.

Du hast nun zwei Möglichkeiten, wie du vorgehen möchtest, wenn du mit GitHub arbeiten möchtest.

Am einfachsten ist es, wenn du auf GitHub ein neues Repository eröffnest.

Clicke unter Repositories auf New. Gib dem Repository einen Namen. Dieser soll die folgenden Kriterien erfüllen.

• auf Englisch
• kurz aber zum Projekt passend
• keine Leerzeichen (verwende Underlines _)

Gib an, ob das Repo private oder public sein soll. Füge ein passendes Gitignore-File hinzu. Wàhle die Programmiersprache deines Projekts.

Für grössere Projekte oder für solche, die du veröffentlichen möchtest, lohnt es sich, die Option Initialize this repository with a README anzuwählen. Im zweiten Fall sollte man sich auch mit Lizenzen auseinandersetzen und eine solche hinzufügen.

Dann kannst du das Repo erstellen.

Klone das Repo nun auf deinen Computer. Hast du auf GitHub das Repo geöffnet, so kannst du unter Clone or download den Link zum Repo kopieren

snippet.bash

git clone https://github.com/username/repo_name.git

Alternativ kannst du ein bereits auf deinem deinem Rechner vorhandenes Projekt, welches du mit Git verwaltest, auf GitHub pushen.

Erstelle zuerst auf GitHub ein neues Repository. Üblicherweise hat dieses den gleichen Namen wie der Ordner deines Projekte (ist aber kein Muss). Wähle kein Gitignore-File und wähle die Option Initialize this repository with a README nicht an.

Nun musst du das lokale Repo mit dem leeren auf Repo auf GitHub verbinden:

snippet.bash

git remote add origin https://github.com/username

Das Repo auf GitHub wird das remote Repository genannt (remote = entfernt). Das (oder die) remote Repository eines Projekts kann man anzeigen mit

snippet.bash

git remote -v

Nun können die Daten auf GitHub gepushed werden:

snippet.bash

git push origin master

Möchte man ein remote Repository entfernen, so tippt man

snippet.bash

git remote rm origin

Hast du lokal auf deinem Computer Änderungen vorgenommen und diese committed (siehe Mit Git arbeiten), so kannst du diese auf GitHub pushen:

snippet.bash

git push

Gehe nun auf GitHub und vergewissere dich, dass alles geklappt hat.

Du kannst ein privates Repo für andere GitHub-Benutzer freigeben, damit diese mit dir an diesem Arbeiten können. Wähle dazu auf GitHub das Repo an, klicke auf Settings / Collaborators und wähle den Benutzer aus.

Mit einem gratis Account von GitHub kannst du bis zu drei Collaborators zu einem Repo hinzufügen.

In der Git Bash können die Unterschiede zwischen zwei Files, normalerweise zwei unterschiedliche Versionen des gleichen Files, ganz einfach dargestellt werden:

snippet.bash

diff file1 file2

TODO

Es gibt andere Dienste, die in etwa das Gleiche anbieten wie GitHub, wie z.B. Bitbucket.

Git-Clients sind Programme mit graphischen Oberflächen, mit denen man die oben beschriebenen Arbeitsschritte ebenfalls vornehmen kann. Ein Beispiel dafür ist GitKraken. Es ist aber empfohlen, sich daran zu gewöhnen, mit der Git Bash zu arbeiten. Einige IDEs wie Visual Studio oder Visual Studio Code haben einen integrierten Git-Client.

Wir haben oben gesehen, dass man Python Programme mit einem beliebigen Editor schreiben und im Terminal ausführen kann mit

snippet.bash

python mein_programm.py

Damit kann man im Prinzip alles erreichen, um den Komfort (und damit den Programmierspass) zu erhöhen, lohnt es sich, eine IDE (Integrated Development Environment) zu verwenden. Dies ist ein fancy Edior, mit dem man den Code gleich auf Knopfdruck ausführen kann. Typische Funktionen einer IDE sind:

• Autocomplete: Die IDE kennt die verwendete Programmiersprache. Beginnt man damit, einen Ausdruck zu tippen, so schlägt einem die IDE gleich vor, wie man den Ausdruck vervollständigen kann. Möchte man z.B. eine for-Schlaufe Programmieren, kann man in vielen IDEs for + TAB (+ TAB) zu tippen. Die Struktur einer for-Schlaufe wird dann automatisch generiert.
• Linting: Die IDE überprüft deinen Code fortlaufend und streicht (logische) Fehler sofort an. So kannst du Fehler korrigieren, bevor du den Code ausführst.
• Debugger: Man kann Breakpoints setzen, um den Code an beliebigen Punkten anzuhalten. Dies ist besonders geeignet, um Bugs ausfindig zu machen und zu beheben. Es ist auch sehr nützlich, um grosse und komplizierte Programme zu verstehen, in dem man deren Logik Schritt für Schritt folgt.

Um Python Programme zu schreiben gibt es viele geeignete Editors. Mit Anaconda wird bereits die Spyder-IDE mit installiert. Speziell für Python wurde auch Pycharm entwickelt. Es wird aber empfohlen, Visual Studio Code zu verwenden.

Visual Studio Code (VS Code) ist eine sehr mächtige IDE, die gratis und open Source ist. Mit VS Code kann man Code in den unterschiedlichsten Programmiersprachen entwickeln.

Stand 2019 ist VS Code die mit Abstand beliebteste IDE, wie der 2019 Survey von Stack Overflow zeigt:

{width=300}

Downloade und installiere VS Code: https://code.visualstudio.com/

Es ist sehr empfohlen, bei der Installation die folgenden Optionen anzuwählen:

• Aktion „Mit Code öffnen“ dem Dateikontextmenu von Windows-Explorer hinzufügen
• Aktion „Mit Code öffnen“ dem Verzeichniskontextmenu von Windows-Explorer hinzufügen
• Zu PATH hinzufügen

Auch empfohlen ist die Option:

• Code als Editor für unterstützte Dateitypen registrieren

Diese Option macht VS Code zu deinem Standardeditor. Entscheide selbst ob du dies möchtest. Mein Tipp: Mache es, VS Code ist wirklich toll!

Extensions sind Tools, die einem das Leben erleichtern sollen. Entwickelt man Python Programme, so lohnt es sich, einige Python-Extensions auszuprobieren

Klicke links auf Extensions (Ctrl+Shift+X) und tippe einen Suchbegriff, z.B. Python ein.

Empfehlungen:

• Python (Linting, Debugging …)* von Microsoft
• Visual Studio IntelliCode

weitere Empfehlungen:

• vscode-icons: schöne Icons
• GitLens: erweiterte Funktionalitäten für Git
• Live Share: Teilen vom VS Code Bildschirm z.B. für Support (habe noch nicht ausprobiert, falls du Lust hast, es auszuprobieren, melde dich bei mir)

In VS Code unterscheidet man zwischen globalen Einstellungen und lokalen Projekteinstellungen. Die ersten gelten für alle Projekte, die zweiten gelten für das jeweilige Projekt. Die lokalen Einstellungen überschreiben wenn nötig die globalen Einstellungen.

Klicke unten links auf das Zahnradsymbol, dann auf Settings / User. Dort kannst du deine Einstellungen vornehmen. Diese werden in einem JSON-Textfile gespeichert (mehr Info zu JSON: https://wiki.selfhtml.org/wiki/JSON). Am besten nimmst du Änderungen direkt in diesem File vor. Klicke dazu oben rechts auf das Symbol Open Settings (JSON).

Am einfachsten öffnest du die globalen Einstellungen aber wie folgt:<br> Command Palette / Open Settings (JSON)

Öffne/kreiere die lokalen Projekteinstellungen wie folgt:<br> Klicke unten links auf das Zahnradsymbol, dann auf Settings / Workspace / Open Settings (JSON)<br> Falls dieses noch nicht existiert, erstellt dies im Projektordner einen Unterordner .vscode und darin das File settings.json. Darin kannst du nun genau gleich Einstellungen vornehmen wie bei den globalen Einstellungen.

Es lohnt sich sehr, die wichtigsten Key Bindings (auch Shortcuts oder Key commands) eines Editors zu lernen. Die wichtigsten Key Bindings für VS Code findest du hier:

• Shortcuts für Windows
• Shortcuts für MacOS
• Shortcuts für Linux

Mehr Infos zu Key Bindings findest du hier: https://code.visualstudio.com/docs/getstarted/keybindings

Falls du die Key Bindings selbst editieren möchtest, öffne den Shortcut-Edior: Ctrl+K Ctrl+S

Falls du dir einen anderen Editor wie Sublime Text gewohnt bist, kannst du eine entsprechende Extension installieren, die dessen Key Bindings übernimmt.

Hier findest du eine (subjektive) Liste wichtiger Befehle:

VS Code allgemein:

• Command Palette: Ctrl+Shift+P
• Neues Fenster von VS Code: Ctrl+Shift+N
• Einstellungen öffnen: Ctrl+, (Komma)
• Keyboard Shortcuts: Ctrl+K Ctrl+S
• Zeige/Verstecke Sidebar: Ctrl+B
• Zeige Explorer: Ctrl+Shift+E
• VS Code im Terminal öffnen: in Terminal: code .

Coding:

• Kommentieren: Ctrl+K Ctrl+C
• Kommentieren aufheben: Ctrl+K Ctrl+U„ Linie duplizieren: Shift+Alt+Up (duplizieren nach oben), Shift+Alt+Down (nach unten)
• Word Wrap ein/aus: Alt+Z (lange Linien auf mehreren Zeilen anzeigen)
• Multi-line Edits: Bearbeite mehrere Zeilen gleichzeitig:
  • Alt gedrückt: kann Cursor an mehreren Orten setzen $\rightarrow$ mehrere Zeilen gleichzeitig bearbeiten
  • Shift+Alt+I: setzt Cursors an Ende aller selektierter Zeilen
  • Shift+Alt+I 2x Home: setzt Cursors an Anfang aller selektierter Zeilen
  • Esc: Multi-line Edit beenden

Du hast wahrscheinliche mehrere verschiedene Python Interpreter auf deinem Computer Installiert: Anaconda (ev. mit mehreren Virtual Environments), eine System-Installation, mehrere Virtuellen Environments. VS Code sollte diese alle automatisch erkennen. Du musst VS Code nun mitteilen, mit welchem Interpreter er ein Programm ausführen soll:

Klicke unten links auf Python … und wähle dann den gewünschten Interpreter.

Du kannst in den globalen Einstellungen angeben, welcher Python Interpreter per Default verwendet werden soll:

snippet.json

{
    "python.pythonPath": "C:\\..."
}

Falls du dir nicht sicher bist, wie der Pfad zum Interpreter lautet, gehe wie folgt vor: 1. Öffne die gewünschte Python Umgebung im Terminal. 2. Tippe python 3. Gib dann ein:

snippet.python

import sys
sys.executable

Folgende globalen Einstellungen werden als Startpunkt empfohlen

snippet.json

{
    "files.encoding": "utf8",
    "python.pythonPath": "C:\\...\\python.exe",
    "python.linting.enabled": true,
    "editor.formatOnSave": true,
    "launch": {
        "version": "0.2.0",
        "configurations": [
            {
                "name": "Python System: Integrated Terminal",
                "type": "python",
                "request": "launch",
                "program": "${file}",
                "console": "integratedTerminal"
            },
            {
                "name": "Python System: External Terminal",
                "type": "python",
                "request": "launch",
                "program": "${file}",
                "console": "externalTerminal"
            }
        ]
    }
}

Natürlich musst du den Eintrag für "python.pythonPath" anpassen.

Du kannst nun zwischen zwei Debuggern auswählen: Einen, bei dem die Konsole in VS Code integriert ist (Python System: Integrated Terminal), und eine mit einer externen Konsole (Python System: External Terminal). Beide Debugger greifen aber auf den gleichen Python Interpreter zurück.

Klicke auf F5 um den Code auszuführen.

Falls du an einem Projekt arbeitest, welches aus mehreren Codefiles besteht, du möchtest aber immer nur das Hauptfile (sagen wir, es heisse main.py) ausführen, so kannst du dies dem Debugger mitteilen. Gehe dazu ins settings.json File des Projekts (nicht die globalen Einstellungen!) und passe dort für die launch configuration die folgende Zeile an:

"program": "${workspaceFolder}/main.py",

Öffne einen Projektordner über File / Open Folder. Hast du bei der Installation die entsprechende Option angewählt, kannst du im File-Explorer dies auch direkt machen mit: Rechter Mausklick auf Ordner / Open with Code

Mit F5 kannst du Code auszuführen.

Man kann Breakpoints setzen, um den Code an beliebigen Punkten anzuhalten. Dies ist besonders geeignet, um Bugs ausfindig zu machen und zu beheben. Es ist auch sehr nützlich, um grosse und komplizierte Programme zu verstehen, in dem man deren Logik Schritt für Schritt folgt.

VS Code hat einen integrierten Debugger. Öffne diesen, in dem du links auf das Käfersymbol (bug) klickst.

Einen Breakpoint setzen geht wie folgt: Klicke im Code links von der Zeilennummer. Der Breakpoint wird mit einem roten Punkt gekennzeichnet.

Wichtige Key-Commands:

• Continue [F5]: Code ausführen, weiter laufen lassen (bis zum nächsten Breakpoint)
• Step over [F10]: Führe Code einen Schritt weiter aus. Funktionen werden einfach ausgeführt, ohne dass in die Definition der Funktion hineingesprungen wird.
• Step into [F11]: Springe in Definition der Funktion
• Step out [Shift + F11]: Springe aus Definition der Funktion hinaus
• Restart [Ctrl + Shift + F5]: Starte Code neu
• Stop [Shift + F5]: Stoppe Code

Code Snippets sind kleine Code Templates (also Vorlagen), die man immer wieder braucht.

Viele Snippets kommen bereits mit installierten Extensions daher. Hat man Python eingerichtet und tippt z.B. ifel, so erscheint ein Hinweis, dass ein if/else Snippet existiert. Mit Ctrl+Space kann man das Snippet dann anzeigen und mit Enter einfügen. Im Code wird dann die Struktur eines if-else Blocks eingefügt:

snippet.python

if condition:
    pass
else:
    pass

Diesen kann man dann entsprechend anpassen.

Man kann auch selbst Snipptes definieren:

CP / Preferences: Configure User Snippets

Dann muss man sich für den Snippet-Typ entscheiden:

• New global snippet file: Snippets für allen Projekte, kann Snippets für allen Programmiersprachen in einem File definieren
• New snippet file for '…': Snippets für das aktuelle Projekt
• wähle Programmiersprache aus: globale Snippets aber separates File für alle Programmiersprachen (empfohlen)

Sobald man eine dieser Möglichkeiten auswählt, wird ein entsprechendes File erstellt. Darin findet man Anweisungen, wie Snipptes zu definieren sind.