220 lines
5.1 KiB
Markdown
220 lines
5.1 KiB
Markdown
Python ist **intepretiert** und **interaktiv**, **dynamisch**, **highlevel**, **Objektorientiert**, **strukturiert**, **Aspektorientiert**, **Funktional (Beweisbarkeit)** -> Reference Counting
|
||
|
||
| Interpreter | Compiler |
|
||
| ----------------------- | ------------------------------------------------ |
|
||
| Zeile für Zeile | Übersetzt den ganzen Code auf einmal -> Bytecode |
|
||
| Keine ausführbare Datei | Ausführbare Datei |
|
||
| Fehler werden gezeigt | Fehler werden gesammelt und dann angezeigt |
|
||
|
||
### Codingstandards
|
||
|
||
**Zen of Python**
|
||
|
||
Mit `import this` erscheint das Zen of Python
|
||
|
||
**Beautiful is better than ugly.**
|
||
Explicit is better than implicit.
|
||
**Simple is better than complex.**
|
||
Complex is better than complicated.
|
||
Flat is better than nested.
|
||
Sparse is better than dense.
|
||
**Readability counts.**
|
||
Special cases aren't special enough to break the rules.
|
||
Although practicality beats purity.
|
||
**Errors should never pass silently.**
|
||
Unless explicitly silenced.
|
||
In the face of ambiguity, refuse the temptation to guess.
|
||
There should be one-- and preferably only one --obvious way to do it.
|
||
Although that way may not be obvious at first unless you're Dutch.
|
||
Now is better than never.
|
||
Although never is often better than *right* now.
|
||
**If the implementation is hard to explain, it's a bad idea.**
|
||
**If the implementation is easy to explain, it may be a good idea.**
|
||
Namespaces are one honking great idea -- let's do more of those!
|
||
|
||
**PEP8**
|
||
|
||
**Package:** lowercase
|
||
**Module:** my_module.oy
|
||
**Function:** my_function
|
||
**Variable:** my_variable
|
||
**Class:** MyClass
|
||
**Method:** my_method
|
||
**Exception:** HTTPSServerError
|
||
**Constant:** HELLO_WORLD
|
||
|
||
Mit `type()` kann man den Datentyp auslesen. Mit `del()` kann man Variabeln löschen. Mit `hex()` erhalten wir die Hex des Wertes.
|
||
|
||
### Datentypen
|
||
|
||
**Numbers**
|
||
- Bool (true, false)
|
||
- Int (1, 2)
|
||
- Float (1,234)
|
||
- Complex (4j)
|
||
|
||
|
||
|
||
- [ ] Boolean, wenn Zahl höher ist
|
||
|
||
**Sequences**
|
||
|
||
|
||
|
||
#### Listen
|
||
|
||
Listen sind veränderbar.
|
||
```
|
||
my_list = [1, 2, "HelloWorld"]
|
||
my_list[0]
|
||
```
|
||
|
||
`reverse`
|
||
`clear`
|
||
`copy`
|
||
`count`
|
||
`extend`
|
||
`index`
|
||
`insert`
|
||
`remove`
|
||
#### Tuples
|
||
|
||
Nicht veränderbar nur auslesen ist erlaubt
|
||
```
|
||
tup = ("Test", 1, 4, False)
|
||
```
|
||
|
||
**Settypes**
|
||
|
||
|
||
|
||
|
||
#### Sets
|
||
|
||
Sind Sets ohne Duplikate
|
||
|
||
```
|
||
colors = set(["blue", "red", "green"])
|
||
colors = {"hello", "world"}
|
||
colors.add("Hello")
|
||
```
|
||
#### Frozensets
|
||
|
||
Frozensets sind sets, die nicht Veränderbar sind
|
||
|
||
```
|
||
colors2 = frozenset(["blue", "red", "green"])
|
||
```
|
||
|
||
**Mappings**
|
||
|
||
|
||
|
||
#### Dictionary
|
||
|
||
```
|
||
de_en = {"Milch" : "Milk", "Mehl" : "Flour"}
|
||
print(de_en["Milch"])
|
||
```
|
||
|
||
Zugriff key:value
|
||
### Rechenoptionen
|
||
|
||
```
|
||
Grundoperationen: +, -, *, /
|
||
Gruppierung: ()
|
||
Potenz: **
|
||
Floor division: // -> Wieviel mal die Zahl hinein passt
|
||
Modulo: %
|
||
```
|
||
|
||
### Kontrollstrukturen Schleifen
|
||
|
||
If Schleifen werden wie folgt geschrieben:
|
||
|
||
```
|
||
if "Milch" in de_en:
|
||
print("Milch vorhanden")
|
||
elif "Mehl" in de_en:
|
||
print("Mehl vorhanden")
|
||
else:
|
||
print("Der Wert wurde nicht gefunden")
|
||
```
|
||
|
||
For Schleifen, wobei `range(von,bis,schrittgrösse)` Wobei 5 Exklusiv ist.
|
||
|
||
```
|
||
for i in range(5):
|
||
print(i)
|
||
|
||
for value in de_en.values():
|
||
if value == "Milk":
|
||
print("Milk vorhanden")
|
||
```
|
||
Mit `break` wird der Loop beendet und mit `continue` überspringt er den restlichen Teil des Codes und macht mit der nächsten Iteration weiter.
|
||
|
||
### Funktionen
|
||
|
||
Grundregel: Alles was mindestens 2x gebraucht wird, sollte in eine funktion geschrieben werden. Funktionen können Optional Parameter haben und nur in der Funktion gültige Variabeln. Sie können auch einen Wert zurückgeben.
|
||
|
||
```
|
||
def fun(x:int):
|
||
"""This function returns the square of x"""
|
||
return x**2
|
||
|
||
print(fun.__doc__)
|
||
```
|
||
|
||
Funktionen können eine Anzahl an unbestimmten Funktionen erhalten, aber jedoch nur **einen Wert** unter anderem auch eine Liste zurückgeben.
|
||
|
||
**\*args:** Beliebige Argumente als Tupel
|
||
**\*\*kwargs:** Beliebige Keyword Argumente
|
||
|
||
```
|
||
def summe(*args):
|
||
"""Berechnet die Summe aller übergebenen Zahlen."""
|
||
total = 0
|
||
for zahl in args:
|
||
total += zahl
|
||
return total
|
||
```
|
||
|
||
```
|
||
def print_info(**kwargs):
|
||
"""Gibt die Schlüssel-Wert-Paare aus dem übergebenen Dictionary aus."""
|
||
for key, value in kwargs.items():
|
||
print(f"{key}: {value}")
|
||
```
|
||
### Rekursionen
|
||
|
||
Wiederaufruf von der eigenen Funktion, bis zur Erfüllungsbedienung vom Basisfall.
|
||
|
||
```
|
||
def fakultaet(n):
|
||
if n == 0:
|
||
return 1
|
||
else: # Rekursiver Fall
|
||
return n * fakultaet(n-1)
|
||
|
||
print(fakultaet(5))
|
||
```
|
||
### Exception
|
||
|
||
Errorhandling in Python wird ähnlich wie bei anderen Sprachen gemacht, ausser statt **catch** mit **except** abgebildet.
|
||
|
||
Das **else** wird nachdem try ausgeführt jedoch nicht nachdem except und das **finally** wird in jedem Fall ausgeführt.
|
||
|
||
```
|
||
while True:
|
||
try:
|
||
x = int(input("Please enter a number: "))
|
||
except ValueError:
|
||
print("Oops! That was no valid number. Try again...")
|
||
else:
|
||
print("You entered: ", x)
|
||
break
|
||
finally:
|
||
print("Thank you for using this program.")
|
||
```
|
||
|