{
  "assessmentTests": {
    "python_test": {
      "name": "Python Test",
      "desc": "30 scenariovragen over syntax, functies, datastructuren en objectgedrag — ontdek of jouw Python-kennis aansluit bij wat een vacature onder Python-vaardigheid verstaat.",
      "recommendation": "Jouw Python-vaardigheidsprofiel",
      "results": {
        "beginner": {
          "name": "Beginner",
          "desc": "Je kunt een kort script volgen en waarden erin wijzigen, maar de vragen die je hebt gemist draaien om Python-specifiek gedrag in plaats van algemene logica — een standaardargument dat eenmaal wordt gebouwd en hergebruikt, is versus == op twee gelijkende lijsten, een variabele die lokaal wordt zodra je er ergens in een functie aan toewijst. Dit gaat niet over slecht programmeren; dit zijn Python-specifieke regels die ook ervaren programmeurs van andere talen even tegenhouden. Ze zijn belangrijk op het werk omdat elk een plek is waar een bug in code die op het eerste gezicht correct eruitziet.",
          "recommendation": "Begin met drie dingen, in deze volgorde: veranderbare standaardargumenten (waarom basket=[] gevaarlijk is), het verschil tussen is en ==, en hoe variabele scope in een functie werkt. De officiële Python-handleiding op docs.python.org behandelt alle drie direct, en de term \"Python gotchas\" levert werkende voorbeelden van elk op."
        },
        "intermediate": {
          "name": "Intermediate",
          "desc": "Je beheerst dagelijks scripting gemakkelijk — datastructuren, controlestromen, eenvoudige functies — en zou niet afgebogen worden door routineonderhoudswerk of een kleine feature in een bestaande codebase. Het gat tussen hier en Advanced gaat vooral om wat gebeurt als Python's handige features met elkaar interacteren: een shallow copy die geneste gegevens gedeeld laat terwijl je dacht dat ze gedupliceerd waren, een generator-waarde die stilzwijgend niet deel wordt van de output, decorators die in een volgorde stapelen die gemakkelijk omgekeerd kan raken. Dit zijn bugs die een senior reviewer in tien seconden signaleert en iedereen anders een uur lang achtervolgt.",
          "recommendation": "Richt je op object- en iteratie-interne zaken: shallow versus deep copy, wat een generator werkelijk doet met return, en hoe decorator-stapelvolgorde werkt. Daarna klassebasics die meeste tutorials overslaan — standaardequaliteit zonder __eq__, en waarom een veranderbare klassenattribuut wordt gedeeld over elke instantie."
        },
        "advanced": {
          "name": "Advanced",
          "desc": "Dit is het niveau dat de meeste vacatures bedoelen met \"sterke Python\". Je reikt naar het juiste gereedschap zonder naar hem op zoek te gaan, je weet waarom een stuk gedeelde toestand veranderde in plaats van alleen dat het veranderde, en je kunt iemands functie lezen en de output correct voorspellen. Wat dit bereik van de top scheidt is de defensieve kant van het werk: weten welke van twee correct ogende benaderingen onjuist zal werken zodra een klassenattribuut, een keyword-only argument, of een uitzonderingshiërarchie betrokken is.",
          "recommendation": "Duw voort in de onderdelen die een codebase beschermen die andere mensen ook aanraken: keyword-only argumenten als een API-ontwerpaanzet in plaats van een syntaxisnieuwsgierigheid, de uitzonderingshiërarchie (zodat except-clausules de juiste fouten vangen, niet alleen één klasse), en contextbeheerders als de standaardmanier om opruiming te garanderen. Real Python's deep-dive artikelen zijn een goed volgende stap voor alle drie."
        },
        "expert": {
          "name": "Expert",
          "desc": "Je scoorde aan de top van elke sectie — kernyntax, functies en scope, datastructuren, en object-oriented idiomen. Praktisch gezegd betekent dat je een vreemd bestand kan overhandigd krijgen en uitleggen waarom het de output geeft die het doet, niet alleen wat de syntax zou zeggen, wat de moeilijkere en waardevolere vaardigheid is. Op dit niveau is de ruwe taal zelden de beperkende factor in je werk; de limiet is meestal de omvang of vorm van het systeem rond de code.",
          "recommendation": "De opbrengsten zijn nu in gereedschap en review: statische typechecking met mypy of pyright, profileren voor optimalisering in plaats van gissen, en het lezen van pull requests van andere mensen voor precies deze categorie bug — de bugs die elke test doorstaan en nog steeds het verkeerde doen onder bepaalde invoer. Als je gescreend wordt voor een rol, beschrijf een bug als deze die je hebt gevonden in plaats van taalgeneraties te noemen — het toont de redenering, niet alleen het vocabulaire."
        }
      },
      "questions": [
        {
          "question": "Je schrijft def add_item(item, basket=[]): basket.append(item); return basket, en je roept add_item('a') en add_item('b') aan, beide keren basket achterlaten. Wat retourneert de tweede aanroep?",
          "options": [
            {
              "icon": "",
              "label": "['b'] — elke aanroep krijgt een frisse lege lijst als standaard"
            },
            {
              "icon": "",
              "label": "TypeError — je moet een basket-argument leveren"
            },
            {
              "icon": "",
              "label": "['a', 'b'] — de standaardlijst wordt eenmaal aangemaakt en hergebruikt over aanroepen heen"
            },
            {
              "icon": "",
              "label": "['a'] daarna ['b'] als twee onafhankelijke eenelementlijsten"
            }
          ]
        },
        {
          "question": "a = [1, 2, 3] en b = [1, 2, 3]. Wat retourneert a == b, en wat retourneert a is b?",
          "options": [
            {
              "icon": "",
              "label": "True voor beide — identieke lijsten zijn altijd hetzelfde object"
            },
            {
              "icon": "",
              "label": "True voor ==, False voor is — gelijke inhoud maar verschillende objecten in geheugen"
            },
            {
              "icon": "",
              "label": "False voor beide — afzonderlijke literals zijn nooit gelijk in Python"
            },
            {
              "icon": "",
              "label": "True voor is, False voor == — is controleert waardeequivalentie voor lijsten"
            }
          ]
        },
        {
          "question": "In Python 3, wat evalueert 7 / 2 naar, en wat evalueert 7 // 2 naar?",
          "options": [
            {
              "icon": "",
              "label": "3.5, daarna 3 — / geeft altijd een float terug, // beperkt het resultaat"
            },
            {
              "icon": "",
              "label": "3, daarna 3.5 — / trunceert en // geeft een float terug"
            },
            {
              "icon": "",
              "label": "3.5, daarna 3.5 — beide operatoren geven een float terug in Python 3"
            },
            {
              "icon": "",
              "label": "3, daarna 3 — beide operatoren beperken het resultaat in Python 3"
            }
          ]
        },
        {
          "question": "s = 'hello', daarna voer je s[0] = 'H' uit. Wat gebeurt er?",
          "options": [
            {
              "icon": "",
              "label": "s wordt 'Hello'"
            },
            {
              "icon": "",
              "label": "s wordt 'Hhello' omdat het teken wordt ingevoegd, niet vervangen"
            },
            {
              "icon": "",
              "label": "TypeError — strings zijn onveranderbaar en ondersteunen geen itemtoewijzing"
            },
            {
              "icon": "",
              "label": "Niets — de toewijzing wordt stilzwijgend genegeerd en s blijft 'hello'"
            }
          ]
        },
        {
          "question": "x = [10, 20, 30, 40, 50]. Wat retourneert x[1:4]?",
          "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' en age = 30. Wat produceert f'{name} is {age}'?",
          "options": [
            {
              "icon": "",
              "label": "{name} is {age}"
            },
            {
              "icon": "",
              "label": "Ana is 30"
            },
            {
              "icon": "",
              "label": "name is age"
            },
            {
              "icon": "",
              "label": "Een TypeError, omdat f-strings de format()-methode vereisen"
            }
          ]
        },
        {
          "question": "Wat evalueert 1 < 2 < 3 naar?",
          "options": [
            {
              "icon": "",
              "label": "True — Python ketelt de vergelijkingen als (1 < 2) and (2 < 3)"
            },
            {
              "icon": "",
              "label": "False — kettingvergelijkingen worden van links naar rechts geëvalueerd zonder kortsluiting, wat 1 < 2 < 3 -> 1 < True -> False geeft"
            },
            {
              "icon": "",
              "label": "Een SyntaxError — vergelijkingen kunnen niet worden geketeld"
            },
            {
              "icon": "",
              "label": "3 — Python geeft de laatste waarde in de keten terug"
            }
          ]
        },
        {
          "question": "Wat retourneert bool([]), en wat retourneert bool([0])?",
          "options": [
            {
              "icon": "",
              "label": "False, daarna False — elke lijst met alleen falsy-waarden is falsy"
            },
            {
              "icon": "",
              "label": "False, daarna True — een lege lijst is falsy, een lijst met één element (zelfs 0) is truthy"
            },
            {
              "icon": "",
              "label": "True, daarna True — niet-None-objecten zijn altijd truthy"
            },
            {
              "icon": "",
              "label": "True, daarna False — een lijst is truthy alleen wanneer leeg"
            }
          ]
        },
        {
          "question": "Een moduleniveau count = 0 bestaat. Binnen def increment(): count += 1; return count, je roept increment() aan. Wat gebeurt er?",
          "options": [
            {
              "icon": "",
              "label": "UnboundLocalError — toewijzing aan count ergens in de functie maakt het lokaal, dus count += 1 probeert een lokale variabele te lezen voordat deze is toegewezen"
            },
            {
              "icon": "",
              "label": "Het retourneert 1 en verhoogt de moduleniveau count naar 1"
            },
            {
              "icon": "",
              "label": "Het retourneert 1 maar laat de moduleniveau count op 0"
            },
            {
              "icon": "",
              "label": "Het verhoogt NameError omdat count nooit in de functie werd gedeclareerd"
            }
          ]
        },
        {
          "question": "def f(*args, **kwargs): return args, kwargs. Wat retourneert f(1, 2, x=3)?",
          "options": [
            {
              "icon": "",
              "label": "([1, 2], {'x': 3})"
            },
            {
              "icon": "",
              "label": "((1, 2), {'x': 3})"
            },
            {
              "icon": "",
              "label": "(1, 2, {'x': 3})"
            },
            {
              "icon": "",
              "label": "TypeError — positie- en sleutelwoordargumenten kunnen niet in één aanroep worden gemengd"
            }
          ]
        },
        {
          "question": "Je bouwt funcs = [lambda: i for i in range(3)] in een lus. Wat retourneert [f() for f in funcs]?",
          "options": [
            {
              "icon": "",
              "label": "[2, 2, 2] — elke lambda zoekt i op wanneer deze wordt aangeroepen, en tegen die tijd is de lus klaar met i gelijk aan 2"
            },
            {
              "icon": "",
              "label": "[0, 1, 2] — elke lambda pakt de waarde van i vast op het moment dat deze werd gemaakt"
            },
            {
              "icon": "",
              "label": "[0, 0, 0] — lambda's pakken altijd de eerste waarde vast die aan een variabele is toegewezen"
            },
            {
              "icon": "",
              "label": "Een NameError, omdat i niet meer bestaat zodra de lus eindigt"
            }
          ]
        },
        {
          "question": "Een functie is gedefinieerd met @a rechtstreeks boven @b, die rechtstreeks boven def f(): pass zit. In welke volgorde worden de decorators op f toegepast?",
          "options": [
            {
              "icon": "",
              "label": "b wikkelt f eerst in, dan wikkelt a het resultaat van b in — de decorator die het dichtst bij de functie staat wordt eerst uitgevoerd"
            },
            {
              "icon": "",
              "label": "a wikkelt f eerst in, dan wikkelt b het resultaat in — decorators passen van boven naar beneden toe"
            },
            {
              "icon": "",
              "label": "Beide decorators wikkelingen f onafhankelijk in en alleen de laatste gedefinieerde neemt effect"
            },
            {
              "icon": "",
              "label": "Het hangt af van de volgorde waarin de decorators worden geïmporteerd, niet van hun positie in de code"
            }
          ]
        },
        {
          "question": "def f(a, *, b): return a + b. Welke van deze aanroepen werkt?",
          "options": [
            {
              "icon": "",
              "label": "f(1, b=2) — b moet worden doorgegeven als sleutelwoord omdat het na de kale * in de handtekening staat"
            },
            {
              "icon": "",
              "label": "f(1, 2) — positieargumenten vullen parameters van links naar rechts ongeacht de *"
            },
            {
              "icon": "",
              "label": "f(a=1, 2) — sleutelwoordargumenten moeten eerst komen"
            },
            {
              "icon": "",
              "label": "f(1) — b is optioneel omdat het na de * volgt"
            }
          ]
        },
        {
          "question": "Een generatorfunctie yieldt 1, vervolgens yieldt 2, vervolgens doet return 99. Wat bevat list(the_generator()), en wat gebeurt er met de 99?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 99] — return binnen een generator werkt als één meer yield"
            },
            {
              "icon": "",
              "label": "[99] — return overschrijft onmiddellijk waarden die al zijn gegeven"
            },
            {
              "icon": "",
              "label": "[1, 2] — de retourwaarde van een generator wordt de waarde die aan de StopIteration is bevestigd die het opwekt, deze wordt niet gegeven"
            },
            {
              "icon": "",
              "label": "Een RuntimeError, omdat generatoren geen return-statement kunnen bevatten"
            }
          ]
        },
        {
          "question": "In een outer()-functie wordt x = 1 ingesteld, vervolgens doet een geneste inner() nonlocal x; x += 1, en outer() roept inner() aan voordat x wordt geretourneerd. Wat retourneert outer()?",
          "options": [
            {
              "icon": "",
              "label": "1 — inner() werkt op zijn eigen lokale kopie van x, dus de verandering blijft niet bestaan"
            },
            {
              "icon": "",
              "label": "Een UnboundLocalError, omdat x niet in inner() is gedeclareerd voordat de nonlocal-verklaring plaatsvond"
            },
            {
              "icon": "",
              "label": "Een SyntaxError — nonlocal kan alleen in klassen worden gebruikt"
            },
            {
              "icon": "",
              "label": "2 — nonlocal stelt inner() in staat om de x van de buitenfunctie te wijzigen in plaats van een nieuwe lokale variabele aan te maken"
            }
          ]
        },
        {
          "question": "d = {'a': 1, 'b': 2}. Wat retourneert d.get('c', 0), en voegt het 'c' aan de woordenboek toe?",
          "options": [
            {
              "icon": "",
              "label": "0, en nee — get() retourneert de standaard zonder de sleutel in te voegen"
            },
            {
              "icon": "",
              "label": "0, en ja — get() voegt de sleutel in met de standaardwaarde"
            },
            {
              "icon": "",
              "label": "KeyError, omdat 'c' niet bestaat"
            },
            {
              "icon": "",
              "label": "None, en ja — get() voegt altijd ontbrekende sleutels toe met een None-waarde"
            }
          ]
        },
        {
          "question": "t = (1, 2, [3, 4]). Kun je t[2].append(5) uitvoeren, en kun je t[0] = 10 uitvoeren?",
          "options": [
            {
              "icon": "",
              "label": "Beide werken — het nesten van een lijst in een tuple maakt de hele tuple veranderbaar"
            },
            {
              "icon": "",
              "label": "Beide verhooggen TypeError — niets in een tuple kan ooit worden gewijzigd"
            },
            {
              "icon": "",
              "label": "t[2].append(5) verhoogt TypeError, maar t[0] = 10 werkt omdat tuples hertoewij zing van hun eerste element toestaan"
            },
            {
              "icon": "",
              "label": "t[2].append(5) werkt omdat de lijst binnenin veranderbaar is; t[0] = 10 verhoogt TypeError omdat de tuple zelf onveranderbaar is"
            }
          ]
        },
        {
          "question": "Welke van deze retourneert een iterator die waarden lui berekent in plaats van de hele reeks tegelijk in geheugen op te bouwen: [x*x for x in range(1000000)] of (x*x for x in range(1000000))?",
          "options": [
            {
              "icon": "",
              "label": "De met haakjes, (x*x for x in range(1000000)) — dat is een generatorexpressie"
            },
            {
              "icon": "",
              "label": "De met vierkante haakjes — lijstcomprehensies zijn altijd lui in Python 3"
            },
            {
              "icon": "",
              "label": "Beide zijn lui — het enige verschil is het type dat aan het einde wordt geretourneerd"
            },
            {
              "icon": "",
              "label": "Geen van beide — beide bouwen de volledige reeks onmiddellijk in geheugen op"
            }
          ]
        },
        {
          "question": "Een try-blok deelt door nul, de except ZeroDivisionError-clausule drukt 'a' af, en een finally-clausule drukt 'b' af. Wat wordt afgedrukt, en in welke volgorde?",
          "options": [
            {
              "icon": "",
              "label": "b daarna a — finally wordt altijd voor een except-clausule uitgevoerd"
            },
            {
              "icon": "",
              "label": "a daarna b — de overeenkomstige except wordt eerst uitgevoerd, en finally wordt altijd daarna uitgevoerd ongeacht"
            },
            {
              "icon": "",
              "label": "Alleen b — de uitzondering wordt niet echt gevangen, dus 'a' wordt nooit afgedrukt"
            },
            {
              "icon": "",
              "label": "Alleen a — finally wordt overgeslagen zodra een uitzondering al is afgehandeld"
            }
          ]
        },
        {
          "question": "import copy; a = [[1, 2], [3, 4]]; b = copy.copy(a); b[0].append(99). Verandert a[0] ook?",
          "options": [
            {
              "icon": "",
              "label": "Nee — copy.copy() dupliceert altijd geneste objecten ook"
            },
            {
              "icon": "",
              "label": "Nee — het toevoegen aan b[0] maakt een gloednieuwe lijst voor alleen b[0]"
            },
            {
              "icon": "",
              "label": "Ja, maar alleen omdat copy.copy() werd aangeroepen zonder het deepcopy-argument"
            },
            {
              "icon": "",
              "label": "Ja — copy.copy() maakt een oppervlakkige kopie, dus de geneste lijsten worden nog steeds gedeeld tussen a en b"
            }
          ]
        },
        {
          "question": "d = {'x': 1, 'y': 2}. Wat controleert 'x' in d — de sleutels, de waarden, of beide?",
          "options": [
            {
              "icon": "",
              "label": "De waarden — `in` controleert of 1 of 2 gelijk is aan 'x'"
            },
            {
              "icon": "",
              "label": "Zowel sleutels als waarden worden gecontroleerd"
            },
            {
              "icon": "",
              "label": "Geen van beide — `in` op een dict verhoogt altijd TypeError"
            },
            {
              "icon": "",
              "label": "De sleutels — `in` op een woordenboek test lidmaatschap onder zijn sleutels, niet zijn waarden"
            }
          ]
        },
        {
          "question": "names = ['Al', 'Bo'] en scores = [10, 20]. Wat retourneert list(zip(names, scores))?",
          "options": [
            {
              "icon": "",
              "label": "[('Al', 'Bo'), (10, 20)]"
            },
            {
              "icon": "",
              "label": "['Al', 10, 'Bo', 20]"
            },
            {
              "icon": "",
              "label": "[('Al', 10), ('Bo', 20)]"
            },
            {
              "icon": "",
              "label": "Een ValueError, omdat zip drie of meer argumenten vereist"
            }
          ]
        },
        {
          "question": "class Dog: tricks = [] bevat een klassenvidualliste, en add_trick voegt toe aan self.tricks. d1 = Dog() en d2 = Dog() worden beide aangemaakt, vervolgens wordt d1.add_trick('sit') uitgevoerd. Wat bevat d2.tricks?",
          "options": [
            {
              "icon": "",
              "label": "[] — elke instantie krijgt haar eigen onafhankelijke kopie van tricks"
            },
            {
              "icon": "",
              "label": "['sit'] — tricks is een klassenviduaalliste gedeeld door elke instantie, dus d1's verandering is ook op d2 zichtbaar"
            },
            {
              "icon": "",
              "label": "Een TypeError — instanties kunnen niet aan een klassenattribuut toevoegen"
            },
            {
              "icon": "",
              "label": "['sit'] alleen nadat d2 = Dog() opnieuw wordt uitgevoerd"
            }
          ]
        },
        {
          "question": "class A heeft def greet(self): return 'A'. class B(A) heeft def greet(self): return 'B' + super().greet(). Wat retourneert B().greet()?",
          "options": [
            {
              "icon": "",
              "label": "'AB' — super() wordt altijd voor de subklasse's eigen code uitgevoerd"
            },
            {
              "icon": "",
              "label": "'B' — super().greet() wordt genegeerd omdat B al greet overschrijft"
            },
            {
              "icon": "",
              "label": "'BA' — super().greet() roept de methode van A aan en het resultaat wordt aan 'B' toegevoegd"
            },
            {
              "icon": "",
              "label": "Een AttributeError, omdat A geen greet-methode voor B zichtbaar heeft"
            }
          ]
        },
        {
          "question": "class Point slaat self.x in __init__ op en definieert geen andere methoden. p1 = Point(1) en p2 = Point(1). Wat retourneert p1 == p2 standaard?",
          "options": [
            {
              "icon": "",
              "label": "True — Python vergelijkt standaard alle overeenkomstige kenmerken"
            },
            {
              "icon": "",
              "label": "False — zonder een aangepaste __eq__ __eq__, keert == terug naar identiteitsvergelijking, en p1 en p2 zijn verschillende objecten"
            },
            {
              "icon": "",
              "label": "True, maar alleen omdat beide objecten met hetzelfde argument zijn aangemaakt"
            },
            {
              "icon": "",
              "label": "Een TypeError, omdat Point geen __eq__ definieert"
            }
          ]
        },
        {
          "question": "Welke except-clausule hieronder zal ook een ZeroDivisionError vangen: except ArithmeticError, except ValueError, of except KeyError?",
          "options": [
            {
              "icon": "",
              "label": "except ValueError — delingsfouten worden behandeld als ongeldige waarden"
            },
            {
              "icon": "",
              "label": "except KeyError — elke runtime-fout die niet aan een specifiek type is gekoppeld, valt terug op KeyError"
            },
            {
              "icon": "",
              "label": "Geen van beide — alleen except ZeroDivisionError zelf kan het vangen"
            },
            {
              "icon": "",
              "label": "except ArithmeticError — ZeroDivisionError is een subklasse van ArithmeticError"
            }
          ]
        },
        {
          "question": "Je opent een bestand met open('data.txt') as f: en een uitzondering wordt opgeworpen tijdens het lezen in het blok. Wordt het bestand nog steeds gesloten?",
          "options": [
            {
              "icon": "",
              "label": "Nee — het bestand blijft open omdat het blok niet normaal is beëindigd"
            },
            {
              "icon": "",
              "label": "Alleen als je ook een finally-clausule rond de with-verklaring voegt"
            },
            {
              "icon": "",
              "label": "Ja — de with-verklaring roept de __exit__-methode van het bestand aan, die het sluit, zelfs als in het blok een uitzondering optreedt"
            },
            {
              "icon": "",
              "label": "Het hangt af van het uitzonderingstype — alleen uitzonderingen die elders worden gevangen, activeren opruiming"
            }
          ]
        },
        {
          "question": "x = [3, 1, 2] en y = x.sort(). Wat bevat y?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3] — sort() retourneert de nieuw gesorteerde lijst"
            },
            {
              "icon": "",
              "label": "None — list.sort() sorteert ter plekke en retourneert None; x zelf wordt [1, 2, 3]"
            },
            {
              "icon": "",
              "label": "[3, 1, 2] — sort() retourneert de originele ongesorteerde lijst en wijzigt alleen de interne volgorde van x"
            },
            {
              "icon": "",
              "label": "Een TypeError, omdat sort() niet aan een variabele kan worden toegewezen"
            }
          ]
        },
        {
          "question": "Wat gebeurt er wanneer je 'Score: ' + 42 uitvoert?",
          "options": [
            {
              "icon": "",
              "label": "'Score: 42' — Python converteert het getal automatisch in een +-expressie"
            },
            {
              "icon": "",
              "label": "'Score: ' — het getal wordt stilzwijgend weggelaten"
            },
            {
              "icon": "",
              "label": "42 — de string wordt in een getal omgezet en toegevoegd"
            },
            {
              "icon": "",
              "label": "TypeError — je kunt een str en een int niet rechtstreeks samenvoegen, 42 moet eerst met str() worden omgezet"
            }
          ]
        },
        {
          "question": "Je moet controleren of een lijst genaamd results leeg is. Wat is de idiomatische Python-manier: if results == []: , if len(results) == 0: , of if not results: ?",
          "options": [
            {
              "icon": "",
              "label": "if results == []: — dit is de enige betrouwbare manier om een lege lijst te detecteren"
            },
            {
              "icon": "",
              "label": "if len(results) == 0: — dit is vereist omdat lege lijsten truthy zijn in Python"
            },
            {
              "icon": "",
              "label": "Alle drie worden praktisch nooit gebruikt; de standaardbenadering is if results is None:"
            },
            {
              "icon": "",
              "label": "if not results: — Python-idioom vertrouwt op waarheid, en een lege lijst is falsy"
            }
          ]
        }
      ],
      "optionOrderVersion": "92945565db6c55da"
    }
  }
}