{
  "assessmentTests": {
    "python_test": {
      "name": "पायथन टेस्ट",
      "desc": "सिंटेक्स, फ़ंक्शन, डेटा स्ट्रक्चर और ऑब्जेक्ट के व्यवहार पर 30 परिदृश्य-आधारित प्रश्न — पता लगाएँ कि क्या आपकी पायथन कौशल वह है जो नौकरी की पोस्टिंग पायथन प्रवीणता से माने।",
      "recommendation": "आपकी पायथन कौशल प्रोफ़ाइल",
      "results": {
        "beginner": {
          "name": "नौसिखिया",
          "desc": "आप एक छोटी स्क्रिप्ट का अनुसरण कर सकते हैं और उसमें मान बदल सकते हैं, लेकिन जो प्रश्न आप गलत करते हैं वे भाषा के अपने विशिष्ट व्यवहार के आसपास जमा होते हैं न कि सामान्य तर्क के — एक डिफ़ॉल्ट तर्क जो एक बार बनाया जाता है और फिर फिर से उपयोग किया जाता है, दो समान दिखने वाली सूचियों पर `is` बनाम `==`, एक वेरिएबल जो किसी फ़ंक्शन में कहीं भी असाइनमेंट के क्षण प्रोग्राम-स्थानीय हो जाता है। यह प्रोग्रामिंग में बुरे होने के बारे में नहीं है; ये पायथन-विशिष्ट नियम हैं जो दूसरी भाषाओं से आने वाले लोगों को उतना ही परेशान करते हैं जितना शुरुआत करने वाले। काम पर ये महत्वपूर्ण हैं क्योंकि प्रत्येक वह जगह है जहाँ एक बग उस कोड में छिपता है जो एक नजर में सही लगता है।",
          "recommendation": "इन तीन चीजों से शुरुआत करें, इसी क्रम में: म्यूटेबल डिफ़ॉल्ट तर्क (क्यों `basket=[]` खतरनाक है), `is` और `==` के बीच का अंतर, और एक फ़ंक्शन के अंदर वेरिएबल स्कोप कैसे काम करता है। docs.python.org पर आधिकारिक पायथन ट्यूटोरियल तीनों को सीधे कवर करता है, और \"Python gotchas\" शब्द प्रत्येक के काम किए हुए उदाहरण खोज देता है।"
        },
        "intermediate": {
          "name": "मध्यवर्ती",
          "desc": "आप रोज़मर्रा की स्क्रिप्टिंग में आराम से काम करते हैं — डेटा स्ट्रक्चर, कंट्रोल फ्लो, सीधे-सादे फ़ंक्शन — और दिनचर्या रखरखाव कार्य या किसी मौजूदा कोडबेस पर एक छोटी सी सुविधा से धीमे नहीं होंगे। यहाँ और उन्नत के बीच का अंतर ज़्यादातर इस बात में है कि जब पायथन की सुविधाएँ एक-दूसरे के साथ बातचीत करती हैं: एक उथली प्रति आपको नेस्टेड डेटा साझा छोड़ देती है जब आप उसे डुप्लिकेट होने की उम्मीद करते हैं, एक जनरेटर का रिटर्न मान शांति से अपने आउटपुट का हिस्सा नहीं बनता, डेकोरेटर एक ऐसे क्रम में स्टैक करते हैं जो गलत पाने में आसान है। ये वह तरह की बग हैं जो एक वरिष्ठ समीक्षक दस सेकंड में पकड़ता है और बाकी सब एक घंटा खोजने में लगाते हैं।",
          "recommendation": "ऑब्जेक्ट और पुनरावृत्ति आंतरिकता पर ध्यान दें: उथली बनाम गहरी प्रति, एक जनरेटर वास्तव में रिटर्न के साथ क्या करता है, और डेकोरेटर स्टैकिंग क्रम कैसे काम करता है। फिर क्लास बेसिक्स जो अधिकांश ट्यूटोरियल छोड़ते हैं — `__eq__` के बिना डिफ़ॉल्ट समानता, और क्यों एक म्यूटेबल क्लास विशेषता हर इंस्टेंस के बीच साझा की जाती है।"
        },
        "advanced": {
          "name": "उन्नत",
          "desc": "यह वह स्तर है जो अधिकांश नौकरी पोस्टिंग \"मजबूत पायथन\" से माने। आप बिना तलाशे सही टूल तक पहुँचते हैं, आप जानते हैं कि एक साझा स्थिति क्यों बदली न केवल यह कि वह बदली, और आप किसी और के फ़ंक्शन को पढ़ सकते हैं और इसका आउटपुट सही तरीके से भविष्यवाणी कर सकते हैं। जो यह बैंड शीर्ष से अलग करता है वह काम का रक्षात्मक पक्ष है: जानना कि दो सही दिखने वाले दृष्टिकोणों में से कौन एक बार क्लास विशेषता, एक कीवर्ड-केवल तर्क, या एक अपवाद पदानुक्रम शामिल होने के बाद गलत तरीके से काम करेगा।",
          "recommendation": "उन हिस्सों में धकेलें जो एक कोडबेस की रक्षा करते हैं जो अन्य लोग भी स्पर्श करते हैं: कीवर्ड-केवल तर्क API-डिजाइन विकल्प के रूप में एक सिंटैक्स जिज्ञासा के बजाय, अपवाद पदानुक्रम (ताकि except खंड त्रुटियों के सही परिवार को पकड़ें, केवल एक वर्ग नहीं), और संदर्भ प्रबंधक सफाई की गारंटी देने का मानक तरीका। रियल पायथन के गहन-गोता लेख सभी तीनों के लिए अगला अच्छा पड़ाव है।"
        },
        "expert": {
          "name": "विशेषज्ञ",
          "desc": "आपने हर खंड में शीर्ष पर स्कोर किया — कोर सिंटेक्स, फ़ंक्शन और स्कोप, डेटा संरचनाएँ, और ऑब्जेक्ट-ओरिएंटेड मुहावरे। व्यावहारिक रूप से, इसका मतलब है कि आप एक अजनबी की फ़ाइल को सौंपे जा सकते हैं और समझा सकते हैं कि वह आउटपुट क्यों पैदा करती है न केवल यह कि सिंटैक्स क्या कहता है, जो कठिन और अधिक मूल्यवान कौशल है। इस स्तर पर कच्ची भाषा शायद ही कभी आपके काम में सीमित करने वाला कारक होता है; सीमा आमतौर पर कोड के चारों ओर प्रणाली का आकार या आकार है।",
          "recommendation": "अब रिटर्न टूलिंग और समीक्षा में हैं: mypy या pyright के साथ स्टेटिक प्रकार की जांच, अनुमान लगाने के बजाय अनुकूलन से पहले प्रोफ़ाइलिंग, और इस श्रेणी की बग के लिए बिल्कुल सही अन्य लोगों के पुल अनुरोधों को पढ़ना — जो प्रत्येक परीक्षा को पास करते हैं और फिर भी एक विशिष्ट इनपुट के तहत गलत काम करते हैं। यदि आप एक भूमिका के लिए स्क्रीन किए जा रहे हैं, तो इस तरह की एक बग का वर्णन करें जो आपने पाई थी न कि भाषा सुविधाओं का नाम रखते हुए — यह तर्क प्रदर्शित करता है, केवल शब्दावली नहीं।"
        }
      },
      "questions": [
        {
          "question": "आप `def add_item(item, basket=[]): basket.append(item); return basket` लिखते हैं, फिर `add_item('a')` और `add_item('b')` दोनों को कॉल करते हैं, दोनों बार basket को छोड़ देते हैं। दूसरी कॉल क्या रिटर्न करती है?",
          "options": [
            {
              "icon": "",
              "label": "`['b']` — प्रत्येक कॉल डिफ़ॉल्ट रूप से एक ताज़ी खाली सूची प्राप्त करता है"
            },
            {
              "icon": "",
              "label": "`TypeError` — आपको एक basket तर्क की आपूर्ति करनी चाहिए"
            },
            {
              "icon": "",
              "label": "`['a', 'b']` — डिफ़ॉल्ट सूची एक बार बनाई जाती है और कॉल भर में फिर से उपयोग की जाती है"
            },
            {
              "icon": "",
              "label": "`['a']` फिर `['b']` दो स्वतंत्र एकल-आइटम सूचियों के रूप में"
            }
          ]
        },
        {
          "question": "`a = [1, 2, 3]` और `b = [1, 2, 3]`। `a == b` क्या रिटर्न करता है, और `a is b` क्या रिटर्न करता है?",
          "options": [
            {
              "icon": "",
              "label": "दोनों के लिए True — समान सूचियाँ हमेशा एक ही ऑब्जेक्ट होती हैं"
            },
            {
              "icon": "",
              "label": "`==` के लिए True, `is` के लिए False — समान सामग्री लेकिन मेमोरी में विभिन्न ऑब्जेक्ट"
            },
            {
              "icon": "",
              "label": "दोनों के लिए False — अलग शाब्दिक कभी भी पायथन में समान नहीं होते"
            },
            {
              "icon": "",
              "label": "`is` के लिए True, `==` के लिए False — `is` सूचियों के लिए मान समानता की जांच करता है"
            }
          ]
        },
        {
          "question": "पायथन 3 में, `7 / 2` किसका मूल्यांकन करता है, और `7 // 2` किसका मूल्यांकन करता है?",
          "options": [
            {
              "icon": "",
              "label": "`3.5`, फिर `3` — `/` हमेशा एक फ्लोट रिटर्न करता है, `//` परिणाम को फ़्लोर करता है"
            },
            {
              "icon": "",
              "label": "`3`, फिर `3.5` — `/` को छोटा करता है और `//` एक फ्लोट रिटर्न करता है"
            },
            {
              "icon": "",
              "label": "`3.5`, फिर `3.5` — दोनों ऑपरेटर पायथन 3 में एक फ्लोट रिटर्न करते हैं"
            },
            {
              "icon": "",
              "label": "`3`, फिर `3` — दोनों ऑपरेटर पायथन 3 में परिणाम को फ़्लोर करते हैं"
            }
          ]
        },
        {
          "question": "`s = 'hello'`, फिर आप `s[0] = 'H'` चलाते हैं। क्या होता है?",
          "options": [
            {
              "icon": "",
              "label": "`s` `'Hello'` हो जाता है"
            },
            {
              "icon": "",
              "label": "`s` `'Hhello'` हो जाता है क्योंकि वर्ण डाला जाता है, प्रतिस्थापित नहीं होता"
            },
            {
              "icon": "",
              "label": "`TypeError` — तार अपरिवर्तनीय हैं और आइटम असाइनमेंट का समर्थन नहीं करते"
            },
            {
              "icon": "",
              "label": "कुछ नहीं — असाइनमेंट चुपचाप अनदेखा किया जाता है और `s` `'hello'` रहता है"
            }
          ]
        },
        {
          "question": "`x = [10, 20, 30, 40, 50]`। `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'` और `age = 30`। `f'{name} is {age}'` क्या उत्पादन करता है?",
          "options": [
            {
              "icon": "",
              "label": "`{name} is {age}`"
            },
            {
              "icon": "",
              "label": "`Ana is 30`"
            },
            {
              "icon": "",
              "label": "`name is age`"
            },
            {
              "icon": "",
              "label": "एक `TypeError`, क्योंकि f-strings को `format()` विधि की आवश्यकता है"
            }
          ]
        },
        {
          "question": "`1 < 2 < 3` का मूल्यांकन क्या करता है?",
          "options": [
            {
              "icon": "",
              "label": "`True` — पायथन तुलनाओं को `(1 < 2) and (2 < 3)` के रूप में चेन करता है"
            },
            {
              "icon": "",
              "label": "`False` — चेन की गई तुलनाएँ बाएँ से दाएँ मूल्यांकित की जाती हैं बिना short-circuiting के, `1 < 2 < 3 -> 1 < True -> False` देता है"
            },
            {
              "icon": "",
              "label": "एक `SyntaxError` — तुलनाओं को चेन नहीं किया जा सकता"
            },
            {
              "icon": "",
              "label": "`3` — पायथन चेन में अंतिम मान रिटर्न करता है"
            }
          ]
        },
        {
          "question": "`bool([])` क्या रिटर्न करता है, और `bool([0])` क्या रिटर्न करता है?",
          "options": [
            {
              "icon": "",
              "label": "`False`, फिर `False` — केवल falsy मानों वाली कोई भी सूची falsy है"
            },
            {
              "icon": "",
              "label": "`False`, फिर `True` — एक खाली सूची falsy है, एक तत्व वाली सूची (यहाँ तक कि `0`) truthy है"
            },
            {
              "icon": "",
              "label": "`True`, फिर `True` — non-None ऑब्जेक्ट हमेशा truthy होते हैं"
            },
            {
              "icon": "",
              "label": "`True`, फिर `False` — एक सूची केवल तब truthy होती है जब खाली हो"
            }
          ]
        },
        {
          "question": "एक मॉड्यूल-स्तरीय `count = 0` मौजूद है। `def increment()` के अंदर: `count += 1; return count`, आप `increment()` को कॉल करते हैं। क्या होता है?",
          "options": [
            {
              "icon": "",
              "label": "`UnboundLocalError` — फ़ंक्शन में कहीं भी `count` को असाइन करना इसे स्थानीय बनाता है, इसलिए `count += 1` असाइन किए जाने से पहले एक स्थानीय वेरिएबल को पढ़ने का प्रयास करता है"
            },
            {
              "icon": "",
              "label": "यह `1` रिटर्न करता है और मॉड्यूल-स्तरीय `count` को `1` तक बढ़ाता है"
            },
            {
              "icon": "",
              "label": "यह `1` रिटर्न करता है लेकिन मॉड्यूल-स्तरीय `count` को `0` पर छोड़ता है"
            },
            {
              "icon": "",
              "label": "यह `NameError` उठाता है क्योंकि `count` को फ़ंक्शन के अंदर कभी घोषित नहीं किया गया था"
            }
          ]
        },
        {
          "question": "`def f(*args, **kwargs): return args, kwargs`। `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` — स्थितीय और कीवर्ड तर्कों को एक कॉल में मिश्रित नहीं किया जा सकता"
            }
          ]
        },
        {
          "question": "आप `funcs = [lambda: i for i in range(3)]` लूप में बनाते हैं। `[f() for f in funcs]` क्या रिटर्न करता है?",
          "options": [
            {
              "icon": "",
              "label": "`[2, 2, 2]` — प्रत्येक lambda कॉल किए जाने पर `i` को देखता है, और तब तक लूप `i` के बराबर `2` के साथ समाप्त हो गया है"
            },
            {
              "icon": "",
              "label": "`[0, 1, 2]` — प्रत्येक lambda इसे बनाए जाने के समय `i` का मान कैप्चर करता है"
            },
            {
              "icon": "",
              "label": "`[0, 0, 0]` — lambdas हमेशा एक वेरिएबल को असाइन किए गए पहले मान को कैप्चर करते हैं"
            },
            {
              "icon": "",
              "label": "एक `NameError`, क्योंकि `i` अब लूप समाप्त होने के बाद मौजूद नहीं है"
            }
          ]
        },
        {
          "question": "एक फ़ंक्शन को `@a` के साथ सीधे `@b` के ऊपर परिभाषित किया जाता है, जो सीधे `def f(): pass` के ऊपर बैठता है। किस क्रम में डेकोरेटर `f` पर लागू होते हैं?",
          "options": [
            {
              "icon": "",
              "label": "`b` पहले `f` को लपेटता है, फिर `a` `b` के परिणाम को लपेटता है — फ़ंक्शन के सबसे निकट का डेकोरेटर पहले चलता है"
            },
            {
              "icon": "",
              "label": "`a` पहले `f` को लपेटता है, फिर `b` परिणाम को लपेटता है — डेकोरेटर ऊपर से नीचे तक लागू होते हैं"
            },
            {
              "icon": "",
              "label": "दोनों डेकोरेटर `f` को स्वतंत्र रूप से लपेटते हैं और केवल अंतिम परिभाषित होता है"
            },
            {
              "icon": "",
              "label": "यह कोड में उनकी स्थिति के बजाय डेकोरेटर को आयात करने के क्रम पर निर्भर करता है"
            }
          ]
        },
        {
          "question": "`def f(a, *, b): return a + b`। इनमें से कौन सी कॉल काम करती है?",
          "options": [
            {
              "icon": "",
              "label": "`f(1, b=2)` — `b` को कीवर्ड द्वारा पास किया जाना चाहिए क्योंकि यह हस्ताक्षर में नंगे `*` के बाद आता है"
            },
            {
              "icon": "",
              "label": "`f(1, 2)` — स्थितीय तर्क `*` के बावजूद बाएँ से दाएँ पैरामीटर भरते हैं"
            },
            {
              "icon": "",
              "label": "`f(a=1, 2)` — कीवर्ड तर्कों को पहले आना चाहिए"
            },
            {
              "icon": "",
              "label": "`f(1)` — `b` वैकल्पिक है क्योंकि यह `*` का अनुसरण करता है"
            }
          ]
        },
        {
          "question": "एक जनरेटर फ़ंक्शन `1` को yield करता है, फिर `2` को yield करता है, फिर `return 99` करता है। `list(the_generator())` क्या सम्मिलित है, और `99` को क्या होता है?",
          "options": [
            {
              "icon": "",
              "label": "`[1, 2, 99]` — एक जनरेटर के अंदर return एक और yield की तरह व्यवहार करता है"
            },
            {
              "icon": "",
              "label": "`[99]` — return तुरंत किसी भी पहले से yield किए गए मानों को ओवरराइड करता है"
            },
            {
              "icon": "",
              "label": "`[1, 2]` — एक जनरेटर का return मान StopIteration से जुड़ा मान बन जाता है जो वह उठाता है, इसे yield नहीं किया जाता"
            },
            {
              "icon": "",
              "label": "एक `RuntimeError`, क्योंकि जनरेटर में return कथन नहीं हो सकता"
            }
          ]
        },
        {
          "question": "एक `outer()` फ़ंक्शन में, `x = 1` सेट किया जाता है, फिर एक नेस्टेड `inner()` `nonlocal x; x += 1` करता है, और `outer()` रिटर्न करने से पहले `inner()` को कॉल करता है। `outer()` क्या रिटर्न करता है?",
          "options": [
            {
              "icon": "",
              "label": "`1` — `inner()` `x` की अपनी स्थानीय प्रति पर काम करता है, इसलिए परिवर्तन बना नहीं रहता"
            },
            {
              "icon": "",
              "label": "एक `UnboundLocalError`, क्योंकि `x` nonlocal कथन से पहले `inner()` के अंदर घोषित नहीं है"
            },
            {
              "icon": "",
              "label": "एक `SyntaxError` — `nonlocal` केवल क्लास के अंदर उपयोग किया जा सकता है"
            },
            {
              "icon": "",
              "label": "`2` — `nonlocal` `inner()` को एक नया स्थानीय वेरिएबल बनाने के बजाय बाहरी फ़ंक्शन के `x` को संशोधित करने देता है"
            }
          ]
        },
        {
          "question": "`d = {'a': 1, 'b': 2}`। `d.get('c', 0)` क्या रिटर्न करता है, और क्या यह डिक्शनरी में `'c'` जोड़ता है?",
          "options": [
            {
              "icon": "",
              "label": "`0`, और नहीं — `get()` डिफ़ॉल्ट को कुंजी को डाले बिना रिटर्न करता है"
            },
            {
              "icon": "",
              "label": "`0`, और हाँ — `get()` कुंजी को डिफ़ॉल्ट मान के साथ डालता है"
            },
            {
              "icon": "",
              "label": "`KeyError`, क्योंकि `'c'` मौजूद नहीं है"
            },
            {
              "icon": "",
              "label": "`None`, और हाँ — `get()` हमेशा None मान के साथ अनुपस्थित कुंजियाँ जोड़ता है"
            }
          ]
        },
        {
          "question": "`t = (1, 2, [3, 4])`। क्या आप `t[2].append(5)` चला सकते हैं, और क्या आप `t[0] = 10` चला सकते हैं?",
          "options": [
            {
              "icon": "",
              "label": "दोनों काम करते हैं — एक tuple में एक सूची को नेस्ट करने से पूरा tuple म्यूटेबल हो जाता है"
            },
            {
              "icon": "",
              "label": "दोनों `TypeError` उठाते हैं — tuple के अंदर कुछ भी कभी नहीं बदला जा सकता"
            },
            {
              "icon": "",
              "label": "`t[2].append(5)` `TypeError` उठाता है, लेकिन `t[0] = 10` काम करता है क्योंकि tuple अपने पहले तत्व के पुनः असाइनमेंट की अनुमति देते हैं"
            },
            {
              "icon": "",
              "label": "`t[2].append(5)` काम करता है क्योंकि सूची म्यूटेबल है; `t[0] = 10` `TypeError` उठाता है क्योंकि tuple स्वयं अपरिवर्तनीय है"
            }
          ]
        },
        {
          "question": "इनमें से कौन एक पुनरावृत्ति रिटर्न करता है जो मूल्यों की गणना आलसी तरीके से करता है बजाय पूरे अनुक्रम को मेमोरी में बनाने के: `[x*x for x in range(1000000)]` या `(x*x for x in range(1000000))`?",
          "options": [
            {
              "icon": "",
              "label": "कोष्ठक वाला, `(x*x for x in range(1000000))` — वह एक जनरेटर अभिव्यक्ति है"
            },
            {
              "icon": "",
              "label": "वर्ग कोष्ठक वाला — सूची comprehensions पायथन 3 में हमेशा आलसी होते हैं"
            },
            {
              "icon": "",
              "label": "दोनों आलसी हैं — एकमात्र अंतर अंत में रिटर्न किए गए प्रकार का है"
            },
            {
              "icon": "",
              "label": "न ही — दोनों पूरे अनुक्रम को तुरंत मेमोरी में बनाते हैं"
            }
          ]
        },
        {
          "question": "एक try ब्लॉक शून्य से विभाजन करता है, `except ZeroDivisionError` खंड `'a'` प्रिंट करता है, और एक finally खंड `'b'` प्रिंट करता है। क्या प्रिंट होता है, और किस क्रम में?",
          "options": [
            {
              "icon": "",
              "label": "`b` फिर `a` — finally हमेशा किसी भी except खंड से पहले चलता है"
            },
            {
              "icon": "",
              "label": "`a` फिर `b` — मिलान करने वाला except पहले चलता है, और finally हमेशा बाद में चलता है चाहे कुछ भी हो"
            },
            {
              "icon": "",
              "label": "केवल `b` — अपवाद वास्तव में पकड़ा नहीं जाता, इसलिए `'a'` कभी प्रिंट नहीं होता"
            },
            {
              "icon": "",
              "label": "केवल `a` — finally को छोड़ दिया जाता है एक बार अपवाद को पहले से ही संभाला जा चुका है"
            }
          ]
        },
        {
          "question": "`import copy; a = [[1, 2], [3, 4]]; b = copy.copy(a); b[0].append(99)`। क्या `a[0]` भी बदलता है?",
          "options": [
            {
              "icon": "",
              "label": "नहीं — `copy.copy()` हमेशा नेस्टेड ऑब्जेक्ट को भी डुप्लिकेट करता है"
            },
            {
              "icon": "",
              "label": "नहीं — `b[0]` में append करना केवल `b[0]` के लिए एक बिल्कुल नई सूची बनाता है"
            },
            {
              "icon": "",
              "label": "हाँ, लेकिन केवल क्योंकि `copy.copy()` deepcopy तर्क के बिना कॉल किया गया था"
            },
            {
              "icon": "",
              "label": "हाँ — `copy.copy()` एक उथली प्रति बनाता है, इसलिए नेस्टेड सूचियाँ अभी भी `a` और `b` के बीच साझा की जाती हैं"
            }
          ]
        },
        {
          "question": "`d = {'x': 1, 'y': 2}`। `'x' in d` किसके विरुद्ध जांच करता है — कुंजियों के, मानों के, या दोनों के?",
          "options": [
            {
              "icon": "",
              "label": "मानों के — `in` जांचता है कि क्या `1` या `2` `'x'` के बराबर है"
            },
            {
              "icon": "",
              "label": "कुंजियों और मानों दोनों को जांचा जाता है"
            },
            {
              "icon": "",
              "label": "न ही — एक dict पर `in` हमेशा `TypeError` उठाता है"
            },
            {
              "icon": "",
              "label": "कुंजियों के — एक डिक्शनरी पर `in` इसकी कुंजियों के बीच सदस्यता का परीक्षण करता है, इसके मानों के बीच नहीं"
            }
          ]
        },
        {
          "question": "`names = ['Al', 'Bo']` और `scores = [10, 20]`। `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`, क्योंकि `zip` को तीन या अधिक तर्कों की आवश्यकता है"
            }
          ]
        },
        {
          "question": "`class Dog: tricks = []` एक क्लास-स्तरीय सूची रखता है, और `add_trick` को `self.tricks` में जोड़ता है। `d1 = Dog()` और `d2 = Dog()` दोनों बनाए जाते हैं, फिर `d1.add_trick('sit')` चलता है। `d2.tricks` में क्या है?",
          "options": [
            {
              "icon": "",
              "label": "`[]` — प्रत्येक इंस्टेंस को tricks की अपनी स्वतंत्र प्रति मिलती है"
            },
            {
              "icon": "",
              "label": "`['sit']` — `tricks` एक क्लास-स्तरीय सूची है जो हर इंस्टेंस द्वारा साझा की जाती है, इसलिए `d1` का परिवर्तन `d2` पर भी दिखाई देता है"
            },
            {
              "icon": "",
              "label": "एक `TypeError` — इंस्टेंस एक क्लास विशेषता में जोड़ नहीं सकते"
            },
            {
              "icon": "",
              "label": "`['sit']` केवल `d2 = Dog()` को फिर से चलाने के बाद"
            }
          ]
        },
        {
          "question": "`class A` के पास `def greet(self): return 'A'` है। `class B(A)` के पास `def greet(self): return 'B' + super().greet()` है। `B().greet()` क्या रिटर्न करता है?",
          "options": [
            {
              "icon": "",
              "label": "`'AB'` — `super()` हमेशा subclass के अपने कोड से पहले चलता है"
            },
            {
              "icon": "",
              "label": "`'B'` — `super().greet()` को अनदेखा किया जाता है क्योंकि `B` पहले से `greet` को ओवरराइड करता है"
            },
            {
              "icon": "",
              "label": "`'BA'` — `super().greet()` `A` की विधि को कॉल करता है और इसका परिणाम `'B'` में जोड़ा जाता है"
            },
            {
              "icon": "",
              "label": "एक `AttributeError`, क्योंकि `A` के पास `B` के लिए दिखाई देने वाली greet विधि नहीं है"
            }
          ]
        },
        {
          "question": "`class Point` __init__ में `self.x` को store करता है और अन्य विधियों को परिभाषित नहीं करता। `p1 = Point(1)` और `p2 = Point(1)`। डिफ़ॉल्ट रूप से `p1 == p2` क्या रिटर्न करता है?",
          "options": [
            {
              "icon": "",
              "label": "`True` — पायथन डिफ़ॉल्ट रूप से सभी मिलान करने वाली विशेषताओं की तुलना करता है"
            },
            {
              "icon": "",
              "label": "`False` — कस्टम `__eq__` के बिना, `==` पहचान तुलना पर वापस गिरता है, और `p1` और `p2` विभिन्न ऑब्जेक्ट हैं"
            },
            {
              "icon": "",
              "label": "`True`, लेकिन केवल क्योंकि दोनों ऑब्जेक्ट को एक ही तर्क के साथ बनाया गया था"
            },
            {
              "icon": "",
              "label": "एक `TypeError`, क्योंकि `Point` `__eq__` को परिभाषित नहीं करता"
            }
          ]
        },
        {
          "question": "नीचे कौन सा except खंड `ZeroDivisionError` को भी पकड़ेगा: `except ArithmeticError`, `except ValueError`, या `except KeyError`?",
          "options": [
            {
              "icon": "",
              "label": "`except ValueError` — विभाजन त्रुटियों को अमान्य मानों के रूप में माना जाता है"
            },
            {
              "icon": "",
              "label": "`except KeyError` — कोई भी रनटाइम त्रुटि एक विशिष्ट प्रकार से जुड़ी नहीं है `KeyError` पर वापस गिरती है"
            },
            {
              "icon": "",
              "label": "कोई भी नहीं — केवल `except ZeroDivisionError` स्वयं इसे पकड़ सकता है"
            },
            {
              "icon": "",
              "label": "`except ArithmeticError` — `ZeroDivisionError` `ArithmeticError` का एक subclass है"
            }
          ]
        },
        {
          "question": "आप `open('data.txt') as f:` के साथ एक फ़ाइल खोलते हैं और ब्लॉक के अंदर पढ़ते समय एक अपवाद उठाया जाता है। क्या फ़ाइल अभी भी बंद हो जाती है?",
          "options": [
            {
              "icon": "",
              "label": "नहीं — फ़ाइल खुली रहती है क्योंकि ब्लॉक सामान्य तरीके से समाप्त नहीं हुआ"
            },
            {
              "icon": "",
              "label": "केवल यदि आप with कथन के चारों ओर एक finally खंड भी जोड़ते हैं"
            },
            {
              "icon": "",
              "label": "हाँ — with कथन फ़ाइल की `__exit__` विधि को कॉल करता है, जो इसे बंद करता है, भले ही ब्लॉक के अंदर एक अपवाद हो"
            },
            {
              "icon": "",
              "label": "यह अपवाद प्रकार पर निर्भर करता है — केवल अपवाद जहाँ कहीं और पकड़े जाते हैं सफाई को ट्रिगर करते हैं"
            }
          ]
        },
        {
          "question": "`x = [3, 1, 2]` और `y = x.sort()`। `y` में क्या है?",
          "options": [
            {
              "icon": "",
              "label": "`[1, 2, 3]` — `sort()` नई सॉर्ट की गई सूची रिटर्न करता है"
            },
            {
              "icon": "",
              "label": "`None` — `list.sort()` जगह में सॉर्ट करता है और `None` रिटर्न करता है; `x` स्वयं `[1, 2, 3]` हो जाता है"
            },
            {
              "icon": "",
              "label": "`[3, 1, 2]` — `sort()` मूल unsorted सूची रिटर्न करता है और केवल `x` के आंतरिक क्रम को बदलता है"
            },
            {
              "icon": "",
              "label": "एक `TypeError`, क्योंकि `sort()` को एक वेरिएबल को असाइन नहीं किया जा सकता"
            }
          ]
        },
        {
          "question": "जब आप `'Score: ' + 42` चलाते हैं तो क्या होता है?",
          "options": [
            {
              "icon": "",
              "label": "`'Score: 42'` — पायथन एक `+` अभिव्यक्ति के अंदर संख्या को स्वचालित रूप से परिवर्तित करता है"
            },
            {
              "icon": "",
              "label": "`'Score: '` — संख्या को चुपचाप छोड़ दिया जाता है"
            },
            {
              "icon": "",
              "label": "`42` — स्ट्रिंग को एक संख्या में बाध्य किया जाता है और जोड़ा जाता है"
            },
            {
              "icon": "",
              "label": "`TypeError` — आप सीधे एक str और एक int को concatenate नहीं कर सकते, `42` को `str()` के साथ परिवर्तित किया जाना चाहिए"
            }
          ]
        },
        {
          "question": "आपको यह जांचने की आवश्यकता है कि क्या `results` नामक एक सूची खाली है। कौन सा idiomatic पायथन तरीका है: `if results == []:`, `if len(results) == 0:`, या `if not results:`?",
          "options": [
            {
              "icon": "",
              "label": "`if results == []:` — यह एक खाली सूची का पता लगाने का एकमात्र विश्वसनीय तरीका है"
            },
            {
              "icon": "",
              "label": "`if len(results) == 0:` — यह आवश्यक है क्योंकि खाली सूचियाँ पायथन में truthy हैं"
            },
            {
              "icon": "",
              "label": "तीनों को व्यवहार में कभी भी उपयोग नहीं किया जाता है; मानक दृष्टिकोण `if results is None:` है"
            },
            {
              "icon": "",
              "label": "`if not results:` — पायथन मुहावरा truthiness पर निर्भर करता है, और एक खाली सूची falsy है"
            }
          ]
        }
      ],
      "optionOrderVersion": "92945565db6c55da"
    }
  }
}