Python

Python Konzepte

Shebang Line

Jedes Python Programm sollte eine Shebang Line haben, die vom Interpreter ausgewertet werden kann. Auf Windows mit Python 3 sollte diese Zeile wie folgt aussehen:

#! python3.

Variablen

Eine Variable wird im einfachsten Fall erzeugt, indem Werte zugewiesen werden.

Operationen mit Variablen

Operanden

• + steht für Addition (float und integer) oder Konkatinierung, also Verkettung (string und Listen)
• – steht für Subtraktion
• * steht für Multiplikation
• / steht für Dividion
• % ist der ganzteilige Rest einer Division

Statt einer Variablen per „Variable = Variable + 5“ den Wert 5 zu addieren kann man den Ausdruck mit „Variable += 5“ verwenden. Gilt auch für die anderen Operanden!

Integer und Float

• Bei Integer und Float gelten die normalen Rechenprozeduren (+, -, *, / etc.)
• Die Funktion str wandelt Integer oder float Werte in Strings um (typischerweise für Ausgabe)

Strings

• Strings werden mit einem einfachen Hochkomma eingleitet und beendet
• Alternativ ist auch die Verwendung des Doppelhochkommas möglich
• Mehrere Strings kann man mit dem + Zeichen zu einem neuen Strings zusammensetzen
• Die Funktion int wandelt einen String (so er Zahlen enthält) oder einen Float Wert in einen Integer um
• Mit der Funktion len lassen sich Längen ermitteln. Bei Strings erhält man die Anzahl der Zeichen und bei Listen enthält man die Anzahl der Werte.

Escape Characters

Um in Strings bestimmte Zeichen nutzen zu können benötigt man Escape Characters. Diese sind:

Escape Character	Bedeutet
\‘	Einfaches Anführungszeichen
\“	doppeltes Anführungszeichen
\t	Tabulator
\n	Zeilenvorschub (New Line)
\\	Ein Backslash

Man kann auch multiline Strings erzeugen. Diese werden mit 3 Anführungszeichen oder drei doppelten Anführungszeichen eingeleitet und beendet. Die normale Einrückung für Python gilt dann nicht einzelne oder doppelte Anführungszeichen müssen nicht escaped werden.

print('''Dear Alice,
Eve's cat has been arrested for
catnapping, cat burglary, and extortion.
Sincerely, Bob''')

Diese Multistring Möglichkeit kann man im Code auch nutzen, um Kommentare über mehrere Zeilen zu schrieben. Einfach mit den Hochkommata einleiten und beenden!

Teilzeichenketten

Auf Zeichen in Strings kann man ähnlich wie auf Werte in Listen zugreifen.

testString = 'Dies ist ein Test'
print (testString [3]) # ergibt ein 's'
print (testString [0:4]) # ergibt ein 'Dies'
print (testString [-1]) # ergibt ein 't' (letzter Buchstabe)
print (testString [-4:]) # ergibt ein 'Test'

Auch das Auswerten mit in und not in erfolgt ähnlich zu Listen:

testString = 'Dies ist ein Test'
print ('Dies' in testString) # ergibt true
print ('dies' in testString) # ergibt false
print ('Dies' not in testString) # ergibt false
print ('dies' not in testString) # ergibt true

Stringmanipulation

Dann ist es häufig erforderlich, Leerzeichen und Steuerzeichen aus Texten zu entfernen.

testString = ' Dies ist ein Test '
print (teststring.strip()) # entfernt entsprechende Zeichen rechts und links -> 'Dies ist ein Test'
print (teststring.lstrip()) # entfernt entsprechende Zeichen links -> 'Dies ist ein Test '
print (teststring.rstrip()) # entfernt entsprechende Zeichen rechts -> ' Dies ist ein Test'

Man kann der Methode auch eine String übergeben. Die Buchstaben werden dann links oder rechts entfernt, bis ein Buchstabe auftaucht, der nicht übergeben wurde.

Listen

