Python

Python ist eine Programmiersprache, die häufig für den Raspberry Pi genutzt wird. Die nachfolgenden Beschreibungen in diesem Artikel beziehen sich auf die Version Python 3. Nicht alle Programmierstrukturen, die hier beschrieben werden, funktionieren auch mit älteren Python Versionen.

Grundlegendes

Phython ist als Einstiegssprache in die Welt der Programmierung gedacht. Daher ist sie in vielen Elementen deutlich einfacher zu nutzen als zum Beispiel C. Die sprachlichen Besonderheiten von Python werden in diesem Abschnitt erläutert.

Python-Programme haben üblicherweise die Endung .py Bei Dateien mit der Endung .pyc handelt es sich um den compilierten Code eines Python-Programms.

Allgemeine Syntaxregeln

Anweisungen werden in Python üblicherweise einzeilig angegeben. Es ist kein Zeichen am Zeilenende zum Abschluss des Befehls nötig. Bsp:

printf(„Hello World!“)

Durch das Trennzeichen \ können Befehle auch auf mehrer Zeilen aufgeteilt werden.

Mit dem Strichpunkt ; als Trennzeichen können auch mehrere Anweisungen in einer Zeile zusammengefasst werden.

Strukturierung durch Einrücken

In Python werden Programmblöcke durch einfaches Einrücken gekennzeichnet. Um mehrere Befehle in einem Block zusammenzufassen sind keine Soderzeichen wie z.B. Klammern oder Schlüsselwörter nötig.

Kommentare

Einzeilige Kommentare werden mit dem Zeichen # am Zeilenanfang eingeleitet.

# Dies ist ein Kommentar

Mehrzeilige Kommentare werden mit „““ eingeleitet und auch mit „““ beendet.

Module

Module bieten in Python die Möglichkeit zusätzliche Funktionen im Programmcode verfügbar zu machen. Für viele wichtige Grundfunktionen sind bereits Module verfügbar. Einige werden auch in diesem Artikel erwähnt und sind im Kapitel „Wichtige Module“ aufgelistet. Module werden mit dem Befehl import in ein Programm eingebunden, was üblicherweise zu Beginn des Programms geschieht. Es gibt dabei verschiedene Varianten des Befehls import:

import modulname

Importiert das Modul mit all seinen Funktionen. Die Funktionen können anschließend nach dem Schema modulname.funktionsname( ) aufgerufen werden.

import modulname as m

Importiert das Modul mit all seinen Funktionen. Die Funktionen können anschließend nach dem Schema m.funktionsname( ) aufgerufen werden. Dies ist sinnvoll um bei besonders langen Modulnamen den Quelltext übersichtlich zu halten.

From modulname import f1, f2

Importiert die Funktionen f1 und f2 aus dem Modul. Die Funktionen können anschließend direkt mit ihrem Funktionsnamen angesprochen werden, ohne den Modulnamen im Aufruf davor zu setzen.

Elementare Funktionen

Print

Print dient zur Ausgabe von Texten auf dem Bildschirm:

print('Indentify text...')
print('-------------')
print(result)

Input

Input dient zur Eingabeaufforderung für den Benutzer. Hierdurch kann der Benutzer über die Tastatur Eingaben vornehmen:

imagefile = input('Enter filename: ')

Datenstrukturen

Der Umgang mit Variablen und Datenstrukturen in Python ist relativ einfach, wenn man einige wichtige Grundregeln beachtet.

1. Jeder Variablen muss ein Wert zugewiesen werden, bevor sie das erste Mal verwendet wird. Sonst tritt ein Fehler auf.
2. Es sind keine Typdeklarationen notwendig. Dies erledigt Python automatisch im Hintergrund.
3. Variablen sollen mit einem Buchstaben beginnen. Bei den weiteren Zeichen sind auch Zahlen und Unterstriche erlaubt.

Das Arbeiten mit Variablen ist also etwas anders als bei klassischen Programmiersprachen, wie zum Beispiel bei C. Es wird ausschließlich in Objekten gedacht.

Eine neue Variable wird direkt durch Wertzuweisung erzeugt.

Bsp:

a = 32

Es gibt die folgenden Datenstrukturen:

Zeichenketten

Eine der wichtigsten Datenstrukturen sind auch in Python die Zeichenketten.

Zeichenketten können wahlweise mit einfachem oder doppeltem Apostroph dargestellt werden.

Bsp:

a = ‚eine Zeichenkette ‚

b = „und auch eine Zeichenkette“

Mit dem + Operator können Zeichenketten zusammengefügt werden:

c = a + b

c = ‚eine Zeichenkette und auch eine Zeichenkette‘

Daneben gibt es noch eine Reihe weiterer Funktionen, die sehr hilfreich bei der Analyse und Verarbeitung von Zeichenketten sein können:

len(a) gibt die Anzahl der Zeichen in der Zeichenkette a aus

a.find(Zeichen)gibt die Position in der Zeichenkette a an, an welcher die Zeichenkette ‚Zeichen‘ steht

