"""
- Sets/Mengen sind Sequenzen, die wohl-unterschiedene Elemente enthalten. D.h., in einem Set können keine Elemente wiederholt auftreten.
- Sets sind unsortiert.
- Wie Dictionarys werden Sets durch "{}" markiert.
- Set Elemente bestehen aber ander als Dictionarys nicht aus Schlüssel-Wert-Paaren sondern nur aus einzelnen Schlüsseln.
"""
set1 = {1,2,3,3,3}
print(set1)
set1 = {1,2,3,3,3}
print(set1)
set1_anders = set1
set1_anders.add(4)
print(set1 is set1_anders)
# Was passiert hier?
set2 = {}
print(set2)
print(type(set2))
set3 = set()
print(type(set3))
"""
- Ein leeres Set kann mit Hilfe der Set-Funktion erstellt werden.
- Auch andere Sequenzen können in Sets umgewandelt werden
"""
set4 = set([1,1,2,3,4,5,5])
print(set4)
set5 = set({"one": 1, "two": 2, "three": 3})
print(set5)
set4 = set([1,1,2,3,4,5,5])
""" Anzahl der Elemente einer Liste """
number_of_elements_set4 = len(set4)
print(number_of_elements_set4)
""" Element hinzufügen """
set5.add("four")
print(set5)
""" Element entfernen """
set5.discard("four")
print(set5)
""" Set um ein weiteres Set erweitern """
set5.update(set4)
# Hier wird ein bereits bestehendes Set erweitert.
print(set5)
""" Schnitt """
set6 = set1.intersection(set4) # Oder set1 & set4
print(set6)
""" Vereinigung """
set7 = set4.union(set5) # Oder set4 | set5
# Hier wird ein neues Set erstellt.
print(set7)
""" Differenzmenge """
set8 = set4.difference(set1)
print(set8)
""" Teilmengentest """
is_it = set1.issubset(set4)
print(is_it)
"""
- Tupel, markiert durch (), sind ebenfalls ein Sequenz-Datentyp.
- Sie sind nicht veränderbar.
- Die Verarbeitung von Tupeln ist effizienter als die von Listen
"""
tuple1 = ("es", "sg", "3.", "n")
print(tuple1)
"""
- Mit Hilfe der Format-Methode können wir in einen String, der {} Platzhalter enthält, Daten verschiedenen Typs an den entsprechenden Stellen in den String einfügen.
- Die einzufügenden Daten werden dabei automagisch zu Strings umgewandelt.
"""
my_fillable_string = "Hier kommt das erste Datum: {}. Jetzt noch eins: {}. Alle guten Dinge sind {}."
print(my_fillable_string)
my_fillable_string = "Hier kommt das erste Datum: {}. Jetzt noch eins: {}. Alle guten Dinge sind {}."
print(my_fillable_string.format("08.01.2019", [8, 1, 2019], 3))
# print(my_fillable_string)
"""
- Die Daten werden in der Reihenfolge in den String eingfügt, in der sie der Methode als Argument bereitgestellt werden, FALLS nicht anders definiert.
- Die Reihenfolge kann aber auch explizit angegeben werden.
"""
another_format_string = "Hier kommt erst das zweite Datum: {1}. Und nun das erste: {0}"
print(another_format_string.format("Das Erste", "Das Zweite"))
# Die Format-Methode eignet sich auch sehr gut um Daten strukturiert auszugeben
# daten_matrix = [["c1", "c2", "c3"],[1,0,0],[0,1,0],[0,0,1]]
daten_matrix = [[1,0,0],[0,1,0],[0,0,1]]
struktur = "{} {:>5} {:>5}"
for l in daten_matrix:
print(struktur.format(*l))
"""
In Zeile 9 des letzten Code Schnipsels wird der Asterisk-Operator (*) benutzt.
Der Format-Methode wird eine Liste übergeben, deren Elemente mit Hilfe des *
einzeln als Argumente verfügbar gemacht werden.
(https://docs.python.org/3.7/tutorial/controlflow.html#unpacking-argument-lists).
"""
list1 = [["Element " + str(i)] for i in range(3) if i < 3]
print(list1)
my_string1 = "Set comprehensions ähneln von der Form her bis auf die Klammern den List comprehensions Beachten Sie dass Sets ungeordnet sind und jedes Element nur einmal enthalten ist"
set1 = {c for c in my_string1.replace(" ", "") if c not in "äöü"}
print(set1)
# Set-Comprehensions funktionieren ähnlich wie List-Comprehensions, mit den Besonderheiten, die für Sets gelten.
list2 = ["car", "Cars", "Office", "offices", "Actor", "actors", "Actress", "actresses"]
sg_pl_dict1 = {item : "pl" if item.endswith("s") and not item.endswith("ss") else "sg" for item in list2}
print(sg_pl_dict1)
sg_pl_dict2 = {item.lower() if item[0].isupper else item: "pl" if item.endswith("s") and not item.endswith("ss") else "sg" for item in list2}
print(sg_pl_dict2)
# Sowohl die Wahl des Schlüssels als auch die Wahl des zugehörigen Werts kann an Bedingungen geknüpft werden.
sg_pl_dict3 = {item.lower() if item[0].isupper else item: "pl" if item.endswith("s") and not item.endswith("ss") else "sg" for item in list2 if not item.startswith(("a", "A"))}
print(sg_pl_dict3)
# Darüber hinaus können auch noch weitere Bedingungen als Filter benutzt werden.
"""
- Für Tuple gibt es keine Comprehension-Syntax
- Die Generator-Expression: Nach und nach werden die Elemente aus der Range-Funktion bereitgestellt.
(Von durch Generator-Expressions wird nach der Verarbeitung kein Objekt in den Speicher geschrieben (resourcen-schonend,
https://www.python.org/dev/peps/pep-0289/).
- Die Tuple-Funktion nimmt die Elemente entgegen und erstellt ein Tupel.
"""
no_tuple_comprehension = tuple(i for i in range(10))
print(no_tuple_comprehension)
import re # Um reguläre Ausdrücke benutzen zu können müsen wir erst das entsprechende Modul importieren.
"""
eichenarten (Auswahl)
- . => Repräsentiert ein beliebiges Zeichen
- \d => Ziffern
- \D => alle Zeichen außer Ziffern
- \w => Whitespace (Zeilenumbrüche("\n"), Tabs("\t"), Leerzeichen(" "))
- \W => Alle Zeichen außer Whitespace
- ^ => Beginn eines Strings
- $ => Ende eines Strings
- \ => Escape Character
Gruppen und Mengen (Auswahl)
- [...] => Menge von Zeichen
- (...) => Gruppe von Zeichen
- ^ innerhalb eines Sets ([^ ...]) => keine Zeichen aus dem Set
- (A|B|C) => A oder B oder C
Quantifizierer (Auswahl)
- + => das vorherige Element tritt ein- oder mehrmals auf
- * => das vorherige Element tritt 0 oder mehrmals auf
- ? => das vorherige Element tritt 0- oder einmal auf
"""
objekt_string = "Dr. Angela Dorothea Merkel"
# objekt_string = "Annegret Kramp-Karrenbauer"
# objekt_string = "Johnnie Walker"
# objekt_string = "Dr. Oetker"
# objekt_string = "Ben"
# Muster definieren
re_name = "((Dr.|Prof.|Prof. Dr.) )?(([A-Z][a-z]*)( [A-Z][a-z]*)?)? ([A-Z][a-z]*(-[A-Z][a-z]*)?)$"
muster = re.compile(re_name)
"""
- Im Muster sind die akademischen Grade optional: "((Dr.|Prof.|Prof. Dr.) )?".
Dann folgt eine (verschachtelte) Gruppe für Vornamen und eine Gruppe für
Nachnamen.
- Die Vornamen Gruppe ist deshalb verschachtelt, weil wir davon ausgehen, dass
Personen mehrere Vornamen haben können: "(([A-Z][a-z]*)( [A-Z][a-z]*)?)?".
Das Leerzeichen in der zweiten Subgruppe ist notwendig um mehrere Vornamen
verbinden zu können.
- Bei Nachnamen erwarten wir nur einen einzelnen zusammenhängenden String
(ohne Leerzeichen), aber wir erhalten die Option für Doppelnamen, die mit
einem Bindestrich verbunden sind: "([A-Z][a-z]*(-[A-Z][a-z]*)?)$".
"""
# Suchen
erster_treffer = re.search(muster, objekt_string)
"""
Die Search-Methode gibt den ersten Match im Objekt-String zurück.
Falls kein Match gefunden wird, wird eine leere Liste zurückgegeben.
"""
print(erster_treffer)
if erster_treffer != None: # Hier wird überprüft ob ein Match gefunden wurde.
for i in range(7): # Hier werden alle 7 Gruppen ausgegeben.
if erster_treffer.group(i): # Hier wird überprüft, ob die jeweilige Gruppe einen nicht-leeren String enthält.
print(erster_treffer.group(i).lstrip()) # Per group(<index>) kann auf Gruppen zugegriffen werden.
alle_treffer = re.findall(muster, objekt_string)
"""
- Rückgabe der Findall-Methode: Liste von Tupeln, Jedes Tupel entspricht einem
Treffer.
- Die Tupelelemente entsprechen den gematchten Gruppen.
- Alle optionalen Gruppen die nicht gematcht wurden, werden als leerer String
ausgegeben.
"""
print(alle_treffer)
# Ersetzen
# string_mit_ersetzungen = re.sub(muster, <einzusetzender string>, objekt_string, count = 0 )
# Der optionale Parameter count bestimmt wieviele Matches ersetzt werden.
# sollen. Wird Count auf 0 gesetzt oder nicht angegeben, werden alle Matches ersetzt.
"""
Fehler Typen:
- SyntaxError
- IndentationError
- NameError
- AttributeError
- TypeError
- ValueError
- KeyError
- FileNotFoundError
Versuchen Sie immer einen Fehlertyp zu antizipieren, wenn Sie mit ~try~ und
~except~ Fehler abfangen.
"""
"""
"It is Easier to Ask for Forgiveness than Permission"
"""
Misch_Masch = ["123", "drei", "456", None, True]
Fehlermeldung = "Das folgende Element wurde aus der Liste auf Grund eines {} entfernt: {}"
for element in Misch_Masch:
try:
element = int(element)
except ValueError:
Misch_Masch.remove(element)
print(Fehlermeldung.format(ValueError, element))
except TypeError: # Sie können mehrere Except-Statements nutzen.
Misch_Masch.remove(element)
print(Fehlermeldung.format(TypeError, element))
else:
print("Das folgende Element wurde in einen Integer-Wert umgewandelt: {}".format(element))
finally:
print("So sieht die Liste im Moment aus: {}".format(Misch_Masch))