{
  "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-ડિઝાઇન પસંદગી તરીકે, એક્સેપ્શન હાયરાર્કી (જેથી એક્સેપ્ટ ક્લોઝ ભૂલના યોગ્ય કુટુંબને પકડે, માત્ર એક ક્લાસને નહીં), અને ક્લીનઅપની ખાતરી આપવાની પ્રમાણભૂત રીત તરીકે કન્ટેક્સ્ટ મેનેજર્સ. રિયલ પાયથનના ડીપ-ડાઇવ લેખો આ ત્રણેય માટે એક સારો આગલો સ્ટોપ છે."
        },
        "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"
            },
            {
              "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": "`==` માટે સાચું, `is` માટે ખોટું"
            },
            {
              "icon": "",
              "label": "બંને માટે False"
            },
            {
              "icon": "",
              "label": "`is` માટે સાચું, `==` માટે ખોટું"
            }
          ]
        },
        {
          "question": "પાયથન 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": "ખોટું, પછી ખોટું"
            },
            {
              "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 સાથે વ્યાખ્યાયિત કરવામાં આવ્યું છે, જે 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": "'સ્કોર: 42'"
            },
            {
              "icon": "",
              "label": "'સ્કોર: '"
            },
            {
              "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": "પાયથન ટેસ્ટ"
  }
}