{
  "assessmentTests": {
    "python_test": {
      "name": "Python चाचणी",
      "desc": "सिंटॅक्स, फंक्शन्स, डेटा स्ट्रक्चर्स आणि ऑब्जेक्टच्या वर्तनावरील 30 प्रसंगाधारित प्रश्न — नोकरीच्या जाहिरातीत Python प्रवीणता म्हणजे जे अपेक्षित असते, त्याच्याशी तुमचे Python जुळते का ते जाणून घ्या.",
      "recommendation": "तुमचे Python कौशल्य प्रोफाइल",
      "results": {
        "beginner": {
          "name": "नवशिके",
          "desc": "तुम्ही एखादी छोटी स्क्रिप्ट समजून घेऊ शकता आणि त्यातील व्हॅल्यू बदलू शकता, पण तुमच्याकडून चुकलेले प्रश्न सामान्य लॉजिकऐवजी भाषेच्या स्वतःच्या विशिष्ट वर्तनाभोवती केंद्रित आहेत — एकदाच तयार होऊन पुन्हा वापरला जाणारा डिफॉल्ट आर्ग्युमेंट, दिसायला सारख्या दोन लिस्टवर is विरुद्ध ==, आणि फंक्शनमध्ये कुठेही असाइन केल्याक्षणी लोकल बनणारे व्हेरिएबल. हे सर्व प्रोग्रामिंगमध्ये कमकुवत असण्याबद्दल नाही; हे Python-विशिष्ट नियम आहेत, जे इतर भाषांमधून आलेल्या लोकांनाही नवशिक्यांइतकेच अडचणीत आणतात. कामाच्या ठिकाणी ते महत्त्वाचे ठरतात, कारण त्यातील प्रत्येक नियम म्हणजे वरवर बरोबर दिसणाऱ्या कोडमध्ये बग लपण्याची जागा आहे.",
          "recommendation": "तीन गोष्टींपासून, याच क्रमाने सुरुवात करा: म्युटेबल डिफॉल्ट आर्ग्युमेंट्स (basket=[] धोकादायक का आहे), is आणि == मधील फरक, आणि फंक्शनमध्ये व्हेरिएबल स्कोप कसा काम करतो. docs.python.org वरील अधिकृत Python ट्युटोरियल या तिन्ही गोष्टी थेट समजावून सांगते, आणि \"Python gotchas\" हा शब्द शोधल्यास प्रत्येकाची सोडवलेली उदाहरणे मिळतात."
        },
        "intermediate": {
          "name": "मध्यम",
          "desc": "तुम्ही रोजची स्क्रिप्टिंगची कामे सहजपणे हाताळता — डेटा स्ट्रक्चर्स, कंट्रोल फ्लो, सोपी फंक्शन्स — आणि नेहमीच्या देखभालीच्या कामात किंवा विद्यमान कोडबेसवरील लहान फीचरमध्ये तुमचा वेग मंदावणार नाही. येथून प्रगत पातळीपर्यंतचे अंतर बहुतेक वेळा Python ची सोयीची वैशिष्ट्ये एकमेकांशी कशी संवाद साधतात यात आहे: शॅलो कॉपीमुळे नेस्टेड डेटा डुप्लिकेट होईल अशी अपेक्षा असताना तो सामायिक राहणे, जनरेटरची रिटर्न व्हॅल्यू त्याच्या आउटपुटचा भाग न बनता शांतपणे गायब होणे, आणि डेकोरेटर्स उलट क्रमात रचले जाणे सहज घडू शकते. असे बग सीनियर रिव्ह्यूअर दहा सेकंदांत शोधतो आणि इतर सगळे तासभर त्यांच्या मागे लागतात.",
          "recommendation": "ऑब्जेक्ट आणि इटरेशनच्या अंतर्गत कार्यप्रणालीवर लक्ष केंद्रित करा: शॅलो कॉपी विरुद्ध डीप कॉपी, जनरेटर return चे प्रत्यक्षात काय करतो, आणि डेकोरेटर्सचा स्टॅकिंग क्रम कसा काम करतो. त्यानंतर बहुतेक ट्युटोरियल्स वगळतात अशा क्लासच्या मूलभूत गोष्टी शिका — __eq__ नसताना डिफॉल्ट समानता, आणि म्युटेबल क्लास अॅट्रिब्यूट प्रत्येक इन्स्टन्समध्ये सामायिक का असतो."
        },
        "advanced": {
          "name": "प्रगत",
          "desc": "बहुतेक नोकरीच्या जाहिराती \"दमदार Python\" म्हणजे हीच पातळी समजतात. योग्य साधन शोधाशोध न करता तुमच्या हाताशी येते, एखादी सामायिक स्थिती बदलली एवढेच नव्हे, तर ती का बदलली हे तुम्हाला माहीत असते, आणि दुसऱ्याचे फंक्शन वाचून त्याचे आउटपुट बरोबर ओळखू शकता. या पातळीला सर्वोच्च पातळीपासून वेगळे करते ते कामाचे बचावात्मक अंग: क्लास अॅट्रिब्यूट, कीवर्ड-ओन्ली आर्ग्युमेंट किंवा एक्सेप्शन हायरार्की यांचा समावेश असताना, बरोबर दिसणाऱ्या दोन पद्धतींपैकी कोणती चुकीचे वागेल हे जाणणे.",
          "recommendation": "इतर लोकही ज्याला हात लावतात अशा कोडबेसचे संरक्षण करणाऱ्या भागांमध्ये खोलवर जा: API-डिझाइनचा निर्णय म्हणून कीवर्ड-ओन्ली आर्ग्युमेंट्स (केवळ सिंटॅक्समधील कुतूहल म्हणून नव्हे), एक्सेप्शन हायरार्की (म्हणजे except क्लॉज केवळ एका क्लासऐवजी योग्य त्रुटी-कुटुंब पकडतात), आणि क्लीनअप निश्चित करण्याचा प्रमाणित मार्ग म्हणून कॉन्टेक्स्ट मॅनेजर्स. Real Python मधील सखोल लेख या तिन्हींसाठी पुढचा चांगला टप्पा आहेत."
        },
        "expert": {
          "name": "तज्ज्ञ",
          "desc": "तुम्ही प्रत्येक विभागात सर्वोच्च गुण मिळवले — मूलभूत सिंटॅक्स, फंक्शन्स आणि स्कोप, डेटा स्ट्रक्चर्स आणि ऑब्जेक्ट-ओरिएंटेड पद्धती. व्यावहारिकदृष्ट्या याचा अर्थ असा की एखाद्या अनोळखी व्यक्तीची फाइल हातात दिली तरी ती तसे आउटपुट का देते हे तुम्ही समजावू शकता, सिंटॅक्स काय सांगतो एवढेच नव्हे, आणि हे अधिक कठीण व अधिक मौल्यवान कौशल्य आहे. या पातळीवर तुमच्या कामात भाषा क्वचितच अडथळा ठरते; मर्यादा सहसा कोडभोवतीच्या सिस्टीमच्या आकाराची किंवा स्वरूपाची असते.",
          "recommendation": "आता फायदा टूलिंग आणि रिव्ह्यूमध्ये आहे: mypy किंवा pyright सह स्टॅटिक टाइप चेकिंग, अंदाज बांधण्याऐवजी ऑप्टिमाइझ करण्यापूर्वी प्रोफाइलिंग, आणि नेमक्या याच प्रकारच्या बगसाठी इतरांच्या पुल रिक्वेस्ट वाचणे — जे बग प्रत्येक टेस्ट पास करतात आणि तरीही विशिष्ट इनपुटवर चुकीचे वागतात. एखाद्या भूमिकेसाठी तुमची छाननी होत असेल, तर भाषेच्या वैशिष्ट्यांची नावे घेण्याऐवजी तुम्हाला सापडलेल्या अशा एखाद्या बगचे वर्णन करा — त्यातून केवळ शब्दसंग्रह नव्हे, तर तुमची विचारपद्धती दिसते."
        }
      },
      "questions": [
        {
          "question": "तुम्ही def add_item(item, basket=[]): basket.append(item); return basket लिहिता, मग दोन्ही वेळा basket वगळून add_item('a') आणि add_item('b') कॉल करता. दुसरा कॉल काय रिटर्न करतो?",
          "options": [
            {
              "icon": "",
              "label": "['b']"
            },
            {
              "icon": "",
              "label": "एक TypeError"
            },
            {
              "icon": "",
              "label": "['a', 'b']"
            },
            {
              "icon": "",
              "label": "['a']"
            }
          ]
        },
        {
          "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"
            }
          ]
        },
        {
          "question": "Python 3 मध्ये 7 / 2 चे मूल्य काय येते, आणि 7 // 2 चे मूल्य काय येते?",
          "options": [
            {
              "icon": "",
              "label": "3.5, नंतर 3"
            },
            {
              "icon": "",
              "label": "3, नंतर 3.5"
            },
            {
              "icon": "",
              "label": "3.5, नंतर 3.5"
            },
            {
              "icon": "",
              "label": "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"
            }
          ]
        },
        {
          "question": "1 < 2 < 3 चे मूल्य काय येते?",
          "options": [
            {
              "icon": "",
              "label": "खरे"
            },
            {
              "icon": "",
              "label": "खोटे"
            },
            {
              "icon": "",
              "label": "एक SyntaxError"
            },
            {
              "icon": "",
              "label": "3"
            }
          ]
        },
        {
          "question": "bool([]) काय रिटर्न करते, आणि bool([0]) काय रिटर्न करते?",
          "options": [
            {
              "icon": "",
              "label": "False, नंतर False"
            },
            {
              "icon": "",
              "label": "False, नंतर True"
            },
            {
              "icon": "",
              "label": "True, नंतर True"
            },
            {
              "icon": "",
              "label": "True, नंतर False"
            }
          ]
        },
        {
          "question": "मॉड्यूल-स्तरावर count = 0 अस्तित्वात आहे. def increment(): count += 1; return count च्या आत तुम्ही increment() कॉल करता. काय होते?",
          "options": [
            {
              "icon": "",
              "label": "UnboundLocalError येतो"
            },
            {
              "icon": "",
              "label": "ते 1 रिटर्न करते आणि ग्लोबल count 1 वर सेट करते"
            },
            {
              "icon": "",
              "label": "ते 1 रिटर्न करते; ग्लोबल count 0 च राहतो"
            },
            {
              "icon": "",
              "label": "TypeError हा अपवाद उद्भवतो"
            }
          ]
        },
        {
          "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]"
            },
            {
              "icon": "",
              "label": "[0, 1, 2]"
            },
            {
              "icon": "",
              "label": "[0, 0, 0]"
            },
            {
              "icon": "",
              "label": "एक NameError"
            }
          ]
        },
        {
          "question": "एखादे फंक्शन @a सह परिभाषित केले आहे, जे थेट @b च्या वर आहे, आणि @b थेट def f(): pass च्या वर आहे. f ला डेकोरेटर्स कोणत्या क्रमाने लागू होतात?",
          "options": [
            {
              "icon": "",
              "label": "आधी b f ला गुंडाळतो, मग a त्या निकालाला गुंडाळतो"
            },
            {
              "icon": "",
              "label": "आधी a f ला गुंडाळतो, मग b त्या निकालाला गुंडाळतो"
            },
            {
              "icon": "",
              "label": "फक्त सर्वात शेवटी परिभाषित केलेला लागू होतो"
            },
            {
              "icon": "",
              "label": "ते इम्पोर्टच्या क्रमावर अवलंबून असते"
            }
          ]
        },
        {
          "question": "def f(a, *, b): return a + b. यापैकी कोणता कॉल चालतो?",
          "options": [
            {
              "icon": "",
              "label": "f(1, b=2)"
            },
            {
              "icon": "",
              "label": "f(1, 2)"
            },
            {
              "icon": "",
              "label": "f(a=1, 2)"
            },
            {
              "icon": "",
              "label": "f(1)"
            }
          ]
        },
        {
          "question": "एक जनरेटर फंक्शन 1 यील्ड करते, मग 2 यील्ड करते, मग return 99 करते. list(the_generator()) मध्ये काय असते, आणि 99 चे काय होते?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 99], कारण return शेवटच्या यील्डसारखे काम करते"
            },
            {
              "icon": "",
              "label": "[99], कारण return यील्ड्सवर वरचढ ठरते"
            },
            {
              "icon": "",
              "label": "[1, 2], आणि 99 हे StopIteration चे मूल्य बनते"
            },
            {
              "icon": "",
              "label": "RuntimeError हा अपवाद उद्भवतो"
            }
          ]
        },
        {
          "question": "एका outer() फंक्शनमध्ये x = 1 सेट केले आहे, मग नेस्टेड inner() मध्ये nonlocal x; x += 1 आहे, आणि outer() x रिटर्न करण्यापूर्वी inner() कॉल करते. outer() काय रिटर्न करते?",
          "options": [
            {
              "icon": "",
              "label": "1"
            },
            {
              "icon": "",
              "label": "UnboundLocalError"
            },
            {
              "icon": "",
              "label": "एक SyntaxError"
            },
            {
              "icon": "",
              "label": "2"
            }
          ]
        },
        {
          "question": "d = {'a': 1, 'b': 2}. d.get('c', 0) काय रिटर्न करते, आणि ते डिक्शनरीमध्ये 'c' जोडते का?",
          "options": [
            {
              "icon": "",
              "label": "0, आणि नाही"
            },
            {
              "icon": "",
              "label": "0, आणि होय"
            },
            {
              "icon": "",
              "label": "एक KeyError"
            },
            {
              "icon": "",
              "label": "None, आणि होय"
            }
          ]
        },
        {
          "question": "t = (1, 2, [3, 4]). तुम्ही t[2].append(5) चालवू शकता का, आणि t[0] = 10 चालवू शकता का?",
          "options": [
            {
              "icon": "",
              "label": "दोन्ही चालतात"
            },
            {
              "icon": "",
              "label": "दोन्हीमुळे TypeError येतो"
            },
            {
              "icon": "",
              "label": "t[2].append(5) मुळे TypeError येतो; t[0] = 10 चालते"
            },
            {
              "icon": "",
              "label": "t[2].append(5) चालते; t[0] = 10 मुळे TypeError येतो"
            }
          ]
        },
        {
          "question": "यापैकी कोणते, संपूर्ण सीक्वेन्स एकाच वेळी मेमरीमध्ये तयार करण्याऐवजी व्हॅल्यू लेझी पद्धतीने मोजणारा इटरेटर रिटर्न करते: [x*x for x in range(1000000)] की (x*x for x in range(1000000))?",
          "options": [
            {
              "icon": "",
              "label": "गोल कंस असलेले"
            },
            {
              "icon": "",
              "label": "चौकोनी कंस असलेले"
            },
            {
              "icon": "",
              "label": "दोन्ही; फक्त निकालाचा प्रकार वेगळा असतो"
            },
            {
              "icon": "",
              "label": "एकही नाही; दोन्ही संपूर्ण लिस्ट तयार करतात"
            }
          ]
        },
        {
          "question": "try ब्लॉकमध्ये शून्याने भागाकार होतो, except ZeroDivisionError क्लॉज 'a' प्रिंट करतो, आणि finally क्लॉज 'b' प्रिंट करतो. काय प्रिंट होते आणि कोणत्या क्रमाने?",
          "options": [
            {
              "icon": "",
              "label": "आधी b मग a"
            },
            {
              "icon": "",
              "label": "आधी a मग b"
            },
            {
              "icon": "",
              "label": "फक्त b"
            },
            {
              "icon": "",
              "label": "फक्त a"
            }
          ]
        },
        {
          "question": "import copy; a = [[1, 2], [3, 4]]; b = copy.copy(a); b[0].append(99). a[0] देखील बदलते का?",
          "options": [
            {
              "icon": "",
              "label": "No"
            },
            {
              "icon": "",
              "label": "एरर येतो"
            },
            {
              "icon": "",
              "label": "फक्त deepcopy वापरल्यास"
            },
            {
              "icon": "",
              "label": "होय"
            }
          ]
        },
        {
          "question": "d = {'x': 1, 'y': 2}. 'x' in d कशाशी तपासते — कीज, व्हॅल्यूज की दोन्ही?",
          "options": [
            {
              "icon": "",
              "label": "व्हॅल्यूज"
            },
            {
              "icon": "",
              "label": "कीज आणि व्हॅल्यूज दोन्ही"
            },
            {
              "icon": "",
              "label": "दोन्हीपैकी नाही; TypeError येतो"
            },
            {
              "icon": "",
              "label": "कीज"
            }
          ]
        },
        {
          "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"
            }
          ]
        },
        {
          "question": "class Dog: tricks = [] मध्ये क्लास-स्तरावरील लिस्ट आहे, आणि add_trick self.tricks मध्ये जोडते. d1 = Dog() आणि d2 = Dog() दोन्ही तयार केले जातात, मग d1.add_trick('sit') चालते. d2.tricks मध्ये काय असते?",
          "options": [
            {
              "icon": "",
              "label": "[]"
            },
            {
              "icon": "",
              "label": "['sit']"
            },
            {
              "icon": "",
              "label": "एक TypeError"
            },
            {
              "icon": "",
              "label": "एकही नाही"
            }
          ]
        },
        {
          "question": "class A मध्ये def greet(self): return 'A' आहे. class B(A) मध्ये def greet(self): return 'B' + super().greet() आहे. B().greet() काय रिटर्न करते?",
          "options": [
            {
              "icon": "",
              "label": "'AB'"
            },
            {
              "icon": "",
              "label": "'B'"
            },
            {
              "icon": "",
              "label": "'BA'"
            },
            {
              "icon": "",
              "label": "AttributeError"
            }
          ]
        },
        {
          "question": "class Point त्याच्या __init__ मध्ये self.x साठवते आणि इतर कोणतीही मेथड परिभाषित करत नाही. p1 = Point(1) आणि p2 = Point(1). p1 == p2 डिफॉल्टनुसार काय रिटर्न करते?",
          "options": [
            {
              "icon": "",
              "label": "खरे"
            },
            {
              "icon": "",
              "label": "खोटे"
            },
            {
              "icon": "",
              "label": "एकही नाही"
            },
            {
              "icon": "",
              "label": "एक TypeError"
            }
          ]
        },
        {
          "question": "खालीलपैकी कोणता except क्लॉज ZeroDivisionError देखील पकडेल: except ArithmeticError, except ValueError की except KeyError?",
          "options": [
            {
              "icon": "",
              "label": "except ValueError"
            },
            {
              "icon": "",
              "label": "except KeyError"
            },
            {
              "icon": "",
              "label": "यापैकी एकही नाही"
            },
            {
              "icon": "",
              "label": "except ArithmeticError"
            }
          ]
        },
        {
          "question": "तुम्ही open('data.txt') as f: ने फाइल उघडता आणि ब्लॉकमध्ये वाचताना एक एक्सेप्शन उद्भवते. फाइल तरीही बंद होते का?",
          "options": [
            {
              "icon": "",
              "label": "No"
            },
            {
              "icon": "",
              "label": "फक्त finally क्लॉज जोडल्यासच"
            },
            {
              "icon": "",
              "label": "होय"
            },
            {
              "icon": "",
              "label": "ते एक्सेप्शनच्या प्रकारावर अवलंबून असते"
            }
          ]
        },
        {
          "question": "x = [3, 1, 2] आणि y = x.sort(). y मध्ये काय असते?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3]"
            },
            {
              "icon": "",
              "label": "एकही नाही"
            },
            {
              "icon": "",
              "label": "[3, 1, 2]"
            },
            {
              "icon": "",
              "label": "एक TypeError"
            }
          ]
        },
        {
          "question": "'Score: ' + 42 चालवल्यास काय होते?",
          "options": [
            {
              "icon": "",
              "label": "'Score: 42'"
            },
            {
              "icon": "",
              "label": "'Score: '"
            },
            {
              "icon": "",
              "label": "42"
            },
            {
              "icon": "",
              "label": "ते TypeError उत्पन्न करते"
            }
          ]
        },
        {
          "question": "तुम्हाला results नावाची लिस्ट रिकामी आहे का ते तपासायचे आहे. Python मधील योग्य शैलीचा मार्ग कोणता: if results == []: , if len(results) == 0: की if not results: ?",
          "options": [
            {
              "icon": "",
              "label": "if results == []:"
            },
            {
              "icon": "",
              "label": "if len(results) == 0:"
            },
            {
              "icon": "",
              "label": "if results is None:"
            },
            {
              "icon": "",
              "label": "if not results:"
            }
          ]
        }
      ],
      "optionOrderVersion": "26e0df963ab76db1"
    }
  },
  "testNames": {
    "python-test": "Python चाचणी"
  }
}