• Listen stellen in Bezug auf eine Variable einen Wert da (die Liste). Es kann aber auf die Einzelwerte der Liste zugegriffen werden, wobei der erste Wert der Liste den Index 0 hat
• Bei Listen kann man mit dem Plus Operator ebenfalls Listen miteinander kombinieren.
• Listen können widerrum Listen enthalten
• Greift man auf Listen mit negativen Indizes zu, so werden die Werte von hinten nummeriert. So steht der Index -1 für den letzten und der Index -2 für den vorletzten Wert der Liste.
• Aus Listen kann man auch Slices entnehmen. Das sind Teile der Liste, die widerrum als Liste dargestellt werden. Dabei Gibt man an ab welchem Index und bis VOR welchem Index der Slice geht. Wenn man aus einer Liste mit 5 Werten die Werte 2 – 4 haben möchte, lautet die Indexangabe [2:5]
• Lässt man im Index unter Nutzung des Doppelpunktes einen der Werte weg, so wird beim Weglassen des ersten Wertes die Liste von Anfang an übernommen und bei Weglassen des zweiten Wertes die Liste bis zum Ende übernommen
• Mit der Funktion del kann man einzelne Werte aus Listen löschen
• Weist man eine Liste einer Variablen zu, so erstellt man keine Kopie der Werte, sondern eine Referenz. Sprich egal mit welchem der beiden Variablennamen man die Liste anspricht, man hantiert mit den gleichen Werte und bei Änderungen sind die Änderungen auch über beide Variablennamen sichtbar.
• Die Funktion list kann ein Tuple oder einen String in eine Liste umwandeln

Tuple

• Tuple sind ähnlich wie Listen, aber sind nicht änderbar
• In der Zuweisung werden runde Klammern verwendet
• Die Funktion tuple kann eine Liste oder einen String in ein Tuple umwandeln

Dictionaries

• Dictionaries sind auch ähnlich zu Listen zu sehen
• In der Zuweisung werden geschweifte Klammern verwendet
• Es handelt sich um Key -> Value Paare
• Was also bei einer Liste der Index ist, stellt bei Dictionaries der Key dar
• Daher sind Dictionaries auch nicht geordnet wie Listen (Index 0 – n) -> Das bedeutet zwei Listen sind nur gleich, wenn auch die Reihenfolge der Werte gleich ist. Bei Dictionaries ist die Reihenfolge der Werte nicht relevant in Bezug auf Gleichheit, es müssen nur alle Key-Value Kombinationen in zwei Strings vorhanden sein, damit diese gleich sind

mutable und immutable Variablen

Listen und Dictionarys sind mutable Variablen wohingegen Strings, Integer, Float, Tuples etc. immutable Typen sind.

Mutable Daten können über Methoden geändert werden. Immutable Daten können nur über Zuweisungen in Gänze geändert werden.

Zusätzlich ist beim übergeben von mutable Daten an Funktionen oder beim zuweisen an andere Variablen zu beachten, dass diese nur als Referenz übergeben / „kopiert“ werden. Änderungen am übergebenen Wert beziehen sich also auch immer auf den Ausgangswert. Will man das nicht, also tatsächlich eine Kopie einer Liste übergeben, so muss man das Modul copy einbinden und die Funktion copy.copy() nutzen. Wenn eine Liste kopiert werden soll, die Ihrerseits Listen enthält, ist copy.deepcopy() erforderlich!

Hier einige Beispiele inkl. Transformation zwischen Datentypen:

Zahlen

MeinInteger = 5 # Erzeugt eine Variable vom Typ Integer
print (MeinInteger) # Zahl wird ausgegeben
print ('Hallo', str(MeinInteger)) # Wegen Stringausgabe muss Zahl in String gewandelt werden
#
MeinFloat = 5.0 # Erzeugt eine Variable vom Typ Float, also Gleitkommazahl
print (MeinFloat) # Zahl wird ausgegeben
print ('Hallo', str(MeinFloat)) # Kombination String und Float in der Ausgabe

String

MeinString = 'Hallo' # Erzeugt eine Variable vom Typ String
print (MeinString) # String wird ausgegeben
print (len (MeinString)) # Anzahl Zeichen eines Strings
print (MeinString)
TestListe = list(MeinString)
print (TestListe)
TestListe.sort(key=str.lower)
print (TestListe)

Listen

