{
  "assessmentTests": {
    "python_test": {
      "name": "Python Testi",
      "desc": "Sintaksis, funksiyalar, ma'lumot strukturalari va ob'ekt xatti-harakati bo'yicha 30 ta stsenariy savoli — ish elanida \"Python professionalligi\" nimani bildirsa, sizning Python bilimingiz shunga mos kelishini aniqlang.",
      "recommendation": "Sizning Python ko'nikmalari profili",
      "results": {
        "beginner": {
          "name": "Boshlangiches",
          "desc": "Qisqa skriptni o'qiy olasiz va uning ichidagi qiymatlarni o'zgartiray olasiz, ammo siz o'tkazib yuborgan savollar umumiy mantiq bilan emas, balki tilning o'z xatti-harakati bilan bog'liq — bir marta yaratilgan va qayta ishlatiladigan default argument, bir xil ko'rinadigon ikki ro'yxatdagi is va ==, funksiyaning istalgan joyida tayinlanadigan vaqtda lokal bo'lib qoladigan o'zgaruvchi. Buning hammasi dasturlashda yomon bo'lish haqida emas; bu boshqa tillardan kelib tushganlar uchun ham, boshlangiches uchun ham bir xil shaklda muammo bo'ladigan Python-ga xos qoidalardir. Ular ishda muhim, chunki har biri — bu biroqqa to'g'ri ko'rinadigon kodda yashiringan xatoning joyi.",
          "recommendation": "Uchta narsadan boshlang, shu tartibda: o'zgaruvchan default argumentlar (nega basket=[] xavfli), is va == orasidagi farq, va o'zgaruvchi scope funksiya ichida qanday ishlashi. docs.python.org dagi rasmiy Python o'quv qo'llanmasi uchtalasini to'g'ridan-to'g'ri qamrab oladi, va \"Python gotchas\" atamasi har birining bajarilgan namunalarini beradi."
        },
        "intermediate": {
          "name": "O'rta daraja",
          "desc": "Siz kundalik scriptingni osongina bajaray olasiz — ma'lumot strukturalari, control flow, oddiy funksiyalar — va mavjud codebase da routine ishlar yoki kichik feature shu uchun sekinlashmaysiz. Buning Advanced orasidagi farq asosan Python-ning qulay funksiyalari bir-biri bilan qanday o'zaro ta'sir qilishida: shallow copy ichidagi ma'lumotlarni kutgandek nusxalangan joyda bagallash, generator-ning return qiymati ohista-sekin uning chiqishiga aylantirmasligi, decorator-lar stacking qilish tartibida ortga qaytarish oson. Bunday xatolar senior reviewer shunga 10 soniya ichida ishora qiladi va boshqalar bitta soat davomida qidiradi.",
          "recommendation": "Ob'ekt va iteration ichki qismlariga e'tibor bering: shallow va deep copy, generator aslida return bilan nima qilishi, va decorator stacking tartibining qanday ishlashi. Shunda ko'pchilik o'quv qo'llanmalarni o'tkazib ketadigan class asoslari — __eq__ qatlamasida default tenglik, va nega o'zgaruvchan class atributi har bir instance bo'ylab bagallangan."
        },
        "advanced": {
          "name": "Ilg'or",
          "desc": "Bu ko'p ish elanlarida \"kuchli Python\" deb atashadi. Siz ong bosmay to'g'ri vositani topasiz, nima uchun bag'langan state o'zgarganini bilasiz, va boshqa odam yozgan funksiyani o'qib uning chiqishini to'g'ri prognozlavasiz. Bu band ni topqoligini ata qiluvchi — ishning himoya tomoni: class atributi, keyword-only argument yoki exception hierarchy ishlatilganda ikkita to'g'ri ko'rinadigon yondashuv qaysi biri noto'g'ri bo'lishini bilish.",
          "recommendation": "Boshqa odamlar ham uni teginuvchi codebase-ni himaya qiluvchi qismlarga kirishni bosing: keyword-only argumentlar syntax ijodiyoti emas balki API-design tanlovi sifatida, exception ierarxiyasi (shuning uchun except klauzulari to'g'ri error oilasini ushlasa, faqat bitta klassni emas), va context manager-lar garantiya qilingan cleanup ning standart usuli sifatida. Real Python-ning chuqur-dalami maqolalari barcha uchta uchun yaxshi keyingi bosqich."
        },
        "expert": {
          "name": "Mutaxassis",
          "desc": "Siz har bir bo'lim bo'ylab yuqori ballga erishdingiz — core syntax, funksiyalar va scope, ma'lumot strukturalari, va ob'ekt-orientatsiyalangan idiomalar. Amaliy jihatdan, bu qiya odam-ning faylini berib ulashgan va uning nima uchun shu chiqishni ishlashini tushuntira olasizligingiz demak, faqat sintaksis nimani qilishini emas, bu qiyinroq va ko'proq qimmatli koʻnikma. Shu darajada xom til ozod ravishda ishni qisqartiruvchi omil bo'lmasdan; chegarasi odatda kod atrofidagi tizim o'lchami yoki shakli.",
          "recommendation": "Qaytarilganlari shu vaqtda tooling va review-da: static type checking mypy yoki pyright bilan, optimallashtirish oldin profilining, o'yin va boshqa adamning pull request-larini shunga o'xshash xatalar — barcha testlarni o'tib, shu bilan birga aniq input ostida noto'g'ri narsani amalga oshiradigan ushbu toifaning xatalarini o'qish. Agar rol uchun shu vaqtda filtrlansa, til o'ziga xos funksiyalarini emas balki shunga o'xshash xatoni topganligingizni tushuntirib ber — bu fikrlashning, faqat emas ham lug'atni namoy etadi."
        }
      },
      "questions": [
        {
          "question": "Siz def add_item(item, basket=[]): basket.append(item); return basket yozib, keyin add_item('a') va add_item('b') chaqirasiz, ikkala marta ham basket shunga qoldiring. Ikkinchi chaqiruv nima qaytaradi?",
          "options": [
            {
              "icon": "",
              "label": "['b'] — har bir chaqiruv default orqali yangi bo'sh ro'yxat oladi"
            },
            {
              "icon": "",
              "label": "TypeError — basket argument suplyatsiya qilish shart"
            },
            {
              "icon": "",
              "label": "['a', 'b'] — default ro'yxat bir marta yaratiladi va chaqiruvlar bo'ylab qayta ishlatilib turadi"
            },
            {
              "icon": "",
              "label": "['a'] keyin ['b'] ikkita mustaqil bitta-elem ro'yxat sifatida"
            }
          ]
        },
        {
          "question": "a = [1, 2, 3] va b = [1, 2, 3]. a == b nima qaytaradi, va a is b nima qaytaradi?",
          "options": [
            {
              "icon": "",
              "label": "Ikkalasi uchun True — bir xil ro'yxatlar har doim bir xil ob'ekt"
            },
            {
              "icon": "",
              "label": "== uchun True, is uchun False — teng tarkibi ammo xotiraning turli ob'ektlari"
            },
            {
              "icon": "",
              "label": "Ikkalasi uchun False — alohida literallar Python-da hech qachon teng emas"
            },
            {
              "icon": "",
              "label": "is uchun True, == uchun False — is ro'yxatlar uchun qiymat tengligi tekshiradi"
            }
          ]
        },
        {
          "question": "Python 3 da, 7 / 2 nima qiymatga teng, va 7 // 2 nima qiymatga teng?",
          "options": [
            {
              "icon": "",
              "label": "3.5, keyin 3 — / har doim float qaytaradi, // natijani qanday ortga o'tkazadi"
            },
            {
              "icon": "",
              "label": "3, keyin 3.5 — / kesiladi va // float qaytaradi"
            },
            {
              "icon": "",
              "label": "3.5, keyin 3.5 — ikkala operator Python 3-da float qaytaradi"
            },
            {
              "icon": "",
              "label": "3, keyin 3 — ikkala operator Python 3-da natijani qanday ortga o'tkazadi"
            }
          ]
        },
        {
          "question": "s = 'hello', keyin siz s[0] = 'H' ishlatib ishlatmaysiz. Nima bo'ladi?",
          "options": [
            {
              "icon": "",
              "label": "s 'Hello' bo'ladi"
            },
            {
              "icon": "",
              "label": "s 'Hhello' bo'ladi, chunki belgi almashtirish o'rniga kiritiladi"
            },
            {
              "icon": "",
              "label": "TypeError — stringlar o'zgarmas va element tayinlashni qo'llamaydi"
            },
            {
              "icon": "",
              "label": "Hech nima — tayinlash jim-jami e'tiborsiz qoldiriladi va s 'hello' qoladi"
            }
          ]
        },
        {
          "question": "x = [10, 20, 30, 40, 50]. x[1:4] nima qaytaradi?",
          "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' va age = 30. f'{name} is {age}' nima ishlab chiqaradi?",
          "options": [
            {
              "icon": "",
              "label": "{name} is {age}"
            },
            {
              "icon": "",
              "label": "Ana is 30"
            },
            {
              "icon": "",
              "label": "name is age"
            },
            {
              "icon": "",
              "label": "TypeError, chunki f-stringlar format() methodini talab qiladi"
            }
          ]
        },
        {
          "question": "1 < 2 < 3 nima qiymatga teng?",
          "options": [
            {
              "icon": "",
              "label": "True — Python taqqoslashlarni (1 < 2) va (2 < 3) sifatida zanjirga soladi"
            },
            {
              "icon": "",
              "label": "False — zanjirga solishtirilgan taqqoslashlar short-circuiting qilmasdan chapdan o'ngga baholanadi, 1 < 2 < 3 -> 1 < True -> False beradi"
            },
            {
              "icon": "",
              "label": "SyntaxError — taqqoslashlarni zanjirga solib bo'lmaydi"
            },
            {
              "icon": "",
              "label": "3 — Python zanjirlashning oxirgi qiymatini qaytaradi"
            }
          ]
        },
        {
          "question": "bool([]) nima qaytaradi, va bool([0]) nima qaytaradi?",
          "options": [
            {
              "icon": "",
              "label": "False, keyin False — faqat yolg'on qiymatlarni o'z ichiga olgan har qanday ro'yxat yolg'on"
            },
            {
              "icon": "",
              "label": "False, keyin True — bo'sh ro'yxat yolg'on, bitta elementni o'z ichiga olgan ro'yxat (hatto 0 ham) to'g'ri"
            },
            {
              "icon": "",
              "label": "True, keyin True — None-ga teng bo'lmagan ob'ektlar har doim to'g'ri"
            },
            {
              "icon": "",
              "label": "True, keyin False — ro'yxat faqat bo'sh bo'lganda to'g'ri"
            }
          ]
        },
        {
          "question": "Module-darajasida count = 0 mavjud. def increment() ichida: count += 1; return count, va siz increment() chaqirasiz. Nima bo'ladi?",
          "options": [
            {
              "icon": "",
              "label": "UnboundLocalError — funksiyaning istalgan joyida countga tayinlash uni lokal qiladi, shuning uchun count += 1 tayinlanishidan oldin lokal o'zgaruvchini o'qishga harakat qiladi"
            },
            {
              "icon": "",
              "label": "U 1 ni qaytaradi va module-darajasidagi countni 1 ga ko'taraydi"
            },
            {
              "icon": "",
              "label": "U 1 ni qaytaradi, ammo module-darajasidagi countni 0-da qoldiradi"
            },
            {
              "icon": "",
              "label": "NameError, chunki count funksiya ichida hech qachon e'lon qilinmadi"
            }
          ]
        },
        {
          "question": "def f(*args, **kwargs): return args, kwargs. f(1, 2, x=3) nima qaytaradi?",
          "options": [
            {
              "icon": "",
              "label": "([1, 2], {'x': 3})"
            },
            {
              "icon": "",
              "label": "((1, 2), {'x': 3})"
            },
            {
              "icon": "",
              "label": "(1, 2, {'x': 3})"
            },
            {
              "icon": "",
              "label": "TypeError — positional va keyword argumentlarni bitta chaqiruvda aralashtirib bo'lmaydi"
            }
          ]
        },
        {
          "question": "Siz funcs = [lambda: i for i in range(3)] zanjirlashda tuzasiz. [f() for f in funcs] nima qaytaradi?",
          "options": [
            {
              "icon": "",
              "label": "[2, 2, 2] — har bir lambda chaqiruvda i qidiraydi, va u vaqtga kelib zanjirlash i 2 ga teng bilan tugagan"
            },
            {
              "icon": "",
              "label": "[0, 1, 2] — har bir lambda uni yaratilganda i qiymatini ushlaydi"
            },
            {
              "icon": "",
              "label": "[0, 0, 0] — lambdalar har doim o'zgaruvchiga tayinlangan birinchi qiymatni ushlaydi"
            },
            {
              "icon": "",
              "label": "NameError, chunki zanjirlash tugagach i endi mavjud emas"
            }
          ]
        },
        {
          "question": "Funksiya @a bilan to'g'ridan-to'g'ri @b ustiga e'lon qilinadi, bu def f(): pass ustiga to'g'ridan-to'g'ri o'tiraydi. Decorator-lar f-ga qanday tartibda qo'llaniladi?",
          "options": [
            {
              "icon": "",
              "label": "b birinchi f ni o'rash, keyin a b natijasini o'rash — funksiyaga eng yaqin decorator birinchi ishlaydi"
            },
            {
              "icon": "",
              "label": "a birinchi f ni o'rash, keyin b natijasini o'rash — decorator-lar tepaidan pastga qo'llaniladi"
            },
            {
              "icon": "",
              "label": "Ikkala decorator f ni mustaqil ravishda o'rash, va faqat oxirgi belgilangan bitta ta'sir ko'rsatadi"
            },
            {
              "icon": "",
              "label": "Bu decorator-larni qanday import qilinganigiga bog'liq, kodda ularning o'riniga emas"
            }
          ]
        },
        {
          "question": "def f(a, *, b): return a + b. Quyidagi chaqiruvlardan qaysi biri ishlaydi?",
          "options": [
            {
              "icon": "",
              "label": "f(1, b=2) — b signature ichidagi bare * dan keyin bo'lgani uchun keyword orqali o'tkazilishi kerak"
            },
            {
              "icon": "",
              "label": "f(1, 2) — positional argumentlar * ga qaramay chapdan o'ngga parametrlarni to'ldiradi"
            },
            {
              "icon": "",
              "label": "f(a=1, 2) — keyword argumentlar birinchi kelishi kerak"
            },
            {
              "icon": "",
              "label": "f(1) — b * dan keyin kelishi uchun ixtiyoriy"
            }
          ]
        },
        {
          "question": "Generator funksiya yields 1, keyin yields 2, keyin return 99 qiladi. list(the_generator()) nima o'z ichiga oladi, va 99 bilan nima bo'ladi?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 99] — generator ichidagi return bitta ko'proq yield kabi ishlaydi"
            },
            {
              "icon": "",
              "label": "[99] — return allaqachon yield qiligan qiymatlarni darhol bekor qiladi"
            },
            {
              "icon": "",
              "label": "[1, 2] — generator-ning return qiymati u ko'taradigan StopIteration-ga biriktiradi, u yield qilinmaydi"
            },
            {
              "icon": "",
              "label": "RuntimeError, chunki generator-lar return statementni o'z ichiga ola olmaydi"
            }
          ]
        },
        {
          "question": "Outer() funksiyada x = 1 o'rnatiladi, keyin nested inner() nonlocal x; x += 1 qiladi, va outer() inner() chaqiradi qaytarishdan oldin x. Outer() nima qaytaradi?",
          "options": [
            {
              "icon": "",
              "label": "1 — inner() x-ning o'z lokal nushasida ishlaydi, shuning uchun o'zgarish saqlanmaydi"
            },
            {
              "icon": "",
              "label": "UnboundLocalError, chunki x inner() ichida nonlocal statement-dan oldin e'lon qilinmadi"
            },
            {
              "icon": "",
              "label": "SyntaxError — nonlocal faqat klasslar ichida ishlatilishi mumkin"
            },
            {
              "icon": "",
              "label": "2 — nonlocal inner() ning o'z lokal o'zgaruvchisini yaratmasdan o'rniga outer funksiya-ning x ini o'zgartirishga ruxsat beradi"
            }
          ]
        },
        {
          "question": "d = {'a': 1, 'b': 2}. d.get('c', 0) nima qaytaradi, va u 'c' ni dictionary-ga qo'shaydimi?",
          "options": [
            {
              "icon": "",
              "label": "0, va yo'q — get() default ni key kiritmasdan qaytaradi"
            },
            {
              "icon": "",
              "label": "0, va ha — get() key ni default qiymat bilan kiritadi"
            },
            {
              "icon": "",
              "label": "KeyError, chunki 'c' mavjud emas"
            },
            {
              "icon": "",
              "label": "None, va ha — get() har doim yo'q qo'llanmalarni None qiymati bilan qo'shadi"
            }
          ]
        },
        {
          "question": "t = (1, 2, [3, 4]). Siz t[2].append(5) ishlatib ishlatay olasiz, va siz t[0] = 10 ishlatay olasiz?",
          "options": [
            {
              "icon": "",
              "label": "Ikkalasi ham ishlaydi — tuple ichiga ro'yxat joylastirish butun tuple-ni o'zgaruvchan qiladi"
            },
            {
              "icon": "",
              "label": "Ikkalasi ham TypeError ko'taraydi — tuple ichidagi hech nima hech qachon o'zgartirilmaydi"
            },
            {
              "icon": "",
              "label": "t[2].append(5) TypeError ko'taraydi, ammo t[0] = 10 ishlaydi, chunki tuple-lar ularning birinchi elementini qayta tayinlashga ruxsat beradi"
            },
            {
              "icon": "",
              "label": "t[2].append(5) ishlaydi, chunki ro'yxat o'zgaruvchan; t[0] = 10 TypeError ko'taraydi, chunki tuple o'zi o'zgarmas"
            }
          ]
        },
        {
          "question": "Qaysi biri butun ketma-ketlikni xotirada yaratish o'rniga noqulay ravishda qiymatlarni hisoblash iteratorini qaytaradi: [x*x for x in range(1000000)] yoki (x*x for x in range(1000000))?",
          "options": [
            {
              "icon": "",
              "label": "Qavsli biri, (x*x for x in range(1000000)) — bu generator ifodasi"
            },
            {
              "icon": "",
              "label": "Kvadrat qavsli biri — list comprehensions Python 3-da har doim noqulay"
            },
            {
              "icon": "",
              "label": "Ikkalasi ham noqulay — yagona farq oxirida qaytarilgan tur"
            },
            {
              "icon": "",
              "label": "Hech biri — ikkalasi ham darhol butun ketma-ketlikni xotirada yaratadi"
            }
          ]
        },
        {
          "question": "try bloki bo'lgan nolga bo'linadi, except ZeroDivisionError klauzula 'a' ni bosadi, va finally klauzula 'b' ni bosadi. Nima bosadi, va qanday tartibda?",
          "options": [
            {
              "icon": "",
              "label": "b keyin a — finally har doim istalgan except klauzuladan oldin ishlaydi"
            },
            {
              "icon": "",
              "label": "a keyin b — mos except birinchi ishlaydi, va finally har doim juda ko'proq ko'proq baham kelib chiqadi"
            },
            {
              "icon": "",
              "label": "Faqat b — exception aslida ushlangan emas, shuning uchun 'a' hech qachon bosadi emas"
            },
            {
              "icon": "",
              "label": "Faqat a — finally exception allaqachon boshqarish keyin o'tkazib yuboriladi"
            }
          ]
        },
        {
          "question": "import copy; a = [[1, 2], [3, 4]]; b = copy.copy(a); b[0].append(99). a[0] ham o'zgaradimi?",
          "options": [
            {
              "icon": "",
              "label": "Yo'q — copy.copy() har doim nested ob'ektlarni ham nusxalaydi"
            },
            {
              "icon": "",
              "label": "Yo'q — b[0]-ga qo'shish b[0]-ning faqat yangi ro'yxatini yaratadi"
            },
            {
              "icon": "",
              "label": "Ha, ammo faqat copy.copy() deepcopy argument qilmasdan chaqirilgani uchun"
            },
            {
              "icon": "",
              "label": "Ha — copy.copy() shallow nusxa yaratadi, shuning uchun nested ro'yxatlar a va b o'rtasida ham bagallangan"
            }
          ]
        },
        {
          "question": "d = {'x': 1, 'y': 2}. 'x' in d nima-ga tekshiradi — keys, values, yoki ikkalasi?",
          "options": [
            {
              "icon": "",
              "label": "Values-ga — `in` 1 yoki 2 'x' ga teng bo'lmasini tekshiradi"
            },
            {
              "icon": "",
              "label": "Keys va values ham tekshiriladi"
            },
            {
              "icon": "",
              "label": "Hech biri — `in` dict-da har doim TypeError ko'taraydi"
            },
            {
              "icon": "",
              "label": "Keys-ga — `in` dictionary-da membership uning key-lar orasida sinovlar, uning values orasida emas"
            }
          ]
        },
        {
          "question": "names = ['Al', 'Bo'] va scores = [10, 20]. list(zip(names, scores)) nima qaytaradi?",
          "options": [
            {
              "icon": "",
              "label": "[('Al', 'Bo'), (10, 20)]"
            },
            {
              "icon": "",
              "label": "['Al', 10, 'Bo', 20]"
            },
            {
              "icon": "",
              "label": "[('Al', 10), ('Bo', 20)]"
            },
            {
              "icon": "",
              "label": "ValueError, chunki zip uchta yoki undan ko'p argumentlarni talab qiladi"
            }
          ]
        },
        {
          "question": "class Dog: tricks = [] class-darajasidagi ro'yxatni o'z ichiga oladi, va add_trick self.tricks-ga qo'shadi. d1 = Dog() va d2 = Dog() ikkalasi ham yaratildi, keyin d1.add_trick('sit') ishlaydi. d2.tricks nima o'z ichiga oladi?",
          "options": [
            {
              "icon": "",
              "label": "[] — har bir instance tricks-ning o'z mustaqil nusxasini oladi"
            },
            {
              "icon": "",
              "label": "['sit'] — tricks class-darajasidagi ro'yxat, har bir instance-ni bagallanganligi uchun d1-ning o'zgarishi d2-da ham ko'rinyapti"
            },
            {
              "icon": "",
              "label": "TypeError — instancelar class atributiga qo'sha olmaydi"
            },
            {
              "icon": "",
              "label": "['sit'] faqat d2 = Dog() qayta ishlatilib turadi"
            }
          ]
        },
        {
          "question": "class A def greet(self): return 'A' ni o'z ichiga oladi. class B(A) def greet(self): return 'B' + super().greet() ni o'z ichiga oladi. B().greet() nima qaytaradi?",
          "options": [
            {
              "icon": "",
              "label": "\"BA\" — super() B-ning o'z kodidan birinchi ishlaydi"
            },
            {
              "icon": "",
              "label": "\"B\" — super().greet() e'tiborsiz qoldiriladi, chunki B allaqachon greet-ni bekor qiladi"
            },
            {
              "icon": "",
              "label": "\"BA\" — super().greet() A-ning method-ni chaqiradi va uning natijasi 'B'-ga qo'shiladi"
            },
            {
              "icon": "",
              "label": "AttributeError, chunki A B-ga ko'rinyapti greet method-si yo'q"
            }
          ]
        },
        {
          "question": "class Point __init__ ichida self.x saqlaydi va boshqa methodlar e'lon qilmaydi. p1 = Point(1) va p2 = Point(1). Default-da p1 == p2 nima qaytaradi?",
          "options": [
            {
              "icon": "",
              "label": "True — Python default-da barcha mos atributlarni taqqoslaydi"
            },
            {
              "icon": "",
              "label": "False — custom __eq__ qilmasdan, == identity taqqoslashga o'tadi, va p1 va p2 turli ob'ektlar"
            },
            {
              "icon": "",
              "label": "True, ammo faqat chunki ikkala ob'ekt bir xil argument bilan yaratildi"
            },
            {
              "icon": "",
              "label": "TypeError, chunki Point __eq__ e'lon qilmadi"
            }
          ]
        },
        {
          "question": "Quyida qaysi except klauzula ZeroDivisionError ni ham ushlaydi: except ArithmeticError, except ValueError, yoki except KeyError?",
          "options": [
            {
              "icon": "",
              "label": "except ValueError — bo'lish xatolari invalid qiymatlar deb qabul qilinadi"
            },
            {
              "icon": "",
              "label": "except KeyError — har qanday runtime error aniq turga bog'liq emas, KeyError-ga qayta tushadi"
            },
            {
              "icon": "",
              "label": "Hech biri — faqat except ZeroDivisionError o'zi uni ushlaya oladi"
            },
            {
              "icon": "",
              "label": "except ArithmeticError — ZeroDivisionError ArithmeticError subclassi"
            }
          ]
        },
        {
          "question": "Siz open('data.txt') as f: bilan fayl ochib, blok ichida o'qish vaqtida exception ko'tariladi. File ham yopiladi?",
          "options": [
            {
              "icon": "",
              "label": "Yo'q — blok normal tubingda tugamadi, chunki file ochiq qoladi"
            },
            {
              "icon": "",
              "label": "Faqat agar siz with statement atrofida finally klauzulani qo'shsangiz"
            },
            {
              "icon": "",
              "label": "Ha — with statement file-ning __exit__ method-ni chaqiradi, bu uni yopadi, blok ichida exception bo'lsa ham"
            },
            {
              "icon": "",
              "label": "Bu exception turi-ga bog'liq — faqat boshqarib qo'yilgan exception-lar cleanup trigger"
            }
          ]
        },
        {
          "question": "x = [3, 1, 2] va y = x.sort(). y nima o'z ichiga oladi?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3] — sort() yangi sartilab qilingan ro'yxatni qaytaradi"
            },
            {
              "icon": "",
              "label": "None — list.sort() joyida sartilab turadi va None qaytaradi; x o'zi [1, 2, 3] bo'ladi"
            },
            {
              "icon": "",
              "label": "[3, 1, 2] — sort() asl unsorted ro'yxatni qaytaradi va x-ning ichki tartibini o'zgartiradi"
            },
            {
              "icon": "",
              "label": "TypeError, chunki sort() o'zgaruvchiga tayinlash mumkin emas"
            }
          ]
        },
        {
          "question": "'Score: ' + 42 ishlatib ishlatganda nima bo'ladi?",
          "options": [
            {
              "icon": "",
              "label": "'Score: 42' — Python + ifodasi ichida raqamni avtomatik ravishda o'zgartirib turadi"
            },
            {
              "icon": "",
              "label": "'Score: ' — raqam jim-jali o'tkazib yuboriladi"
            },
            {
              "icon": "",
              "label": "42 — string raqamga majbur qilinadi va qo'shiladi"
            },
            {
              "icon": "",
              "label": "TypeError — siz str va int-ni to'g'ridan-to'g'ri ketma-ketlikda ola olmaysiz, 42 str() bilan o'zgartirilishi kerak"
            }
          ]
        },
        {
          "question": "Siz results bo'lgan ro'yxatning bo'sh bo'lishini tekshirishlari lozim. Idiomatic Python usuli qaysi: if results == []: , if len(results) == 0: , yoki if not results: ?",
          "options": [
            {
              "icon": "",
              "label": "if results == []: — bu bo'sh ro'yxatni aniqlashning yagona ishonch mumkin yo'li"
            },
            {
              "icon": "",
              "label": "if len(results) == 0: — bu talab, chunki bo'sh ro'yxatlar Python-da haq"
            },
            {
              "icon": "",
              "label": "Barcha uchta amaliyotda hech qachon ishlatilmaydi; standart yondashuv if results is None:"
            },
            {
              "icon": "",
              "label": "if not results: — Python idioma haqiqatga tayanadi, va bo'sh ro'yxat yolg'on"
            }
          ]
        }
      ],
      "optionOrderVersion": "92945565db6c55da"
    }
  }
}