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...