Informatik Flashcards
Was ist die Syntax einer Sprache?
grammatikalische Regeln, denen eine Sprache folgt
Welche Elemente hat die Python-Syntax?
Literalte, Bezeichner, Schlüsselworte, Operatoren, Blöcke, Kommentare
Was macht ein Bezeichner?
bezeichnet Variablen, Funktionen oder Datentypen. Sind Platzhalter für Dinge, die einen Wert haben können; Beginnen mit Buchstaben und stehen nicht in Anführungszeichen; Bsp. def bezeichner_name; bezeichner = 1
Was macht ein Schlüsselwort?
haben eigene, unveränderliche Bedeutung und beginnen mit Buchstaben;
and, as, assert, async, break, continue, class, def, del, elif, else, if, false, for, from, in, is, not, or, ….
Was macht ein Operator?
Verknüpft mehrere Ausdrücke zu einem neuen Ausdruck, sind Sonderzeichenketten oder Schlüsselworte; Bsp. () [] {} + - * / // < > => >= == != if else is not in
Was ist ein Block?
Zusammenhängender Quelltext, der in Python druck einrücken und : gekennzeichnet wird
Was ist ein Kommentar?
Beschreibt Code, beginnt mit # und Endet am Ende der Zeile
Was ist ein Ausdruck?
Ein Ausdruck repräsentiert einen Wert, zu dem er Auswertet, er kann aus einem Literal, dem Bezeichner einer Variablen, einem Funktionsaufruf oder einem mit Operatoren zusammengesetzten Ausruck bestehen
Was gibt es für verschiedene Operatoren und was machen diese?
unärer Operator: haben einen Operanden -a
binärer Operator: verknüpfen zwei Operanden a+b
ternärer Operator: verknüpfen drei Operanden if..else..
Außerdem gibt es einen prefix, infix und postfix - Operator (vorne, mitte, hinten)
z.B. a+b binärer Infix-Operator; -a unärer Präfix-Operator
Was bedeutet Operatorenpräzedenz?
Operatoren haben Präzedenzreihenfolge, in einer Reihe z.B. linksassoziativ; Veränderbar mit ()
Was sind Arithmetische Operatoren?
+ - * / % ** ~ //
Was sind Bitoperatoren?
& (bitweises und) | (bitweises oder)
Was sind Bitoperatoren?
& (bitweises und) | (bitweises oder) ^ (bitweises entweder oder), bit-shift («_space;»)
Zahl in bitschreibweise (2^3 + 2^2 + 2^1 + 2^0) = 15
1 1 1 0 = 14
0 1 0 1 = 5
—————————————–
14&5 0 1 0 0 = 4
14|5 1 1 1 1 = 15
14«1 1 1 1 0 0 = 28
14»1 0 1 1 1 = 7
Was sind Vegleichsoperatoren?
Vergleiche, einschließlich Test auf Inhalt und Identität:
in, not in, is, is not, , >=, !=, == -> Bsp. 3>10 -> false
Was sind Boolsche Operatoren?
not, and, or true and false -> false; not false = true; true or false = true
Konditionalausdrücke sind was?
Zusammengesetzte Operatoren und Zeichenketten:
“Apple” if 3<4 else “Banana” -> “Apple”, weil 3<4
Ausdrücke mit Zeichenketten? Was für Unterschiede?
Konkatenation: “Hallo” + “Welt” -> “Hallo Welt”
Repetition: “Na” * 6 -> “NaNaNaNaNaNa”
Was ist die Zuweisung?
Ist ein Ausdruck, der einer Variablen mit dem Namen Bezeichner den Wert des Ausdrucks zuweist; Kann später im Programm überschrieben werden
a = 1
Modifizierte Zuweisung: a+=2, a-=2 a//=2, a*=2
Was ist das Imperative Programmierparadigma?
Programm besteht aus Liste von Answeisungen, die nacheinander ausgeführt werden können; Anweisungen werden durch Zeilenumbrüche getrennt, es seidenn durch \ über mehrere Zeilen
Was ist eine Funktion? Welche Bestandteile?
Mehrere benötigte Anweisungen werden zu einer Prozedur zusammengefasst und mit Bezeichner benannt -> Funktion
Eine Funktion muss in dem Moment definiert sein, in dem sie aufgerufen wird, kann aber überschrieben werden
Funktionsaufruf: print(), funktion(Parameter)
Funktionsargumente: Argumente, die der Funktion beim Aufruf übergeben werden
Funktionsdefinition: def funktion(Parameter):
Leere Funktionen müssen mit pass gekennzeichnet werden, sonst gibt es einen Fehler (pass tut einfach nichts)
Funktionen können einen return-Wert besitzen (nach return wird Funktion verlassen)
Was sind optionale Parameter einer Funktion?
Verpflichtende Argumente: def funktion(name, nachname):
Beide Argumente sind beim Aufruf verpflichtend
Optionale Argumente: def funktion(name, nachname=”mahler”):
Wenn bei nachname nun nichts eingegeben wird, wird default-Wert “mahler” gesetzt, name ist verpflichtend; wird nachname übergeben, wird “mahler” überschrieben
Details zur print()-Funktion?
print(“Hallo”, “du”, “Idiot”, sep=”-“, end=”!”)
-> Hallo-du-Idiot!
Was macht die Input-Funktion?
wert=input(“Sag dein Name!”)
-> Eingabe des wert
Was für Kontrollstrukturen gibt es?
if, if else, elif, for, while
Was macht die if-Kontrollstruktur?
Ausführung eines Codes findet nur statt, wenn if-Bedingung erfüllt wurde
if a>b:
Was macht die if-Kontrollstruktur?
Ausführung eines Codes findet nur statt, wenn if-Bedingung erfüllt wurde
def max(a,b):
if a>b:
return a
return b
Gibt in Funktion a zurück, wenn a>b, ansonsten als default b, kann auch mit else geschrieben werden:
def max(a,b):
if a>b:
return a
else:
return b
Zusätzlich kann elif (else..if) benutzt werden if…elif…elif…else
Wie funktioniert eine for-Schleife?
for-Schleife führt Codeblock mehrfach aus und setzt dabei nacheinander Werte für die Schleifenvariable ein:
for wert in 100, 200, 500, 1000:
print(wert)
-> 100 200 500 1000 (untereinander)
break verlässt for-Schleife (Wenn ein Wert beim iterieren “gefunden” wurde)
continue springt zum Beginn des Schleifenkörpers zurück setzt nächsten Wert ein (Abbruch eines Durchgangs, Start neuer Durchgang)
for wert in range(5):
print(wert)
-> 0 1 2 3 4
for wert in range(3,7):
print(wert)
-> 3 4 5 6
for wert in range(3,8,2):
print(wert)
-> 3 5 7
Was macht for..else?
Führt else genau dann aus, wenn Schleife NICHT durch ein break verlassen wurde
Wie funktioniert die while-Schleife?
Führt Schleifenkörper so lange aus, bis Schleifenbedingung erfüllt ist
a=0
while a<3:
a+=1
-> geht durch while-Schleife, bis a=3, dann weiter
while…else:
a=4
while a<3:
a+=1
else:
print(“a war schon immer größer als 3)
-> geht direkt in else, da while einmal zu FALSE ausgewertet wurde
Wie funktioniert die while-Schleife?
Führt Schleifenkörper so lange aus, bis Schleifenbedingung erfüllt ist
while
Funktionen von Processing?
Initialisieren: def setup(): -> size()
Draw: def draw():
cicle(), text(), line(), rect()
stroke(), strokeWeight(), fill()
mousePressed(), mouseReleased(), mouseX(), mouseY(), hour(), minute(), second()
Was ist ein Algorithmus?
ein Schema, mit dem wir den Lösungsweg für eine Problemstellung so aufschreiben, dass man Code schreiben kann, mit dem die Lösung berechnet werden kann
Was ist Iteration?
Manche Probleme lassen sich durch wiederholte gleichartige Berechnungen lösen. Eine einzelne Wiederholung berechnet man als Iteration, in Python while und for für Iterationen.
def fak_iterativ(n):
akkum = 1
for i in range(1,n+1):
akkum = akkum * i
return akkum
Was ist Rekursion?
Eine Funktion heißt rekursiv, wenn sie sich selbst aufruft, auch wenn das über mehrere Zwischenaufrufe von Funktionen passiert, die sich gegenseitig aufrufen
def fak_rekursiv(n):
if n < 2:
return 1
return n * fak_rekursiv(n-1)
Die Anzahl der Selbstaufrufe können gezählt werden und werden als Rekursionstiefe bezeichnet, Python bricht ab einer bestimmten Rekursionstiefe ab
Was ist Information?
Digitaler Speicher besteht aus Bits, die nur zwei Zustände unterscheiden können. (z.B. 0/1, wahr/falsch,..) Meist werden mehrere Bits zusammengefasst und als logische Einheit von Information betrachtet; n Bit Information unterscheidet dabei 2^n verschiedene Zuständen; Wenn man zwischen N verschiedenen Zuständen unterscheiden kann, besitzt man log2N an Information
Was ist ein Datentyp?
Interpretation der Zustände entspricht dem Datentyp. Damit Operationen auf Werten überhaupt möglich sind, muss Python wissen, welchen Typs die als Bits im Speicher abgelegten Daten haben. Durch type() kann man sich den Typ ausgeben lassen.
Was ist statische bzw dynamische Typisierung?
Unterschied zwischen statisch typisierten Programmiersprachen und dynamisch typisierten Sprachen. Statisch bedeutet, dass bereits zu dem Zeitpunkt, zu dem das Programm geschrieben ist, der Datentyp jeder Variable, jedes Ausdrucks bekannt sein kann. Dynamisch typisiert bedeutet, dass erst bei der Ausführung des Codes der Datentyp einer Variable feststeht. Python ist duck typed, erst wenn bei der Ausführung erkannt wird, dass eine Operation nicht möglich ist, gibt es einen Fehler.
Was ist ein Type hint?
Es gibt optionale type hints, die in Funktion bestimmten Datentyp erwarten.
def summe( a : int, b: int) -> int:
return a + b
Was ist der Bool´sche Datentyp?
Kennt nur Werte true und false; in Bedingungstests von if, while, sowie als Operand von or, and und not gibt es auch die Interpretation von anderen Typen als wahr und falsch; True entspricht allen ganzen Zahlen außer 0, False 0 und umgekehrt.
A and B entspricht B if A else A
A or B entspricht A if A else B`
Bsp. 3 and „Banana“ -> „Banana“, da Banana trueisch
„Banana“ and not „Cat“ or „Apple“ -> „Apple“
False + 0 -> 0, True + 0 -> 1
Was ist der None-Type?
Wert None vom Typ NoneType, der signalisiert, dass ein Ausdruck keinen eigentlichen Wert hat.
Was sind ganze Zahlen (Type int)
Ganze Zahlen haben den Typ int, der nicht durch bit begrenzt ist, sondern wächst bis zum Füllen des Hauptspeichers an; die Division von zwei ganzen Zahlen liefert einen float-Wert zurück. Es seidenn man benutzt //
Was sind Fließkommazahlen (Type float)?
Entsprechen dem Typ float; dargestellt mit . und nicht , 0.0 ist false, alles andere true
Was sind komplexe Fließkommazahlen (Type complex)?
Basieren auf float, implizieren immaginäre Zahlen
1j*1j = (-1+0j) = -1
bei gemischten Operationen mit int oder float findet ein automatischer Cast auf complex statt
Was sind Zeichenketten (Type str)?
Sind Unicode-basiert, erst bei Lesen und Schreiben von außen spielt das Encoding eine Rolle
“String” oder ‘String’
Mehrzeilige String-Literale können Zeilenumbrüche enthalten """Ein String""" '''Ein String''' -> 3x Anführungszeichen
Möchte man “ printen: print(“ ‘ “) oder print(‘ “ ‘)
Was gibt es für Sonderzeichen in einem String?
print(“C:\DOS>”) -> C:\DOS> -> \
print(“A\nha!”) -> A
ha! -> \n
print(“Eins\t1) -> Eins 1 ->\n (Tab)
wird vor den String ein r geschrieben, werden Sonderzeichen ignoriert print(r”1\n2) -> 1n\2
Wie funktioniert Typumwandlung?
int(3.9) -> 3
int(“3”) -> 3
int(float(“3.9”))->3 !!hier muss “3.9” von str erst in float, dann in int umgewandelt werden
Was ist eine lokale Variable?
Gleicher Name kann an verschiedenen Stellen im Quelltest auf verschiedene Speicherbereiche verweisen und unterschiedlichen Speicherbereichen zugeordnet sein. z.B. in
- verschiedenen for-Schleifen
- verschiedenen Funktionen
Dabei stellt die Variable dann eine lokale Variable dar, da sie nur innerhalb der Funktionen sichtbar sind; diese liegen im Stapelspeicher (Stack)
Möchte man in einer Funktion die außen stehende globale Variable verwenden, kann man global v benutzen, um diese zuzuweisen;
Was ist eine globale Variable?
Globale Variablen sind über Funktionen hinaus sichtbar; benutzt jeweils den gleichen Speicher
Wenn die gleich benannte Variable einmal ausßerhalb und innerhalb einer Funktion auftauchen, wird in der Funktion die innerhalb der Funktion definierte Variable benutzt, diese verdeckt dann die globale Variable
Was ist ein scope?
Sichtarbkeitsbereich, Python bewegt sich von innen nach außen, sucht zuerst innerhalb aktueller Funktion, dann in umgebenden Funktionen, dann im globalen scope, dann im built-in scope (print z.B.)
global legt fest, dass die Sucher erst im globalen Scope beginnt
Kann man Variablen löschen?
Ja, mit del VARIABLE kann man die Variable löschen und so Speicher freigeben
Was ist ein Modul?
Python hat auch schon im Auslieferungszustand zahlreiche Bibliotheken zur Verfügung, die als Module organisiert sind. Mit der import-Anweisung ermöglichen wir unseren Programmen den Zugriff:
import math (oder import math as m)
math.sin(math.pi) (oder m.sin(m.pi)
Was ist ein Tupel?
Ein in Python eingebauter Container; ein Datentyp der mehrere Werte beinhaltet, nämlich Tupel (2), Tripel (3), …
a = (3, 4)
a = (“drei”, “vier”)
a, b = 3, “drei”
Tupel mit nur einem Element:
a = (“drei”,)
Zugriff auf Tupel:
tupel[0]
tupel[2:4] -> Index 2 und 3
tupel[-1] -> Letzter Eintrag
Was haben Container für eingebaute Operationen?
- a in b testet, ob eine Sequenz b den Wert a enthält
- a not in b testet, ob eine Sequenz b den Wert a nicht enthält
- == überprüft ob Länge gleich und jedes Element übereinstimmt
- len(a) gibt Anzahl Elemente zurück
- min(a) gibt kleinstes Element zurück
- max(a) gibt größtes Element zurück
- a.count(b) liefert zurück, wie oft es b in a gibt
- a.index(b) liefert Index von b zurück
- a+b erzeugt eine aus a und b aneinandergesetzte Sequenz
- a*n erzeugt eine Sequenz, die a n-mal aneinandersetzt
Wie iteriert man über Container?
zaehler = (‘eins’, ‘zwei’, ‘drei’, ‘los’)
for z in zaehler:
print(z,”!”)
eins !
zwei !
drei !
los !
Wie kann man auf verschiedene Abschnitte eines Sequenztyps (Tupel ist z.B. ein Sequenztyp) zugreifen?
- a[i:j] sind alle Elemente von i bis j (ausschließlich j)
- a[i:j:k] sind alle k-ten Elemente (z.B. jedes zweite) von i bis j (ausschließlich)
- a[:i] oder a[i:] alle Elemente bis i(ausschließlich) oder von i(einschließlich) ab
- a[:] für alle Elemente
- a[::-1] für alle Elemente in umgekehrter Reihenfolge
Wie kann man einen Tupel mit range() initialisieren?
t = tuple(range(1,11))
Wie kann man Strings slicen?
’’ in ‘team’ -> True
‘i’ in ‘team’ or ‘u’ in ‘team’ -> False
‘tea’ in ‘team’ -> True
t = ‘team’
print(t[0]) -> t
Wie kann man Strings zusammensetzen?
” und “.join((“1”,”2”,”3”)) -> 1 und 2 und 3 String wird zwischen Elemente des Tupels gesetzt
Wie kann man über Strings iterieren?
a = "123"
b = tuple(a) -> ("1","2","3")
oder
for x in "Zeichen":
print(x)
-> Z
e
i
c
h
e
n
Wie initialisiert man eine Liste?
a = [1, 2, 3] -> [1, 2, 3]
list((1,2,3)) -> aus Tupel wird Liste
list(range(22)) -> [0, 1, 2, …, 21]
In Liste können mehrere Datentypen a = [“becher”, 3, 2.3]
Welche Operationen kann man auf Listen ausführen?
- liste.append(ELEMENT) fügt ELEMENT ans Ende von liste (z.B. auch ein ganzes Tupel als solches)
- liste.remove(ELEMENT) entfernt ELEMENT aus Liste (Alle anderen folgenden Elemente “rutschen” auf)
- liste.extend(ELEMENT) fügt Elemente von ELEMENT ans Ende von liste (z.B. die einzelnen Elemente von einem Tupel)
- liste.sort() sortiert liste (z.B. Zahlen aufsteigend)
- liste.clear() löscht alle Elemente von liste
- liste.reverse() kehrt Reihenfolge von liste um
Welche Operationen kann man auf Listen ausführen?
- liste.append(ELEMENT) fügt ELEMENT ans Ende von liste (z.B. auch ein ganzes Tupel als solches)
- liste.remove(ELEMENT) entfernt ELEMENT aus Liste (Alle anderen folgenden Elemente “rutschen” auf)
- liste.extend(ELEMENT) fügt Elemente von ELEMENT ans Ende von liste (z.B. die einzelnen Elemente von einem Tupel)
- liste.sort() sortiert liste (z.B. Zahlen aufsteigend)
- liste.clear() löscht alle Elemente von liste
- liste.reverse() kehrt Reihenfolge von liste um
Wie kann man eine Liste verändern (zuweisen, entfernen)?
- a[1] = “zwei” -> an Index 1 wird “zwei” als String gesetzt, das vorherige Element wird überschrieben
- del a[0] -> Element an Index 0 wird entfernt, alle folgenden Elemente rutschen nach
a=list(range(100))
del a[:95] -> [95,96,97,98,99]
Wie kann man Listen mit Sclicing zuweisen?
a = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] b = list(range(30)) b[3:25] = a[-3:]
b -> [0, 1, 2, ‘e’, ‘f’, ‘g’, 25, 26, 27, 28, 29] Ersetzt alle Zahlen von 3 bis 24 mit e, f, g
Wie initialisiert man Mengen(set)?
a = {1,2,3} -> {1,2,3}
set() erzeugt eine leere Menge
Man kann nicht über Mengen iterieren und auch nicht die Reihenfolge der Elemente bestimmen
Was für Operatoren kann man auf Mengen ausführen?
- menge.add(ELEMENT)
- menge.remove(ELEMENT)
- menge.clear()
Wie kann man Mengen miteinander vergleichen?
- 1 in {1,2,3} -> True
- {1,2}.issubset({1,2,3}) -> ist Teilmenge?
- {1,2,3}.issuperset({1,2}) -> ist Übermenge?
- {1, 2}.union({2, 3}) -> Vereinigungsmenge -> {1,2,3}
- {1, 2}.intersection({2, 3}) -> Schnittmenge -> {2}
- {1, 2}.difference({2,3}) -> Mengendifferenz -> {1}
Was gibt es für Container- und Sequenztypen?
- Tupel a=(2,3,4)
- Listen list=[2,3,4]
- Mengen men={2,3,4}
Wie initialisiert man ein Dictionary?
d = { “1” : “Eins”, 2: “Zwei”, “three”: “Drei”}
Der vordere Wert ist der Schlüssel. Dieser kann unterschiedliche Datentypen haben
Wie greift man auf ein Dictionary zu?
d = { “1” : “Eins”, 2: “Zwei”, “three”: “Drei”}
print(d[“three”])
print(d) -> Drei
Wie fügt man ein Element zu einem vorhandenen Dictionary hinzu?
d = { “1” : “Eins”, 2: “Zwei”, “three”: “Drei”}
d[“4”] = 4 -> {‘1’: ‘Eins’, 2: ‘Zwei’, ‘three’: ‘Drei’, ‘4’: 4}
Wie iteriert man über ein Dictionary?
d = { “1” : “Oise”, 2 : “Zwo”, “trois” : “Drei” }
for a in d:
print(a)
1
2
trois
- > Schlüsselwörter werden ausgegeben
for a in d.values():
print(a)
Oise
Zwo
Drei
- > Einträge zu Schlüsselwort werden ausgegeben
for a in d.items():
print(a)
(‘1’, ‘Oise’)
(2, ‘Zwo’)
(‘trois’, ‘Drei’)
-> Gesamter Eintrag als Tupel wird ausgegeben
ODER
for k,v in d.items():
print(k," ",v)
1 Oise
2 Zwo
trois Drei
-> Einträge werden als einzelne Variablen ausgegeben
Was sind Iteratoren?
Ein Iterator ist ein Implementierungsmuster, bei dem man:
- ein Element erhalten kann (durch Aufruf einer Mehtode next)
- erfahren kann, dass keine weiteren Elemente zur Verfügung stehen
Iterierbare sind Typen, die einen Iterator erzeugen können, mit denen man sie aufzählen kann.
for…in mit einem einzelnen Ausdruck verwendet, wird der Ausdruck als Iterable aufgefasst, ein Iterator erzeugt, dan zählt die Schleife die Elemente darin auf.
Leere Iteratoren werden als falsch behandelt, nichtleere als wahr, deswegen macht for..else einen Sinn: Die Schleife wird durchlaufen, solange der Iterator wahr ist und wenn er falsch ist, der else Zweig.
Was sind Generatoren?
Generatoren werden als Funktion geschrieben und enthalten mindestens ein yield-Statement. Damit kann man Iterierbare programmieren. Beispiel:
def example_generator():
yield 1
yield 2
yield 3
kann dann in for-Schleife aufgerufen werden:
for i in example_generator():
print(i)
1
2
3
Wie funktioniert yield in Generatoren?
Ausführung wird bei jedem yield angehalten und das Argument als Rückgabewert zurückgeliefert. Beim nächsten next-Aufruf des Iterators wird die Funktion an der Stelle, an der sie mit yield verlassen wurde, fortgesetzt, bis wieder ein yield-Statement erreich wird. Durch return erzeugt der Iterator ein StopIteration und die Iteration endet.
Man kann mit yield from iterierbare in den Ausgabestrom eines Generators einbetten:
def generator_mit_yield_from():
yield "Test beginnt"
yield from range(3)
yield "Test ende"
for i in generator_mit_yield_from():
print(i)
liefert: Test beginnt 0 1 2 Test ende
Was gibt es für Builtins für Iterierbare?
- min, max
- sum (Summe der Elemente)
- sorted (sortierte Liste der Elemente)
Iterierbare-Konverter:
- reversed (ITERABLE) liefert Iterierbares zurück, was Elemente des übergebenen Iterators rückwärts aufzählt
- enumerate(ITERABLE, start=0) liefert Iterierbares zurück, das Paare (Index, Element) mit aufsteigendem Ganzzahlindex erzeugt, start gibt ersten Index an
- zip (ITERABLE1,ITERABLE2) liefert ein Iterierbares zurück, das Paare aus den Elementen der übergebenen Iterierbaren erzeugt
Logische Quantoren:
- any(ITERABLE) liefert True zurück, falls eines der in Iterable enthaltenen Elemente logisch wahr ist, leer ist falsch
- all(ITERABLE) liefert True zurück, falls alle der in ITERABLE enthaltenen Elemente logisch wahr ist, leer ist true
Was gibt es für Zeichen bei Markdown?
- Absatz: \
- Hervorhebung: wort oder wort
- Listen mit 1. 2. 3. …
- Überschriften mit # ## ###
- Tabellen: a|b|c
|:–|:-:|–:|
|links|zentriert|rechts
|1|2|3| - Hyperlinks oder Name
- Bilder
Wie kann man Markdown in Quellcode einbinden bei Python?
```{.markdown}
text
~~~
```{.python}
code
~~~
Wie kann man Strings mit f-String formatieren?
+ oder . join werden Strings konkateniert (Zusammengesetzt)
Schöner geht das aber mit f-Strings:
f”hier ist ein Text mit {a} Buchstaben und {b} Wörtern.”
Anstelle a oder b können Variablen benutzt werden, geschrieben mit “” oder ‘’
Was macht .format bei String-Literalen? (Mit Dictionaries)
adresse = {“plz” : “66333”, “ort” : “Völklingen”, “state” : “Saarland”}
adress_lines = { “eins” : “Meine Adresse ist {plz} {ort} in {state}.”, “zwei” : Ich wohne im {state} in {ort} ({plz}).”}
print(“Nummer eins:”, adress_lines[“eins”].format(adresse)
print(“Nummer zwei:”, adress_lines[“zwei”].format(adresse)
Nehme zwei Dictionaries und formatiere sie :)
Was macht .format?
time = 9
“Es ist {} Uhr”.format(time)
‘Es ist 9 Uhr’
ODER
zahlen = [“Eins”, “Zwei”]
“Nach {} kommt {}”.format(zahlen)
“Nach {1} kommt {0}”.format(zahlen)
ODER
“Nach {} kommt {}”.format(“müde”, “blöd”)
Wie funktionien Feldbreiten in der Formatsprache?
rechtsbündig:
f”»{‘2’:10}<>2 <>{2:10}<> 2< kann man steuern, ob linksbündig, zentriert oder rechtsbündig:
f”»{2:<10}<>2 <>{2:^10}<> 2 <>{2:>10}<> 2<
Wie formatiert man Zahlen in der Formatsprache?
f”{2:05}” -> 00002
mit Angabe der 0 vor der 5 wird mit 0 anstatt mit Leerzeichen aufgefüllt
f”{1:10}{-1:10}{1:+10}{-1:+10}{1:010}{1:+010}”
‘ 1 -1 +1 -10000000001+000000001’
f”{1} {-1} {1:+} {-1:+}”
‘1 -1 +1 -1’
Wie kann man Fließkommazahlen formatieren?
f”{1/3}” -> 0,33333333333333333333
f”{1/3:g}” -> 0.333333
f”{1.0:g}” -> 1
f”{1:f}” -> 1.0
Feldbreite kombiniert mit Nachkommastellen:
f”{1/3:10.4} -> 0.3333 (links sind zehn Leerzeichen)
Wie geht man mit Exceptions um?
try: blabla
except ValueError:
except NameError:
Wie funktioniert else, finally in einem try-Block?
- try:
- else: wird genau dann ausgeführt, wenn try durchlaufen wurde und nicht durch Exception verlassen wurde
- finally: wird immer aufgerufen, auch wenn es einen Error gab
except nur, wenn Error auftritt
Wie kann man eigene Exceptions werfen?
mit der raise-Anweisung mann man neue Exception werfen.
import math
def wurzel_von_zahl_minus_1(z):
if z <= 1.0:
raise ValueError(f”Die Funktion \
wurzel_von_zahl_minus_1 funktioniert nur mit Zahlen >= 1, \
nicht aber mit {z}”)
return math.sqrt(z-1)
wurzel_von_zahl_minus_1(0)
Was macht assert?
Man überprüft, ob eine bestimmte Bedingung erfüllt ist, wenn diese nicht erfüllt ist, wird ein AssertionError ausgelöst.
assert True == True -> läuft
assert True == False -> Assertion Error
Es geht auch mit Fehlermeldung:
assert True == False, “Wie soll das gehen?!”
Wie kann man Textdateien manuell lesen?
Ganze Datei:
f = open("assets/test.txt")
f.readline() liest einzelne Zeile
f.readlines() liest die Zeilen mit Umbrüchen etc
f.close() schließt StreamWie kann man Dateien mit with-as lesen und schreiben?
with open("test.txt") as f:
print(f)
f ist iterierbar:
with open(file_name) as f:
for line in f:
print(line)
dann kann man Sachen rückwärts laufen lassen:
print(f”{line[::-1]}”)
Wie kann man Textdateien geschickt schreiben?
with open(file_name, 'w') as f:
f.write("Hello *Markdown*!\n")
oder schreiben und lesen gleichzeitig
with open("test.txt") as f:
with open("flip.txt","w") as otherf:
for line in f:
otherf.write(f"{line.rstrip()[::-1]}\n")
Wie liest man CSV-Dateien manuell ein?
with open("assets/people.csv") as f:
people = [ line.rstrip().split(';') for line in f]
Pro Zeile wird nun eine Liste erstelt, die in die Liste people gespeichert wird
Wie kann man CSV-Dateien mit dem CSV-Modul lesen?
import csv
with open("assets/people.csv") as csvfile:
csv_reader = csv.reader(csvfile, delimiter=";")
people = [row for row in csv_reader]
Optional kann als dialect z.B. “ecxel” angegeben werden, um dieses zu übernehmen
Wie kann man CSV-Dateien mit CSV-Modul schreiben?
import csv (people ist schon definiert und eine Liste)
with open(‘assets/test.csv’, ‘w’) as csvfile:
csv_writer = csv.writer(csvfile, dialect=”unix”)
for row in people:
csv_writer.writerow(row)
Wie kann man CSV-Dateien mit CSV-Modul schreiben?
import csv (people ist schon definiert und eine Liste)
with open(‘assets/test.csv’, ‘w’) as csvfile:
csv_writer = csv.writer(csvfile, dialect=”unix”)
for row in people:
csv_writer.writerow(row)
Wie kann man JSON-Strings erzeugen?
import json
jspn.dumps((1,2,[3,4]))
oder als Dictionary:
json.dumps({ i*i : i for i in range(10) })
Wie kann man in JSON schreiben?
t = json.loads(‘[1, 2, [“ahahaha”, 4]]’)
print(t)
-> schreibt Liste in t
generell mit json.dump() schreiben und json.load() lesen
Wie durchsucht man Strings mit der re-Funktion (.search())?
import re
re. search(“a”, “Falafel”)
- >
alternativ kann man sich auch direkt den Span zurückgeben lassen
input_string = “Falafel”
matchresult = re.search(“la”, input_string)
print(matchresult.span())
-> (2,4)
Wie kann man Strings mit der re-Funktion durchsuchen (.findall())?
re.findall(“a”, “Falafel”)
[‘a’, ‘a’]
-> liefert Liste mit gefundenen Strings
Wie kann man Strings mit der re.Funktion durchsuchen (finditer())?
liefert einen Iterator über alle Match-Objekte zu den gefundenen Strings
for s in re.finditer(“a”, “Falafel”):
print(“Fand: “,s)
Fand:
Fand:
Wie funktionieren Platzhalter in re-Funktion?
s = “Maier”
re. findall(“M.[ai]er”, s)
- > [“Maier], würde aber kein Meier finden
Wie geht die Zeichenauswahl mit [] bei re?
re. search(“1[24680]”,”Es ist nicht 5, nicht 13, sondern 18 Uhr.”)
- >
Alle Zahlen in Klammern werden gesucht, wenn eine gematcht wird, wird das Objekt ausgegeben
re. search(“[f-t]”, “Musica”)
- > sucht nach Bereich
Was gibt es für Charakterklassen in regulären Ausdrücken?
\s whitespace \S
\d Ziffer \D
\w Buchstabe \W
Was sind die wichtigsten Funktionen der regulären Ausdrücke?
Metacharacters / Spezialsonderzeichen: ?+*.|[]{}()^$\
Quoting mit \
^ ist Stringanfang (Zeilenanfang mit optionalem Parameter re.MULTILINE)
$ ist Stringende (Zeilenende mit optionalem Parameter re.MULTILINE)
alles andere sind Literale
Konkatenation: Hintereinanderschreiben
Zeichenauswahl in [],
Komplement mit ^ als erstes Zeichen in […]
Bereich(e) mit -
Charakterklassen: \s, \d, \w, \S, \D, \W, .
Repetition: Wiederholung des vorangegangenen Teilausdrucks: ? 0- oder 1- mal, * mindestens 0-mal, + mindestens 1-mal:
{Anzahl}, {von,bis}
* (oder anderer Quantor) matcht greedy, *? (oder …?) lazy
Alternation: a|b als „entweder a oder b“
Präzedenz: Alternation | bindet schwächer als Konkatenation, Konkatenation schwächer als Repetition *,+,? - für alles andere gibt es Gruppen mit ( , )
Was ist ein Seiteneffekt?
Eine programmierte Funktion, die einen äußeren Zustand verändert, bewirkt einen Seiteneffekt. Das heißt, sie kann globale Variablen verändern, obwohl man das vielleicht nicht möchte.
Was bedeutet referentielle Transparenz?
Eine programmierte Funktion, deren Aufruf man durch ihr Ergebnis ersetzen kann, ohne den Effekt im Gesamtprogramm zu verändern, wenn man nur ihre Argumente kennt, heißt referentiell transparent.
Der Wert der Funktion ist also ausschließlich von ihren Übergabeparametern abhängig.
Insbesondere ist eine Funktion referentiell intransparent, wenn sie von globalen Variablen abhängig ist oder sie Eingaben entgegennimmt, die über Werte ihrer Parameter hinausgehen
Was sind reine Funktionen?
Eine Funktion heißt reine Funktion, wenn sie keine Seiteneffekte bewirkt und referentiell transparent ist.
Mathematische Funktionen sind stets rein.
Was ist ein Funktional? Oder Funktion höherer Ordnung?
Ein Funktional ist eine Funktion, die eine Funktion auf etwas abbildet oder eiwas auf eine Funktion/in einen Raum von Funktionen abbildet.
Beispiele:
- ein Bild (das ist eine Funktion, die Pixelkoordinaten auf z.B. Helligkeit abbildet) auf die mittlere Helligkeit abbilden: dabei wird eine Funktion (das Bild) auf etwas abegbildet
- aus Frequenz und Amplitude ein Sinus-Signal generieren: dabei werden zwei Sakalare quf eine Funktion abgebildet (die einen Zeitpunkt die Auslenkung zu dem Zeitpunkt abbildet)
- ein Bild auf ein doppelt so helles Bild abbilden: dabei wird eine Funktion (das Eingabebild) auf eine andere (das Ausgabebild) abgebildet
Wie funktionieren Lambda-Funktionen?
Mit Hilfe des lambda-Operators können anonyme Funktionen, d.h. Funktionen ohne Namen erzeugt werden. Sie haben eine beliebe Anzahl von Parametern, führen einen Ausdruck aus und liefern den Wert dieses Ausdrucks als Rückgabewert zurück.
f = lambda x, y : x + y
f(1,1)
2
Was ist *args?
def var_args_funktion(farg, *args):
print("Formales arg:", farg
for arg in args:
print("weiteres arg:", arg)
var_args_funktion(1, 2, "drei") --> Formales arg: 1 weiteres arg: 2 weiteres arg: drei
Wenn man noch nicht weiß, wie viele Argumente man übergeben möchte
Was bedeutet funktionale Programmierung?
Funktionale Programmierung ist ein Programmierparadigma, innerhalb dessen Funktionen nicht nur definiert und angewendet werden können, sondern auch wie Daten miteinander verknüpft, als Parameter verwendet und als Funktionsergebnisse auftreten können. Dadurch kann ein funktionales Programm sehr weitreichend neue Berechnungsvorschriften zur Laufzeit zusammensetzen und anwenden. Programmiersprachen, die funktionale Programmierung ermöglichen, heißen funktional.
Die besonderen Eigenschaften der funktionalen Programmierung ermöglichen es, auf die in der imperativen Programmierung benötigten inneren Zustände eines Berechnungsprozesses ebenso zu verzichten wie auf die zugehörigen Zustandsänderungen, die auch Seiteneffekte genannt werden. Der Verzicht darauf vereinfacht auf der einen Seite die semantische Analyse eines Computerprogramms erheblich und eröffnet auf der anderen Seite weitreichende Möglichkeiten zur regelbasierten, algebraischen Programmtransformation und -synthese. Daraus ergibt sich die erhebliche praktische Bedeutung der funktionalen Programmierung für die Informatik.
Wie kann man die Laufzeit messen?
def fib_5():
return recursive_fib(5)
timeit. timeit(fib_5)
2. 5742798848077655
Was sind Filter?
Mit filter(FUNCTION, ITERABLE) können wir iterierbare Variablen (z.B.: Listen, aber auch Range, oder eigene Generatoren, …) effizient auf die Elemente beschränken, die eine berechenbare Eigenschaft erfüllen
filter gibt ein Iterierbares zurück, das alle die Elemente des ITERABLE aufzählt, für die FUNCTION zu wahr auswertet:
def is_positive(i):
return i > 0
for v in filter(is_positive,
[-2,1,-5,1,2,3.1415]):
print(v)
->> 1 1 2 3.1415
Was sind Maps?
map(FUNCTION, *ITERABLES) wendet eine Funktion einzeln auf Tupel von Elementen aus den *iterables an und lässt uns darüber iterieren, wendet also die Abbildung („map“) FUNCTION auf die Inhalte an:
list( map(lambda x : x*x, range(5))
)
—>
[0, 1, 4, 9, 16]
Beispiel für mehrere Elemente aus Iterables:
tuple ( map (lambda a, b : a + b, [1,2,3], [4,5,6]) )
—>
(5, 7, 9)
Was macht reduce?
functools.reduce(FUNCTION, ITERABLE, [INITIAL]) bildet eine „Zusammenfassung“ eines Iterierbaren, indem
- falls vorhanden, der INITIAL-Wert mit dem ersten Element,
- andernfalls die ersten beiden Elemente
mit Hilfe der angegebenen Funktion verknüpft werden, dann das Ergebnis mit dem nächsten usw. bis die Sequenz vollständig verarbeitet ist. Dann erhält man das Ergebnis zurück.
functools.reduce( lambda a, b : a + b,
[1,2,9])
–>
12
functools.reduce( lambda a, b : a * b,
[4,5,6,7])
–>
840
functools.reduce( lambda a, b : a * b, b, [5,2], 10)
–>
100 (Startwert b, heißt 1052)
