Computer Setup OLD [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== 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).

===== - Terminal =====

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

===== - Python installieren (System-Installation) =====

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:
```bash
py -VERSION myprog.py
```
also z.B.
```bash
py -3.7 myprog.py
```

==== - Installation von Python Modulen ====

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
```bash
pip install numpy
```
Möchtest du alle installierten Module, sowie deren Version einsehen, tippe
```bash
pip **freeze**
```
Schreibe diese Information in eine Datei:
```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
```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:
```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:
```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
```

==== - Ausführen von Python Programmen ====

Erstelle eine kleine Testdatei mit dem Namen `helloworld.py` mit Inhalt:
```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:
```bash
python helloworld.py
```

===== - Python installieren II (Virtual Environments (VE)) =====

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.

==== - Erstellen eines Virtual Environment ====

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
```bash
python -m venv env
```

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

==== - Aktivieren und Deaktivieren eines VE ====

**Aktiviere** das VE *env* mit:
```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:
```bash
(env) C:\Users\...
```

Möchtest du nun im gewählten VE ein Python Programm ausführen, tippe einfach
```bash
python mein_programm.py
```

**Deaktiviere** das VE mit
```bash
deactivate
```

==== - Module ====

Du kannst nun mit *pip* Module installieren (siehe [Installation von Python Modulen](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:
```bash
pip install -r requirements.txt
```

==== - Wrapper für virtuelle Environments ====

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?


==== - Anaconda VE ====

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.

===== - Git und GitHub =====

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

==== - Git ====

**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.

=== - Installation ===

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

=== - Gitignore ===

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.

=== - Erstellen eines Git Repository ===

== Git Repository initialisieren ==

Ö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
```bash
git init
```

== Status ==

Der **wichtigste Befehl** unter Git ist
```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. 

== Dateien zu Repository hinzufügen ==

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.

![](figures/git_wokingdir_index_head.PNG){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
```bash
git add <filename>
```
Mit
```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**:
```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*.

=== - Mit Git arbeiten ===

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
```bash
git add <filename>
```
fügst du wieder ein gezieltes File dem Index hinzu, mit
```bash
git add *
```
fügst du alle ungetrackten Files hinzu.

**Committe deine Änderungen** nun mit 
```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
```bash
git rm --cached fileName
git rm -r --cached folderName
```

Zeige alle von Git getrackten Dateien
```bash
git ls-files # oder:
git ls-tree -r master
```


==== - GitHub ====

**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)

![](figures/github_idea.PNG){width=300}

=== - Account ===

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.

### Repository auf GitHub erstellen

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
```bash
git clone https://github.com/username/repo_name.git
```

=== - Repository lokal erstellen ===

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:
```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
```bash
git remote -v
```
Nun können die Daten auf GitHub gepushed werden:
```bash
git push origin master
```

Möchte man ein **remote Repository entfernen**, so tippt man
```bash
git remote rm origin
```

=== - Mit GitHub arbeiten ===

Hast du lokal auf deinem Computer Änderungen vorgenommen und diese committed (siehe [Mit Git arbeiten](Mit_Git_arbeiten)), so kannst du diese auf GitHub **pushen**:
```bash
git push
```
Gehe nun auf GitHub und vergewissere dich, dass alles geklappt hat.

=== - Kollaborationen ====

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.

=== - Diff ===

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

=== - Branches ===

TODO

==== - Alternativen zu GitHub ====

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

==== - Git-Clients ====

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.


===== - IDE (Integrated Development Environment) =====

Wir haben oben gesehen, dass man Python Programme mit einem beliebigen Editor schreiben und im Terminal ausführen kann mit
```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 =====

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:

![](figures/stack_overflow_2019_ide.PNG){width=300}

==== - Installation ====

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 ====

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)

==== - Einstellungen ====

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. 

=== - Globale 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)*

=== - Lokale Projekteinstellungen ===

Ö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.

==== - Key Bindings ====

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](https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf)
* [Shortcuts für MacOS](https://code.visualstudio.com/shortcuts/keyboard-shortcuts-macos.pdf)
* [Shortcuts für Linux](https://code.visualstudio.com/shortcuts/keyboard-shortcuts-linux.pdf)

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 **S**hortcut-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

==== - Python Interpreter & Debugger konfigurieren ====

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:
```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:
```python
import sys
sys.executable
```

Folgende **globalen Einstellungen** werden als Startpunkt empfohlen
```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.

=== - Gezieltes Programm ausfü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:

<code json>
"program": "${workspaceFolder}/main.py",
</code>


==== - Mit VS Code arbeiten ====

**Ö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.


==== - 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.

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 ====

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

=== - Vordefinierte Snippets ===

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:

```python
if condition:
    pass
else:
    pass
```

Diesen kann man dann entsprechend anpassen.

=== - Selbst definierte Snippets ===

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.