a[0] liefert das Zeichen an Position 0, also das erste Zeichen. Mit negativen Zahlen fängt die Zählung am Ende der Zeichenkette an, d.h. Mit -1 bekommt man das letzte Zeichen geliefert.

a[:] Ausgabe aller Zeichen der Zeichenkette a

a[:3] Ausgabe aller Zeichen der Zeichenkette a bis zum dritten Zeichen

a[4:] Ausgabe aller Zeichen der Zeichenkette a ab dem vierten Zeichen

a[2:5] Ausgabe aller Zeichen der Zeichenkette a vom zweiten bis zum fünften Zeichen

Listen

Listen sind in Python ähnlich den aus vielen anderen Programmiersprachen bekannten Arrays. Eine Liste dient zur Abspeicherung vieler Daten in einem Datenkonstrukt. Im Gegensatz zu herkömmlichen Arrays können in Listen in Python aber Elemente von unterschiedlichen Datentypen gespeichert werden.

Beispiel:

liste = [1, a , ‚hugo‘]

liste[2]

>>> ‚hugo‘

Der Zugriff auf einzelne Listenelemente erfolgt genauso wie bei Zeichenketten.

Eine Liste kann auch verschachtelt werden. d.h. die Elemente einer Liste können ebenfalls Listen sein.

Sehr häufige Anwendung findet auch der Befehl

list

, mit dem eine Zeichenkette in eine Liste umgewandelt werden kann

Eine elegeante Möglichkeit um Listen zu verarbeiten stellen List Comprehension dar. Dabei handelt es sich um eine Art Schleife, in der jedes Listenelement bearbeitet wird.

Diese wird mit folgendem Ausdruck durchgeführt:

ausdruck for x in liste

aktion

Bsp:

for line in ergebnis.decode(‚utf8‘).splitlines():
print(line)

Tupel

Tupel sind Listen mit unveränderlichen Datenelementen. Sie werden wie folgt definiert:

testtupel = (1,3,7)

Sets

Sets sind Datenkostrukte in denen jedes Element nur einmal vorkommt. Außerdem kann sich die Anordnung der Elemente während der Verarbeitung ändern. Ein Set wird wie folgt definiert:

testset = {1,3,7}

Dictionaries

Dictionaries sind Datenstrukturen, bei denen auf die Elemente mit Hilfe eines Schlüssels zugegriffen wird. Ähnlich wie bei Sets kann sich die Reihenfolge der Elemente beliebig ändern. Ein Dictionarie wird wie folgt definiert:

hausnummern = {‚Meier‘ : 1, ‚Mueller‘ : 2, ‚ Schulze: 3‘}

Der Zugriff erfolgt mit dem Verweis auf den Schlüssel:

hausnummern[‚Mueller‘]

Operatoren

Die aus C bekannten Inkrement- und Dekrement-Operatoren gibt es in Python nicht.

Verzweigungen und Schleifen

In Python gibt es wie auch in anderen Programmiersprachen Verzweigungen und schleifen. Allerdings gibt es keine Switch-Case Anweisung wie zum Beispiel in C.

Verzweigungen

If-Abfragen sind mit beliebig vielen aufeinanderfolgenden Abfragen möglich. Diese werden durch das Schlüsselwort elif verknüpft. Optional kann ein else Block ans Ende gestellt werden:

if bedingung1:

befehl1

elif bedingung2:

befehl2

else:

befehl3

Für bedingte Variablenzuweisungen gibt es auch eine Kurzschreibweise:

variable = wert1 if bedingung1 else wert2

Schleifen

Für Schleifen gibt es in Python die Möglichkeiten diese als for-Schleife oder als while-Schleife darzustellen.

i = 1

while i < 500:

print(i)

i += 1

Funktionen

Eine Funktion wird mit dem Schlüsselwort

def

definiert.

Der zur Funktion zugehörige Code wird durch bloßes Einrücken im Quelltext der Funktion zugeordnet.

def convertToGray(img):

    img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    return img_gray

Eine Funktion darf nicht leer sein, sondern muss mindestens eine Programmzeile enthalten, sonst kommt es zu einem Fehler, wenn anschließend wieder eine nicht-eingerückte Zeile steht.

Variablen in Funktionen

Globale Variablen, also Variablen, die außerhalb einer Funktion definiert sind, können unmittelbar innerhalb einer Funktion benutzt werden.

Variablen, die innerhalb einer Funktion definiert werden sind lokal. Sie sind nur innerhalb dieser Funktion bekannt. Dies gilt auch, wenn die in der Funktion definierte Variable den gleichen namen wie eine globale Variable hat.

Um globale Variable in einer Funktion zu ändern, können diese innerhalb einer Funktion mit dem Schlüsselwort global eingebunden werden. Dies ist aber nicht empfehlenswert, da es zu unübersichtlichem Code führt. Stattdessen sollte eine Rückgabe eines Funktionsergebnisses über den Befehl return erfolgen und anschließend enie Zuweisung des Funktionsergebnis nach dem Funktionsaufruf.