{
  "assessmentTests": {
    "python_test": {
      "name": "Python Test",
      "desc": "30 Szenariofragen zu Syntax, Funktionen, Datenstrukturen und Objektverhalten - entdecken Sie, ob Ihre Python-Kenntnisse dem entsprechen, was eine Stellenanzeige unter Python-Kompetenz versteht.",
      "recommendation": "Ihr Python-Kompetenzprofil",
      "results": {
        "beginner": {
          "name": "Anfänger",
          "desc": "Sie können einem kurzen Skript folgen und Werte darin ändern, aber die Fragen, die Sie vermisst haben, konzentrieren sich auf das spezifische Verhalten der Sprache selbst, nicht auf allgemeine Logik - ein Standardargument, das einmal aufgebaut und wiederverwendet wird, is versus == bei zwei gleichaussehenden Listen, eine Variable, die lokal wird, sobald Sie sie irgendwo in einer Funktion zuweisen. Nichts davon bedeutet, dass Sie schlecht programmieren; das sind Python-spezifische Regeln, die Menschen aus anderen Sprachen genauso oft verwirren wie Anfänger. Sie sind wichtig bei der Arbeit, weil jede dieser Regeln ein Platz ist, an dem sich ein Fehler in Code versteckt, der auf den ersten Blick korrekt aussieht.",
          "recommendation": "Beginnen Sie mit drei Dingen, in dieser Reihenfolge: veränderbare Standardargumente (warum basket=[] gefährlich ist), der Unterschied zwischen is und ==, und wie der Variablengültigkeitsbereich innerhalb einer Funktion funktioniert. Das offizielle Python-Tutorial auf docs.python.org behandelt alle drei direkt, und der Begriff \"Python gotchas\" findet bearbeitete Beispiele für jeden."
        },
        "intermediate": {
          "name": "Mittelstufe",
          "desc": "Sie bewältigen alltägliches Scripting mühelos - Datenstrukturen, Kontrollfluss, unkomplizierte Funktionen - und würden nicht durch routinemäßige Wartungsarbeiten oder ein kleines Feature in einer bestehenden Codebasis verlangsamt. Der Unterschied zwischen hier und Advanced besteht hauptsächlich darin, was passiert, wenn Pythons Komfortfunktionen miteinander interagieren: eine flache Kopie, die verschachtelte Daten teilt, wenn Sie erwartet haben, dass sie dupliziert werden, der Rückgabewert eines Generators, der stille nicht Teil der Ausgabe wird, Decorators, die in einer Reihenfolge stapeln, die leicht rückwärts zu bekommen ist. Das sind die Art von Fehlern, die ein Senior-Reviewer in zehn Sekunden kennzeichnet und alle anderen eine Stunde damit verbringen, sie zu verfolgen.",
          "recommendation": "Konzentrieren Sie sich auf Objekt- und Iterationsinterna: flache versus tiefe Kopie, was ein Generator wirklich mit return macht, und wie die Decorator-Stapelreihenfolge funktioniert. Dann Klassengrundsätze, die die meisten Tutorials überspringen - Standard-Gleichheit ohne __eq__, und warum ein änderbares Klassenattribut über alle Instanzen hinweg geteilt wird."
        },
        "advanced": {
          "name": "Fortgeschritten",
          "desc": "Dies ist das Niveau, das die meisten Stellenanzeigen unter \"starkem Python\" verstehen. Sie greifen auf das richtige Werkzeug zu, ohne danach zu suchen, Sie wissen, warum sich ein gemeinsames Datenelement verändert hat, nicht nur dass es sich verändert hat, und Sie können die Funktion einer anderen Person lesen und ihre Ausgabe korrekt vorhersagen. Was diese Gruppe von der Spitze trennt, ist die defensive Seite der Arbeit: zu wissen, welcher von zwei korrekt aussehenden Ansätzen misbehaved, sobald ein Klassenattribut, ein Argument nur für Schlüsselwörter oder eine Ausnahmehierarchie beteiligt ist.",
          "recommendation": "Drücken Sie in die Teile, die eine Codebasis schützen, an der auch andere Menschen arbeiten: Argumente nur für Schlüsselwörter als API-Design-Wahl und nicht nur als Syntax-Neugier, die Ausnahmehierarchie (damit except-Klauseln die richtige Fehlerfamilie erfassen, nicht nur eine Klasse), und Kontext-Manager als Standardmethode, um Cleanup zu garantieren. Die Deep-Dive-Artikel von Real Python sind eine gute nächste Station für alle drei."
        },
        "expert": {
          "name": "Experte",
          "desc": "Sie haben in allen Abschnitten die höchste Punktzahl erreicht - Kernsyntax, Funktionen und Gültigkeitsbereich, Datenstrukturen und objektorientierte Redewendungen. Praktisch bedeutet das, dass Sie eine fremde Datei bekommen und erklären können, warum sie die Ausgabe erzeugt, die sie tut, nicht nur das, was die Syntax sagen sollte, was die schwierigere und wertvollere Fähigkeit ist. Auf dieser Ebene ist die Rohsprache selten der einschränkende Faktor in Ihrer Arbeit; die Grenze ist normalerweise die Größe oder Form des Systems um den Code herum.",
          "recommendation": "Die Ergebnisse liegen jetzt in Werkzeugen und Überprüfung: statische Typüberprüfung mit mypy oder pyright, Profilierung vor der Optimierung statt Raten, und das Lesen der Pull Requests anderer Menschen auf genau diese Fehlerkategorie - die, die jeden Test bestehen und immer noch das Falsche unter einer bestimmten Eingabe tun. Wenn Sie für eine Stelle überprüft werden, beschreiben Sie einen Fehler wie diesen, den Sie gefunden haben, anstatt Sprachfunktionen zu benennen - das demonstriert das Denken, nicht nur das Vokabular."
        }
      },
      "questions": [
        {
          "question": "Sie schreiben def add_item(item, basket=[]): basket.append(item); return basket, dann rufen Sie add_item('a') und add_item('b') auf, wobei Sie basket beide Male weglassen. Was gibt der zweite Aufruf zurück?",
          "options": [
            {
              "icon": "",
              "label": "['b'] - jeder Aufruf erhält standardmäßig eine neue leere Liste"
            },
            {
              "icon": "",
              "label": "TypeError - Sie müssen ein basket-Argument angeben"
            },
            {
              "icon": "",
              "label": "['a', 'b'] - die Standardliste wird einmal erstellt und über Aufrufe hinweg wiederverwendet"
            },
            {
              "icon": "",
              "label": "['a'] dann ['b'] als zwei unabhängige Listen mit je einem Element"
            }
          ]
        },
        {
          "question": "a = [1, 2, 3] und b = [1, 2, 3]. Was gibt a == b zurück, und was gibt a is b zurück?",
          "options": [
            {
              "icon": "",
              "label": "True für beide - identische Listen sind immer das gleiche Objekt"
            },
            {
              "icon": "",
              "label": "True für ==, False für is - gleicher Inhalt, aber unterschiedliche Objekte im Speicher"
            },
            {
              "icon": "",
              "label": "False für beide - separate Literale sind in Python nie gleich"
            },
            {
              "icon": "",
              "label": "True für is, False für == - is prüft Wertgleichheit bei Listen"
            }
          ]
        },
        {
          "question": "In Python 3, was ergibt 7 / 2, und was ergibt 7 // 2?",
          "options": [
            {
              "icon": "",
              "label": "3.5, dann 3 - / gibt immer einen float zurück, // rundet das Ergebnis ab"
            },
            {
              "icon": "",
              "label": "3, dann 3.5 - / truncates und // gibt einen float zurück"
            },
            {
              "icon": "",
              "label": "3.5, dann 3.5 - beide Operatoren geben in Python 3 einen float zurück"
            },
            {
              "icon": "",
              "label": "3, dann 3 - beide Operatoren runden das Ergebnis in Python 3 ab"
            }
          ]
        },
        {
          "question": "s = 'hello', dann führen Sie s[0] = 'H' aus. Was passiert?",
          "options": [
            {
              "icon": "",
              "label": "s wird zu 'Hello'"
            },
            {
              "icon": "",
              "label": "s wird zu 'Hhello', weil das Zeichen eingefügt wird, nicht ersetzt"
            },
            {
              "icon": "",
              "label": "TypeError - Zeichenketten sind unveränderlich und unterstützen keine Elementzuweisung"
            },
            {
              "icon": "",
              "label": "Nichts - die Zuweisung wird stillschweigend ignoriert und s bleibt 'hello'"
            }
          ]
        },
        {
          "question": "x = [10, 20, 30, 40, 50]. Was gibt x[1:4] zurück?",
          "options": [
            {
              "icon": "",
              "label": "[20, 30, 40, 50]"
            },
            {
              "icon": "",
              "label": "[10, 20, 30, 40]"
            },
            {
              "icon": "",
              "label": "[20, 30, 40]"
            },
            {
              "icon": "",
              "label": "[30, 40]"
            }
          ]
        },
        {
          "question": "name = 'Ana' und age = 30. Was erzeugt f'{name} is {age}'?",
          "options": [
            {
              "icon": "",
              "label": "{name} is {age}"
            },
            {
              "icon": "",
              "label": "Ana is 30"
            },
            {
              "icon": "",
              "label": "name is age"
            },
            {
              "icon": "",
              "label": "Ein TypeError, weil f-Strings die format()-Methode erfordern"
            }
          ]
        },
        {
          "question": "Was ergibt 1 < 2 < 3?",
          "options": [
            {
              "icon": "",
              "label": "True - Python verkettet die Vergleiche als (1 < 2) and (2 < 3)"
            },
            {
              "icon": "",
              "label": "False - verknüpfte Vergleiche werden von links nach rechts ohne Short-Circuit ausgewertet, was 1 < 2 < 3 -> 1 < True -> False ergibt"
            },
            {
              "icon": "",
              "label": "Ein SyntaxError - Vergleiche können nicht verkettet werden"
            },
            {
              "icon": "",
              "label": "3 - Python gibt den letzten Wert in der Kette zurück"
            }
          ]
        },
        {
          "question": "Was gibt bool([]) zurück, und was gibt bool([0]) zurück?",
          "options": [
            {
              "icon": "",
              "label": "False, dann False - jede Liste, die nur falsy-Werte enthält, ist falsy"
            },
            {
              "icon": "",
              "label": "False, dann True - eine leere Liste ist falsy, eine Liste mit einem Element (sogar 0) ist truthy"
            },
            {
              "icon": "",
              "label": "True, dann True - Nicht-None-Objekte sind immer truthy"
            },
            {
              "icon": "",
              "label": "True, dann False - eine Liste ist nur dann truthy, wenn sie leer ist"
            }
          ]
        },
        {
          "question": "Es existiert ein count = 0 auf Modulebene. Innerhalb von def increment(): count += 1; return count rufen Sie increment() auf. Was passiert?",
          "options": [
            {
              "icon": "",
              "label": "UnboundLocalError - eine Zuweisung zu count überall in der Funktion macht es lokal, also versucht count += 1, eine lokale Variable zu lesen, bevor sie zugewiesen wird"
            },
            {
              "icon": "",
              "label": "Es gibt 1 zurück und erhöht das count auf Modulebene auf 1"
            },
            {
              "icon": "",
              "label": "Es gibt 1 zurück, lässt aber das count auf Modulebene bei 0"
            },
            {
              "icon": "",
              "label": "Es wirft NameError aus, weil count nie innerhalb der Funktion deklariert wurde"
            }
          ]
        },
        {
          "question": "def f(*args, **kwargs): return args, kwargs. Was gibt f(1, 2, x=3) zurück?",
          "options": [
            {
              "icon": "",
              "label": "([1, 2], {'x': 3})"
            },
            {
              "icon": "",
              "label": "((1, 2), {'x': 3})"
            },
            {
              "icon": "",
              "label": "(1, 2, {'x': 3})"
            },
            {
              "icon": "",
              "label": "TypeError - Positions- und Schlüsselwortargumente können nicht in einem Aufruf gemischt werden"
            }
          ]
        },
        {
          "question": "Sie erstellen funcs = [lambda: i for i in range(3)] in einer Schleife. Was gibt [f() for f in funcs] zurück?",
          "options": [
            {
              "icon": "",
              "label": "[2, 2, 2] - jedes lambda sucht i beim Aufruf auf, und bis dahin hat die Schleife mit i gleich 2 beendet"
            },
            {
              "icon": "",
              "label": "[0, 1, 2] - jedes lambda erfasst den Wert von i zum Zeitpunkt seiner Erstellung"
            },
            {
              "icon": "",
              "label": "[0, 0, 0] - lambdas erfassen immer den ersten Wert, der einer Variablen zugewiesen wird"
            },
            {
              "icon": "",
              "label": "Ein NameError, weil i nach dem Ende der Schleife nicht mehr existiert"
            }
          ]
        },
        {
          "question": "Eine Funktion wird mit @a direkt über @b definiert, die direkt über def f(): pass sitzt. In welcher Reihenfolge werden die Decorators auf f angewendet?",
          "options": [
            {
              "icon": "",
              "label": "b wickelt f zuerst ein, dann wickelt a das Ergebnis von b ein - der Decorator am nächsten zur Funktion läuft zuerst"
            },
            {
              "icon": "",
              "label": "a wickelt f zuerst ein, dann wickelt b das Ergebnis ein - Decorators werden von oben nach unten angewendet"
            },
            {
              "icon": "",
              "label": "Beide Decorators wickeln f unabhängig ein und nur der zuletzt definierte hat Auswirkungen"
            },
            {
              "icon": "",
              "label": "Es hängt von der Reihenfolge ab, in der die Decorators importiert werden, nicht ihrer Position im Code"
            }
          ]
        },
        {
          "question": "def f(a, *, b): return a + b. Welche dieser Aufrufe funktioniert?",
          "options": [
            {
              "icon": "",
              "label": "f(1, b=2) - b muss als Schlüsselwort übergeben werden, weil es nach dem bloßen * in der Signatur kommt"
            },
            {
              "icon": "",
              "label": "f(1, 2) - Positionsargumente füllen Parameter von links nach rechts, unabhängig von *"
            },
            {
              "icon": "",
              "label": "f(a=1, 2) - Schlüsselwortargumente müssen zuerst kommen"
            },
            {
              "icon": "",
              "label": "f(1) - b ist optional, weil es nach * folgt"
            }
          ]
        },
        {
          "question": "Eine Generator-Funktion macht yield 1, dann yields 2, dann macht return 99. Was enthält list(the_generator()), und was passiert mit der 99?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 99] - return innerhalb eines Generators verhält sich wie ein weiteres yield"
            },
            {
              "icon": "",
              "label": "[99] - return setzt sofort alle bereits yielded Werte außer Kraft"
            },
            {
              "icon": "",
              "label": "[1, 2] - der Rückgabewert eines Generators wird zum Wert, der an die StopIteration angehängt wird, die er auslöst, er wird nicht yielded"
            },
            {
              "icon": "",
              "label": "Ein RuntimeError, weil Generatoren keine return-Anweisung enthalten dürfen"
            }
          ]
        },
        {
          "question": "In einer outer()-Funktion wird x = 1 gesetzt, dann macht ein verschachteltes inner() nonlocal x; x += 1, und outer() ruft inner() auf, bevor es x zurückgibt. Was gibt outer() zurück?",
          "options": [
            {
              "icon": "",
              "label": "1 - inner() operiert auf seiner eigenen lokalen Kopie von x, daher wird die Änderung nicht beibehalten"
            },
            {
              "icon": "",
              "label": "Ein UnboundLocalError, weil x innerhalb von inner() vor der nonlocal-Anweisung nicht deklariert wird"
            },
            {
              "icon": "",
              "label": "Ein SyntaxError - nonlocal kann nur innerhalb von Klassen verwendet werden"
            },
            {
              "icon": "",
              "label": "2 - nonlocal lässt inner() das x der äußeren Funktion ändern, anstatt eine neue lokale Variable zu erstellen"
            }
          ]
        },
        {
          "question": "d = {'a': 1, 'b': 2}. Was gibt d.get('c', 0) zurück, und fügt es 'c' zum Wörterbuch hinzu?",
          "options": [
            {
              "icon": "",
              "label": "0, und nein - get() gibt den Standard zurück, ohne den Schlüssel einzufügen"
            },
            {
              "icon": "",
              "label": "0, und ja - get() fügt den Schlüssel mit dem Standardwert ein"
            },
            {
              "icon": "",
              "label": "KeyError, weil 'c' nicht existiert"
            },
            {
              "icon": "",
              "label": "None, und ja - get() fügt immer fehlende Schlüssel mit einem None-Wert hinzu"
            }
          ]
        },
        {
          "question": "t = (1, 2, [3, 4]). Können Sie t[2].append(5) ausführen, und können Sie t[0] = 10 ausführen?",
          "options": [
            {
              "icon": "",
              "label": "Beide funktionieren - das Verschachteln einer Liste in einem Tupel macht das gesamte Tupel veränderbar"
            },
            {
              "icon": "",
              "label": "Beide werfen TypeError aus - nichts in einem Tupel kann jemals geändert werden"
            },
            {
              "icon": "",
              "label": "t[2].append(5) wirft TypeError aus, aber t[0] = 10 funktioniert, weil Tupel eine Neuzuweisung ihres ersten Elements erlauben"
            },
            {
              "icon": "",
              "label": "t[2].append(5) funktioniert, weil die Liste innen veränderbar ist; t[0] = 10 wirft TypeError aus, weil das Tupel selbst unveränderlich ist"
            }
          ]
        },
        {
          "question": "Welche dieser Varianten gibt einen Iterator zurück, der Werte träge berechnet, anstatt die gesamte Sequenz auf einmal im Speicher aufzubauen: [x*x for x in range(1000000)] oder (x*x for x in range(1000000))?",
          "options": [
            {
              "icon": "",
              "label": "Die mit Klammern, (x*x for x in range(1000000)) - das ist ein Generator-Ausdruck"
            },
            {
              "icon": "",
              "label": "Die mit eckigen Klammern - Listenverständigungen sind in Python 3 immer träge"
            },
            {
              "icon": "",
              "label": "Beide sind träge - der einzige Unterschied ist der Typ, der am Ende zurückgegeben wird"
            },
            {
              "icon": "",
              "label": "Keine von beiden - beide bauen die gesamte Sequenz sofort im Speicher auf"
            }
          ]
        },
        {
          "question": "Ein try-Block dividiert durch Null, die except ZeroDivisionError-Klausel druckt 'a', und eine finally-Klausel druckt 'b'. Was wird gedruckt, und in welcher Reihenfolge?",
          "options": [
            {
              "icon": "",
              "label": "b dann a - finally läuft immer vor einer except-Klausel"
            },
            {
              "icon": "",
              "label": "a dann b - die entsprechende except läuft zuerst, und finally läuft danach immer, unabhängig"
            },
            {
              "icon": "",
              "label": "Nur b - die Ausnahme wird nicht wirklich abgefangen, daher wird 'a' nie gedruckt"
            },
            {
              "icon": "",
              "label": "Nur a - finally wird übersprungen, sobald eine Ausnahme bereits behandelt wurde"
            }
          ]
        },
        {
          "question": "import copy; a = [[1, 2], [3, 4]]; b = copy.copy(a); b[0].append(99). Ändert sich a[0] auch?",
          "options": [
            {
              "icon": "",
              "label": "Nein - copy.copy() dupliziert auch immer verschachtelte Objekte"
            },
            {
              "icon": "",
              "label": "Nein - das Anhängen an b[0] erstellt nur für b[0] eine ganz neue Liste"
            },
            {
              "icon": "",
              "label": "Ja, aber nur weil copy.copy() ohne das deepcopy-Argument aufgerufen wurde"
            },
            {
              "icon": "",
              "label": "Ja - copy.copy() erstellt eine flache Kopie, daher werden die verschachtelt Listen noch zwischen a und b geteilt"
            }
          ]
        },
        {
          "question": "d = {'x': 1, 'y': 2}. Was prüft 'x' in d - die Schlüssel, die Werte oder beides?",
          "options": [
            {
              "icon": "",
              "label": "Die Werte - `in` prüft, ob 1 oder 2 gleich 'x' ist"
            },
            {
              "icon": "",
              "label": "Sowohl Schlüssel als auch Werte werden überprüft"
            },
            {
              "icon": "",
              "label": "Weder - `in` auf einem dict wirft immer TypeError aus"
            },
            {
              "icon": "",
              "label": "Die Schlüssel - `in` bei einem Wörterbuch testet die Zugehörigkeit zu seinen Schlüsseln, nicht zu seinen Werten"
            }
          ]
        },
        {
          "question": "names = ['Al', 'Bo'] und scores = [10, 20]. Was gibt list(zip(names, scores)) zurück?",
          "options": [
            {
              "icon": "",
              "label": "[('Al', 'Bo'), (10, 20)]"
            },
            {
              "icon": "",
              "label": "['Al', 10, 'Bo', 20]"
            },
            {
              "icon": "",
              "label": "[('Al', 10), ('Bo', 20)]"
            },
            {
              "icon": "",
              "label": "Ein ValueError, weil zip drei oder mehr Argumente erfordert"
            }
          ]
        },
        {
          "question": "class Dog: tricks = [] hält eine Liste auf Klassenebene, und add_trick hängt an self.tricks an. d1 = Dog() und d2 = Dog() werden beide erstellt, dann läuft d1.add_trick('sit'). Was enthält d2.tricks?",
          "options": [
            {
              "icon": "",
              "label": "[] - jede Instanz erhält ihre eigene unabhängige Kopie von tricks"
            },
            {
              "icon": "",
              "label": "['sit'] - tricks ist eine Liste auf Klassenebene, die von jeder Instanz geteilt wird, daher ist d1s Änderung auch auf d2 sichtbar"
            },
            {
              "icon": "",
              "label": "Ein TypeError - Instanzen können nicht an ein Klassenattribut anhängen"
            },
            {
              "icon": "",
              "label": "['sit'] nur nach dem erneuten Ausführen von d2 = Dog()"
            }
          ]
        },
        {
          "question": "class A hat def greet(self): return 'A'. class B(A) hat def greet(self): return 'B' + super().greet(). Was gibt B().greet() zurück?",
          "options": [
            {
              "icon": "",
              "label": "'AB' - super() läuft immer vor dem eigenen Code der Subklasse"
            },
            {
              "icon": "",
              "label": "'B' - super().greet() wird ignoriert, weil B greet bereits überschreibt"
            },
            {
              "icon": "",
              "label": "'BA' - super().greet() ruft As Methode auf und sein Ergebnis wird an 'B' angehängt"
            },
            {
              "icon": "",
              "label": "Ein AttributeError, weil A keine für B sichtbare greet-Methode hat"
            }
          ]
        },
        {
          "question": "class Point speichert self.x in __init__ und definiert keine anderen Methoden. p1 = Point(1) und p2 = Point(1). Was gibt p1 == p2 standardmäßig zurück?",
          "options": [
            {
              "icon": "",
              "label": "True - Python vergleicht standardmäßig alle übereinstimmenden Attribute"
            },
            {
              "icon": "",
              "label": "False - ohne ein benutzerdefiniertes __eq__, fällt == auf Identitätsvergleich zurück, und p1 und p2 sind unterschiedliche Objekte"
            },
            {
              "icon": "",
              "label": "True, aber nur weil beide Objekte mit dem gleichen Argument erstellt wurden"
            },
            {
              "icon": "",
              "label": "Ein TypeError, weil Point __eq__ nicht definiert"
            }
          ]
        },
        {
          "question": "Welche except-Klausel unten wird auch einen ZeroDivisionError erfassen: except ArithmeticError, except ValueError oder except KeyError?",
          "options": [
            {
              "icon": "",
              "label": "except ValueError - Divisionsfehler werden als ungültige Werte behandelt"
            },
            {
              "icon": "",
              "label": "except KeyError - jeder Laufzeitfehler, der nicht an einen bestimmten Typ gebunden ist, fällt auf KeyError zurück"
            },
            {
              "icon": "",
              "label": "Keiner von ihnen - nur except ZeroDivisionError selbst kann ihn abfangen"
            },
            {
              "icon": "",
              "label": "except ArithmeticError - ZeroDivisionError ist eine Unterklasse von ArithmeticError"
            }
          ]
        },
        {
          "question": "Sie öffnen eine Datei mit open('data.txt') as f: und eine Ausnahme wird beim Lesen innerhalb des Blocks ausgelöst. Wird die Datei noch geschlossen?",
          "options": [
            {
              "icon": "",
              "label": "Nein - die Datei bleibt offen, weil der Block nicht normal beendet wurde"
            },
            {
              "icon": "",
              "label": "Nur wenn Sie auch eine finally-Klausel um die with-Anweisung hinzufügen"
            },
            {
              "icon": "",
              "label": "Ja - die with-Anweisung ruft die __exit__-Methode der Datei auf, die sie schließt, auch wenn eine Ausnahme innerhalb des Blocks auftritt"
            },
            {
              "icon": "",
              "label": "Es hängt vom Ausnahmetype ab - nur Ausnahmen, die anderswo abgefangen werden, lösen Cleanup aus"
            }
          ]
        },
        {
          "question": "x = [3, 1, 2] und y = x.sort(). Was enthält y?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3] - sort() gibt die neu sortierte Liste zurück"
            },
            {
              "icon": "",
              "label": "None - list.sort() sortiert an Ort und Stelle und gibt None zurück; x selbst wird [1, 2, 3]"
            },
            {
              "icon": "",
              "label": "[3, 1, 2] - sort() gibt die ursprüngliche unsortierte Liste zurück und ändert nur xs interne Reihenfolge"
            },
            {
              "icon": "",
              "label": "Ein TypeError, weil sort() nicht einer Variablen zugewiesen werden kann"
            }
          ]
        },
        {
          "question": "Was passiert, wenn Sie 'Score: ' + 42 ausführen?",
          "options": [
            {
              "icon": "",
              "label": "'Score: 42' - Python konvertiert die Zahl automatisch in einem + Ausdruck"
            },
            {
              "icon": "",
              "label": "'Score: ' - die Zahl wird stillschweigend verworfen"
            },
            {
              "icon": "",
              "label": "42 - die Zeichenkette wird zu einer Zahl umgewandelt und addiert"
            },
            {
              "icon": "",
              "label": "TypeError - Sie können eine str und einen int nicht direkt verketten, 42 muss zuerst mit str() konvertiert werden"
            }
          ]
        },
        {
          "question": "Sie müssen überprüfen, ob eine Liste namens results leer ist. Welche ist die idiomatische Python-Methode: if results == []: , if len(results) == 0: oder if not results: ?",
          "options": [
            {
              "icon": "",
              "label": "if results == []: - dies ist die einzige zuverlässige Methode, eine leere Liste zu erkennen"
            },
            {
              "icon": "",
              "label": "if len(results) == 0: - dies ist erforderlich, da leere Listen in Python truthy sind"
            },
            {
              "icon": "",
              "label": "Alle drei werden in der Praxis gleichermaßen nie verwendet; der Standardansatz ist if results is None:"
            },
            {
              "icon": "",
              "label": "if not results: - Python-Redewendung basiert auf Wahrheit, und eine leere Liste ist falsy"
            }
          ]
        }
      ],
      "optionOrderVersion": "92945565db6c55da"
    }
  }
}