Uncategorized

”’Aufgabe 1)a) Erstelle eine Liste die den Text “Python” in getrennen Buchstaben enthält (Ein Buchstabe als String je Eintrag)b) Führe die Buchstaben der Liste innerhalb von einer Codezeile zu dem Wort Python als String zusammen (Tipp: via join())”’myList = [“P”, “y”, “t”, “h”, “o”, “n”] # a)myWord = “”.join(myList) # b)print(myWord)”’Aufgabe 2)a) Erstelle eine String Liste mit 6 Hauptstädtenb) Füge programmatisch eine Stadt an den Anfang der Liste, ohne Werte aus der Liste zu löschen/zu überschreibenc) Füge programmatisch eine Stadt an das Ende der Liste, ohne Werte aus der Liste zu löschen/zu überschreibend) Füge programmatisch eine Stadt bei Index 3 ein ohne Werte aus der Liste zu löschen/zu überschreibene) Ersetze programmatisch, die Stadt bei Index 5 durch eine andere statt (überschreiben)f) Lösche programmatisch die letzten beiden städte aus der listeg) Vertausche programmatisch die Position der letzten und ersten Hauptstadt in der Listeh) Gebe programmatisch innerhalb von einer Expression die ersten drei Hauptstädte aus der Liste in der Konsole ausi) Führe die Städte der Liste innerhalb von einer Codezeile programmatisch zu einem Text zusammen und speichere das Ergebnis in der Variable cityText.j) Passe die Logik aus i) so an , dass die Städte in cityText durch “, ” getrent sind. (Komma und Leerzeichen)k) Lösche programmatisch die Variable der Liste mit den Hauptstädten aus der Memory (so als hätte sie nie existiert)”’myCities = [“Berlin”, “Paris”, “Prag”, “Wien”, “Bern”, “London”] # a)myCities.insert(0, “Stockholm”) # b)myCities.append(“Madrid”) # c)myCities.insert(3, “Lissabon”) # d)myCities[5] = “Budapest” # e)#myCities = myCities[:-2] # f) Liste von Anfang bis Drittletzte Werte behaltendel myCities[-2:] # f) Alternative: Letzte beiden Werte entfernenmyCities[0], myCities[-1] = myCities[-1], myCities[0] # g) Anmerkung: Man kann meherer Einzelnwerte in einer Zeile zuweisen (via Komma Trennung (Anzhal der zuweisungen muss übereinstimmen))print(myCities[0:3]) # h)cityText = “”.join(myCities) # i)cityText = “, “.join(myCities) # j)del myCities # k)print(cityText)# print(myCities) # deleted ok: => NameError: name ‘myCities’ is not defined”’Aufgabe 3:a) Erstelle eine String Liste mit Zahlen von 1 bis 8b) Erstelle eine Kopie dieser Liste und kehre in der selben Codezeile die Reihenfolge der Listeinträge für die neue Liste um.c) Kehre nun die Reihenfolge der neuen Liste noch einmal um, aber benutze diesmal ein anderes Verfahren als in b).d) Gebe innerhalb von einer Codezeile nur die geraden Zahlen der Liste in der Konsole aus, ohne die Liste (Cache) selbst zu manipulieren.e) Gebe innerhalb von einer Codezeile nur die ungeraden Zahlen der Liste in der Konsole aus, ohne die Liste (Cache) selbst zu manipulieren.f) Leere die Liste innerhalb von einer Codezeileg) Füge der leeren Liste den Wert 10 und 11 hinzu.h) Ersetze den Wert 11 innerhalb von einer Codezeile durch den Wert 101i) Lösche die gesamte Liste aus dem Cachej) VERSUCHE die gelöschte Liste in der Konsole auszugeben, ohne das der Code crasht.k) Wenn der Code crasht, soll der Error in der Konsole ausgeben werden.”’myList = [‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’] # a)myList = [str(i) for i in range(1, 9)] # a) AlternativrevList = myList[::-1] # b)revList.reverse() # c)# revList = sorted(revList, reverse=False) # c) Alternativ … geht auch .revList.sort()print(revList[1::2]) # d) print(revList[::2]) # e) del revList[:] # f)revList += [10, 11] # g)revList[1] = 101 # h)del revList # i)try: print(revList) # j)except Exception as e: print(e) # k)# Aufgabe 4)# a) Erstelle einen While Loop und beende die Iteration Kopfgesteuert bei der 20ten Iteration.i = 0while i < 20: print(i) i += 1# b) Erstelle einen While Loop mit der Bedingung True, und beende die Iteration Fußgesteuert bei der 20ten Iteration.i = 0while True: print(i) i += 1 if i >= 20: break# Aufgabe 5 + 6 besprchen wir später …