MeineListe = ['Hund', 'Katze', 'Maus', 'Floh'] # Erzeugt eine Variable vom Typ Liste
print (MeineListe) # Gesamte Liste wird als Liste ausgegeben
print (MeineListe[0]) # Erster Wert der Liste
print (MeineListe[-1]) # Letzter Wert der Liste
for i in MeineListe: # Einzelwerte der Liste werden ausgegeben
print (i)
print (MeineListe[0:2]) # Neue Liste mit den beiden ersten Werten der Ausgangsliste
print (MeineListe[0:-1]) # Neue Liste mit allen Werten der Ausgangsliste außer dem letzten
print (MeineListe[1:]) # Neue Liste enthält alle Werte ab dem Index 1
print (MeineListe[:2]) # Neue Liste enthält alle Werte bis vor dem Index 2
#
MeinegeschachtelteListe = [['Hund', 'Katze', 'Maus'],['Elephant', 'Ochse']]
for i in MeinegeschachtelteListe: # Listen der Liste werden ausgegeben
print (i)
for i in MeinegeschachtelteListe: # Einzelwerte der Listen werden ausgegeben
for j in i:
print (j)
print (len (MeinegeschachtelteListe)) # Anzahl der Werte der geschachtelten Liste
print (MeinegeschachtelteListe + MeineListe) # Einzelwerte der Liste werden als Werte an die Liste angehängt
print (MeinegeschachtelteListe + [MeineListe]) # Gesamtliste wird als ein neuer Wert an die Liste angehängt
MeinegeschachtelteListe[1] = MeineListe
print (MeinegeschachtelteListe)
del MeinegeschachtelteListe[1]
print (MeinegeschachtelteListe)

Tuple

MeinTuple = ('Hund', 'Katze', 'Maus', 'Floh') # Erzeugt eine Variable vom Typ Tuple
print (MeinTuple) # Gesamtes Tuple wird als Liste ausgegeben

Dictionaries

MeinDictionary = {'Hammer': 'Nagel', 'Säge': 'Brett','Schraubendreher':'Schraube'}
print (MeinDictionary)
print (MeinDictionary ['Säge'])
MeinDictionary ['Zange'] = 'Nagel'
print (MeinDictionary)

Beispiel zum Zugriff auf Key->Values in einer Schleife

for k,v in MeinDictionary.items():
print ('Werkzeug: ' + k + ' Material: ' + v)

Methoden von Variablen

Es gibt für Variablentypen Methoden mit denen die Variablen bearbeitet werden können. Der Aufruf der Methoden erfolgt mit „Variable.Methodenname“. Hier ein paar Beispiele:

Strings

testString = 'Dies ist ein Test'
print (testString.upper())

ergibt ‚DIES IST EIN TEST‘

print (testString.lower())

ergibt ‚dies ist ein test‘

weitere Methoden:

.isupper() -> nur Großbuchstaben?
.islower() -> nur Kleinbuchstaben?
.isalpha() -> nur Buchstaben?
.isalnum() -> nur alphanumerisch, also Ziffern und Buchstaben
.isdecimal() -> nur Zahlen?
isspace() -> nur Leerzeichen, Tabs und New Lines
.istitle() -> Nur Wörter im String , die mit einem Großbuchstaben beginnen und danach nur noch Kleinbuchstaben enthalten
.startswith(string) -> Es wird geprüft, ob der string identisch mit dem Anfang der Variable ist deren Methode aufgerufen wird
.endswith(string) -> Es wird geprüft, ob der string identisch mit dem Ende der Variable ist deren Methode aufgerufen wird

join

testListe = ('Dies', 'ist', 'ein', 'Test')
print (', '.join(testListe))

Bildet aus einer Liste einen String und setzt den String auf den die Methode angewendet wird zwischen die Werte.
Das kann insbesondere dann Sinn machen, wenn man mehrere Strings in einer Liste zusammenfassen möchte und dabei einen Zeilenumbruch einfügen will:

testString = '\n'.join(testListe)
print (testString)

Split

testString = 'Dies ist ein Test'
print (testString.split(' '))

Trennt einen Text in eine Liste auf. Hier wird als Trennzeichen ein blank übergeben, was aber Default ist

Listen

MeineListe = ['Hund', 'katze', 'Maus', 'floh']

Erzeugt eine Variable vom Typ Liste

print (MeineListe.index('Maus'))

Liefert den Index zurück, an dem der Wert in der Liste gefunden wird. Es wird das erste Aufkommen des Wertes zurückgegeben – Ist der Wert nicht enthalten gibt es einen Fehler.

