1. Grundlagen¶
Grundrechenarten und Regeln¶
print(5 + 4) # Addition
print(5 - 4) # Subtraktion
print(5 * 4) # Multiplikation
print(5 / 4) # Division
print(5 ** 4)# Exponent
print(5 % 4) # Modulus/Remaider
print(5 // 4)# Integer division
print((5 + 4) *3) #Punkt vor Strich
print(1) # Zahlen können ohne Markup eingefügt werden
print(1.5) # Kommata werden anstatt mit ',' mit einem '.' geschrieben
Strings (Zeichenketten)¶
Zeichen die zwischen Anführungszeichen stehen
print("Hallo Welt") #Einfacher String in Anführungszeichen
name ="Alex" # Strings können in Variablen gespeichert werden
print(name)
Strings zusammenführen¶
Mehrere Strings können durch + oder Leerzeichen zusammengefügt werden
print("Mein Name ist Alex. " + "Wie ist dein Name?")
print("Mein Name ist Alex. " "Wie ist dein Name?")
Strings replizieren¶
Strings können einfach repliziert werden.
print("Alex" * 5)
Strings kürzen¶
Strings können über [Zahl:Zahl] gekürzt werden. Wobei die Zahlen die zu überspringenden Zeichen angeben.
print("Hallo Welt!"[6:-1]) #Die ersten 0-6 Zeichen werden übersprungen
Bestimmte Zeichen eines Strings ausgeben¶
Einzelne String-Zeichen können mittel [Zahl] ausgegeben werden, wobei Zahl die gesuchte Position ist
print("Hallo Welt"[6]) # das 7. Zeichen wird ausgegeben
Boolean¶
Für Wahr oder Falsch werden die Booleans True und False ausgegeben
b = False
print(b)
Variablen¶
Variablen können benutzt werden, um Werte zuzuweisen und später einfach aufzurufen.
Für Variablen gelten drei Regeln:
- nur ein Wort
- nur Buchstaben, Zahlen und der Underscore (_)
- darf nicht mit einer Zahl beginnen
a = 5 # Einfache Variable
print(a)
b = 5 + 6 # Zahlen können in Variablen verrechnet werden
print(b)
print(a + b) # Variablen können verrechnet werden
Kommentare¶
Kommentare im Code erleichtern die Lesbarkeit und werden nicht ausgeführt. Dafür nutzt man #
# Dies ist ein Kommentar
# print("Hallo Welt") Diese Zeile wird nicht ausgeführt
print("Hello Welt") # Diese Zeile wird ausgeführt
print("dies ist ein String")
print(1) # eine Zahl
print(1 + 2) # eine Rechnung in der Print()-Funktion
input Function¶
Mithilfe der input() Funktion können Eingaben über die Konsole an das Programm übergeben werden. Die Eingabe kann in einer Variable gespeichert werden.
print('Wie ist dein Name?') # ask for their name
myName = input() # eine Zeile mit Eingabe wird geöffnet
print('Hallo {}'.format(myName))
len Function¶
Berechnet die Länge eines Strings als Integer
len('hello')
Strings aus einer Liste zu einem String zusammenfügen¶
join()-Befehl auf einen String: string.join(liste)
students = ["Alex", "Bob", "Cedric", "Erika"]
print(", ".join(students))
2. Listen¶
Listen können mehrere Elemente enthalten und sind veränderliche Datenstruktur.
Listenname = ["Element1", Element2", ... ]
students = ["Alex", "Bob", "Cedric", "Erika"]
print(students)
Element aus Liste auswählen¶
Elemente einer Liste sind aufsteigend von 0 an nummeriert.
Per Index kann ein einzelnes Element über seine Listenposition angewählt werden: Listenname[Position]
print(students[0])
Über eine negative Positionsnummer kann die Liste vom Ende zum Anfang ausgelesen werden. Die Ausgabe ist wieder in Reihenfolge der orginalen Liste
print(students[-1])
Liste Trennen¶
Eine Liste kann auch aufgeteilt (gesliced) werden. Hierfür wird Zahl:Zahl. Wobei die Zahlen die zu überspringenden Indexe angeben.
print(students[2:4])
print(students[1:-1]) #auch hier können negative Positionen benutzt werden
print(students[1:]) # mit auslassen einer Zahl wird die Liste bis zum Ende ausgeführt
Element einer Liste anhängen¶
über append() kann ein Element an das Ende einer Liste hinzugefügt werden
students.append("Franz")
print(students)
ebenso mit + können weitere Elemente hinzugefügt werden
students = ["Alex", "Bob", "Cedric", "Erika"] + ["Ferdinand"]
print(students)
Elemente aus Liste entfernen¶
mit del kann ein bestimmtes Element anhand der Position aus einer Liste entfernt werden
del students[3]
print(students)
mit remove kann ein bestimmtes Element anhand des Strings aus einer Liste entfernt werden
students.remove("Alex")
print(students)
über .pop() kann das letzte Element aus der Liste entfernt werden
x = students.pop() #aus Students wird das letzte Element entfernt
print(students) #restliche Liste
print(x) #entferntes Element
List Comprehension¶
Einfache Umwandlung bzw Neuerstellung einer Liste. Beachte, dass die Variablen ungleich der Listennamen vergeben werden müssen!
xs = [1,2,3,4]
ys = [x * x for x in xs] # für jeden Wert in xs wird das Quadrat in ys gespeichert
print(xs)
print(ys)
students = ["Alex", "Bob", "Cedric", "Erika", "Ferdinand"]
lengths = [len(student) for student in students]
#für jede Länge eines Studentennames wird das Ergebnis in "lenghts" gespeichert
print(lengths)
#Zu viele Zeilen!
xs = []
for x in range(0,10):
xs.append(x/10)
print(xs)
#einfacher:
xs = [x/10 for x in range(0,10)]
print(xs)
Listen verschachteln¶
Listen können ineinander verschachtelt werden um z.B. eine Matrix zu modellieren.
[[Liste1],[Liste2]]
Beachte, dass verschachtelte Listen mit einem Kommata getrennt werden.
liste = [
["Element1", "Element2", "Element3"],
["Element4", "Element5", "Element6"]
]
print(liste[0][2])
print(liste[1][1])
3. Daten umwandeln¶
Einen String in eine Ganzzahl umwandeln¶
int()-Befehl auf einen String: int(string)
a = int("5")
print(a)
Einen String in eine Kommazahl umwandeln¶
float()-Befehl auf einen String: float(string)
a = float("5.5")
print(a)
Eine Zahl in einen String umwandeln¶
str()-Befehl auf eine Ganzzahl oder Kommazahl: str(zahl)
age = str(21)
print(age)
Einen String in eine Liste aufspalten¶
split()-Befehl auf einen String: string.split()
students = "Alex, Bob, Cedric, Erika"
print(students.split()) # Kommata werden übernommen
print(students.split(", ")) # Kommata werden ausgelassen
4. Operatoren¶
Vergleichoperatoren¶
Verschiedene Operatoren zum Vergleichen von Variablen/Zahlen
- a == b Werte sind gleich
- a != b Werte sind ungleich
- a < b Wert b ist größer als Wert a
- a > b Wert a ist größer als Wert b
- a <= b Wert b ist größer-gleich Wert a
- a >= b Wert a ist größer-gleich Wert a Die Ausgabe über print() gibt die Booleans True(Wahr) oder False(Falsch) aus
a = 5
b = 6
print(a == b) # Gleichheit
print(a != b) # Ungleichheit
print(a < b) # kleiner als
print(a > b) # größer als
print(a <= b) # kleiner-gleich als
print(a >= b) # größer-gleich als
print( "Hallo" == "World") # auch Strings können verglichen werden
print(True is True) # für Boolean Werte keine '='-Zeichen benutzen!
print(True is not True) # Boolean werden mit 'is' und 'is not' abgefragt
Gatter¶
# Für and müssen beide Variablen den gleichen Wert annehmen
print(True and True)
print(True and False)
print(False and True)
print(False and False)
# Für or muss eine der Variablen True annehmen
print(True or True)
print(True or False)
print(False or True)
print(False or False)
# 'not' Gatter negieren Ihr Ergebnis
print(not True)
print(not False)
Der in-Operator¶
mit in-Operatoren kann man überprüfen, ob ein Element in einem anderen Element enthalten ist
der in-Operator mit Listen:
students = ["Alex", "Bob", "Cedric", "Erika"]
print("Monika" in students) # Monika ist nicht in der Liste
print("Bob" in students) # Bob ist in der Liste
der in-Operator mit Strings
satz ="Ja dieser Text ist ein String!"
print("Ja" in satz) # "Ja" ist in dem String enthalten
Der not-Operator¶
Der not-Operator negiert das Ergebnis bzw. die Abfrage.
Beachte, dass der not-Operator vor und nach der Variable kommen kann
print( not 5 == 5) # Das Erbgenis von "5 == 5" ist wahr, "not" negiert das Ergebnis
# Es können auch Listen abgefragt werden:
names = ["Andreas", "Bertold"]
print("Alex" not in names)
Mehr Operatoren¶
i = 5
print(i)
i += 1 # Mit += kann die Variable mit den nachstehenden Wert addiert und in i gespeichert werden
print(i)
i -= 1 # Mit -= kann die Variable mit den nachstehenden Wert subtrahiert und in i gespeichert werden
print(i)
5. Schleifen¶
if-else-Struktur¶
Ausführen bestimmter Abschnitte nur bei bestimmter Bedingung in if-else-Struktur. if fordert eine Bedingung, wird diese Bedingung erfüllt wird der eingrückte nachstehende Code ausgeführt. else wird ausgeführt, wenn die Bedingung nicht erfüllt wird
Jeder Codeblock wird nur einmal ausgeführt. Beachte die Einrückung für den Codeabschnitt!
if Bedingung:
Auszuführender_Code
else:
Sonst-Auszuführender_Code
x = 5
if x < 10:
print("x ist kleiner als 10")
else:
print("x ist größer als 9")
print("Ich bin nicht mehr Eingerückt")
Müssen mehr als zwei if-else Fälle abgefragt werden, nutzt man elif nächste_Bedinung: als Kurzfassung.
x = 5
if x == 8:
print("x ist 8")
elif x==7:
print("x ist 7")
elif x==6:
print("x ist 6")
elif x==5:
print("x ist 5")
else:
print("x ist nicht zwischen 4 und 9")
for-Schleife¶
Die for-Schleife durchläuft eine anzugebende Sequenz
# Das Funktioniert sowohl mit Zahlen als auch Strings
liste = [1, 2, 5]
for i in liste:
print(i)
liste = ["Max", "Mustermann", "Michael"]
for i in liste:
print(i)
Das range-Objekt wird dazu genutzt, die Sequenzlänge vorzugeben. D.h. wie oft die Schleife durchlaufen werden soll.
for i in range(0, 5): # von 0 bis 4 werden alle Zahlen ausgegeben
print(i)
while-Schleife¶
while-Schleifen führen einen Code-Block mehrmals hintereinander aus, bis eine Abbruchbedingung erfüllt ist. Innerhalb einer while-Schleife muss ein Zustand verändert werden, damit das Programm die Schleife auch wieder verlassen kann!
zähler = 0
while zähler < 3:
print(zähler)
zähler += 1
Continue & Break¶
Während eines Schleifendurchlaufs kann der man vorzeitig abbrechen und mit dem nächsten Schleifendurchlauf fortfahren (continue) oder die gesamte Schleife abbrechen (break).
for i in range(0, 4):
if i == 2:
continue # anstatt print(2) auszuführen wird 2 übersprungen und mit dem nächsten Durchlauf fortgesetzt
print(i)
for i in range(0, 4):
if i == 2:
break # an dieser Stelle wird die Schleife abgebrochen und nicht weiter ausgeführt
print(i)
6. Funktionen¶
Funktionen sind t´zusammengefasste Codeblöcke. Mittels Funktionen vermeidet man mehrmals verwendete Codeblöcke. Eine Funktion kann merhmals im Programm aufgerufen werden, nachdem sie definiert wurde.
Beachte, der Funktion oder ihren Variablen keine Dopplungen aus deinem Code zu geben!
Funktionen definieren und Aufrufen¶
def Funktionname():
Code
def print_more(): # Das Definieren der Funktion
print("hi")
print("there")
print_more() # Das Aufrufen der Funktion mit ihrem Funktionsnamen()
Funktionen können auch mit einem oder mehreren Argumenten arbeiten¶
def Funktionname(Argument):
Code
def print_name(name): # hier wird in Klammern ein Argument übergeben, ein Argument kann frei definiert werden
print("Hallo mein Name ist " + name + ".") #das Argument wird mit Argument-Namen übernommen und kann verwendet werden
print_name("Hans")
def print_more(name, count):
for i in range(0, count):
print(name)
print_more("Hallo!", 3)
Ineinander verschachtelte Funktionen sind auch möglich¶
def print_name(name):
print("Hallo mein Name ist " + name + ".")
def print_alter(alter):
print("Ich bin " + str(alter) + " Jahre alt.")
def NameUndAlter(name, alter):
print_name(name)
print_alter(alter)
NameUndAlter("Hans", 23)
Werte zurückgeben mit 'return'¶
Mit dem Befehl return können Werte aus einer Funktion zurückgegeben werden. Funktionen mit return können wie Variablen behandelt werden.
def return_element(name):
return name
print(return_element("Hi"))
7. Dateien¶
Einfaches öffnen und schließen von Dateien kann mit open() und close() realisiert werden.
Mit dem with-Konstruktor müssen geöffnete Dateien danach nicht mit der close() -Methode geschlossen werden.
open("dateiname", "operator")
write.CodeMitDatei
close()
with open("dateiname.dateiendung", "operator") as dateiname_in_funktion:
Code
Mögliche Dateien sind .txt, .csv (comma seperated values), ...
Textdateien schreiben¶
Zum schreiben einer neuen Datei nutzt man den Operator w (write)
Soll nichts überschrieben werden oder Text angehängt werden nutzt man den Operator a (append)
file = open("test.txt", "w")
file.write("Diese Datei wurde mit Phyton geschrieben. \n")
file.close()
Textdateien lesen und Inhalt ausgeben¶
Zum lesen einer Datei nutzen wir den Operator "r" (read)
file = open("test.txt", "r")
for line in file: # Alle Zeilen nacheinander auslesen
print(line.strip()) #eine Zeile ohne Zeilenumbruch ausgeben
file.close()
Zeichen aus Datei entfernen¶
das Entfernen bestimmter Zeichen ist mit Python einfach realisierbar. Es wurde schon im oberen Beispiel gezeigt:
.strip entfernt Sonderzeichen wie z.B. \n (Zeilenumbruch)
8. Dictionaries¶
Die Verknüpfung verschiedener Strings und Listen wird mit Dictionaries erfolgen. Dictionaries werden mit {"Schlüssel:Zuweisung} aufgebaut
d = {"Berlin":"BER", "Helsinki":"Hel", "Barcelona":"BAC"} # Aufbau eines Dictionaries
print(d) # Ausgabe des gesamten Dictionaries
print(d["Helsinki"]) # Ausgabe der Wertzuweisung für den Schlüssel "Helsinki"
print(d.get("Helsinki")) # vermeidet Fehler falls Schlüssel nicht im Dictionarie enthalten
print(d.get("Budapest")) # Beispiel für nicht-existenz
print(d.items()) # Ausgabe des Dictionaries als Liste mit Tupel
Dictionaries kann jedem Element/Schlüssel auch eine Definition zugewiesen werden
for key, wert in d.items():
print(key + " : " + wert)
Listen in Dictionaries¶
staedte = {
"München": ["MUC", "Bayern"],
"Berlin": ["BER", "Berlin"]
}
print(staedte["Berlin"])
9. Tupel¶
Ähnlich zu Listen, jedoch unveränderliche Datenstruktur.
t = (1, 2, 3) # ein Tupel wird mit runden Klammern gebildet
print(t) # abrufen des gesamten Tupel
print(t[1]) # abrufen eines bestimmten Tupel-Elements
Tupel definieren¶
Der Inhalt eines Tupels kann durch Variablen definiert und zugewiesen werden. Erleichtert den Zugriff und das Entpacken
student = ("Max Mustermann", 20, "Maschinenbau") # Tupel bilden
name, alter, fach = student # Tupel entpacken und Definition zuweisen
print(fach) # Information aus Tupel anhand der Definition entpacken
Eine Liste mit Tupel¶
students = [
("Max", 20), # Komma zwischen Tupel nicht vergessen!
("Alex", 30)
]
for name, alter in students: # Definitionen zuweisen
print(name)
10. Module¶
Mit Modulen können Funktionen und Rechnungen aus anderen Python-Programmen in einem anderen Wiederbenutzt werden.
Dafür erstellt man erst ein Python-Programm (Datei mit .py-Endung). Diese wird über den import-Befehl geladen.
# Das 'hallo.py' Programm:
def welt():
print("Hallo Welt")
welt()
import hallo # die Datei hallo.py wird in das aktuelle Programm eingebunden
hallo.welt() # die Funktion welt() im hallo.py-Programm wird in unserem aktuellen Skript ausgeführt
from hallo import welt # damit wird explizit nur die Funktion 'welt()' in das aktuelle Programm geladen, jede weitere mit ',' getrennt
welt() # die Funktion kann damit direkt benutzt werden
# Achte auf Dopplungen von Funktionsnamen in unterschiedlichen Programmen!
from hallo import * # mit dem '*' werden alle Funktionen aus 'hallo.py' in das aktuelle Programm geladen
welt()
import hallo as h # mit der 'as'-Methode wird zum Aufrufen eines Programms im Skript ein 'Ersatzname' genutzt
h.welt() # diese Variante kann lange Programmnamen abkürzen
Modulordner definieren und strukturieren¶
Um viele Programme und Module strukturiert zu halten ist es oft praktisch diese in einem extra Ordner zu speichern. Hierbei ist es vorteilhaft eine Modul-Datei mit der Auflistung aller möglichen Programme zu führen.
# Modul-Datei: __init__.py
__all__ = ["datei"] # all Beschreibt alle Module, "datei" ist ein Programm namens 'datei.py' im Modulordner
# hier wird der Vorteil der Modul-Datei gezeigt
from ordner import * # alle Funktionen aus dem Ordner 'ordner' werden geladen
datei.f()
Module importieren¶
für zusätzliche Funktionen können externe bzw. fertige Module in Python importiert werden.
Den Python-Modul-Indes findet man hier: https://docs.python.org/3/py-modindex.html
Einige der wichtigsten Module werden folgend vorgestellt
Mathe plotten¶
mit der Bibliothek für Matheplotter (mathplotlib.pyplot) können Funktionen und Zahlen Grafisch visualisiert werden.
%matplotlib inline
import matplotlib.pyplot as plt # hier wird das Matplolib-Modul importiert und mit der Variable plt verknüpft
plt.scatter([1, 2 , 3], [4, 3, 2]) # plt. kann dann für das Modul benutzt werden
plt.show()
Programm Beenden/Abbrechen¶
Mit sys.exit (muss importiert werden) kann ein laufendes Programm vorzeitig abgebrochen werden.
import sys
#sys.exit() (Bei Anwendung hier kann der weitere Verlauf nicht umgesetzt werden)
Programm pausieren¶
Manchmal ist es notwenig das Programm pausieren zu lassen (Bsp Crawler auf Webseite). Dafür nutzt man das Modul time
import time # Time-Modul importieren
time.sleep(1) # '1'-Sekunde Programmpause
Webseiten runterladen¶
Mit einem request kann eine bestimmte Webseite heruntergeladen und der HTML-Code ausgegeben werden (http://docs.python-requests.org/en/master/).
import requests
r = requests.get("http://www.google.de")
print(r.status_code)
Elemente in HTML finden¶
Aus html-Dateien kann man mit BeautifulSoup (https://www.crummy.com/software/BeautifulSoup/bs4/doc/) Informationen zerlegen und extrahieren.
from bs4 import BeautifulSoup # BeautifulSoup importieren
# Beispiel HTML-Datei
htmlDatei = """
<html>
<body>
<p class="something">Ich bin ein Absatz!</p>
<p>Ich bin noch ein Absatz</p>
</body>
</html>
"""
doc = BeautifulSoup(htmlDatei, "html.parser") # HTML-Datei mit BeautifulSoup Parsen/Einlesen
for p in doc.find_all("p"): # im Dokument alle <p>-Konstruktoren finden
print(p.attrs) # für alle <p> dessen Attribute ausgeben
print(p.text) # für alle <p> dessen Text ausgeben
relative URLs¶
Einige Elemente (z.B. Bilder) sind auf Webseiten nur relativ zu Ihrer Webseite verlinkt. Beim Crawlen kann der gesamte Bildpfad mit urljoin hergestellt werden.
from urllib.parse import urljoin # urljoin importieren
from bs4 import BeautifulSoup # BeautifulSoup importieren
url = "http://python.beispiel.programmierenlernen.io/index.php" #Webseiten-URL die durchsucht wurde
r = requests.get(url)
doc = BeautifulSoup(r.text, "html.parser") # HTML-Datei mit BeautifulSoup Parsen/Einlesen
for card in doc.select(".card"):
image = card.select_one("img").attrs["src"]
imageURL = urljoin(url, image)
print("relative URL: " + image + " gesamte URL: " + imageURL)
Generatoren¶
Generatoren erzeugen Listen (meist aus Crawlern) die viele Einträge enthält. Aus dieser Liste können eine bestimmte Anzahl an Einträgen ausgegeben werden. Die .fetch()-Methode erkennt dies dadurch automatisch.
def gen_generator():
for i in range(0, 3):
print("gen: " + str(i))
yield i
for element in gen_generator(): # Alle Elemente der Liste ausgeben
print("for: " + str(element))
print("####")
for element in gen_generator(): # die ersten 2 Elemente ausgeben
if element == 1:
break
print("for: " + str(element))
10. Objektorientierung¶
Klassen sind Baupläne für Objekte. Die erzeugten Objekte nennt man Instanzen dieser Klasse.
class Student(): # Klasse Student erstellen, Klassennamen beginnen gemäß Konvention mit Großbuchstaben
pass # Leere Klasse zulassen
erik = Student() # Instanz erzeugen
erik.firstname = "Erik" # zwei Variablen für das Objekt,
erik.lastname = "Mustermann" # auf díe über das Objekt per Punktschreibweise zugegriffen werden kann
print(erik.firstname)
class Student():
def __init__(self, firstname, lastname): # durch Definition der Variablen mittel einer Methode
self.firstname = firstname # können Instanzen einfach hinzugefügt werden
self.lastname = lastname
monika = Student("Monika", "Mueller") # Kurzschreibweise für Instanz
print(monika.lastname)
Methoden und Definitionen können innerhalb von Objekten gebildet werden um Namensübertretungen zu verhindern bzw.
innerhalb eines Objekts alle Namenskonventionen festzuhalten.
self ist ein Schlüsselwort, es fungiert gewissermassen als Platzhalter für die jeweilige Instanz
class Student():
def name(self): # ein Konstruktor, der eine Funktion für das Objekt definiert
print(self.firstname + " " + self.lastname)
erik = Student()
erik.firstname = "Erik"
erik.lastname = "Mustermann"
erik.name()
class Student():
def __init__(self, firstname, lastname):
self.firstname = firstname
self.lastname = lastname
self.term = 1 # Hier initialisiert die neue Variable term (Eigenschaft)
def increase_term(self): # Mit dieser Methode erhöht die Variable term um 1
self.term = self.term + 1
def name(self): # name() gibt Name und Anzahl der Semester aus
print(self.firstname + " " + self.lastname +
" (Semester: " + str(self.term) + ")")
erik = Student("Erik", "Mustermann")
erik.name()
erik.increase_term() #Semester erhöhen
erik.name()
Private Eigenschaften und Methoden¶
Private Eigenschaften erlauben sauberes Kapseln von Eigenschaften und Methoden. Dadurch können Variablen und Methoden vor außerhalb geschützt werden. Wichtig wenn diese Variablen / Methoden noch angeüasst werden.
Mit zwei Unterstrichen vor der Variable wird diese privat. Methoden könne auf dieselbe Weise eingeschränkt werden.
class Student():
def increase_term(self):
self.__term = self.__term + 1
def get_term(self): # um von außen noch auf die Variable term zugreifen zu können
return self.__term
def __do_something(self):
print("doSomething")
Vererbung¶
Durch Vererbung können Daten aufgeteilt und besser modelliert werden.
Als Parameter wird die Klasse übergeben, von der neue Eigenschaften und Methoden vererbt werden sollen (Mutterklasse).
class WorkingStudent(Student):
def __init__(self, firstname, surname, company):
# mit super() wird Python gezeigt, dass die init()-Methode der Mutterklasse angewendet werden soll
super().__init__(firstname, surname)
self.company = company
def name(self):
return super().name() + " (" + self.company + ")"
Die type() und isinstance() Funktionen¶
Mit der type()-Funktion kann der Typ eines Objektes festgestellt werden.
Die Funktion isinstance() erhält zwei Parameter: die Variable und die Klasse bezüglich derer auf Zugehörigkeit der Variable geprüft werden soll. isinstance() liefert einen Bool zurück.
print(type(student))
print(isinstance(student, Student))
Statische Variablen¶
Anstatt Instanzen können auch Variablen an Klassen gebunden werden. Diese heißen statisch, weil sie nicht an einer einzelnen Instanz hängen. Werden die Variablen geändert, werden sie für alle Objekte geändert.
class Car:
price = "expensive" # der Preis wird auf jedes Objekt übertragen das mit der Klasse 'Car' erstellt wurde
c = Car
print(c.price)
Styleguide für Klassen und Variablen¶
In Python verwendet man dazu nach Konvention:
- PascalCase (
IchBesteheAusMehrerenWoertern) - sneak_case (
ich_bestehe_aus_mehreren_woertern)
Anders als in anderen Programmiersprachen benutzt man nicht:
- camelCase (
ichBesteheAusMehrerenWoertern)
Besondere Methoden¶
Die str-Funktion gibt für print(objekt) eine Definierte Form aus.
Die repr-Methode gibt für Objekt eine Definierte Form aus.
Die len-Methode gibt für print(len(Objekt)) die Länge aus.
class PhoneBook():
def __init__(self):
self.__entries = {}
def add(self, name, phone_number):
self.__entries[name] = phone_number
def get(self, name):
if name in self.__entries:
return self.__entries[name]
else:
return None
def __str__(self):
return "PhoneBook(" + str(self.__entries) + ")"
def __repr__(self):
return "PhoneBook(" + str(self.__entries) + ")"
def __len__(self):
return len(self.__entries)
book = PhoneBook()
book.add("Mustermann", "1234")
book.add("Mueller", "9876")
print(book) #für str-Funktion
book #für repr-Funktion
print(len(book)) # für len-Funktion