### AUFGABE 1)
# a) Erstelle zwei Zahlenvariablen und gib ihre Summe mit print() im Terminal (Konsole) aus.
a = 555
b = 444
print(a + b)
# b) Gebe v w x y z in der Konsole aus und nutze hierfür nur 1x die print() Funktion (Tipp: nutze Argumente)
print("v", "w", "x", "y", "z")
# Alternativ:
a = "v w x y z" # sieht in konsole gleich aus, aber ...
print(a) # verwendet nur ein Argument
# c) Gebe 6 Single Quotes in der Konsole aus ''''''
print("''''''")
########################################################################
### AUFGABE 2)
# a) Lass den Benutzer eine Zahl eingeben, verdopple sie und gib das Ergebnis im Terminal (Konsole) aus.
# Variante 0:
'''
userData = input("please input data here")
try:
userData = float(userData) * 2 # hier brauch man wirklich einen wert wie zB "10.7" oder "3.5" => integer-string (wie "4") geht nicht
print(userData)
except:
try:
userData = int(userData) * 2
print(userData)
except:
print("invalid value. please re-run script and try again")
# Variante 1:
userData = input("please input data here")
userData = int(userData) * 2
print(userData)
# Variante 2:
userData = input("please input data here")
print(userData)
userData = int(userData)
userData *= 2 # gleichbedeutend mit => userData = userData * 2
print(userData)
# Variante 3:
userData = int(input("please input data here"))
print(userData * 2)
# Variante 4:
userData = int(input("please input data here")) * 2
print(userData)
'''
########################################################################
### AUFGABE 3)
# a) Schreibe zwei Variablen und weise diesen je unterschiedliche String-Werte (Texte) zu.
a = "Hallo"
b = "Welt"
# b) Schreibe eine neue Variable und weise dieser die beiden ersten Variablenwerte als Textkette zu (concat)
c = a + b
print(c)
########################################################################
### AUFGABE 4)
myVar1 = "Hallo"
myVar2 = 10
myVar3 = 3.7
# a) Verkette myVar1 und myVar2 zu einem Text und gebe das Ergebnis in der Konsole aus.
print(myVar1 + str(myVar2))
# b) Gebe Dir den Datentyp für alle drei myVars in der Konsole aus.
print(type(myVar1), type(myVar2), type(myVar3))
# c) Verkette myVar1 und myVar3 zu einem Text und gebe das Ergebnis in der Konsole aus.
print(myVar1 + str(myVar3))
# d) Verkette myVar2 und myVar3 zu einem Text und gebe das Ergebnis in der Konsole aus
print(str(myVar2) + str(myVar3))
# e) Dividiere myVar2 durch 2 und gebe das Ergebnis und den Datentyp des Ergebnisses in der Konsole aus.
varDiv = myVar2 / 2
print(varDiv, type(varDiv)) # Ergebnis aus normaler Division ist IMMER float
# f) Teile myVar2 durch myVar3 und weise das Ergebnis einer neuen Variablen namens myResult zu.
myResult = myVar2 / myVar3
print(myResult)
# g) Runde myResult ohne eigene mathematische Berechnungen ab (ohne Nachkommastelle).
print(int(myResult)) # mit integer casting schneiden wr die Nachkommastellen ab
# => Abrundung bei positiven zahlen
# h) Runde myResult mit eigener mathematischer Berechnung ab (zwei Nachkommastellen).
# Variante 1:
rounded = round(myResult, 2) # wunderschön :-) ... aber ist kaufmännische rundung round() funktion entscheidet also ob auf- oder abrundung
print(rounded)
# Variante 2:
rounded = int(rounded * 100) / 100
print(rounded)
# i) Multipliziere myVar1 mit 10 und gebe Dir das Ergebnis in er Konsole aus
print(myVar1 * 10)
print("- " * 30) # zB gut für seperator lines um Übersicht zu behalten
# j) Multipliziere myVar2 mit 10 und gebe Dir das Ergebnis in er Konsole aus
print(myVar2 * 10)
# k) Multipliziere myVar3 mit 10 und gebe Dir das Ergebnis in er Konsole aus
print(myVar3 * 10) # => was einmal float ist bleibt float außer wir casten explizit in int
########################################################################
### AUFGABE 5)
# a) Simuliere einen Fehler (z.B. Division durch 0) und fange ihn mit try/except ab, um einen Crash zu verhindern.
try:
a = 5 / 0
print(a)
except Exception as e:
print(e)
print(type(e))
########################################################################
### AUFGABE 6)
myFloat = 67.5
# a) Ermittele programmatisch den Datentyp von myFloat und speichere diesen in einer Variable: myType
myType = type(myFloat)
print(myType)
# b) Ermittele programmatisch den Datentyp von myType und gebe das Ergebnis in der Konsole aus
typeOfMyType = type(myType)
print(typeOfMyType) # alle Klassen sind von der Klasse <class 'type'> ..
print(type(typeOfMyType)) # => auch die Klasse <class 'type'> selbst (sogennante Metaklasse)
########################################################################
### AUFGABE 7) # h)
print("print") # a) einfach wort print als string ausgeben
print(print) # b) inneres print wird nicht aufgerufen, sondern zeigt uns nur das Funktionsobjekt
print(print()) # c) inneres print() = Leerzeile; Äußeres print() = None, weil pinr() funktion keine Wert zurückgibt
# print(myPrint) # d) # python vermutet es ist eine variable, aber die haben wir bisher nie deklariert bzw keinen wert zugewiesen
print(type) # e) Klasse <class 'type'> selbst (sogennante Metaklasse)
print(type(print)) # f) <class 'builtin_function_or_method'> zeigt uns an von welchem Typ die funktion print ist => generisch von vom Typ Funktion oder Methode
print(type(print())) # g) innere print = Leerzeile; äußeres print() ist <class 'NoneType'> weil wir uns den Typ des Rückgabe wertes (None) der print() funktion ausgebe
print("===============================keyword===================================================")
import keyword
print(keyword.kwlist)
print("---------softkwlist-------------------")
print(keyword.softkwlist)
print("============vordefinierten, integrierten Funktionen und Konstanten (Built-ins)============")
import builtins
import pprint
# Die dir()-Funktion gibt eine Liste aller Namen im angegebenen Modul zurück
built_in_names = dir(builtins)
# Für eine sauberere, formatierte Ausgabe (optional)
#pprint.pprint(built_in_names)
# Oder einfach als Liste ausgeben:
print(built_in_names)