MeineListe.append('Fisch') # Ein weiterer Wert wird angehängt
print (MeineListe)
MeineListe.insert(2,'Huhn')

Ein weiterer Wert wird vor Index 2 eingefügt

print (MeineListe)
MeineListe.append('Huhn')
MeineListe.remove('Huhn')

Huhn wird in der Liste gesucht und das ERSTE vorkommen wird gelöscht. Ist Huhn nicht in der Liste, so entsteht ein Fehler.

print (MeineListe)
MeineListe.sort()

Sortieren einer Liste

print (MeineListe)
MeineListe.sort(reverse=True)

Sortieren einer Liste absteigend

print (MeineListe)
MeineListe.sort(key=str.lower)

Sortieren egal ob Groß- oder Kleinbuchstaben

print (MeineListe)

Dictionaries

MeinDictionary = {'Hammer': 'Nagel', 'Säge': 'Brett','Schraubendreher':'Schraube'}
for i in MeinDictionary.values():

Hier werden die Werte des Dictionaries als Liste durchlaufen

print (i)
for i in MeinDictionary.keys():

Das geht auch mit den keys

print (i)
for i in MeinDictionary.items():

Oder man verarbeitet die Key->Values in Gänze als Liste

print (i)
for i in MeinDictionary:

Ohne Methodenangabe erhält man das gleiche Ergebnis wie bei der Ausgabe der Keys!

print (i)

Der Begriff Liste in diesen Beispielen steht aber für eine Pseudoliste. Für Ausgabe, aber nicht Bearbeitung geeignet Dies kann man wie folgt auch gut sehen, da ein Typ dict_keys ausgegeben wird

print (MeinDictionary.keys())

Ausgabe des dict_keys

print (list(MeinDictionary.keys()))

Hier wird eine echte Liste erzeugt. Diese kann man auch einer Variablen zur weiteren Bearbeitung zuweisen

print('Ist Hammer ein Key?: ' + str('Hammer' in MeinDictionary.keys()))

Suchen eines Begriffes in den keys

print('Ist Nagel ein Key?: ' + str('Nagel' in MeinDictionary.keys()))
print('Ist Hammer ein Value?: ' + str('Hammer' in MeinDictionary.values()))

Suchen eines Begriffes in den values

print('Ist Nagel ein Value?: ' + str('Nagel' in MeinDictionary.values()))

Mit der Get Methode kann man Werte eines Dictionaries ohne Fehlerhandling abfragen.

print (MeinDictionary.get('Hammer','nicht zugeordnet')) # liefert 'Nagel' zurück
print (MeinDictionary.get('Vorschlaghammer','nicht zugeordnet')) # liefert 'nicht zugeordnet' zurück

Mit SetDefault kann man einen Key abfragen und wenn dieser nicht existiert, wird er mit dem Standardwert angelegt. Beispiel Zeichen Zählen

MeinText = ' Dieser Text besteht aus verschiedenen Buchstaben und wir schauen mal, wieviele davon jeweils vorkommen'
Alphabet = {}
for Buchstabe in MeinText:
Alphabet.setdefault(Buchstabe, 0)
Alphabet[Buchstabe] +=1
print (Alphabet.items())
Sortierliste =list(Alphabet.items())
Sortierliste.sort(key=lambda tup: tup[0].upper())

Sortierung der Tuple nach Wert 1 als Großbuchstabe

print (Sortierliste)

Steuerung

def MeineFunktion():

Schleifen / Wiederholungen

For Next Schleife

for Schleifenzaehler in range(1,7):
print('Ausgabe ' + str(Schleifenzaehler)) # So oft die Schleife durchlaufen wird, wird diese Ausgabe erzeugt
if Schleifenzaehler > 5:
break # Hier wird die Schleife unabhängig von der eigentlichen Schleifensteuerung unterbrochen

Statt mit dem range Befehl eine Vorgabe von Zahlen zu durchlaufen könnte man auch die Werte einer definierten Liste durchlaufen:

Liste = ('Hund','Katze','Maus')
for Schleifenparameter in Liste:
print('Ausgabe ' + Schleifenparameter) # Schleifenparameter enthält den jeweiligen Listenwert und dieser wird mit ausgegeben.

Verzweigungen

If then else

