{
  "assessmentTests": {
    "python_test": {
      "name": "Pagsusulit sa Python",
      "desc": "30 scenario na tanong sa syntax, functions, data structures at object behaviour — alamin kung tumutugma ang inyong Python sa ibig sabihin ng isang job posting ng Python proficiency.",
      "recommendation": "Ang inyong Python skills profile",
      "results": {
        "beginner": {
          "name": "Nagsisimula pa lang",
          "desc": "Kaya ninyong sundan ang isang maikling script at baguhin ang mga value sa loob nito, pero ang mga tanong na nakaligtaan ninyo ay nag-cluster sa paligid ng sariling specific behaviour ng language sa halip na general logic — isang default argument na ginagawa nang isang beses at ginagamit paulit-ulit, ang is laban sa == sa dalawang listahan na magkamukha, isang variable na nagiging local sa sandaling mag-assign kayo dito kahit saan sa loob ng isang function. Wala sa mga ito ang tungkol sa pagiging mahina sa programming; ito ang mga Python-specific na rules na nakakatisod sa mga taong galing sa ibang languages nang kasing dalas ng mga baguhan. Mahalaga ang mga ito sa trabaho dahil ang bawat isa ay kung saan nagtatago ang isang bug sa code na mukhang tama sa unang tingin.",
          "recommendation": "Magsimula sa tatlong bagay, sa pagkakasunod-sunod na ito: mutable default arguments (kung bakit delikado ang basket=[]), ang pagkakaiba ng is at ==, at kung paano gumagana ang variable scope sa loob ng isang function. Sinasaklaw ng official Python tutorial sa docs.python.org ang lahat ng tatlo nang direkta, at ang terminong \"Python gotchas\" ay naglalabas ng worked examples ng bawat isa."
        },
        "intermediate": {
          "name": "Katamtaman",
          "desc": "Komportable ninyong ha-handle ang everyday scripting — data structures, control flow, straightforward functions — at hindi kayo mababagalan sa routine maintenance work o isang maliit na feature sa isang existing codebase. Ang agwat sa pagitan nito at Advanced ay nasa kadalasan kung ano ang mangyayari kapag nag-interact ang convenience features ng Python sa isa't isa: isang shallow copy na nag-iiwan ng nested data na shared gayong inaasahan ninyong duplicated ito, ang return value ng isang generator na tahimik na hindi nagiging bahagi ng output nito, decorators na nag-stack sa isang order na madaling mabaliktad. Iyon ang klase ng mga bug na napapansin ng isang senior reviewer sa loob ng sampung segundo at ginugugol ng lahat ng iba isang oras para hanapin.",
          "recommendation": "Mag-focus sa object at iteration internals: shallow laban sa deep copy, kung ano talaga ang ginagawa ng isang generator sa return, at kung paano gumagana ang decorator stacking order. Pagkatapos ang class basics na nililiktaan ng karamihan ng tutorials — default equality nang walang __eq__, at kung bakit shared sa bawat instance ang isang mutable class attribute."
        },
        "advanced": {
          "name": "Mataas",
          "desc": "Ito ang level na ibig sabihin ng karamihan ng job postings kapag sinabi nilang \"strong Python.\" Kinukuha ninyo ang tamang tool nang hindi naghahanap dito, alam ninyo kung bakit nagbago ang isang piraso ng shared state sa halip na alam lang na nagbago ito, at kayang basahin ang function ng ibang tao at tama ang paghula sa output nito. Ang naghihiwalay sa band na ito mula sa itaas ay ang defensive side ng trabaho: ang pag-alam kung alin sa dalawang approach na mukhang tama ang magmi-misbehave sa sandaling may kasangkot na class attribute, keyword-only argument, o exception hierarchy.",
          "recommendation": "Itulak papasok sa mga parte na nag-p-protect ng codebase na ginagalaw din ng ibang tao: keyword-only arguments bilang isang API-design choice sa halip na isang syntax curiosity, ang exception hierarchy (para ang except clauses ay huhuli sa tamang family ng error, hindi lang isang class), at context managers bilang standard na paraan para ma-guarantee ang cleanup. Magandang susunod na hakbang para sa lahat ng tatlo ang deep-dive articles ng Real Python."
        },
        "expert": {
          "name": "Eksperto",
          "desc": "Nakakuha kayo ng top score sa bawat section — core syntax, functions at scope, data structures, at object-oriented idioms. Sa praktikal, ibig sabihin nito ay puwede kayong bigyan ng file ng isang stranger at maipaliwanag ninyo kung bakit ito nagpo-produce ng output nito, hindi lang kung ano ang sinasabi ng syntax na dapat nitong gawin, na siyang mas mahirap at mas valuable na skill. Sa level na ito, bihira ang raw language mismo ang limiting factor sa trabaho ninyo; ang limit ay kadalasan ang laki o hugis ng system sa paligid ng code.",
          "recommendation": "Nasa tooling at review na ngayon ang mga return: static type checking gamit ang mypy o pyright, profiling bago mag-optimize sa halip na manghula, at pagbasa ng pull requests ng ibang tao para sa eksaktong kategoryang ito ng bug — ang mga pumapasa sa bawat test pero gumagawa pa rin ng maling bagay sa ilalim ng isang specific input. Kung sine-screen kayo para sa isang role, ilarawan ang isang bug na katulad nito na nahanap ninyo sa halip na pangalanan ang mga language features — ipinapakita nito ang reasoning, hindi lang ang vocabulary."
        }
      },
      "questions": [
        {
          "question": "Isinulat ninyo ang def add_item(item, basket=[]): basket.append(item); return basket, pagkatapos ay tinawag ang add_item('a') at add_item('b'), dalawang beses na hindi nilagyan ng basket. Ano ang ibabalik ng pangalawang tawag?",
          "options": [
            {
              "icon": "",
              "label": "['b'] — bawat tawag ay nakakakuha ng bagong empty list bilang default"
            },
            {
              "icon": "",
              "label": "TypeError — kailangan ninyong magbigay ng basket argument"
            },
            {
              "icon": "",
              "label": "['a', 'b'] — ang default list ay ginagawa nang isang beses at ginagamit paulit-ulit sa mga tawag"
            },
            {
              "icon": "",
              "label": "['a'] pagkatapos ['b'] bilang dalawang independent single-item lists"
            }
          ]
        },
        {
          "question": "a = [1, 2, 3] at b = [1, 2, 3]. Ano ang ibabalik ng a == b, at ano ang ibabalik ng a is b?",
          "options": [
            {
              "icon": "",
              "label": "True para sa dalawa — ang magkaparehong listahan ay palaging ang parehong object"
            },
            {
              "icon": "",
              "label": "True para sa ==, False para sa is — magkaparehong laman pero magkaibang object sa memory"
            },
            {
              "icon": "",
              "label": "False para sa dalawa — ang hiwalay na literals ay hindi kailanman equal sa Python"
            },
            {
              "icon": "",
              "label": "True para sa is, False para sa == — sinusuri ng is ang value equality para sa listahan"
            }
          ]
        },
        {
          "question": "Sa Python 3, magiging ano ang resulta ng 7 / 2, at magiging ano ang resulta ng 7 // 2?",
          "options": [
            {
              "icon": "",
              "label": "3.5, tapos 3 — ang / ay palaging nagbabalik ng float, ang // ay nagfa-floor sa resulta"
            },
            {
              "icon": "",
              "label": "3, tapos 3.5 — ang / ay nagtu-truncate at ang // ay nagbabalik ng float"
            },
            {
              "icon": "",
              "label": "3.5, tapos 3.5 — parehong operator ay nagbabalik ng float sa Python 3"
            },
            {
              "icon": "",
              "label": "3, tapos 3 — parehong operator ay nagfa-floor sa resulta sa Python 3"
            }
          ]
        },
        {
          "question": "s = 'hello', pagkatapos ay tatakbuhin ninyo ang s[0] = 'H'. Ano ang mangyayari?",
          "options": [
            {
              "icon": "",
              "label": "magiging 'Hello' ang s"
            },
            {
              "icon": "",
              "label": "magiging 'Hhello' ang s dahil ang character ay ini-insert, hindi pinapalitan"
            },
            {
              "icon": "",
              "label": "TypeError — ang strings ay immutable at hindi sumusuporta sa item assignment"
            },
            {
              "icon": "",
              "label": "Wala — tahimik na binabalewala ang assignment at nananatiling 'hello' ang s"
            }
          ]
        },
        {
          "question": "x = [10, 20, 30, 40, 50]. Ano ang ibabalik ng 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' at age = 30. Ano ang gagawin ng f'{name} is {age}'?",
          "options": [
            {
              "icon": "",
              "label": "{name} is {age}"
            },
            {
              "icon": "",
              "label": "Ana is 30"
            },
            {
              "icon": "",
              "label": "name is age"
            },
            {
              "icon": "",
              "label": "TypeError, dahil kailangan ng f-strings ang format() method"
            }
          ]
        },
        {
          "question": "Magiging ano ang resulta ng 1 < 2 < 3?",
          "options": [
            {
              "icon": "",
              "label": "True — ini-chain ng Python ang mga comparison bilang (1 < 2) and (2 < 3)"
            },
            {
              "icon": "",
              "label": "False — ang chained comparisons ay ine-evaluate mula kaliwa papuntang kanan nang walang short-circuiting, na nagbibigay ng 1 < 2 < 3 -> 1 < True -> False"
            },
            {
              "icon": "",
              "label": "SyntaxError — hindi puwedeng i-chain ang mga comparison"
            },
            {
              "icon": "",
              "label": "3 — ibinabalik ng Python ang huling value sa chain"
            }
          ]
        },
        {
          "question": "Ano ang ibabalik ng bool([]), at ano ang ibabalik ng bool([0])?",
          "options": [
            {
              "icon": "",
              "label": "False, tapos False — ang anumang listahan na may laman na falsy values lang ay falsy"
            },
            {
              "icon": "",
              "label": "False, tapos True — ang empty list ay falsy, ang listahan na may isang element (kahit 0) ay truthy"
            },
            {
              "icon": "",
              "label": "True, tapos True — ang mga non-None object ay palaging truthy"
            },
            {
              "icon": "",
              "label": "True, tapos False — ang listahan ay truthy lang kapag empty"
            }
          ]
        },
        {
          "question": "May umiiral na module-level count = 0. Sa loob ng def increment(): count += 1; return count, tinawag ninyo ang increment(). Ano ang mangyayari?",
          "options": [
            {
              "icon": "",
              "label": "UnboundLocalError — ang pag-assign sa count kahit saan sa loob ng function ay ginagawa itong local, kaya sinusubukan ng count += 1 na basahin ang isang local variable bago pa ito ma-assign"
            },
            {
              "icon": "",
              "label": "Ibinabalik nito ang 1 at tinataasan ang module-level count papuntang 1"
            },
            {
              "icon": "",
              "label": "Ibinabalik nito ang 1 pero iniiwan ang module-level count sa 0"
            },
            {
              "icon": "",
              "label": "Nagtataas ito ng NameError dahil hindi kailanman na-declare ang count sa loob ng function"
            }
          ]
        },
        {
          "question": "def f(*args, **kwargs): return args, kwargs. Ano ang ibabalik ng 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 — hindi puwedeng paghaluin ang positional at keyword arguments sa isang tawag"
            }
          ]
        },
        {
          "question": "Ginawa ninyo ang funcs = [lambda: i for i in range(3)] sa loob ng loop. Ano ang ibabalik ng [f() for f in funcs]?",
          "options": [
            {
              "icon": "",
              "label": "[2, 2, 2] — hinahanap ng bawat lambda ang i sa oras na tawagin ito, at sa oras na iyon ay tapos na ang loop na ang i ay katumbas ng 2"
            },
            {
              "icon": "",
              "label": "[0, 1, 2] — kina-capture ng bawat lambda ang value ng i sa oras na ito ay nalikha"
            },
            {
              "icon": "",
              "label": "[0, 0, 0] — palaging kina-capture ng lambdas ang unang value na na-assign sa isang variable"
            },
            {
              "icon": "",
              "label": "NameError, dahil hindi na umiiral ang i kapag natapos na ang loop"
            }
          ]
        },
        {
          "question": "May function na naka-define na may @a direkta sa itaas ng @b, na nasa direkta sa itaas ng def f(): pass. Anong order ang pagka-apply ng decorators sa f?",
          "options": [
            {
              "icon": "",
              "label": "Una nang bina-balot ng b ang f, pagkatapos ay binabalot ng a ang resulta ng b — tumatakbo muna ang decorator na pinakamalapit sa function"
            },
            {
              "icon": "",
              "label": "Una nang binabalot ng a ang f, pagkatapos ay binabalot ng b ang resulta — ina-apply ang decorators mula taas papuntang baba"
            },
            {
              "icon": "",
              "label": "Parehong decorator ay bumabalot sa f nang independent at ang huling na-define lang ang may bisa"
            },
            {
              "icon": "",
              "label": "Nakadepende ito sa order kung saan na-import ang decorators, hindi sa posisyon nila sa code"
            }
          ]
        },
        {
          "question": "def f(a, *, b): return a + b. Alin sa mga tawag na ito ang gumagana?",
          "options": [
            {
              "icon": "",
              "label": "f(1, b=2) — kailangang ipasa ang b bilang keyword dahil sumusunod ito sa bare * sa signature"
            },
            {
              "icon": "",
              "label": "f(1, 2) — pinupunan ng positional arguments ang mga parameter mula kaliwa papuntang kanan anuman ang *"
            },
            {
              "icon": "",
              "label": "f(a=1, 2) — kailangang mauna ang keyword arguments"
            },
            {
              "icon": "",
              "label": "f(1) — optional ang b dahil sumusunod ito sa *"
            }
          ]
        },
        {
          "question": "May generator function na nag-yields ng 1, pagkatapos ay nag-yields ng 2, pagkatapos ay gumagawa ng return 99. Ano ang laman ng list(the_generator()), at ano ang mangyayari sa 99?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 99] — ang return sa loob ng isang generator ay kumikilos na parang isa pang yield"
            },
            {
              "icon": "",
              "label": "[99] — agad na nagko-override ang return sa anumang value na na-yield na"
            },
            {
              "icon": "",
              "label": "[1, 2] — ang return value ng isang generator ay nagiging value na naka-attach sa StopIteration na itinataas nito, hindi ito na-yield"
            },
            {
              "icon": "",
              "label": "RuntimeError, dahil hindi puwedeng maglaman ng return statement ang generators"
            }
          ]
        },
        {
          "question": "Sa loob ng isang outer() function, na-set ang x = 1, pagkatapos ang isang naka-nest na inner() ay gumagawa ng nonlocal x; x += 1, at tinatawag ng outer() ang inner() bago i-return ang x. Ano ang ibabalik ng outer()?",
          "options": [
            {
              "icon": "",
              "label": "1 — gumagana ang inner() sa sarili nitong local copy ng x, kaya hindi nagpapatuloy ang pagbabago"
            },
            {
              "icon": "",
              "label": "UnboundLocalError, dahil hindi na-declare ang x sa loob ng inner() bago ang nonlocal statement"
            },
            {
              "icon": "",
              "label": "SyntaxError — puwede lang gamitin ang nonlocal sa loob ng classes"
            },
            {
              "icon": "",
              "label": "2 — pinapayagan ng nonlocal ang inner() na baguhin ang x ng outer function sa halip na gumawa ng bagong local variable"
            }
          ]
        },
        {
          "question": "d = {'a': 1, 'b': 2}. Ano ang ibabalik ng d.get('c', 0), at nagdaragdag ba ito ng 'c' sa dictionary?",
          "options": [
            {
              "icon": "",
              "label": "0, at hindi — ibinabalik ng get() ang default nang hindi nagsisingit ng key"
            },
            {
              "icon": "",
              "label": "0, at oo — nagsisingit ang get() ng key kasama ang default value"
            },
            {
              "icon": "",
              "label": "KeyError, dahil hindi umiiral ang 'c'"
            },
            {
              "icon": "",
              "label": "None, at oo — palaging nagdaragdag ang get() ng mga missing key na may None value"
            }
          ]
        },
        {
          "question": "t = (1, 2, [3, 4]). Puwede ba ninyong patakbuhin ang t[2].append(5), at puwede ba ninyong patakbuhin ang t[0] = 10?",
          "options": [
            {
              "icon": "",
              "label": "Pareho itong gumagana — ang pag-nest ng listahan sa loob ng tuple ay ginagawang mutable ang buong tuple"
            },
            {
              "icon": "",
              "label": "Pareho itong nagtataas ng TypeError — walang anumang bagay sa loob ng tuple ang mababago kailanman"
            },
            {
              "icon": "",
              "label": "nagtataas ng TypeError ang t[2].append(5), pero gumagana ang t[0] = 10 dahil pinapayagan ng tuples ang reassignment ng unang element nito"
            },
            {
              "icon": "",
              "label": "gumagana ang t[2].append(5) dahil mutable ang listahan sa loob; nagtataas ng TypeError ang t[0] = 10 dahil immutable ang tuple mismo"
            }
          ]
        },
        {
          "question": "Alin sa mga ito ang nagbabalik ng iterator na kumu-compute ng values nang lazily sa halip na buuin ang buong sequence sa memory nang sabay-sabay: [x*x for x in range(1000000)] o (x*x for x in range(1000000))?",
          "options": [
            {
              "icon": "",
              "label": "Ang may parentheses, (x*x for x in range(1000000)) — iyon ay isang generator expression"
            },
            {
              "icon": "",
              "label": "Ang may square brackets — ang list comprehensions ay palaging lazy sa Python 3"
            },
            {
              "icon": "",
              "label": "Parehong lazy — ang tanging pagkakaiba ay ang type na ibinabalik sa dulo"
            },
            {
              "icon": "",
              "label": "Wala sa dalawa — pareho nilang binubuo agad ang buong sequence sa memory"
            }
          ]
        },
        {
          "question": "Ang isang try block ay naghahati sa zero, ang except ZeroDivisionError clause ay nag-print ng 'a', at ang finally clause ay nag-print ng 'b'. Ano ang mape-print, at anong order?",
          "options": [
            {
              "icon": "",
              "label": "b tapos a — palaging tumatakbo ang finally bago ang anumang except clause"
            },
            {
              "icon": "",
              "label": "a tapos b — tumatakbo muna ang tumutugmang except, at palaging tumatakbo ang finally pagkatapos anuman ang mangyari"
            },
            {
              "icon": "",
              "label": "b lang — hindi talaga nahuli ang exception, kaya hindi kailanman mape-print ang 'a'"
            },
            {
              "icon": "",
              "label": "a lang — nilalaktawan ang finally kapag na-handle na ang exception"
            }
          ]
        },
        {
          "question": "import copy; a = [[1, 2], [3, 4]]; b = copy.copy(a); b[0].append(99). Nagbabago rin ba ang a[0]?",
          "options": [
            {
              "icon": "",
              "label": "Hindi — palaging dinu-duplicate ng copy.copy() ang mga nested object din"
            },
            {
              "icon": "",
              "label": "Hindi — ang pag-append sa b[0] ay gumagawa ng bagong-bagong listahan para sa b[0] lang"
            },
            {
              "icon": "",
              "label": "Oo, pero dahil lang tinawag ang copy.copy() nang walang deepcopy argument"
            },
            {
              "icon": "",
              "label": "Oo — gumagawa ang copy.copy() ng shallow copy, kaya nananatiling shared ang nested lists sa pagitan ng a at b"
            }
          ]
        },
        {
          "question": "d = {'x': 1, 'y': 2}. Ano ang sinusuri ng 'x' in d — ang keys, ang values, o pareho?",
          "options": [
            {
              "icon": "",
              "label": "Ang values — sinusuri ng `in` kung ang 1 o 2 ay katumbas ng 'x'"
            },
            {
              "icon": "",
              "label": "Sinusuri parehong keys at values"
            },
            {
              "icon": "",
              "label": "Wala sa dalawa — palaging nagtataas ang `in` sa isang dict ng TypeError"
            },
            {
              "icon": "",
              "label": "Ang keys — sinusuri ng `in` sa isang dictionary ang membership sa mga keys nito, hindi sa mga values nito"
            }
          ]
        },
        {
          "question": "names = ['Al', 'Bo'] at scores = [10, 20]. Ano ang ibabalik ng 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": "ValueError, dahil nangangailangan ang zip ng tatlo o higit pang arguments"
            }
          ]
        },
        {
          "question": "May hawak na class-level list ang class Dog: tricks = [], at ang add_trick ay nag-a-append papunta sa self.tricks. Nalikha ang d1 = Dog() at d2 = Dog(), pagkatapos ay tumakbo ang d1.add_trick('sit'). Ano ang laman ng d2.tricks?",
          "options": [
            {
              "icon": "",
              "label": "[] — bawat instance ay nakakakuha ng sarili nitong independent copy ng tricks"
            },
            {
              "icon": "",
              "label": "['sit'] — ang tricks ay isang class-level list na shared ng bawat instance, kaya ang pagbabagong ginawa ni d1 ay makikita rin sa d2"
            },
            {
              "icon": "",
              "label": "TypeError — hindi puwedeng mag-append ang instances sa isang class attribute"
            },
            {
              "icon": "",
              "label": "['sit'] lang pagkatapos ulit tumakbo ang d2 = Dog()"
            }
          ]
        },
        {
          "question": "May class A na may def greet(self): return 'A'. May class B(A) na may def greet(self): return 'B' + super().greet(). Ano ang ibabalik ng B().greet()?",
          "options": [
            {
              "icon": "",
              "label": "'AB' — palaging tumatakbo ang super() bago ang sariling code ng subclass"
            },
            {
              "icon": "",
              "label": "'B' — binabalewala ang super().greet() dahil na-override na ng B ang greet"
            },
            {
              "icon": "",
              "label": "'BA' — tinatawag ng super().greet() ang method ng A at ang resulta nito ay ina-append sa 'B'"
            },
            {
              "icon": "",
              "label": "AttributeError, dahil walang nakikitang greet method ang A para sa B"
            }
          ]
        },
        {
          "question": "Nag-iimbak ang class Point ng self.x sa __init__ at wala nang ibang methods na naka-define. p1 = Point(1) at p2 = Point(1). Ano ang ibabalik ng p1 == p2 bilang default?",
          "options": [
            {
              "icon": "",
              "label": "True — inikukumpara ng Python ang lahat ng magkatugmang attributes bilang default"
            },
            {
              "icon": "",
              "label": "False — kung walang custom __eq__, babalik ang == sa identity comparison, at magkaibang object ang p1 at p2"
            },
            {
              "icon": "",
              "label": "True, pero dahil lang parehong nalikha ang mga object gamit ang parehong argument"
            },
            {
              "icon": "",
              "label": "TypeError, dahil hindi na-define ng Point ang __eq__"
            }
          ]
        },
        {
          "question": "Alin sa mga except clause sa ibaba ang mahuhuli rin sa ZeroDivisionError: except ArithmeticError, except ValueError, o except KeyError?",
          "options": [
            {
              "icon": "",
              "label": "except ValueError — tinuturing na invalid values ang division errors"
            },
            {
              "icon": "",
              "label": "except KeyError — ang anumang runtime error na hindi nakatali sa isang specific type ay babalik sa KeyError"
            },
            {
              "icon": "",
              "label": "Wala sa kanila — ang except ZeroDivisionError mismo lang ang makakahuli nito"
            },
            {
              "icon": "",
              "label": "except ArithmeticError — ang ZeroDivisionError ay isang subclass ng ArithmeticError"
            }
          ]
        },
        {
          "question": "Bumubukas kayo ng file gamit ang open('data.txt') as f: at may itinataas na exception habang nagbabasa sa loob ng block. Sarado pa rin ba ang file?",
          "options": [
            {
              "icon": "",
              "label": "Hindi — nananatiling bukas ang file dahil hindi natapos nang normal ang block"
            },
            {
              "icon": "",
              "label": "Kapag lang nagdagdag din kayo ng finally clause sa paligid ng with statement"
            },
            {
              "icon": "",
              "label": "Oo — tinatawag ng with statement ang __exit__ method ng file, na siyang nagsasara nito, kahit may exception na nangyari sa loob ng block"
            },
            {
              "icon": "",
              "label": "Nakadepende ito sa uri ng exception — tanging ang mga exception na nahuli sa ibang lugar ang nagti-trigger ng cleanup"
            }
          ]
        },
        {
          "question": "x = [3, 1, 2] at y = x.sort(). Ano ang hawak ng y?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3] — ibinabalik ng sort() ang bagong-isinaayos na listahan"
            },
            {
              "icon": "",
              "label": "None — nag-so-sort ang list.sort() in place at nagbabalik ng None; ang x mismo ay nagiging [1, 2, 3]"
            },
            {
              "icon": "",
              "label": "[3, 1, 2] — ibinabalik ng sort() ang orihinal na hindi pa naaayos na listahan at binabago lang ang internal order ng x"
            },
            {
              "icon": "",
              "label": "TypeError, dahil hindi puwedeng i-assign sa isang variable ang sort()"
            }
          ]
        },
        {
          "question": "Ano ang mangyayari kapag pinatakbo ninyo ang 'Score: ' + 42?",
          "options": [
            {
              "icon": "",
              "label": "'Score: 42' — awtomatikong kinu-convert ng Python ang numero sa loob ng isang + expression"
            },
            {
              "icon": "",
              "label": "'Score: ' — tahimik na binabalewala ang numero"
            },
            {
              "icon": "",
              "label": "42 — ang string ay pinipilit maging numero at idinaragdag"
            },
            {
              "icon": "",
              "label": "TypeError — hindi puwedeng i-concatenate nang direkta ang isang str at int, kailangang i-convert muna ang 42 gamit ang str()"
            }
          ]
        },
        {
          "question": "Kailangan ninyong suriin kung walang laman ang isang listahan na tinatawag na results. Alin ang idiomatic na paraan ng Python: if results == []: , if len(results) == 0: , o if not results: ?",
          "options": [
            {
              "icon": "",
              "label": "if results == []: — ito lang ang mapagkakatiwalaang paraan para makita ang isang empty list"
            },
            {
              "icon": "",
              "label": "if len(results) == 0: — kailangan ito dahil ang mga empty list ay truthy sa Python"
            },
            {
              "icon": "",
              "label": "Ang tatlo ay pantay na hindi kailanman ginagamit sa praktika; ang standard approach ay if results is None:"
            },
            {
              "icon": "",
              "label": "if not results: — umaasa ang Python idiom sa truthiness, at ang empty list ay falsy"
            }
          ]
        }
      ],
      "optionOrderVersion": "92945565db6c55da"
    }
  },
  "testNames": {
    "python-test": "Pagsusulit sa Python"
  }
}