Deutscher Python-Kurs: Grundlagentraining

Python Grundlagen

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

Leave a Reply

1 thought on “Deutscher Python-Kurs: Grundlagentraining

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Close

Meta