”’AUFGABE 1)a) Deklariere eine Liste mit dem Variablennamen myList und Werten von 0 bis 4b) Gebe die Liste in der Konsole ausc) Füge mit der richtigen Methode an das Ende der Liste die Zahl 5 hinzud) Entferne mit der richtigen Methode den Wert bei Index 0 aus der Listee) Programmiere eine Schleife, welche die Liste durchläuft, nenne die Schleifenvariable num, und gebe die Schleifenvariable in jedem Schleifenschritt in der Konsole aus.”’myList = [0,1,2,3,4] # a)print(myList) # b)myList.append(5) # c)myList.pop(0) # d)for num in myList: # e) print(num)# – – – – – – – – – – – – – – – – – – – – – – – – – – – -”’AUFGABE 2)a) Deklariere eine Liste mit dem Variablennamen myList und Werten von 1 bis 10b) Deklariere eine Variable namens summe und weise ihr den Wert 0 zuc) Programmiere eine Schleife, welche die Liste durchläuft, und addiere die Schleifenvariable in jedem Schleifenschritt auf die summe variable (kumulieren)d) Erstelle eine Pseudo-Kopie (Pointer) von der myList und nenne sie aliasListe) Füge der Alias Liste bei Index 2 den Wert 100 hinzu (ohne Werte zu ersetzen)f) Gebe die myList und die aliasList in der Konsole aus und schaue Dir die Ergebnisse ang) Erstelle eine echte Kopie der myList in einer neuen Liste namens newListh) Ersetze in der newList den Wert bei Index 0 durch den Wert 1000i) Gebe die myList und aliasList und newList in der Konsole aus und vergleiche die Ergebnissej) Erstelle eine neue Liste namens partialList und weise ihr die ersten 3 Werte aus der myList zu.”’myList = [1,2,3,4,5,6,7,8,9,10] # a)summe = 0 # b)for loopvar in myList: # c) summe += loopvar print(summe) ### so wir in jedem Schleifenschritt der jeweils aktielle Wert der summen var ausgegebenprint(summe) ### hier ist print() nicht mehr teil der schleife => ergebnis der summe var nach schleife wird ausgegeb ### danach können wir auch nichts mehr in die Schleife reinschriebn ### => erst links-einrückung nach indented block, beendet den blockaliasList = myList # d)aliasList.insert(2, 100) # e)print(myList); print(aliasList) # f)newList = myList[:] # g)# newList = myList.copy() # g) alternativnewList[0] = 1000 # h)print(myList); print(aliasList); print(newList) # i)partialList = myList[:3] # j)print(partialList)# – – – – – – – – – – – – – – – – – – – – – – – – – – – -# ACHTUNG# sum = 0 # so würden wir eine built-in function von python überschreiben # danach könnten wir sie nicht mehr benutzen# Was macht sum?? eine summe bilden# zB soprint(sum(myList))# – – – – – – – – – – – – – – – – – – – – – – – – – – – -”’AUFGABE 3)a) Deklariere eine Liste mit dem Variablennamen myList und den Werten: 0, 2, 4, 6, 8, 10b) Prüfe in jedem Schleifenschritt ob die Schleifenvariable größer als 4 ist. b1) Ist dies der Fall, dann gebe die Schleifenvariable in der Konsole aus. b2) Ist dies nicht der Fall, dann gebe “value not greater 4″ in der Konsole aus.”’myList = [0,2,4,6,8,10] # a)for item in myList: if item > 4: # b) print(item) # b1) else: print(“value not greater 4″) # b2)# – – – – – – – – – – – – – – – – – – – – – – – – – – – -”’AUFGABE 4)a) Lasse den User sein Geburtsjahr in der Konsole eingeben und speichere die Eingabe in einer Variable namens birthYearb) Wandele die Usereingabe in eine Zahl umc) Subtrahiere das Geburtsjahr des Users von dem laufenden Jahr 2025 und speichere das Ergebnis in einer Variablen namens caAged) Gebe den Text “Dein Alter ist ca.” und die Variable caAge in der Konsole aus.e) Stelle sicher dass der Code nicht crasht, egal was der User eingibtf) Bonus: Versuche mit if und else eine Logik zu schreiben, die prüft ob das Alter des Users realistisch ist. Ist das Alter unrealistisch, dann gebe in der Konsole aus “Es ist unrealistisch, dass Du ca.” caAge “Jahre alt bist”.”’try: # e) birthYear = int(input(“Enter your year of birth please :-)”)) # a, b) caAge = 2025 – birthYear # c) if caAge > 6 and caAge < 100: # f) print(“Dein alter ist”, caAge) # d) else: # f) print(“Es ist unrealistisch, dass Du ca.”, caAge, “Jahre alt bist”)except Exception as e: # e) print(e) # e)# – – – – – – – – – – – – – – – – – – – – – – – – – – – -# Es gibt natürlich auch möglichkeiten mit genauen jahres, monatgen, tagen, h,m, s, ms zu arbeiten :-)# import time# import datetime# – – – – – – – – – – – – – – – – – – – – – – – – – – – -# AlternativebirthYear = input(“Enter your year of birth please :-)”)try: birthYear = int(birthYear) caAge = 2025 – birthYear if caAge < 6 or caAge > 100: print(“Es ist unrealistisch, dass Du ca.”, caAge, “Jahre alt bist”) else: print(“Dein alter ist”, caAge)except Exception as e: print(“please type a valid integer”) print(e)# – – – – – – – – – – – – – – – – – – – – – – – – – – – -# AlternativebirthYear = input(“Enter your year of birth please :-)”)try: birthYear = int(birthYear) caAge = 2025 – birthYear if caAge > 6 and caAge < 100: print(“Dein alter ist”, caAge) else: print(“Es ist unrealistisch, dass Du ca.”, caAge, “Jahre alt bist”)except Exception as e: print(“please type a valid integer”) print(e)# – – – – – – – – – – – – – – – – – – – – – – – – – – – -# Wir verwenden hier bei Usereingaben lediglich command lines tools (cli)# Sowas nutzen meistens nur user die developer sind# Aber für den non-dev user einer website oder app,# hat man ja eig eine GUI (Graphical User Interface)# Dort kann man dann auch Dinge wie Realtime Inputdata

