{
  "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"
            },
            {
              "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 ಕೊನೆಯ yield ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "[99], ಏಕೆಂದರೆ return yield ಗಳನ್ನು ಅತಿಕ್ರಮಿಸುತ್ತದೆ"
            },
            {
              "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 ಎಂಬ ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿದೆಯೇ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸಬೇಕು. ಇಡಿಯೋಮ್ಯಾಟಿಕ್ ಪೈಥಾನ್ ವಿಧಾನ ಯಾವುದು: 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": "ಪೈಥಾನ್ ಪರೀಕ್ಷೆ"
  }
}