if 2 < 1:
print(' Diese Zeil wird nicht angezeigt, da 2 nicht kleiner als 1 ist')
elif 1 > 2:
print(' Diese Zeile wird auch nicht angezeigt, da 1 auch nicht größer als 2 ist')
elif 0 > 2:
print(' Diese Zeile wird auch nicht angezeigt, da 0 auch nicht größer als 2 ist')
else:
print(' Wenn keine andere Bedingung korrekt ist, wird das hier jetzt halt angezeigt')

Fehlerbehandlung

Fehler werden mit einem Try … Except Konzept behandelt

number = 1
try:
print('Zahl: ' + str(number))
# wird ausgeführt, da die Zahl vor Ausgabe in einen String umgewandelt wird
Print('Zahl: ' + str(number))
# Führt zu dem Namensfehler unten -> Großbuchstabe bei Print
print('Zahl: ' + 1) # führt zu dem Typfehler
except TypeError:
# except wird nur ausgeführt, wenn nach try ein Fehler auftrat
print('Es ist ein Fehler wegen eines Variablentypen aufgetreten')
except NameError:
# except wird nur ausgeführt, wenn nach try ein Fehler auftrat
print('Es ist ein Fehler wegen eines falschen Namens im Code aufgetreten')

Mit dem Except Ausdruck können also verschiedene Fehlertypen abgefangen werden. Diese sollte man zuvor in der Shell ermitteln, indem man ohne try except die Fehlerausgabe anschaut.

>>> Print('Zahl: ' + str(number))
# Führt zu dem Namensfehler unten -> Großbuchstabe bei Print
Traceback (most recent call last):
File "", line 1, in
Print('Zahl: ' + str(number))
NameError: name 'Print' is not defined

Dies war der Name Error

>>> print('Zahl: ' + 1)
# führt zu dem Typfeheler
Traceback (most recent call last):
File "", line 1, in
print('Zahl: ' + 1)
TypeError: must be str, not int

und dies der Type Error

häufig genutzte Befehle

Funktionen

Funktionen werden definiert

Im Anschluß werden die Befehle der Funktion eingerückt angegeben

def MeineFunktion():
    print('Meine Funktion gibt einfach diesen Satz aus')

Der Aufruf der Funktion erfolgt über

MeineFunktion()

Werte an Funktionen übergeben

def MeineFunktion(uebergebenerWert):
print ('Du hast folgendes an die Funktion übergeben: ' + uebergebenerWert)
MeineFunktion('Quatsch')

In dieser Form ist der Parameter beim Aufruf der Funktion erforderlich. Weglassen des Parameters führt zu einer Fehlermeldung! Der Parameter ‚uebergebenerWert‘ ist nur innerhalb der Funktion als Variable ansprechbar und verschwindet mit verlassen der Funktion.

Rückgabewerte von Funktionen

def addiere5 (Ausgangswert):

return Ausgangswert + 5

print(addiere5 (10))

Hier wird im Rahmen des Print Statements der Rückgabewert der Funktion ‚addiere5‘ ausgegeben. An die Funktion wird der Wert 10 übermittelt.

generieren von Zufallszahlen

import random
randomNumber = random.randint(1, 20)

Liefert eine zufällige Zahl zwischen 1 und 20

Ausgeben von Daten

In Python integriert ist die print Funktion für solche Zwecke:

print ('Ein Text') # Gibt den Text aus und standardmäßig wird eine Zeilenschaltung am Ende durchgeführt
print ('nach dem Text')
print ('Ein Text', end='') # Gibt den Text aus und es gibt nichts am Ende, also auch keine Zeilenschaltung!
print ('direkt nach dem Text')

Daneben gibt es aber auch die Möglichkeit mit dem Modul pprint auf erweiterte Ausgabemöglichkeiten insbesondere für Dictionaries zuzugreifen!

import pprint
MeinDictionary = {'Hammer': 'Nagel', 'Säge': 'Brett','Schraubendreher':'Schraube'}
pprint.pprint (MeinDictionary) # sortiert die Ausgabe nach den Keys
print (MeinDictionary) # unsortierte Ausgabe
Test = pprint.pformat (MeinDictionary) # Damit kann man die sortierte Ausgabe an eine Variable übergeben!
print (Test)

