Einführung in Python¶
Grundsätzliche Syntax¶
Die Grundregeln für das Schreiben von einfachen Aussagen und Ausdrücken in Python sind * Am Anfang einer Anweisung dürfen keine Leerzeichen oder Tabulator-Zeichen stehen: Einrückungen spielen in Python eine besondere Rolle und können beim Kompilieren oder Ausführen von Code Probleme verursachen. Stellen Sie vorerst einfach sicher, dass alle Anweisungen am Zeilenanfang beginnen. * Variablennamen in Python können beliebig lang sein und aus Groß- und Kleinbuchstaben, Ziffern (0-9)
und dem Unterstrich (_) bestehen. Eine Einschränkung besteht darin, dass ein Variablenname zwar Ziffern enthalten kann, das erste Zeichen eines Variablennamens jedoch keine Ziffer sein darf. * Das Zeichen ‚#‘ zeigt an, dass der Rest der Zeile ein Kommentar ist. * Python hat eine umfangreiche Hilfe für alle Ihre Fragen eingebaut, die nicht von diesen Modulen abgedeckt werden. Sie können help() für eine Übersicht oder help(x) für jede Bibliothek, jedes Objekt oder jeden Typ x
ausführen, um weitere Informationen zu erhalten. * Im Jupyter Notebook gibt es zudem den Fragezeichen-Operator ?. Hiermit wird ebenfalls die Hilfe aufgerufen und dazu noch hübsch dargestellt.
Variablen¶
Ein Name, der verwendet wird, um in ihm einen Wert zu speichern, wird als Variable bezeichnet. In Python können Variablen deklariert und ihr können Werte wie folgt zugewiesen werden:
[ ]:
x = 100 # 'y' ist die Variable und 100 der ihr zugewiesene Wert
x = y = z = 33 # Der gleiche Wert kann unterschiedlichen Variablen geleichzeitig zugewiesen werden
x = y = z = [1, 2, 3] # ACHTUNG bei mutierbaren Objekten!
x.append(4)
y == z == [1, 2, 3, 4]
xy = 'ist meine Glückszahl' # Die Wertzuweisung muss keine Zahl beinhalten (siehe Datentypen)
print(x + y + z, xy) # print() gibt bei Ausführung den Klammerinhalt aus
[ ]:
ä, α, ヶ, ヷ = 1, 2, 3, 4 # ebenfalls können andere Unicode-Zeichen für Variablen-Namen gewählt werden
Tatsächlich ist es allerdings Konvention, die Variablennamen nur aus dem ASCII-Bereich (A-Z, a-z) zu wählen.
Datentypen¶
Die grundlegenden Datentypen sind: * float (Gleitkommazahlen) * sind immer fehlerbehaftet * begrenzt bis max = 1.7976931348623157e+308 und min = 2.2250738585072014e-308 * int (ganze Zahlen) * str (Zeichenketten) * bool (wahr/ falsch)
[ ]:
2.0 # float
-1234567890 # int
1e100 # int
True # wahr oder binär 1
False # falsch oder binär 0
'Ich bin eine Zeichenkette'
z = "Ich bin eine gleichwertige Zeichenkette"
Datentypen verändern¶
Die Konvertierung von einem zum anderen Datentyp ist möglich über folgende Funktionen: * int(X), d. h. X wird zur ganzen Zahl (Achtung: Die Kommazahlen werden abgeschnitten) * str(X), d. h. X wird zum Zeichenkette
[ ]:
print(int(7.7), int('111', 2), int('7'))
print(str(True), str(1.2345678), str(-2))
Operatoren¶
Python kann wie ein Taschenrechner verwendet werden. Die grundelegenden Operatoren dabei sind:
Symbol |
Was macht das? |
|---|---|
Addition |
|
Subtraktion |
|
* |
Multiplikation |
/ |
Division |
// |
Abgeschnittene Division |
% |
Modulus |
** |
Potenz |
[ ]:
1 + 2
[ ]:
2 - 1
[ ]:
1 * 2
[ ]:
3 / 4
In vielen Sprachen (und älteren Versionen von Python) ist 1/2 = 0 (sog. abgeschnittene Division). In Python 3 wird dieses Verhalten durch einen separaten Operator erfasst, der nach unten rundet: a // b =⌊𝑎𝑏⌋. Darüber hinaus existiert die Modulus Operation, die den Rest eines rationalen Zahl ausgiebt.
[ ]:
print(3 / 4) # normale Division
print(3 // 4) # abgeschnittene Division
print(7 // 4) # abg. Division
print(15 % 10) # Modulus
Relationale Operatoratoren (Beziehung)¶
Relationale Operatoratoren sind boolesche Operatoren, die die Beziehung zwischen zwei Werten prüfen und True oder False ausgeben.
Symbol |
Was bedeutet das? |
|---|---|
== |
True, wenn gleich |
!= |
True, wenn nicht gleich |
< |
weniger als |
> |
mehr als |
<= |
weniger oder gleich |
>= |
mehr oder gleich |
[ ]:
z = 2
z == 2
[ ]:
z > 2
Die Operatoren können auch logisch verkettet werden:
Bedeutung |
Verkettender Operator |
|---|---|
Logical and |
|
Logical or |
|
Negation |
|
Wert Abfrage 1 |
Wert Abfrage 2 |
and-Verkettung |
or-Verkettung |
|---|---|---|---|
True |
False |
False |
True |
False |
True |
False |
True |
True |
True |
True |
True |
False |
False |
False |
False |
[ ]:
# Und
print(True and False)
# Oder
print(True or False)
# Not - invertiert die nachgestellte Aussage
print(not True)
Funktionales Programmieren¶
Neben dem objektorientierten, ist in Python auch das funktionale Programmieren möglich, welches für Ingenieurs-Anwendungen häufiger zum Einsatz kommt. Dabei können Funktionen mit Eingabeparametern (Argument) über die Aufrufe von def oder lambda einmal definiert, über ihren Namen aufgerufen und dabei ihren Parametern ein bestimmter Wert übergeben werden. Über den Aufruf von return kann spezifiziert werden, was die Funktion ausgeben soll. Der Ausgabewert kann dann weiter verwendet
werden, z.B. indem man ihm einer Variable zuordnet oder man ihn sich ausgeben lässt durch print. Dabei ist es essenziell darauf zu achten, dass alles, was zur Funktions-Definition gehört, eingerückt ist. Andernfalls wird es so kompiliert, als gehöre es nicht mehr dazu.
def¶
Mit def kann eine Funktion mit folgender Syntax definiert werden:
[ ]:
def zwei_mal_ausführen(funktion, argument): # def Name (Argumente mit KOMMA getrennt) : | Umlaute sind kein Problem
return funktion(funktion(argument)) # was soll die Funktion ausgeben? | einrücken ist essenziell
def fuenf_addieren(x): # einfache Funktion, die 5 zu seinem Argument x addiert
return x + 5 # was soll die Funktion ausgeben? | einrücken ist essenziell
print(fuenf_addieren(3))
print(zwei_mal_ausführen(fuenf_addieren, 10)) # fünf_addieren ist ein Argument von zwei_mal_ausführen
lambda¶
Bei def weist man die Funktion einer Variablen zu, indem man ihr einen Namen gibt. Man kann eine Funktion aber auch on the fly mittels lambda definieren; weil diese Funktionen dann keinen Namen haben, werden sie als anonym klassifiziert. Es handelt sich meistens um Einzeiler, können aber nicht mehrfach aufgerufen werden.
[ ]:
print((lambda x: x + 5)(5)) # lambda x weist auf eine anonyme Funktion hin, gefolgt vom Funktionsterm und dem Argument
fuenf_addieren = lambda x: x + 5 # lambdas können auch als (mehr oder weniger) normale Funktionen behandelt werden
Kontrollfluss-Statements¶
Kategorie |
Typ |
Bedeutung |
|---|---|---|
Conditional |
If |
Ausführen, wenn ein Zustand zutrifft |
Conditional |
If-Else |
Ausführen, wenn ein Zustand zutrifft, sonst |
Conditional |
Else If |
Ausführen, wenn der eine oder andere Zustand zutrifft, sonst |
Schleifen |
For |
Über einen Bereich (range) laufen |
Schleifen |
While |
Ausführen, bis ein Zustand erreicht wird |
Schleifen |
Break |
Ermöglicht den Abbruch einer Schleife |
Schleifen |
Continue |
Neue Schleife wird erzwungen |
Weiterhin wird Einrückungen zum Markieren von Blöcken verwendet. Daher ist die Menge an Leerzeichen oder Tabulatorzeichen am Anfang einer Zeile sehr wichtig. Dies trägt im Allgemeinen dazu bei, den Code besser lesbar zu machen, kann aber neue Benutzer von Python überrumpeln. Grundatz: Fügt keine Leerzeichen ein, es sei denn, sie werden für den Befehl benötigt.
Bedingungen¶
Finden Anwendung in Kombination mit relationalen Operatoren wie ==, !=, <, etc.
If¶
If: Wenn eine bestimmte Abfrage wahr ist, also den Wert True annimmt, dann führe die zugehörige Anweisung aus, die hinter dem „:“ steht und eingerückt, direkt unter der If Abfrage aufgeführt ist.
if some_condition:
code block
[ ]:
x = 12
if x > 10:
print("Moin")
If-else¶
Wenn die Bedingung unter if zutrifft, führe den Block unter if aus, ansonsten führe die Anweisung unter else aus.
if some_condition:
code block
else:
code block
[ ]:
x = 12
if 10 < x < 11:
print("hello")
else:
print("world")
Else if¶
Gegenüber if-else lässt sich mit elif eine weitere Bedingung einführen.
if some_condition:
code block
elif some_condition:
code block
else:
code block
[ ]:
x = 10
y = 12
if x > y:
print("x > y")
elif x < y:
print("x < y")
else:
print("x = y")
[ ]:
x = 10
y = 12
if x > y:
print("x > y")
elif x < y:
print("x < y")
if x == 10:
print("x = 10")
else:
print("invalid")
else:
print("x = y")
Schleifen¶
For-Schleifen¶
for variable in something:
code block
Für jede Variable in etwas wird der Codeblock ausgeführt. Dies wird Schleifenbildung genannt. Beim Schleifenb. über ganze Zahlen ist die Funktion range() nützlich, die einen Bereich von ganzen Zahlen erzeugt: * Bereich(n) = 0, 1, …, n-1 * Bereich(m,n)= m, m+1, …, n-1 * Bereich(m,n,s)= m, m+s, m+2s, …, m + ((n-m-1)//s) * s (die letzte Zahl ist die höchste Zahl in der Form m+xs, die kleiner als n ist)
[ ]:
for ch in 'abc':
print(ch)
[ ]:
for i in range(3):
print(i)
While-Schleifen¶
while Schleifen sind so lange aktiv, wie ihre Bedinung erfüllt ist.
while some_condition:
code block
[ ]:
i = 1
while i < 4: # Zustand, der wahr sein muss, damit die Schleife weiterläuft
print(i) # Ausgabe
i += 1 # Laufindex
print('Die while Schleife ist nicht mehr aktiv')
Break - Ausbrechen aus einer Schleife¶
[ ]:
for i in range(100):
print(i)
if i >= 5:
break
Bibliotheken¶
Python kommt mit einer Vielzahl an Funktionen. Einige sind bereits standardmäßig integriert (built-in) und immer verfügbar, andere stehen als vorinstallierte Standard-Bibliothek (standard library) bereit und andere wiederzum stehen als externe Bibliotheken zur Verfügung, die von anderen Python-Benutzern erstellt und bereitgestellt wurden (open source). Die externen Bibiliotheken können mit dem Aufruf von pip im Command-Window deines Rechners installiert werden. Um Funktionen aus Bibliotheken
(standard oder extern) nutzen zu können, müssen diese explizit im Python-Code importiert werden, dazu ist der Aufruf von import nötig.
Mathematische Funktionen - math¶
Mit der Standard-Bibliothek math können Funktionen zu Logarithmen, trigonometrische Funktionen, die Konstante \(\pi\) und so weiter importiert werden.
[ ]:
import math
print(math.sin(math.pi / 2))
from math import * # dies vermeidet, vor jede mathematische Funktion `math.` setzen zu müssen
# ACHTUNG: diese sog. "wildcard imports" können den lokalen Namensraum mit Funktionen überschwemmen und zu unvorhersehbaren Nebeneffekten führen.
# Sie verschleiern den Ursprung von Namen und können die IDE verwirren.
print(sin(pi / 2))
Mit Datenmengen arbeiten¶
Für größere gleichförmige Daten werden bestimmte Datenstrukturen verwendet, darunter:
Typ |
Reihenfolge |
Veränderbar |
Doppelte Einträge möglich |
|---|---|---|---|
List |
Ja |
Ja |
Ja |
Tuple |
Ja |
Nein |
Ja |
Set |
Nein |
Ja |
Nein |
Dictionary |
Faktisch ja |
Ja, mit Index |
Nein |
Hinweis: list und tuple werden für gewöhnlich unterschiedlich benutzt: - Eine list wird verwendet, um gleichartige Objekte aufzuzählen: (Datei1, Datei2, …)) - Ein tuple wird verwendet, um mehrere zusammengehörige Objekte zu bündeln: (Vorname, Nachname, …)).
Listen (list)¶
[ ]:
# Liste definieren
thislist = ["Apfel", "Melone", "Orange", "Banane", "Kirsche"]
print(thislist[0]) # Der erste Eintrag hat den Index 0
# negativer Index
print(thislist[-1]) # Dies ist das letzte Element, entsprechend ist -2 das vorletzte Element etc.
# Bereich
print(thislist[2:5]) # Der Bereich ist von Index 2 bis exklusive dem Index 5
# bis..
print(thislist[:4])
# von..
print(thislist[2:])
# Reihenfolge umkehren
print(thislist[::-1]) # kehre gesamte Liste im Arbeitsspeicher um
print(list(reversed(thislist)))
# Das `reversed` enthält das Rezept, um die Liste Schritt für Schritt umzudrehen. Erst der Aufruf von `list` zwingt Python dazu, dieses auch auszuführen.
# Diese Option ist oft leichter lesbar und benötigt häufig weniger Speicher
# Eintrag ändern
thislist[1] = "Schwarzer Pfeffer"
print(thislist)
# for-Schleife durch eine Liste hindurch
for x in thislist:
print(x)
# if-Condition für Liste
if "Apfel" in thislist:
print("Jawoll, Apfel gibts")
# Länge einer Liste abfragen
print(len(thislist))
# einen Eintrag anhängen
thislist.append("Kumquat")
print(thislist)
# einen Eintrag an einer bestimmten Position hinzufügen
thislist.insert(1, "Bestimmte Position")
print(thislist)
# einen Eintrag entfernen
thislist.remove("Bestimmte Position")
print(thislist)
# Eintrag an Position x entfernen
thislist.pop(1)
print(thislist)
# Liste kopieren
mylist = thislist.copy()
# Listen zusammenführen
finallist = mylist + thislist
print(finallist)
# Liste leeren, der array hat Bestand
thislist.clear()
print(thislist)
# Liste komplett löschen
del thislist
print(mylist)
Tupel (Tuple)¶
[ ]:
thistuple = ("Apfel", "Banane")
print(thistuple)
Mengen (Set)¶
[ ]:
thisset = {"Apfel", "Melone", "Orange", "Banane", "Kirsche"}
print(thisset)
Wörterbuch (Dictionary)¶
[ ]:
thisdict = {
"Marke": "Mercedes",
"Modell": "C-Klasse",
"Baujahr": 1997
}
print(thisdict)
Datenvisualisierung¶
Mit der Bibliothek matplotlib sind Funktionen zur Visualisierung enthalten.
[ ]:
import matplotlib.pyplot as plt
import matplotlib
data = [3, 4, 5, 1, 2]
plt.plot(data)
plt.show()
Pandas¶
Pandas ist eine Bibliothek und stellt Funktionen und spezielle Daten-Strukturen zur Manipulation von Tabellen und Zeitreihen zur Verfügung. Die beiden grundlegenden Daten-Strukturen sind dabei:
Series: ein eindimensionales Array-ähnliches Objekt. Es kann verschiedene Daten-Typen aufnehmen, z.B. Integers, Floats, Strings, Python-Objekte, usw. Eine Series kann als eine Datenstruktur mit zwei Arrays angesehen werden: Ein Array fungiert als Index, d. h. als Bezeichner (Label), und ein Array beinhaltet die aktuellen Daten (Werte).
DataFrame: beinhaltet eine geordnete Sammlung von Spalten. Jede Spalte besteht aus einem eindeutigen Daten-Typen, aber verschiedene Spalten haben verschiedene Typen, z.B. könnte die erste Spalte vom Typ Integer sein, während die zweite Spalte vom Typ Boolean ist, usw. Ein DataFrame hat einen Zeilen- und Spalten-Index. Es ist wie ein Dictionary aus Series mit einem normalen Index. Weitere Funktionen unter https://www.python-kurs.eu/pandas_DataFrame.php
[ ]:
import pandas as pd
years = range(2014, 2018)
Jahre = pd.Series(["Semester 1-2", "S. 3-4", "S. 5-6", "S. 7-8"], index=years)
print(Jahre)
[ ]:
cities = {
"Bezeichnung": ["London", "Berlin", "Madrid", "Rom"],
"Einwohner": [8615246, 3562166, 3165235, 2874038],
"Land": ["England", "Deutschland", "Spanien", "Italien"]
}
city_frame = pd.DataFrame(cities)
# Ordinate beschriften
ordinals = ["erste", "zweite", "dritte", "vierte"]
city_frame = pd.DataFrame(cities, index=ordinals)
city_frame
[ ]:
city_frame.plot(xticks=range(len(city_frame.index)), rot=60)
plt.gca().yaxis.set_major_formatter(matplotlib.ticker.FormatStrFormatter('%d'))
plt.show()