{
  "assessmentTests": {
    "python_test": {
      "name": "Python ਟੈਸਟ",
      "desc": "Python ਦੀ ਤੁਹਾਡੀ ਜਾਣਕਾਰੀ ਦਾ ਅਨੁਮਾਨ ਲਗਾਉਣ ਲਈ 30 ਸਵਾਲ।",
      "recommendation": "ਤੁਹਾਡੀ Python ਦੇ ਹੁਨਰ ਦਾ ਪ੍ਰੋਫਾਈਲ",
      "results": {
        "beginner": {
          "name": "ਸ਼ੁਰੂਆਤੀ",
          "desc": "ਤੁਸੀਂ ਛੋਟੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਮਝ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸ ਵਿੱਚ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹੋ, ਪਰ ਜੋ ਪ੍ਰਸ਼ਨ ਤੁਸੀਂ ਖੁੰਨ ਗਏ ਹੋ ਉਹ ਆਮ ਤਰਕ ਦੀ ਬਜਾਏ ਭਾਸ਼ਾ ਦੇ ਅਲਗ ਵਿਹਾਰ ਦੇ ਦੁਆਲੇ ਹਨ। ਇਹ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਵਿੱਚ ਬੁਰੇ ਹੋਣ ਬਾਰੇ ਨਹੀਂ ਹੈ; ਇਹ Python-ਅਲਗ ਨਿਯਮ ਹਨ ਜੋ ਦੂਸਰੀ ਭਾਸ਼ਾਵਾਂ ਤੋਂ ਆਉਣ ਵਾਲਿਆਂ ਦੇ ਲਈ ਵੀ ਆਪੇ ਗੁੰਝਲਦਾਰ ਹੈ। ਉਹ ਕਾਮ ਵਿੱਚ ਮਾਇਨੇ ਰੱਖਦੇ ਹਨ ਕਿਉਂਕਿ ਹਰੇਕ ਇੱਕ ਬਗ ਲੁਕਿਆ ਹੋ ਸਕਦਾ ਹੈ।",
          "recommendation": "ਸ਼ੁਰੂ ਕਰੋ ਤਿੰਨ ਚੀਜ਼ਾਂ ਨਾਲ: ਬਦਲਵੰਧੀ ਮੂਲ ਦਲੀਲਾਂ, is ਅਤੇ == ਦਾ ਅੰਤਰ, ਅਤੇ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਵੇਰੀਏਬਲ ਦਾ ਰਜਾ। ਰਸਮੀ Python ਟਿਉਟੋਰੀਅਲ ਇਨ੍ਹਾਂ ਸਾਰਿਆਂ ਨੂੰ ਸਿੱਧਾ ਕਵਰ ਕਰਦਾ ਹੈ।"
        },
        "intermediate": {
          "name": "ਮੱਧਮ",
          "desc": "ਤੁਸੀਂ ਰੋਜ਼ਮਰਾਹ ਦੀ ਸਕ੍ਰਿਪਟਿੰਗ ਸਪੂਰਤ ਸਮਝਦੇ ਹੋ — ਡੇਟਾ ਢਾਂਚੇ, ਪ੍ਰਵਾਹ ਕੰਟਰੋਲ, ਸਿੱਧੇ ਫੰਕਸ਼ਨ — ਅਤੇ ਰੋਕ-ਖੇਡ ਕਾਮ ਜਾਂ ਮੌਜੂਦ ਕੋਡ 'ਤੇ ਛੋਟੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੁਆਰਾ ਲਿਰ ਨਹੀਂ ਹੋਣਗੇ। ਮੱਧ ਅਤੇ ਲ਼ਾ ਅਡਵਾਂਸਡ ਦੀ ਬਿਚ ਇਰ Python ਦੀ ਸੁਵਿਧਾ ਇੱਕ ਦੂਸਰੇ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ।",
          "recommendation": "ਆਬਜੈਕਟ ਅਤੇ ਦੋਦਨ ਦੇ ਅੰਦਰੂਨ ਹਿੱਸਿਆਂ 'ਤੇ ਫੋਕਸ ਕਰੋ: ਸਥਿਰ vs ਡੇਹਿਰੇ ਕਾਪੀ, ਜੇਨਮੁਖਿ ਸਮਾਲੋਂ ਕੀ ਕਰਦਾ ਹੈ, ਅਤੇ ਸਜਾਅ ਪਿੱਲ ਕ੍ਰਮ ਕੀ ਕਰਦਾ ਹੈ।"
        },
        "advanced": {
          "name": "ਉਮਲੇ",
          "desc": "ਇਹ ਉਹ ਪੱਧਰ ਹੈ ਜਿਸਦਾ ਜ਼ਿਆਦਾਤਰ ਕੰਮ ਪੋਸਟਿੰਗ ਮਤਲਬ ਹੈ। ਤੁਸੀਂ ਸਹੀ ਟੂਲ ਵਜੋਂ ਪਹੁੰਚ ਸਕਦੇ ਹੋ ਬਿਨਾ ਖੋਜ ਕੀਤੇ, ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਸਾਂਝਾ ਅਵਸਥਾ ਕਿਉਂ ਬਦਲ ਗਈ, ਅਤੇ ਤੁਸੀਂ ਕੋਈ ਹੋਰ ਫੰਕਸ਼ਨ ਪੜ੍ਹ ਸਕਦੇ ਹੋ ਅਤੇ ਠੀਕ-ਠੀਕ ਭਵਿਖਾ ਲਗਾ ਸਕਦੇ ਹੋ।",
          "recommendation": "ਜਸ਼ ਕੋਕਬੇਸ ਨੂੰ ਰਫਾਆ ਕਰਨ ਵਾਲੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਝੁੰਝਲਾ ਕਰੋ: ਕੀ-ਮਾਤਰ ਦਲੀਲਾਂ, ਅਪਵਾਦ ਸਮੂਹ, ਅਤੇ ਸਥਾਪਨ ਮੈਨੇਜਰ।"
        },
        "expert": {
          "name": "ਮਾਹਿਰ",
          "desc": "ਤੁਸੀਂ ਹਰੇਕ ਸੈਕਸ਼ਨ ਦੀ ਸਿਖਲਾ ਦੀ ਸਿਖਲਾ ਕੀਤੀ ਹੈ — ਮੂਲ ਰਈ, ਫੰਕਸ਼ਨ ਅਤੇ ਰਜਾ, ਡੇਟਾ ਢਾਂਚੇ, ਅਤੇ ਆਬਜੈਕਟ-ਓ ਇਡਿਆਮਾਂ। ਅਮਲੀ ਤੌਰ 'ਤੇ, ਮਤਲਬ ਤੁਸੀਂ ਕਿਸੇ ਅਜਨਬੀ ਦੀ ਫਾਈਲ ਹਾਥ ਕੀਤੀ ਜਾ ਸਕਦੇ ਹੋ ਅਤੇ ਸਮਝਾ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਕੀ ਕਰਦਾ ਹੈ।",
          "recommendation": "ਬਸਾਉ ਅਤੇ ਸਮੀਖਿਆ ਵਿੱਚ ਰਿਟਨ: ਸਥਿਰ ਕਿਸਮ ਲਾਹ, ਅਨੁਮਾਨ ਤੋਂ ਪਹਿਲਾ ਗਾਇਕੀ, ਅਤੇ ਦੂਸਰਿਆਂ ਦੀਆਂ ਖਿੱਚ ਦੀ ਸਮੀਖਿਆ।"
        }
      },
      "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": "Python 3 ਵਿੱਚ, 7 / 2 ਕੀ ਅਲਾਉਨ ਕਰਦਾ ਹੈ, ਅਤੇ 7 // 2 ਕੀ ਅਲਾਉਨ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "3.5, ਫਿਰ 3 — / ਹਮੇਸ਼ਾ ਇੱਕ float ਵਾਪਸ ਕਰਦਾ ਹੈ, // ਨਤੀਜਾ ਲੁੰਡ ਦਿੰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "3, ਫਿਰ 3.5 — / ਹੌਕ ਦਿੰਦਾ ਹੈ ਅਤੇ // ਇੱਕ float ਵਾਪਸ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "3.5, ਫਿਰ 3.5 — ਦੋਨੇ ਆਪਰੇਟਰ Python 3 ਵਿੱਚ ਇੱਕ float ਵਾਪਸ ਕਰਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "3, ਫਿਰ 3 — ਦੋਨੇ ਆਪਰੇਟਰ Python 3 ਵਿੱਚ ਨਤੀਜਾ ਲੁੰਡ ਦਿੰਦੇ ਹਨ"
            }
          ]
        },
        {
          "question": "s = 'hello', ਫਿਰ ਤੁਸੀਂ s[0] = 'H' ਚਲਾਓ। ਕੀ ਵਾਪਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "s 'Hello' ਬਣ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "s 'Hhello' ਬਣ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਅੱਖਰ ਸੰਮਿਲਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਬਦਲਾਇਆ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "TypeError — ਸਟਰਿੰਗਸ immutable ਹਨ ਅਤੇ ਆਈਟਮ ਅਸਾਈਨਮੈਂਟ ਨੂੰ ਸਹਾਇਤਾ ਨਹੀਂ ਕਰਦੀਆਂ"
            },
            {
              "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 — Python ਸਵਾਦਾਂ ਨੂੰ ਛੋਟ ਕਰਦਾ ਹੈ (1 < 2) ਅਤੇ (2 < 3)"
            },
            {
              "icon": "",
              "label": "False — ਬਾਇਕ ਸਵਾਦ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਮੁਲ ਅੱਖ ਕਰੇ ਜਾਂਦੇ ਹਨ ਛੋਟਾ-ਸਾਰਕਿਟ ਦੇ ਬਿਨਾ, 1 < 2 < 3 -> 1 < True -> False ਦਿੰਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ SyntaxError — ਸਵਾਦ ਪੋਸ਼ ਨਹੀਂ ਕਰ ਸਕਦੇ"
            },
            {
              "icon": "",
              "label": "3 — Python ਚੋਰਾਂ ਵਿੱਚ ਆਖਰੀ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "bool([]) ਕੀ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਤੇ bool([0]) ਕੀ ਵਾਪਸ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "False, ਫਿਰ False — ਕਿਸਹੀ ਲਿਸਟ ਜਿਸ ਵਿੱਚ ਸਿਰਫ਼ ਅਲਿਗਿਸ ਮੁੱਲ ਹਨ falsy ਹਨ"
            },
            {
              "icon": "",
              "label": "False, ਫਿਰ True — ਇੱਕ ਖਾਲੀ ਲਿਸਟ falsy ਹੈ, ਇੱਕ ਲਿਸਟ ਜਿਸ ਵਿੱਚ ਇੱਕ ਆਈਟਮ ਹੈ (ਭਾਵੇਂ 0) truthy ਹੈ"
            },
            {
              "icon": "",
              "label": "True, ਫਿਰ True — ਗੈਰ-None ਬਚਾਓ ਹਮੇਸ਼ਾ truthy ਹੁੰਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "True, ਫਿਰ False — ਇੱਕ ਲਿਸਟ truthy ਹੈ ਸਿਰਫ਼ ਜਦੋਂ ਖਾਲੀ ਹੋਵੇ"
            }
          ]
        },
        {
          "question": "ਇੱਕ module-level count = 0 ਮੌਜੂਦ ਹੈ। def increment() ਦੇ ਅੰਦਰ: count += 1; return count, ਤੁਸੀਂ increment() ਨੂੰ ਕਾਲ ਕਰਦੇ ਹੋ। ਕੀ ਵਾਪਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "UnboundLocalError — ਫੰਕਸ਼ਨ ਵਿੱਚ ਕਿਸੀ ਥਾਂ ਤੇ count ਵਿੱਚ ਅਸਾਈਨ ਕਰਨਾ ਇਸ ਨੂੰ ਸਥਾਨਿਕ ਬਣਾਉਂਦਾ ਹੈ, ਇਸ ਲਈ count += 1 ਅਸਾਈਨ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਸਥਾਨਿਕ ਵੇਰੀਏਬਲ ਨੂੰ ਪੜ੍ਹਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ 1 ਵਾਪਸ ਕਰਦਾ ਹੈ ਅਤੇ module-level count ਨੂੰ 1 ਵਿੱਚ ਵਧਾਉਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ 1 ਵਾਪਸ ਕਰਦਾ ਹੈ ਪਰ module-level 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": "ਇੱਕ generator ਫੰਕਸ਼ਨ 1 ਨੂੰ yield ਕਰਦਾ ਹੈ, ਫਿਰ 2 ਨੂੰ yield ਕਰਦਾ ਹੈ, ਫਿਰ 99 ਦਾ ਰਿਟਰਨ ਕਰਦਾ ਹੈ। list(the_generator()) ਕੀ ਰੱਖਦਾ ਹੈ, ਅਤੇ 99 ਨੂੰ ਕੀ ਵਾਪਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 99] — generator ਅੰਦਰ return ਇੱਕ ਹੋਰ yield ਵਾਂਗ ਵਰਤਾਓ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "[99] — return ਤੁਰੰਤ ਪਹਿਲਾਂ ਤੋਂ ਜਿਰਆਈ ਪੂਰੀ ਮੁੱਲ ਨੂੰ override ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "[1, 2] — generator ਦੀ return ਮੁੱਲ StopIteration ਦੇ ਲਈ ਛੜਿਆ ਜਾ ਰਿਹਾ ਹੈ ਜੋ ਇਹ ਜਾਰੀ ਕਰਦਾ ਹੈ, ਇਹ yield ਨਹੀਂ ਕਰਿਆ ਜਾਂਦਾ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ RuntimeError, ਕਿਉਂਕਿ generators ਕਦੇ ਵੀ ਇੱਕ return ਸਟੇਟਮੈਂਟ ਨਹੀਂ ਰੱਖ ਸਕਦੇ"
            }
          ]
        },
        {
          "question": "ਇੱਕ outer() ਫੰਕਸ਼ਨ ਵਿੱਚ, x = 1 ਸੈਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਫਿਰ ਨਿਸਤੀਲ inner() nonlocal x; x += 1 ਕਰਦਾ ਹੈ, ਅਤੇ outer() ਵਾਪਸ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ inner() ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ x। outer() ਕੀ ਵਾਪਸ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "1 — inner() ਆਪਣੇ ਆਪ ਨਾਲ x ਦੀ ਇੱਕ ਨਿਜੀ ਕਾਪੀ ਕੰਮ ਕਰਦਾ ਹੈ, ਤਬਦੀਲੀ ਕਾਇਮ ਨਹੀਂ ਰਹਦੀ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ UnboundLocalError, ਕਿਉਂਕਿ x ਨੂੰ nonlocal ਸਟੇਟਮੈਂਟ ਤੋਂ ਪਹਿਲਾਂ inner() ਦੇ ਅੰਦਰ ਘੋਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ SyntaxError — nonlocal ਸਿਰਫ਼ ਕਲਾਸ ਦੇ ਅੰਦਰ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "2 — nonlocal inner() ਨੂੰ ਇੱਕ ਨਵਾ ਸਥਾਨਿਕ ਵੇਰੀਏਬਲ ਬਣਾਉਣ ਦੀ ਬਜਾਏ outer ਫੰਕਸ਼ਨ ਦੇ 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 ਨੂੰ mutable ਬਣਾਉਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਦੋਨੋ TypeError ਜਾਰੀ ਕਰਦੇ ਹਨ — tuple ਵਿੱਚ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਨੂੰ ਕਦੇ ਬਦਲਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ"
            },
            {
              "icon": "",
              "label": "t[2].append(5) TypeError ਜਾਰੀ ਕਰਦਾ ਹੈ, ਪਰ t[0] = 10 ਕੰਮ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ tuples ਆਪਣੇ ਪਹਿਲੇ ਆਈਟਮ ਦੀ reassignment ਨੂੰ ਆਗਿਆ ਦਿੰਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "t[2].append(5) ਕੰਮ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ ਅੰਦਰ ਦੀ ਲਿਸਟ mutable ਹੈ; t[0] = 10 TypeError ਜਾਰੀ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ tuple ਆਪ immutable ਹੈ"
            }
          ]
        },
        {
          "question": "ਇਨ੍ਹਾਂ ਵਿੱਚੋਂ ਕਿਹੜਾ ਇੱਕ iterator ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਵਿਸ਼ੁੱਧ ਤੌਰ ਮੈਮੋਰੀ ਵਿੱਚ ਪੂਰਾ ਸਕਵੈਂਸ ਬਣਾਉਣ ਦੀ ਬਜਾਏ: [x*x for x in range(1000000)] ਜਾਂ (x*x for x in range(1000000))?",
          "options": [
            {
              "icon": "",
              "label": "ਪਾਸ਼ਲ ਵਾਲੀ, (x*x for x in range(1000000)) — ਇਹ ਇੱਕ generator ਸਵਾਦ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਵਰਗ ਅਲਫਬੈਟ ਵਾਲੀ — list comprehensions Python 3 ਵਿੱਚ ਹਮੇਸ਼ਾ lazy ਹੁੰਦੀਆਂ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਦੋਨੋ lazy ਹਨ — ਫਰਕ ਸਿਰਫ਼ ਅੰਤ ਵਿੱਚ ਰਿਟਰਨ ਕਰੀ ਕਿਸਮ ਹੈ"
            },
            {
              "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": "ਭਾਵੇਂ — `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 ਵਿੱਚ append ਕਰਦਾ ਹੈ। d1 = Dog() ਅਤੇ d2 = Dog() ਦੋਨੋ ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਫਿਰ d1.add_trick('sit') ਚੱਲਦਾ ਹੈ। d2.tricks ਕੀ ਰੱਖਦੇ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "[] — ਹਰ ਇੱਕ instance ਆਪਣੀ tricks ਦੀ ਆਜ਼ਾਦ ਕਾਪੀ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "['sit'] — tricks ਇੱਕ ਕਲਾਸ-ਲੈਵਲ ਲਿਸਟ ਹੈ ਜੋ ਹਰ ਇੱਕ instance ਦੁਆਰਾ ਸ਼ੇਅਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇਸ ਲਈ d1 ਦੀ ਤਬਦੀਲੀ d2 ਤੇ ਵੀ ਦੇਖੀ ਜਾਂਦੀ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ TypeError — instances ਕਲਾਸ ਸੰਪਾਸ਼ਨ ਨੂੰ append ਨਹੀਂ ਕਰ ਸਕਦੇ"
            },
            {
              "icon": "",
              "label": "['sit'] ਸਿਰਫ਼ d2 = Dog() ਨੂੰ ਮੁੜ-ਚਾਲ ਕਰਨ ਤੋਂ ਬਾਅਦ"
            }
          ]
        },
        {
          "question": "ਕਲਾਸ A ਵਿੱਚ def greet(self): return 'A' ਹੈ। ਕਲਾਸ B(A) ਵਿੱਚ def greet(self): return 'B' + super().greet() ਹੈ। B().greet() ਕੀ ਵਾਪਸ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "'AB' — super() ਹਮੇਸ਼ਾ subclass ਦੇ ਆਪਣੇ ਕੋਡ ਤੋਂ ਪਹਿਲਾਂ ਚਲਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "'B' — super().greet() ਨੂੰ ਨਜ਼ਰ ਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ B ਪਹਿਲਾਂ ਹੀ greet ਨੂੰ override ਕਰ ਦੇਵੇ"
            },
            {
              "icon": "",
              "label": "'BA' — super().greet() A ਦੀ method ਨੂੰ ਸੁੱਡਦਾ ਹੈ ਅਤੇ ਇਸਦਾ ਨਤੀਜਾ 'B' ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਕ AttributeError, ਕਿਉਂਕਿ A ਕੋਲ B ਨੂੰ ਦਿਖਾਈ ਦੇਣ ਵਾਲੀ greet method ਨਹੀਂ ਹੈ"
            }
          ]
        },
        {
          "question": "ਕਲਾਸ Point self.x ਨੂੰ __init__ ਵਿੱਚ ਸਟੋਰ ਕਰਦੀ ਹੈ ਅਤੇ ਕੋਈ ਹੋਰ methods ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕਰਦੀ। p1 = Point(1) ਅਤੇ p2 = Point(1)। p1 == p2 ਪੂਰਵ-ਨਿਰਧਾਰਤ ਰੂਪ ਵਿੱਚ ਕੀ ਵਾਪਸ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਸੱਚ — Python ਪੂਰਵ-ਨਿਰਧਾਰਤ ਰੂਪ ਵਿੱਚ ਸਾਰੀਆਂ ਮਿਲਦੀਆਂ attributes ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਗਲਤ — ਇਕ ਕਸਟਮ __eq__ ਤੋਂ ਬਿਨਾਂ, == identity comparison ਵਿੱਚ ਵਾਪਸ ਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ p1 ਅਤੇ p2 ਵੱਖ-ਵੱਖ objects ਹਨ"
            },
            {
              "icon": "",
              "label": "ਸੱਚ, ਪਰ ਸਿਰਫ ਇਸ ਲਈ ਕਿਉਂਕਿ ਦੋਵੇਂ objects ਨੂੰ ਇੱਕੋ ਸਮਾਨ ਦੁਆਰਾ ਬਣਾਇਆ ਗਿਆ ਸੀ"
            },
            {
              "icon": "",
              "label": "ਇਕ TypeError, ਕਿਉਂਕਿ Point __eq__ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕਰਦਾ"
            }
          ]
        },
        {
          "question": "ਨਿਮਨਲਿਖਤ ਵਿੱਚੋਂ ਕਿਹੜੀ except clause ਵੀ ZeroDivisionError ਨੂੰ ਫੜੇਗੀ: except ArithmeticError, except ValueError, ਜਾਂ except KeyError?",
          "options": [
            {
              "icon": "",
              "label": "except ValueError — ਵਿਭਾਜਨ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਅਮਾਨਤਨ ਮੁੱਲਾਂ ਵਜੋਂ ਮਨਿਆ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "except KeyError — ਕੋਈ ਵੀ runtime error ਜੋ ਕਿ ਕਿਸੇ ਖਾਸ ਕਿਸਮ ਨਾਲ ਨਹੀਂ ਜੁੜੀ KeyError ਵਿੱਚ ਵਾਪਸ ਆ ਜਾਂਦੀ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਨ੍ਹਾਂ ਵਿੱਚੋਂ ਕੋਈ ਵੀ ਨਹੀਂ — ਸਿਰਫ except ZeroDivisionError ਖੁਦ ਇਸਨੂੰ ਫੜ ਸਕਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "except ArithmeticError — ZeroDivisionError ArithmeticError ਦਾ ਇੱਕ subclass ਹੈ"
            }
          ]
        },
        {
          "question": "ਤੁਸੀਂ open('data.txt') as f: ਦੇ ਨਾਲ ਇੱਕ ਫਾਈਲ ਖੋਲਦੇ ਹੋ ਅਤੇ block ਦੇ ਅੰਦਰ ਪੜ੍ਹਦੇ ਸਮੇਂ ਇੱਕ exception ਜਾਰੀ ਹੁੰਦੀ ਹੈ। ਕੀ ਫਾਈਲ ਫਿਰ ਵੀ ਬੰਦ ਹੋ ਜਾਂਦੀ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਨਹੀਂ — ਫਾਈਲ ਖੁੱਲੀ ਰਹਿੰਦੀ ਹੈ ਕਿਉਂਕਿ block ਸਾਧਾਰਨ ਤੌਰ ਤੇ ਖਤਮ ਨਹੀਂ ਹੋਈ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ ਜੇ ਤੁਸੀਂ with statement ਦੁਆਲੇ ਇੱਕ finally clause ਵੀ ਜੋੜਦੇ ਹੋ"
            },
            {
              "icon": "",
              "label": "ਹਾਂ — with statement ਫਾਈਲ ਦੀ __exit__ method ਨੂੰ ਸੁੱਡਦਾ ਹੈ, ਜੋ ਇਸਨੂੰ ਬੰਦ ਕਰ ਦੇਵੇ, ਭਾਵੇਂ block ਦੇ ਅੰਦਰ ਕੋਈ exception ਹੋਵੇ"
            },
            {
              "icon": "",
              "label": "ਇਹ exception ਦੀ ਕਿਸਮ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ — ਸਿਰਫ ਹੋਰ ਜਗ੍ਹਾਂ ਤੋਂ ਫੜੀਆਂ ਗਈਆਂ exceptions cleanup ਨੂੰ ਟਰੀਗਰ ਕਰਦੀਆਂ ਹਨ"
            }
          ]
        },
        {
          "question": "x = [3, 1, 2] ਅਤੇ y = x.sort()। y ਕੀ ਰੱਖਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3] — sort() ਨਵੀਂ sorted list ਵਾਪਸ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਕੋਈ ਨਹੀਂ — list.sort() ਜਗ੍ਹਾ ਵਿੱਚ ਛਾਂਟਦਾ ਹੈ ਅਤੇ None ਵਾਪਸ ਕਰਦਾ ਹੈ; x ਖੁਦ [1, 2, 3] ਬਣ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "[3, 1, 2] — sort() ਅਸਲ unsorted list ਵਾਪਸ ਕਰਦਾ ਹੈ ਅਤੇ ਸਿਰਫ x ਦੀ ਅੰਦਰੂਨੀ ਕਮਾਂਡ ਬਦਲਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਕ TypeError, ਕਿਉਂਕਿ sort() ਨੂੰ ਇੱਕ variable ਵਿੱਚ assign ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ"
            }
          ]
        },
        {
          "question": "ਜਦੋਂ ਤੁਸੀਂ 'Score: ' + 42 ਚਲਾਓ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "'Score: 42' — Python + expression ਦੇ ਅੰਦਰ ਸੰਖਿਆ ਨੂੰ ਸਵੈਚਾਲਤ ਤੌਰ 'ਤੇ ਬਦਲਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "'Score: ' — ਸੰਖਿਆ ਪ੍ਰਸੁੱਪ ਤੌਰ 'ਤੇ ਛੱਡ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ"
            },
            {
              "icon": "",
              "label": "42 — string ਨੂੰ ਸੰਖਿਆ ਵਿੱਚ ਜ਼ਬਰਦਸਤੀ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "TypeError — ਤੁਸੀਂ str ਅਤੇ int ਨੂੰ ਸਿੱਧੇ concatenate ਨਹੀਂ ਕਰ ਸਕਦੇ, 42 ਨੂੰ ਪਹਿਲਾਂ str() ਨਾਲ ਬਦਲਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "ਤੁਹਾਨੂੰ ਚੈੱਕ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਇੱਕ results ਨਾਮਕ list ਖਾਲੀ ਹੈ। ਆਮ Python ਤਰੀਕਾ ਕਿਹੜਾ ਹੈ: if results == []: , if len(results) == 0: , ਜਾਂ if not results: ?",
          "options": [
            {
              "icon": "",
              "label": "if results == []: — ਇਹ ਖਾਲੀ list ਦਾ ਪਤਾ ਲਗਾਉਣ ਦਾ ਇੱਕਮਾਤ੍ਰ ਭਰੋਸੇਮੰਦ ਤਰੀਕਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "if len(results) == 0: — ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ Python ਵਿੱਚ ਖਾਲੀ lists truthy ਹਨ"
            },
            {
              "icon": "",
              "label": "ਸਾਰੇ ਤਿੰਨ ਬਰਾਬਰ ਅਭਿਆਸ ਵਿੱਚ ਕਦੇ ਨਹੀਂ ਵਰਤੇ ਜਾਂਦੇ; ਮਾਨਕ ਪਹੁੰਚ if results is None: ਹੈ"
            },
            {
              "icon": "",
              "label": "if not results: — Python idiom truthiness 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਖਾਲੀ list falsy ਹੈ"
            }
          ]
        }
      ],
      "optionOrderVersion": "92945565db6c55da"
    }
  },
  "testNames": {
    "python-test": "Python ਟੈਸਟ"
  }
}