Bei der Ausgabe von Strings sollte man die Excape Character berücksichtigen, die weiter oben beschrieben sind. Desweiteren gibt es die Möglichkeit, einen String als Raw Text auszugeben, bei dem Escape Character nicht ausgewertet und somit wie angegeben ausgegeben werden. Man stellt ein r vor den eigentlichen String bei print!

test = 'Dies ist Matze\'s Test'
print ('Dies ist Matze\'s Test')
print (r'Dies ist Matze\'s Test')

In diesem Zusammenhang sind auch einige Methoden interessant, mit denen man tabulare Ausgaben erzeugen kann:

meinDict = {'Eier': 10,'Mehl': 1000, 'Backpulver':1, 'Milch': 500}
Anzahl = 0
for i,j in meinDict.items():
print (i.ljust(20,'.') + str(j).rjust(6))
Anzahl += 1
print (('Anzahl Zutaten: ' + str(Anzahl)).center(26))

Gültigkeitsbereich von Variablen

Hier spricht man von global (Programmweit) und local (innerhalb von einer Funktion) scope. Aus dem globalen Scope kann nicht auf lokale Variablen zugegriffen werden. Im lokalen Scope kann man (sollte man aber nicht) auf globale Variablen zugreifen. Man kann nicht von einem lokalen Scope auf Variablen eines anderen lokalen Scopses zugreifen.

local scope

Unter dem local scope versteht man Variablen innerhalb einer Funktion und die übergebenen Parameter an die Funktion. Diese sind nur innerhalb der Funktion gültig und mit Beendigung der Funktion wird der belegte Speicher dieser Werte wieder frei gegeben.

Das bedeutet auch, dass der Aufruf einer Funktion einen local scope erzeugt!

global scope

Hier sind insbesondere die Variablen zu nennen, die global (also außerhalb von Funktionen) definiert werden.

Zugriff auf globale Variablen im local scope

4 Regeln zum Erkennen des Scopes:

• Eine Variable, die außerhalb einer Funktion definiert wird, ist immer eine globale Variable
• Eine Variable in einer Funktion, die mit dem keyword ‚global‘ definiert wird ist eine globale Variable (Diese muss auch zuvor nicht im Hauptprogramm definiert worden sein)
• Wird einer global definierten Variable innerhalb einer Funktion ein Wert zugewiesen, ohne das vorher mit dem global keyword diese Variable als global definiert wurde, so wird eine lokale Variable erzeugt!
• Wird in einer Funktion lediglich auf den Inhalt einer global definierten Variable zugewiesen und kein Wert zugewiesen, so wird die globale Variable ausgelesen!

Beispiel:

def Testfunktion1():
    global testglobal
    testglobal = 'Dies ist eine Variable, die in einer Funktion global definiert wurde, ohne vorher im Hauptprogramm definiert worden zu sein'
    print(globaleVariable) # Da nicht lokal definiert, wird der Inhalt der globalen Variable ausgegeben
def Testfunktion2():
    globaleVariable = 'Quatsch' # Hier wird eine lokale Variable (sinnfrei) erzeugt
    print(globaleVariable)
def Testfunktion3():
    global globaleVariable # Es wird definiert, dass die globaleVariable in dieser Funktion referenziert wird
    globaleVariable = 'Quatsch' # Hier wird die globale Variable tatsächlich verändert
    print(globaleVariable)
def Testfunktion4():
# Diese Funktion liefert eine Fehlermeldung, da die 'globaleVariable' wegen eines Zuweisungsstatements lokal interpretiert wird
# aber die erste Verwendung der lokalen Variable vor der ersten Zuweisung gegeben ist.
    print(globaleVariable)
    globaleVariable = 'Quatsch' # Hier wird die globale Variable tatsächlich verändert
    globaleVariable ='Dies ist der Inhalt der globalen Variable'
Testfunktion1() # es wird die globaleVariable ausgegeben
    print(testglobal) # Die globale Variable ist aber unverändert, da nur lokal überschrieben wurde
Testfunktion2() # es wird die globaleVariable lokal überschrieben ausgegeben
    print(globaleVariable) # Die globale Variable ist aber unverändert, da nur lokal überschrieben wurde
Testfunktion3() # es wird die globaleVariable global überschrieben ausgegeben
print(globaleVariable) # Die globale Variable wurde innerhalb der letzten Funktion verändert
Testfunktion4() # es wird die globaleVariable global überschrieben ausgegeben