### AUFGABE 1”’a) Lege eine Variable namens userBalance an und setze diese = 0b) Lasse den Nutzer eine Eingabe machen: Frage den Nutzer dabei “How long are you married?”c) Caste die Nutzereingabe als Integerd) Sorge dafür dass der Code nicht crasht egal was Nutzer eingibte) Gebe im except bereich “invalid value” in Konsole ausf) Wenn Nutzer 0 eingibt, printe: “Enjoy Your Freedom 😎”g) Wenn Nutzer mehr als 0 Jahre verheiratet ist, printe: “That’s so lovely 😻”h) Implementiere folgende Logik: Wenn nutzer verheiratet ist länger als: 0 Jahre, printe: “That’s so lovely” 😻 10 Jahre, addiere 10 zur userBalance und printe: “Congratulations 🥰, you just won 10 free coins” 25 Jahre, addiere 25 zur userBalance und printe: “Wow 🥳🥰 Congratulations, you just won 50 free coins” 50 Jahre, addiere 50 zur userBalance und printe: “OMG!! 😻😻😻 Thats so beautiful, you just won 100 free coins”i) Wenn der Nutzer negative Zahl eingibt, triggere eine Error Meldung: raise Exception(“Sorry, can’t go back in time yet ^^”)”’userBalance = 0 # a)married = input(“How long are you married? “) # b)try: # d) married = int(married) # c) if married < 0: # i) raise Exception(“Sorry, can’t go back in time yet ^^”) # generischen Error auslösen, mit eigenem Fehlertext if not married: # f) # Alternativ: if married == 0: print(“Enjoy Your Freedom 😎”) elif married <= 10: # g) print(“That’s so lovely 😻”) elif married <= 25: # h) print(“Congratulations 🥰, you just won 10 free coins”) userBalance += 10 elif married <= 50: # h) print(“Wow 🥳🥰 Congratulations, you just won 50 free coins”) userBalance += 50 else: print(“OMG!! 😻😻😻 Thats so beautiful, you just won 100 free coins”) userBalance += 100 except Exception as error: # d) print(“invalid value”, error) # e) print(type(error))if userBalance: print(“userBalance”, userBalance)############################################################################# in try kündigen wir an dass wir code ausprobieren wollen # dh zwischen try & except muss der code der evtl crashen kann# in except wird fehler abgefangen => code crasht dann nicht# wie haben im except die möglichkeit den error in einer vrariable zu schreiben (optional, aber gängig)# dafür mpssen wir dann einen error typ (zB ‘Exception’ oder ‘ValueError’) nennen, … # und diesen mit dem keyword ‘as’ in eine variable schreiben (var namen können wir wie immer selbst bestimmen)# wenn wir das tun, haben wir die möglichkeit auf verscheidene werte die eder error uns zur verfügung stellt zuzugreifen############################################################################# Was passiert bei raise Exception() # Man löst selbst manuell einen echten Error aus => Code crasht !!! # .. außer man hat das raise Exception() auch innerhalb eines try blocks # => in diesem Fall springt der code in den except block # genau so wie einem normane error # den wert den wir als argument mit in die Exception geben # => können wir im except auch mittels … as e: entgegennehmen####################################################################################################################################################################################################################################### AUFGABE 2”’a) Lasse den User eine Eingabe machen, und sage dem Nutzer dabei “Guess the correct programing language”b) Speichere die Eingabe in der Variablen: userGuessc) Prüfe ob userGuess falsy ist, wenn ja dann printe: “please write something useful”d) Prüfe ob userGuess mehr Zeichen hat als 6, wenn ja printe “target is shorter” (Tipp: len(userGuess) gibt anzahl zeichen)e) Prüfe ob userGuess weniger Zeichen hat als 6, wenn ja printe “target is longer”f) Prüfe ob userGuess genau 6 zeichen hat, wenn ja printe “not yet correct, but the number of chars is right tho :-)”g) Prüfe ob userGuess = “python” ist, wenn ja, printe: “YEAH, that’s it you nailed it!”h) Prüfe ob userGuess “p” beginnt, wenn ja printe “good start, but not yet right” (Tipp: userGuess.startswith(“p”) )i) Sorge dafür dass User nicht auf Groß-/Kleinschreibung achten muss (Tipp: userGuess.lower() wandelt string in kleinbuchstaben um)j) Sorge dafür, dass leerzeichen am anfang und ende entfernt werden (Tipp: userGuess.strip() entfernt äußere whitespaces)k) Arrangiere den Code so, dass die Zeichenverarbeitung nützlich greift und die Prüfungen eine sinnvolle Reihenfolge haben”’userGuess = input(“Guess the correct programing language: “) # a, b)userGuess = userGuess.lower().strip() # i, j)if userGuess == “python”: # g) in einem python kurs ist “python” evtl die wahrscheinlichste vermutung print(“YEAH, that’s it you nailed it!”)elif not userGuess: # c) prüfung ob leere string => falsy value print(“please write something useful”)else: if userGuess.startswith(“p”): # h) print(“good start, but not yet right”) if len(userGuess) < 6: # e) print(“target is longer”) elif len(userGuess) > 6: # d) print(“target is shorter”) elif len(userGuess) == 6: # f) print(“not yet correct, but the number of chars is right tho :-)”)########################################################################### Test Cases: # “python” # => target # ok # “” # => falsy # ok # “aaaaa” # => too short # ok # “aaaaaaa” # => too long # ok # “aaaaaa” # => right len # ok # “paaaa” # => right start, too short # ok # “paaaaaa” # => right start, too long # ok # “paaaaa” # => right start, right len # ok####################################################################################################################################################################################################################################### AUFGABE 3”’a) Lasse User eine Eingabe machen, und sage dem Nutzer dabei “Please type a base number you want to exponentiate”b) Speichere die Eingabe in die variable: baseNumc) Lasse User danach noch eine Eingabe machen, und sage dem Nutzer dabei “Please type an integer exponent number to calculate with”d) Speichere die Eingabe in die variable: expoe) Caste expo in integerf) Stelle sicher, dass expo > 1 ist, wenn nicht dann raise eine Exception mit der meldung “exponent must be > 1″g) Erstelle eine variable namens multiplier und konkateniere hierfür als strings den Multiplikationsoperator + baseNumh) Erstelle eine variable namens stringCalc: Konkateniere => baseNum + multiplier * (expo -1)i) Gebe stringCalc in Konsole ausj) Erstelle eine Variable namens: result => und weise folgendes zu: eval(stringCalc)k) Gebe result in der Konsole ausl) Gebe auch folgendes in Konsole aus: eval(baseNum + “**” + str(expo))m) Gebe auch folgendes in der Konsole aus: int(baseNum) ** expon) Sorge dafür dass der code nicht crasht, und wenn ein error auftritt gebe diesen in der Konsole aus”’baseNum = input(“Please type a base number you want to exponentiate”) # a, b)expo = input(“Please type an integer exponent number to calculate

