|
|
[[_TOC_]]
|
|
|
|
|
|
## Einleitung und Werkzeuge
|
|
|
Python ist eine relativ leicht zu erlernende Programmiersprache. Dieser Kasten bietet auf den nächsten Seiten eine kurze Einführung. Wenn Sie das Betriebssystem Raspbian auf dem Raspberry Pi installiert haben, ist bereits alles Nötige vorhanden, um Python-Skripte auszuführen.
|
|
|
|
|
|
Bei den meisten Linux-Distributionen ist Python ebenfalls vorinstalliert. Benutzer von Ubuntu 18.04 oder Linux Mint 19 starten Python in einem Terminalfenster mit dem Befehl python2 (beispielsweise Version 2.7) oder python3 (beispielsweise Version 3.6). Welche Version genau installiert ist, findet man mit
|
|
|
|
|
|
```
|
|
|
python2 --version
|
|
|
```
|
|
|
beziehungsweise
|
|
|
```
|
|
|
python3 --version
|
|
|
```
|
|
|
heraus.
|
|
|
|
|
|
Bei einigen Systemen startet der Befehl python alleine die Standard-Python-Umgebung.
|
|
|
In der Regel sollten Sie immer die aktuellste Python-Version verwenden. **Unsere Beispiele beziehen sich daher immer auf Python3.**
|
|
|
|
|
|
**Editoren:**
|
|
|
Python-Skripte sind einfache Textdateien, die sich mit jedem beliebigen Texteditor erstellen lassen. Beim aktuellen Raspbian 10 (Buster) starten Sie über das Menü und „Entwicklung -> mu“ einen Editor, über den Sie Skriptcode bequem eingeben, prüfen und starten können.
|
|
|
|
|
|
Wer diesen Editor auch unter Ubuntu/Mint verwenden möchte, installiert zuerst das Tool PIP (Python Package Installer) über die Paketverwaltung des Systems (für Python3):
|
|
|
```
|
|
|
sudo apt install python3-pip python3-setuptools
|
|
|
```
|
|
|
Anschließend aktualisieren Sie das Tool:
|
|
|
```
|
|
|
pip3 install -U pip
|
|
|
```
|
|
|
Die Installation ohne vorangestelltes "sudo" erfolgt für den aktuell angemeldeten Benutzer in den Ordner "~/.local/bin". Dieser befindet sich aber noch nicht in der Umgebungsvariablen PATH, was Sie mit aufruf von
|
|
|
```
|
|
|
source ~/.profile
|
|
|
```
|
|
|
ändern. Nach einem Neustart befindet sich der Ordner automatisch in der Umgebungsvariablen PATH.
|
|
|
Jetzt können Sie den Mu-Editor einrichten:
|
|
|
```
|
|
|
pip3 install mu-editor
|
|
|
```
|
|
|
Weitere empfehlenswerte Editoren für Python-Scripts sind Microsoft Visual Studio Code (https://code.visualstudio.com/) und Eric Python IDE (https://eric-ide.python-projects.org).
|
|
|
|
|
|
## Ein erstes Python-Skript
|
|
|
Geben Sie im Editor die Zeile
|
|
|
```python
|
|
|
print('Hello World')
|
|
|
```
|
|
|
ein und speichern Sie die Datei unter dem Namen „hello.py“. Klicken Sie auf „Ausführen“. Im unteren Bereich öffnet sich das Fenster des Python-Interpreters, in dem „Hello World“ ausgegeben wird. Der Befehl „print“ gibt den in der Klammer enthaltenen Text (Zeichenfolge/String) aus, der ein einfachen oder doppelten Anführungszeichen stehen muss. Klicken Sie auf „Stopp“, um den Skript-Interpreter wieder zu beenden.
|
|
|
|
|
|
**Python unterscheidet zwischen Groß- und Kleinschreibung**. „Print“ mit einem großen „P“ am Anfang führt zu einem Fehler. Probieren Sie es aus. Sie erhalten nach einem Klick auf „Ausführen“ die Meldung „NameError: name 'Print' is not defined“. Nach einem Klick auf „Prüfen“ sehen Sie die Meldung „undefined name 'Print'“, ein Pfeil zeigt auf den fehlerhaften Befehl.
|
|
|
|
|
|
## Einfache Variablen verwenden
|
|
|
Oft muss man Text oder Zahlen in Variablen speichern, etwa für Textausgaben oder Berechnungen. Für die Definition und Ausgabe auf den Bildschirm genügen diese beiden Zeilen:
|
|
|
```python
|
|
|
MeinName = 'Sepp'
|
|
|
print('Mein Name ist: ' + MeinName)
|
|
|
```
|
|
|
Der Variablen „MeinName“ wird die Zeichenfolge „Sepp“ zugewiesen. Hinter dem print-Befehl wird an „Mein Name ist: “ per Pluszeichen der Inhalt der Variablen angehängt. Das Ergebnis ist
|
|
|
```python
|
|
|
Mein Name ist: Sepp
|
|
|
```
|
|
|
Auch hier ist die Groß-/Kleinschreibung zu beachten. Die Variable „meinname“ ist eine andere als „MeinName“. Variablen dürfen aus Groß- und Kleinbuchstaben (a-z, A-Z), Ziffern (0-9) und dem Unterstrich bestehen.
|
|
|
|
|
|
Bei den **Anführungszeichen** haben Sie die freie Wahl. Sie können einfache Anführungszeichen (wie im Beispiel) verwenden oder doppelte Anführungszeichen (": Shift-2).
|
|
|
|
|
|
Sollen Variablen Zahlen enthalten, mit denen Sie rechnen wollen, entfallen die Anführungszeichen (vier Zeilen):
|
|
|
```python
|
|
|
zahl1 = 2
|
|
|
zahl2 = 4
|
|
|
ergebnis = zahl1 + zahl2
|
|
|
print(str(ergebnis))
|
|
|
```
|
|
|
Mit „zahl1 + zahl2“ addiert Python die Werte. Entsprechend verwenden Sie „-“, „*“ und „/“. Variablen müssen nicht deklariert werden. Python erkennt den Inhalt automatisch. Fehlen die Anführungszeichen, handelt es sich um einen Integerwert, durch einen Dezimalpunkt wird daraus ein Fließkommawert (Dezimalzahl):
|
|
|
```python
|
|
|
zahl1 = 2.45
|
|
|
```
|
|
|
Da „print“ nur Zeichenketten ausgeben kann, es sich bei „ergebnis“ aber um einen Ganzzahlwert (Integer) handelt , muss die Variable mit „str(ergebnis)“ in eine Zeichenkette umgewandelt werden. Das funktioniert mit Integer- und Fließkommawerten. Mit „int()“ wandelt man Fließkommawerte in Integerwerte um und mit „float()“ Zeichenketten in Fließkommawerte.
|
|
|
|
|
|
## Werte in Listen speichern
|
|
|
Wenn viele Variablen nötig sind, wird es schnell unübersichtlich. Besser geht es mit Listen, die mehrere durch Komma getrennte Werte aufnehmen. Das können Zahlen sein, Zeichenfolgen oder einen Mischung aus beidem (drei Zeilen):
|
|
|
```python
|
|
|
MeineListe = [2, 7, 8, 'red', 'blue']
|
|
|
print(MeineListe)
|
|
|
print(MeineListe[2])
|
|
|
```
|
|
|
Der erste print-Befehl gibt den kompletten Listeninhalt aus, der zweite nur den dritten Wert (die Zählung beginnt bei „0“).
|
|
|
|
|
|
Man kann auch mit einer leeren Liste beginnen und Werte dynamisch hinzufügen (drei Zeilen):
|
|
|
```python
|
|
|
MeineListe = []
|
|
|
MeineListe.append('red')
|
|
|
print(MeineListe)
|
|
|
```
|
|
|
Das funktioniert entsprechend, wenn schon Werte in der Liste enthalten sind.
|
|
|
|
|
|
## Teile von Zeichenketten auslesen
|
|
|
Variablen mit Zeichenletten lassen sich ähnlich wie Listen behandeln. Damit ist es möglich, Zeichen an einer bestimmten Position oder einen Bereich zu extrahieren (drei Zeilen):
|
|
|
```python
|
|
|
MeinString = "Hello World"
|
|
|
print(MeinString[0])
|
|
|
print(MeinString[6:11])
|
|
|
```
|
|
|
Der erste „print“-Befehl gibt das erste Zeichen aus („H“), die Zählung beginnt bei „0“. Die zweite Ausgabe lautet „World“. Das ist etwas verwirrend, weil der Index der Zeichenkette nur von „0“ bis „10“ reicht. Ursache dafür ist, dass Python beim ersten Parameter die Zeichen von „0“ bis „6“ berücksichtigt (inklusive Anfangsposition „0“), beim zweiten aber das letzte Zeichen weglässt (exklusive Endposition „10“). Sie müssen daher zur Endposition immer 1 dazurechnen. Einfacher geht's übrigens mit
|
|
|
print(MeinString[6:])
|
|
|
|
|
|
Fehlt der Endwert, liefert Python alle Zeichen ab Position „0“ bis zum Ende.
|
|
|
Zeichenketten verfügen bei Python übrigens über einige Komfortfunktionen. Wenn Sie Zeichen oder Wörter ersetzen wollen, geht das so (zwei Zeilen):
|
|
|
```python
|
|
|
MeinString = "Hello World"
|
|
|
print(MeinString.replace('World','Universe'))
|
|
|
```
|
|
|
Die Ausgabe lautet „Hello Universe“.
|
|
|
|
|
|
## Bedingte Anweisungen
|
|
|
Python arbeitet Programme Zeile für Zeile ab, bis das Ende erreicht ist. Manchmal sollten Programme jedoch bestimmte Codezeilen abhängig von Bedingungen ausführen und andere nicht. Das nennt man bedingte Anweisungen oder Verzweigungen. Das Python-Schlüsselwort dafür ist „if“.
|
|
|
```python
|
|
|
zahl = 11
|
|
|
if(zahl > 10):
|
|
|
print('Wert ist größer 10')
|
|
|
print('Das ist viel')
|
|
|
else:
|
|
|
print('Wert ist kleiner oder gleich 10')
|
|
|
```
|
|
|
„if“ prüft, ob die Variable „zahl“ größer („>“) als 10 ist. Wenn die Bedingung zutrifft, gibt Python die nachfolgende Meldung aus. Andernfalls wird der Code unter „else“ ausgeführt. Weitere Vergleichsoperatoren sind beispielsweise „==“ (gleich), „!=“ (ungleich), „<“ (kleiner) oder „>=“ (größer als).
|
|
|
|
|
|
Die Zeilen unter „if():“ und „else:“ bilden jeweils einen Codeblock. Damit Python das erkennt, sind die „print“-Zeilen mit mindesten vier Leerzeichen eingerückt. Alternativ funktioniert das auch mit einem Tab. Die „else:“-Zeile ist nicht eingerückt, hier beginnt der nächste Block mit den danach erneut eingerückten „print“-Zeilen (siehe Abbildung). Bei verschachtelten Blöcken gibt es entsprechend mehrfache Einrückungen, etwa wenn innerhalb eines „if():“-Blocks ein weiterer „if():“-Block erforderlich ist.
|
|
|
|
|
|
Der Mu-Editor hilft ihnen bei den korrekten Einrückungen. Drücken Sie nach „if(zahl > 10):“ und „else:“ einfach die Enter-Taste. Der Curser springt dann automatisch an die richtige Position.
|
|
|
|
|
|
## Funktionen verwenden
|
|
|
Funktionen helfen dabei, ein Programm in kleinere, übersichtlichere Teile aufzuspalten. Außerdem ist es damit möglich, identische Codezeilen mehrfach zu verwenden. Dazu ein Beispiel (vier Zeilen):
|
|
|
```python
|
|
|
def add(a,b):
|
|
|
print ('Addiere: ' + str(a) +' und ' + str(b))
|
|
|
return a + b
|
|
|
print ('Ergebnis: ' + str(add(2,3)))
|
|
|
```
|
|
|
Funktionen müssen vor der Zeile stehen, die sie aufruft. Am besten, Sie bringen Funktionen immer am Anfang eines Skripts unter. In unserem Beispiel erfolgt der Aufruf in der letzten Zeile mit „add(2,3)“. Die beiden Parameter werden an die Funktion „def add(a,b)“ übergeben und in den Variablen „a“ und „b“ gespeichert. „return a + b“ führt die Rechnung durch und gibt das Ergebnis der Funktion zurück. Den Rückgabewert von „add“ gibt print wie eine Variable aus.
|
|
|
|
|
|
Funktionen sind Blöcke ähnlich wie bei „if“ beschrieben. Die zweite und dritte Zeile in unserem Beispiel müssen daher eingerückt sein.
|
|
|
|
|
|
## Mit Schleifen arbeiten
|
|
|
Python kennt zwei einfache Schleifenkommandos. Die while-Schleife läuft so lange, bis eine Abbruchregel eintritt. Im folgenden Beispiel (vier Zeilen) erhält die Variable „x“ den Wert „1“. Dann startet die Schleife, gibt den aktuellen Wert von „x“ aus und erhöht den Wert mit „x += 1“ um „1“. Wenn „x“ den Wert „5“ erreicht (kleiner „6“), wird die Schleife beendet.
|
|
|
```python
|
|
|
x=1
|
|
|
while x < 6:
|
|
|
print(x)
|
|
|
x += 1
|
|
|
for-Schleifen kommen zum Einsatz, wenn eine Liste mit Werten ausgegeben, eingelesen oder geändert werden soll:
|
|
|
colors = ['red', 'blue', 'green']
|
|
|
for x in colors:
|
|
|
print(x)
|
|
|
```
|
|
|
Beachten Sie auch hier wieder die Einrückregeln.
|
|
|
|
|
|
## Module importieren
|
|
|
In den bisherigen Beispielen haben wir nur mit dem Standardsprachumfang von Python gearbeitet. Die Installation umfasst jedoch zahlreiche Zusatzmodule für spezielle Aufgaben. Ein Beispiel dafür ist das Modul „os“, das Schnittstellen zum System bereitstellt, etwa für den Zugriff auf Dateien und Ordner oder für den Start externer Programme. Dazu ein Beispiel (fünf Zeilen):
|
|
|
```python
|
|
|
import os
|
|
|
home=os.path.expanduser('~')
|
|
|
os.chdir(home)
|
|
|
files=os.system('ls -l')
|
|
|
print(files)
|
|
|
```
|
|
|
Mit der ersten Zeile lädt Python das gewünschte Modul. Jetzt steht die Funktion „os.path.expanduser“ zur Verfügung, mit der sich der Pfad zum Home-Verzeichnis („~“) ermitteln und in der Variablen „home“ ablegen lässt. „os.chdir“ wechselt in dieses Verzeichnis, dann startet „os.system('ls -l')“ das Tool „/bin/ls“, welches den Verzeichnisinhalt in die Variable „files“ leitet. „print(files)“ gibt das Ergebnis schließlich aus.
|
|
|
|
|
|
Bei der Programmierung der GPIO-Pins verwenden Sie hauptsächlich die Module RPi.GPIO oder gpiozero, die den Zugriff auf die Hardware ermöglichen.
|
|
|
|
|
|
## Python-Skrips starten
|
|
|
Während der Entwicklung ist de Mu-Editor praktisch, in der Regel werden Sie Python-Skripte aber im Terminalfenster oder aus der Ferne in einer SSH-Sitzung starten wollen. Da in Raspbian standardmäßig Python in der Version 2 und 3 installierte ist, starten Sie ein Skript mit
|
|
|
```python
|
|
|
python3 [Pfad/Skriptname]
|
|
|
```
|
|
|
Ersetzen Sie den Platzhalter durch Pfad und Namen der Datei. Wenn Sie in Ihre Skripte als erste Zeile
|
|
|
```python
|
|
|
#!/usr/bin/python3
|
|
|
```
|
|
|
einbauen und die Skriptdatei ausführbar machen („chmod 755 [Pfad/Skriptname]“), lässt sie sich auch einfach mit
|
|
|
```python
|
|
|
./[Pfad/Skriptname]
|
|
|
```
|
|
|
starten.
|
|
|
|
|
|
## Grafische Oberfläche für Skripts
|
|
|
In Python können Sie das GUI-Toolkit tk verwenden, mit dem sich einfach grafische Oberflächen erstellen lassen. Dafür installieren Sie einige zusätzliche Pakete:
|
|
|
```
|
|
|
sudo apt-get install python3-tk python-pmw python3-pil
|
|
|
```
|
|
|
Fenster, Schaltflächen, Labels und andere Elemente werden komplett per Script erzeugt. Das gelingt aufgrund der relativ komplexen Syntax jedoch nicht so einfach. Unser Skript LED-GUI.py zeigt beispielhaft, wie sich eine grafische Oberfläche umsetzen und eine LED darüber steuern lässt. |