Deutscher Python-Kurs als Grundlagentraining (begleitend zu Youtube-Tutorials)
Video #1: Grundlegende mathematische Operationen
# "plus" - ohne Variablen 5+5
10
# "minus" - ohne Variablen x = 4 y = 3 x-y
1
# Multiplikation mit Variablen; Resultat in neuer Variabel "z" gespeichert x = 4 y = 2 z = x*y print(z) # "print" ist eine Funktion (auch manchmal Methode genannt) mit der man Ausgaben in der Konsole tätigt
8
# Division print(8/10)
0.8
# verkettete Operationen print(4*5 + 5 - 4*5/4)
20.0
Video #2: Grundlegende logische Operationen in Python (logische Tests)
# logischer "kleiner als" Test 3 < 4
True
# logischer "gleich oder gleich" Test 4 <= 4
True
# logischer "gleich" Test 4 == 4
True
# logischer "ungleich" Test 4 != 5
True
# logischer "ungleich" Test 4 != 4
False
# "ODER"-Operator (4 < 3) or (4 < 5)
True
# "UND"-Operator (4 < 3) and (4 < 5)
False
# logische Tests können mit allen Datentypen durchgeführt werden "text a" == "text b"
False
"text a" == "text a"
True
# "NICHT"-Operator not 4 < 3
True
Video #3: Grundlagen der Text-Verarbeitung in Python
# Texte (Strings) können mit dem "+"-Operator verknüpft werden "Hello" + " World!"
'Hello World!'
# ... oder man verwendet ein Kommazeichen yur Textverknüpfung
print("Hello","World!")
Hello World!
# Texte können in Variablen gespeichert werden (analog zu bspw. Zahlen) x = "Hello" + " World!"
# med ""-tegnene viser Python, at datatypen er "string" x
'Hello World!'
# Bei direkter Ausgabe von Textwerten ohne die Print-Funktion erscheinen die ""-Zeichen; im Falle der Print-Funktion nicht print(x)
Hello World!
# Dies gilt bei Direkter Textausgabe über "print", ohne Speicherung in einer Variable
print("Hello World!")
Hello World!
# falls wir Text in mehreren Zeilen ausgeben möchten können wir "print" je Zeile anwenden...
print("Hello World!")
print("neue Zeile...")
Hello World! neuer Zeile...
# ... oder wir erzeugen mit \n einen Zeilenbruch
print("Hello World!\nneue Zeile")
Hello World! neue Zeile
# Text in Python ist ein eigener Datentyp ("string", oder "str"); dieser Datentyp hat seine eigene Funktionen (mehr dazu folgt)
x = "Hello"
x = x.replace("e","a")
print(x)
Hallo
# Tabellarische Textteilung kann mit "\t" erreicht werden
print("Hello \t\t\tWorld!")
Hello World!
Video #4: Grundlegende Datentypen in Python – int, float, str, list, tuple, dict, bool, complex
# "int" - Integer bzw. Ganzzahlen isinstance(1,int)
True
isinstance(1.0,int)
False
isinstance(2/2,int)
False
isinstance(int(3/2),int)
True
int(3/2)
1
# float - Gleitzahlen isinstance(2.3,float)
True
# complex - komplexe Zahlen (komplexes Zahlensystem) isinstance(2.13j,complex)
True
# boolean - logischer Datentyp bzw. "digitales Bit" (Wahr oder Falsch) isinstance(False,bool)
True
bool(0)
False
bool(1)
True
bool(1728394)
True
# "str" - String bzw. Text
isinstance("abc",str)
True
isinstance(123,str)
False
isinstance(str(123),str)
True
# list - eine Liste in der unterschiedlichste Datentypen in Form von Elementen abgespeichert werden können [1,2,3]
[1, 2, 3]
[1,1.2,"abc"]
[1, 1.2, 'abc']
x_liste = ["a","b",123]
# erster Eintrag in der Liste, bzw. erstes Listenelement x_liste[0]
'a'
# letzter Eintrag in der Liste, bzw. letztes Listenelement x_liste[-1]
123
# das hinterste Listenelement bzw. jedes Listenelement können wir auch durch Angabe der konkreten Indexnummer erhalten x_liste[-1] == x_liste[2]
True
# eine Liste kann ein Element in einer anderen Liste sein x_2dliste = [["a","b"],[1,2,3,4]] x_2dliste[1][2]
3
# tuple - ein Datentyp ähnlich zu Listen; jedoch können tuple-Elemente nicht entfernt oder geändert (überschrieben) werden x_tuple = (1,2,[1,2],"a") x_tuple[2]
[1, 2]
# falls ich versuche ein tuple-Element zu überschreiben wird Python mir eine Fehlermeldung geben x_tuple[2] = "b"
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-26-dfca17b27425> in <module>()
1 # falls ich versuche ein tuple-Element zu überschreiben wird Python mir eine Fehlermeldung geben
----> 2 x_tuple[2] = "b"
TypeError: 'tuple' object does not support item assignment# dictionary - eine Art Lexikon zur Datenspeicherung in Python
x_dict = {
"schluessel1" : "wert1",
"schluessel2" : "wert2"
}
print(x_dict)
{'schluessel1': 'wert1', 'schluessel2': 'wert2'}
x_dict["schluessel1"]
'wert1'
# in Python kan man seine eigene Datentypen definieren - mehr dazu in einem späteren Video
Video #5: Automatische Datentypkonvertierung in Python
# automatische Datentypkonvertierung in Python; wenn bspw. ein Berechnungsergebnis einen neuen Datentyp benötigt integer_1 = 1 integer_2 = 2 resultat = integer_1 / integer_2 isinstance(resultat,int)
False
isinstance(resultat,float)
True
# hier ein weiteres Beispiel; Python definiert den benötigten Datentyp implizit resultat = False + 1 resultat
1
isinstance(resultat,int)
True
isinstance(resultat,bool)
False
Video #6: Erzwungene Datentypkonvertierung in Python
# wir können die implizite Datentypzuordnung in Python unterbinden, und einen Datentyp vorschreiben; Bsp.: int(2/3)
0
int(3/2)
1
float(1)
1.0
str(20-2)
'18'
str(20-2) + "abc"
'18abc'
bool(False + 1)
True
str(20 + 1 + 2.1)+str("abc")+str(False)
'23.1abcFalse'
Video #7: Funktionen in Python definieren („functions“)
# in Python können wir Funktionen definieren; dies ermöglich bspw. das Recycling von Code-Segmenten
def gruss_schreiben(vorname, nachname):
gruss = "Liebe(r) " + vorname + " " + nachname + ",\n" + "alles Gute von mir!"
print("gruss wurde geschrieben...")
return gruss
nachricht = gruss_schreiben("Linnart","Felkl")
gruss wurde geschrieben...
print(nachricht)
Liebe(r) Linnart Felkl, alles Gute von mir!
Video #8: Looping in Python – „while“ & „for“ Schleifen
# Schleifen ermöglichen iterative Vorgehen und Algorithmen; ein Code-Segment wir durchgeführt bis ein Kriterium verletzt ist
# nachstehend eine "while"-Schleife in Python, als Bsp.:
i = 1
while(i < 6):
print(str(i)+". Iteration")
i +=1
1. Iteration 2. Iteration 3. Iteration 4. Iteration 5. Iteration
# eine "for"-Schleife; mit "for"-Schleifen kann man bspw. eine Liste elementweise durcharbeiten
x_list = [1,2,5,6,10]
for i in x_list:
print(i)
1 2 5 6 10
Video #9: Logische Abläufe mit if-else Strukturen in Python
# mittels "if" und "else" können unterschiedliche Code-Segmente situationsbedingt ausgeführt werden
i = 3.1
if i > 5:
print("i ist grösser als 5")
elif i > 4:
print("i ist grösser als 4 aber nicht grösser als 5")
else:
print("i ist nicht grösser als 4...")
i ist nicht grösser als 4...
Video #10: Klassendefinition in Python (bspw. zur Datentyperzeugung)
# Python ist objektorientiert und erlaubt die Definition von Klassen; so können eigene Datentypen definiert werden
class Person:
# __init__ funktionen bruges senere når vi vil oprette objekter af klassen Person
def __init__(self, alter, name, anschrift):
self.alter = alter
self.name = name
self.anschrift = anschrift
# über __init__ geben wir der Person-Klasse eine Funktion (Methode) welche die Daten ausgibt
def daten_ausgeben(self):
print("alter: " + str(self.alter) + " name: " + self.name + " anschrift: " + self.anschrift)
# jetzt können wir eine Objektinstanz unserer Person-Klasse erzeugen person1 = Person(28,"Linnart","irgendwo in Köln")
# da unsere Klasse "Person" eine Funktion (in diesem Fall "Methode" genannt) enhält, können wir diese auch aufrufen person1.daten_ausgeben()
alter: 28 name: Linnart anschrift: irgendwo in Köln
# wir können unterschiedliche Objektinstanzen erzeugen - und diese bspw. auch in einer Liste abspeichern
person2 = Person(45,"Lisa","Berlin")
person3 = Person(12,"Simon","Kopenhagen")
# eine Liste mit drei Objektinstanzen der Klasse "Person"
personen_liste = [person1,person2,person3]
# "for"-Schleife um Liste abzuarbeiten
for i in personen_liste:
i.daten_ausgeben()
alter: 28 name: Linnart anschrift: irgendwo in Köln alter: 45 name: Lisa anschrift: Berlin alter: 12 name: Simon anschrift: Kopenhagen
# wir können den Inhalt einer Objektinstanz ändern person1.name = "..." person1.alter = -1 person1.anschrift = "..." person1.daten_ausgeben()
alter: -1 name: ... anschrift: ...
# übrige Objektinstanzen der jeweiligen Klasse werden in diesem Fall nicht beeinflusst person2.daten_ausgeben() person3.daten_ausgeben()
alter: 45 name: Lisa anschrift: Berlin alter: 12 name: Simon anschrift: Kopenhagen
# die Beispiele bisher enthielten nur "Instanz"-Variablen; hier ein Beispiel mit einer "Klassen"-Variable
class Junge:
# "Klassen"-Variable
geschlecht = "M"
# "Instanz"-Variablen
def __init__(self,alter,name,anschrift):
self.alter = alter
self.name = name
self.anschrift = anschrift
# vi erzeugen Instanzen der Klasse "Junge"; und geben dabei Alter, Name und Anschrift je Instanz an ("Instanz"-Variablen)
junge1 = Junge(12,"Martin","Paris")
junge2 = Junge(10,"Dennis","Detroit")
# alle Instanzen der Klasse "Junge" haben dieselbe "Klassen"-Variable, mit identischem Wert junge1.geschlecht == junge2.geschlecht
True
print(junge1.geschlecht)
M
Video #11: Grundlagen der Vererbung in Python
# Klassen können Variablen und Methoden erben; Kindklassen erben von Elternklassen
class TopKlasse:
typ1 = "top klasse"
def __init__(self):
pass # pass teilt Python mit, dass wir den Methodenrumpf absichtlich leer lassen möchten
def gruss(self):
print("hallo!")
class ZwischenKlasse(TopKlasse): #die ZwischenKlassen erbt von TopKlasse
typ2 = "zwischen klasse"
def __init__(self):
pass
class UntereKlasse(ZwischenKlasse): #UntereKlasse erbt direkt von ZwischenKlasse - und somit indirekt von TopKlasse
typ3 = "untere klasse"
def __init__(self):
pass
# lass uns die vererbung von "typ1" und "typ2" testen; beides sind in diesem Fall "Klassen"-Variablen test = UntereKlasse() print(test.typ1) print(test.typ2) print(test.typ3)
top klasse zwischen klasse untere klasse
# auch Methoden (Funktionen in Klassen nennen wir Methoden) werden vererbt test.gruss()
hallo!
Video #12: Vererbung von Instanzvariablen in Python
# wie in Video #11 gezeigt werden Klassenvariablen und Methoden an Kindklassen vererbt werden; was mit "Instanz"-Variablen
class AKlasse:
def __init__(self,name):
self.name = name
class BKlasse(AKlasse): # erbt direkt von AKlasse
def __init__(self,alter):
self.alter = alter
class CKlasse(BKlasse): # erbt direkt von BKlasse und somit indirekt von CKlasse
def __init__(self,anschrift):
self.anschrift = anschrift
# funktioniert nachstehender Code fehlerfrei in Python?
cklasse1 = CKlasse("Hans",22,"Spanien")
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-76-be0b96fb7d9e> in <module>()
1 # funktioniert nachstehender Code fehlerfrei in Python?
----> 2 cklasse1 = CKlasse("Hans",22,"Spanien")
TypeError: __init__() takes 2 positional arguments but 4 were given# nein! wenn wir die vererbung von "Instanz"-Variablen gewährleisten möchten müssen wir dies explizit programmieren
class AKlasse:
def __init__(self,name):
self.name = name
class BKlasse(AKlasse):
def __init__(self,name,alter):
AKlasse.__init__(self,name)
self.alter = alter
class CKlasse(BKlasse):
def __init__(self,name,alter,anschrift):
BKlasse.__init__(self,name,alter)
self.anschrift = anschrift
# Test
cklasse1 = CKlasse("Hans",22,"Spanien")
print(cklasse1.name + ", " + str(cklasse1.alter) + ", " + cklasse1.anschrift)
Hans, 22, Spanien
Video #13: Unterschied von globalen und lokalen Variablen in Python
# Python unterscheidet zwischen lokalen und globalen Variablen
globalVar = "dies ist eine globale Variable"
def errichte_lokalVar():
lokalVar = "dies ist eine lokale Variable"
# errichte_lokalVar aufrufen
errichte_lokalVar()
# können wir globalVar ausgeben? print(globalVar)
dies ist eine globale Variable
# können wir lokalVar ausgeben? print(lokalVar)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-82-d1d869cc5eac> in <module>()
1 # können wir lokalVar ausgeben?
----> 2 print(lokalVar)
NameError: name 'lokalVar' is not defined# Variablen können auch innerhalb eines Funktionsrumpfs als globale Variablen definiert werden, mit dem Zusatz "global"
def errichte_globalVar2():
global globalVar2
globalVar2 = "dies ist auch eine globale Variable"
# errichte_globalVar2 aufrufen
errichte_globalVar2()
# können wir globalVar2 ausgeben, obwohl sie innerhalb eines Funktionsrumpfs erzeugt wurde?
print(globalVar2)
dies ist auch eine globale Variable
Video #14: Python Listen-Funktionen (append, extend, pop, remove, clear, index, sort, reverse, count, copy)
# Listen sind Objektinstanzen der Klasse "List", und verfügen deshalb auch über Funktionen (in der Klasse definiert) liste1 = []
# list1 ist aktuell noch leer print(liste1)
[]
# mit "append" können Elemente am Listenende hinzugefügt werden
liste1.append("a")
print(liste1)
['a']
# wir bereits gezeigt können unterschiedliche Datentypen in einer Liste abgespeichert werden liste1.append(4) print(liste1)
['a', 4]
# pop gibt an gegebenem Index das Listenelement aus und enfernt das Element dabei von aus der Liste liste1.pop(0)
'a'
# liste1 nach dem pop aufruf print(liste1)
[4]
# mit "insert" kann ein Element an bestimmter Stelle (dem gegebenem Index) in die Liste eingefügt werden liste1.insert(0,"a") print(liste1)
['a', 4]
# mit "extend" können Listen und nicht nur einzelne Elemente am Listenende hinzugefügt werden liste1.extend([2.0,2.3j,[1,2]]) print(liste1)
['a', 4, 2.0, 2.3j, [1, 2]]
# wir bereits erwähnt können Listen weitere Listen als Elemente enthalten liste1[4][0]
1
# hier referenziere ich das zweite element in der Liste als fünftes Element der "obersten" Liste liste1[4][1]
2
# "insert" kann auch für Listen in Listen verwendet werden liste1[4].insert(0,0)
# Test print(liste1) print(liste1[4]) print(liste1[4][0])
['a', 4, 2.0, 2.3j, [0, 1, 2]] [0, 1, 2] 0
# auch "pop" kann für Listen innerhalb anderer Listen verwendet werden; index -1 bedeutet immer "Listenende" liste1[4].pop(-1)
2
# Test print(liste1)
['a', 4, 2.0, 2.3j, [0, 1]]
# mit "vonIndex:bisIndex" print(liste1[1:3])
[4, 2.0]
# "clear" löscht den gesamten Listeninhalt liste1.clear() print(liste1)
[]
# "remove" löscht den ersten Treffer in einer Liste
liste1.extend(["a","b","c","a","d","a","e"])
liste1.remove("a")
print(liste1)
['b', 'c', 'a', 'd', 'a', 'e']
# "index" gibt den Index des ersten Treffers innerhalb einer Liste an
liste1.index("a")
2
# "count" gibt die Anzahl an Treffern innerhalb einer Liste an
liste1.count("a")
2
# mit "sort" kann eine Liste aufsteigend sortiert werden liste1.sort() print(liste1)
['a', 'a', 'b', 'c', 'd', 'e']
# mit "reverse" kann die Reihenfolge innerhalb einer Liste umgekehrt werden
liste1.append("a")
liste1.reverse()
print(liste1)
['a', 'e', 'd', 'c', 'b', 'a', 'a']
# durch Kombination von "sort" und "reverse" kann eine Liste auch absteigend sortiert werden liste1.sort() liste1.reverse() print(liste1)
['e', 'd', 'c', 'b', 'a', 'a', 'a']
# wir kann eine Liste kopiert werden? entwedert man kopiert eine Referenz (siehe Unten) oder man kopiert nur den Inhalt liste2 = liste1 liste2.append(3) print(liste1)
['e', 'd', 'c', 'b', 'a', 'a', 'a', 5, 3]
# liste2 = liste1 bedeutet, dass liste2 sich auf die gleiche Referenzstelle im Datenspeicher bezieht # das bedeutet, dass die Werte in liste2 immer den Werten in liste1 entsprechen liste1.append(5) print(liste2)
['e', 'd', 'c', 'b', 'a', 'a', 'a', 5, 3, 5]
# mit "copy" werden nur die Listeninhalten kopiert - so können Listen unabhängig weiter verarbeitet werden liste3 = liste1.copy() liste3.clear() print(liste3) print(liste1) print(liste2)
[] ['e', 'd', 'c', 'b', 'a', 'a', 'a', 5, 3, 5] ['e', 'd', 'c', 'b', 'a', 'a', 'a', 5, 3, 5]
Video #15: Bibliothekenimporte (Module, Pakete) in Python
# Python-Dateien (".py"-Dateiende) können importiert werden, bzw. deren Inhalt
def etwas_ausgeben():
print("etwas...")
# obige Funktion habe ich in test1.py, einer Python-Datei, abgespeichert; ich importiere den Inhalt mittels "import"
import test1
# test1 ist jetzt ein "Modul", auf dessen Inhalt ich in meinem Code zugreifen kann
test1.etwas_ausgeben()
etwas...
# den Namen des Moduls können wir mit dem "as"-Kommando beeinflussen import test1 as t1 t1.etwas_ausgeben()
etwas...
# mit der "*"-Wildcard können wir die Funktionsnamen direkt verwenden from test1 import * etwas_ausgeben()
etwas...
Wirtschaftsingenieur mit Interesse an Optimierung, Simulation und mathematischer Modellierung in R, SQL, VBA und Python
Leave a Reply