### AUFGABE 1)# a) Erstelle zwei Zahlenvariablen und gib ihre Summe mit print() im Terminal (Konsole) aus.a = 555b = 444print(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) * 2print(userData)# Variante 2:userData = input(“please input data here”)print(userData)userData = int(userData)userData *= 2 # gleichbedeutend mit => userData = userData * 2print(userData)# Variante 3:userData = int(input(“please input data here”))print(userData * 2)# Variante 4:userData = int(input(“please input data here”)) * 2print(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 + bprint(c)########################################################################### AUFGABE 4)myVar1 = “Hallo”myVar2 = 10myVar3 = 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 ausprint(str(myVar2) + str(myVar3))# e) Dividiere myVar2 durch 2 und gebe das Ergebnis und den Datentyp des Ergebnisses in der Konsole aus.varDiv = myVar2 / 2print(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 / myVar3print(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 abrundungprint(rounded)# Variante 2:rounded = int(rounded * 100) / 100print(rounded)# i) Multipliziere myVar1 mit 10 und gebe Dir das Ergebnis in er Konsole ausprint(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 ausprint(myVar2 * 10)# k) Multipliziere myVar3 mit 10 und gebe Dir das Ergebnis in er Konsole ausprint(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: myTypemyType = type(myFloat)print(myType)# b) Ermittele programmatisch den Datentyp von myType und gebe das Ergebnis in der Konsole austypeOfMyType = 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 ausgebenprint(print) # b) inneres print wird nicht aufgerufen, sondern zeigt uns nur das Funktionsobjektprint(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 zugewiesenprint(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 Methodeprint(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 ausgebeprint(“===============================keyword===================================================”)import keywordprint(keyword.kwlist)print(“———softkwlist——————-“)print(keyword.softkwlist)print(“============vordefinierten, integrierten Funktionen und Konstanten (Built-ins)============”)import builtinsimport pprint# Die dir()-Funktion gibt eine Liste aller Namen im angegebenen Modul zurückbuilt_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)