{
  "assessmentTests": {
    "python_test": {
      "name": "מבחן Python",
      "desc": "30 שאלות תרחיש על תחביר, פונקציות, מבני נתונים והתנהגות אובייקטים — גלו אם רמת ה-Python שלכם תואמת למה שמשרות מתכוונות כשהן דורשות שליטה ב-Python.",
      "recommendation": "פרופיל כישורי Python שלך",
      "results": {
        "beginner": {
          "name": "מתחילים",
          "desc": "אפשר לעקוב אחרי סקריפט קצר ולשנות בו ערכים, אבל השאלות שפספסת מתקבצות סביב התנהגויות ספציפיות של השפה ולא סביב לוגיקה כללית — ארגומנט ברירת מחדל שנבנה פעם אחת ומשמש שוב, is מול == על שתי רשימות שנראות זהות, משתנה שהופך למקומי ברגע שמבצעים לו השמה בכל מקום בפונקציה. זה לא עניין של תכנות גרוע; אלה כללים ספציפיים ל-Python שמכשילים אנשים שמגיעים משפות אחרות באותה מידה כמו מתחילים. זה חשוב בעבודה כי כל אחד מהם הוא המקום שבו באג מסתתר בקוד שנראה תקין במבט ראשון.",
          "recommendation": "התחילו בשלושה דברים, בסדר הזה: ארגומנטי ברירת מחדל משתנים (למה basket=[] מסוכן), ההבדל בין is ל-==, ואיך scope של משתנים עובד בתוך פונקציה. המדריך הרשמי של Python ב-docs.python.org מכסה את שלושתם ישירות, והמונח \"Python gotchas\" מעלה דוגמאות מפורטות לכל אחד."
        },
        "intermediate": {
          "name": "בינוני",
          "desc": "אפשר להתמודד בנוחות עם סקריפטים יומיומיים — מבני נתונים, זרימת בקרה, פונקציות פשוטות — ועבודת תחזוקה שגרתית או פיצ'ר קטן בקוד קיים לא יאטו אותך. הפער בין כאן לרמה מתקדמת הוא בעיקר במה שקורה כשפיצ'רים נוחים של Python מתקשרים זה עם זה: העתקה רדודה שמשאירה נתונים מקוננים משותפים כשציפית לשכפול, ערך החזרה של generator שבשקט לא הופך לחלק מהפלט שלו, decorators שנערמים בסדר שקל להפוך. אלה סוגי הבאגים שסוקר בכיר מזהה בעשר שניות וכל השאר מבזבזים שעה לרדוף אחריהם.",
          "recommendation": "התמקדו בפנימיות של אובייקטים ואיטרציה: העתקה רדודה מול עמוקה, מה generator באמת עושה עם return, ואיך סדר הערימה של decorators עובד. אחר כך בסיסי מחלקות שרוב המדריכים מדלגים עליו — שוויון ברירת מחדל בלי __eq__, ולמה תכונת מחלקה משתנה משותפת בין כל המופעים."
        },
        "advanced": {
          "name": "מתקדם",
          "desc": "זו הרמה שרוב המשרות מתכוונות אליה כש\"Python חזק.\" אפשר להגיע לכלי הנכון בלי לחפש אותו, להבין למה מצב משותף השתנה ולא רק שהוא השתנה, ולקרוא פונקציה של מישהו אחר ולחזות נכון את הפלט שלה. מה שמפריד בין הרמה הזו לעליונה הוא הצד ההגנתי של העבודה: לדעת איזו משתי גישות שנראות נכונות תתנהג לא נכון ברגע שתכונת מחלקה, ארגומנט keyword-only, או היררכיית חריגות מעורבים.",
          "recommendation": "התקדמו לחלקים שמגנים על קוד שאנשים אחרים גם נוגעים בו: ארגומנטי keyword-only כבחירת עיצוב API ולא כסקרנות תחבירית, היררכיית החריגות (כדי שפסקאות except יתפסו את המשפחה הנכונה של שגיאות, לא רק מחלקה אחת), ו-context managers כדרך הסטנדרטית להבטיח ניקוי. המאמרים המעמיקים של Real Python הם תחנה טובה הבאה לשלושתם."
        },
        "expert": {
          "name": "מומחה",
          "desc": "השגת ציון מקסימלי בכל חלק — תחביר בסיסי, פונקציות ו-scope, מבני נתונים, ואידיומים מונחי עצמים. מבחינה מעשית, זה אומר שאפשר לקבל קובץ של מישהו זר ולהסביר למה הוא מייצר את הפלט שהוא מייצר, לא רק מה התחביר אומר שהוא צריך לעשות, וזו המיומנות הקשה והיקרה יותר. ברמה הזו השפה הגולמית היא לעתים רחוקות הגורם המגביל בעבודה; המגבלה היא בדרך כלל הגודל או הצורה של המערכת סביב הקוד.",
          "recommendation": "התשואה עכשיו היא בכלים ובסקירה: בדיקת טיפוסים סטטית עם mypy או pyright, פרופיילינג לפני אופטימיזציה במקום לנחש, וקריאת pull requests של אנשים אחרים בדיוק לקטגוריה הזו של באגים — אלה שעוברים כל בדיקה ועדיין עושים את הדבר הלא נכון תחת קלט ספציפי. אם עוברים סינון לתפקיד, תארו באג כזה שמצאתם במקום לנקוב בשמות של פיצ'רים בשפה — זה מדגים את החשיבה, לא רק את אוצר המילים."
        }
      },
      "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 ל-==, False ל-is — תוכן שווה אבל אובייקטים שונים בזיכרון"
            },
            {
              "icon": "",
              "label": "False לשניהם — ליטרלים נפרדים לעולם לא שווים ב-Python"
            },
            {
              "icon": "",
              "label": "True ל-is, 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 — שני האופרטורים מחזירים float ב-Python 3"
            },
            {
              "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) and (2 < 3)"
            },
            {
              "icon": "",
              "label": "False — השוואות משורשרות מוערכות משמאל לימין בלי short-circuiting, נותן 1 < 2 < 3 -> 1 < True -> False"
            },
            {
              "icon": "",
              "label": "SyntaxError — לא ניתן לשרשר השוואות"
            },
            {
              "icon": "",
              "label": "3 — Python מחזיר את הערך האחרון בשרשרת"
            }
          ]
        },
        {
          "question": "מה bool([]) מחזיר, ומה bool([0]) מחזיר?",
          "options": [
            {
              "icon": "",
              "label": "False, ואז False — כל רשימה שמכילה רק ערכים falsy היא falsy"
            },
            {
              "icon": "",
              "label": "False, ואז True — רשימה ריקה היא falsy, רשימה שמכילה אלמנט אחד (אפילו 0) היא truthy"
            },
            {
              "icon": "",
              "label": "True, ואז True — אובייקטים שאינם None הם תמיד truthy"
            },
            {
              "icon": "",
              "label": "True, ואז False — רשימה היא truthy רק כשהיא ריקה"
            }
          ]
        },
        {
          "question": "קיים count = 0 ברמת המודול. בתוך def increment(): count += 1; return count, קוראים ל-increment(). מה קורה?",
          "options": [
            {
              "icon": "",
              "label": "UnboundLocalError — השמה ל-count בכל מקום בפונקציה הופכת אותו למקומי, אז count += 1 מנסה לקרוא משתנה מקומי לפני שהוקצה לו ערך"
            },
            {
              "icon": "",
              "label": "מחזיר 1 ומעלה את count ברמת המודול ל-1"
            },
            {
              "icon": "",
              "label": "מחזיר 1 אבל משאיר את count ברמת המודול על 0"
            },
            {
              "icon": "",
              "label": "מעלה NameError כי count מעולם לא הוכרז בתוך הפונקציה"
            }
          ]
        },
        {
          "question": "def f(*args, **kwargs): return args, kwargs. מה f(1, 2, x=3) מחזיר?",
          "options": [
            {
              "icon": "",
              "label": "([1, 2], {'x': 3})"
            },
            {
              "icon": "",
              "label": "((1, 2), {'x': 3})"
            },
            {
              "icon": "",
              "label": "(1, 2, {'x': 3})"
            },
            {
              "icon": "",
              "label": "TypeError — לא ניתן לערבב ארגומנטים פוזיציונליים ו-keyword באותה קריאה"
            }
          ]
        },
        {
          "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. באיזה סדר ה-decorators מוחלים על f?",
          "options": [
            {
              "icon": "",
              "label": "b עוטף את f קודם, ואז a עוטף את התוצאה של b — ה-decorator הקרוב ביותר לפונקציה רץ ראשון"
            },
            {
              "icon": "",
              "label": "a עוטף את f קודם, ואז b עוטף את התוצאה — decorators מוחלים מלמעלה למטה"
            },
            {
              "icon": "",
              "label": "שני ה-decorators עוטפים את f באופן עצמאי ורק האחרון שהוגדר נכנס לתוקף"
            },
            {
              "icon": "",
              "label": "זה תלוי בסדר שבו ה-decorators מיובאים, לא במיקומם בקוד"
            }
          ]
        },
        {
          "question": "def f(a, *, b): return a + b. איזו מהקריאות הבאות עובדת?",
          "options": [
            {
              "icon": "",
              "label": "f(1, b=2) — b חייב להיות מועבר כ-keyword כי הוא בא אחרי ה-* החשוף בחתימה"
            },
            {
              "icon": "",
              "label": "f(1, 2) — ארגומנטים פוזיציונליים ממלאים פרמטרים משמאל לימין ללא קשר ל-*"
            },
            {
              "icon": "",
              "label": "f(a=1, 2) — ארגומנטי keyword חייבים לבוא ראשונים"
            },
            {
              "icon": "",
              "label": "f(1) — b הוא אופציונלי כי הוא בא אחרי ה-*"
            }
          ]
        },
        {
          "question": "פונקציית generator עושה yield 1, אז yield 2, ואז return 99. מה list(the_generator()) מכיל, ומה קורה ל-99?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 99] — return בתוך generator מתנהג כמו yield נוסף"
            },
            {
              "icon": "",
              "label": "[99] — return מיד דורס כל ערך שכבר הוחזר ב-yield"
            },
            {
              "icon": "",
              "label": "[1, 2] — ערך ההחזרה של generator הופך לערך המצורף ל-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 לא הוכרז בתוך inner() לפני הצהרת nonlocal"
            },
            {
              "icon": "",
              "label": "SyntaxError — ניתן להשתמש ב-nonlocal רק בתוך מחלקות"
            },
            {
              "icon": "",
              "label": "2 — nonlocal מאפשר ל-inner() לשנות את x של הפונקציה החיצונית במקום ליצור משתנה מקומי חדש"
            }
          ]
        },
        {
          "question": "d = {'a': 1, 'b': 2}. מה מחזיר d.get('c', 0), והאם זה מוסיף את 'c' למילון?",
          "options": [
            {
              "icon": "",
              "label": "0, ולא — get() מחזיר את ערך ברירת המחדל מבלי להוסיף את המפתח"
            },
            {
              "icon": "",
              "label": "0, וכן — get() מוסיף את המפתח עם ערך ברירת המחדל"
            },
            {
              "icon": "",
              "label": "KeyError, כי 'c' לא קיים"
            },
            {
              "icon": "",
              "label": "None, וכן — get() תמיד מוסיף מפתחות חסרים עם ערך None"
            }
          ]
        },
        {
          "question": "t = (1, 2, [3, 4]). האם אפשר להריץ t[2].append(5), והאם אפשר להריץ t[0] = 10?",
          "options": [
            {
              "icon": "",
              "label": "שניהם עובדים — הכנסת רשימה לתוך tuple הופכת את כל ה-tuple לניתן לשינוי"
            },
            {
              "icon": "",
              "label": "שניהם מעלים TypeError — שום דבר בתוך tuple לא ניתן לשינוי לעולם"
            },
            {
              "icon": "",
              "label": "t[2].append(5) מעלה TypeError, אבל t[0] = 10 עובד כי tuples מאפשרים השמה מחדש של האיבר הראשון"
            },
            {
              "icon": "",
              "label": "t[2].append(5) עובד כי הרשימה בפנים ניתנת לשינוי; t[0] = 10 מעלה TypeError כי ה-tuple עצמו אינו ניתן לשינוי"
            }
          ]
        },
        {
          "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"
            },
            {
              "icon": "",
              "label": "שניהם עצלניים — ההבדל היחיד הוא הטיפוס שמוחזר בסוף"
            },
            {
              "icon": "",
              "label": "אף אחד — שניהם בונים את הרצף המלא בזיכרון מיד"
            }
          ]
        },
        {
          "question": "בלוק try מחלק באפס, פסוקית except ZeroDivisionError מדפיסה 'a', ופסוקית finally מדפיסה 'b'. מה מודפס, ובאיזה סדר?",
          "options": [
            {
              "icon": "",
              "label": "b ואז a — finally תמיד רץ לפני כל פסוקית except"
            },
            {
              "icon": "",
              "label": "a ואז b — ה-except המתאים רץ קודם, ו-finally תמיד רץ אחר כך ללא קשר"
            },
            {
              "icon": "",
              "label": "רק b — החריגה לא באמת נתפסת, אז 'a' לעולם לא מודפס"
            },
            {
              "icon": "",
              "label": "רק a — finally מדולג ברגע שחריגה כבר טופלה"
            }
          ]
        },
        {
          "question": "import copy; a = [[1, 2], [3, 4]]; b = copy.copy(a); b[0].append(99). האם a[0] משתנה גם?",
          "options": [
            {
              "icon": "",
              "label": "לא — copy.copy() תמיד משכפל גם אובייקטים מקוננים"
            },
            {
              "icon": "",
              "label": "לא — הוספה ל-b[0] יוצרת רשימה חדשה לגמרי עבור 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` על dict תמיד מעלה TypeError"
            },
            {
              "icon": "",
              "label": "את המפתחות — `in` על מילון בודק שייכות בין המפתחות שלו, לא הערכים"
            }
          ]
        },
        {
          "question": "names = ['Al', 'Bo'] ו-scores = [10, 20]. מה מחזיר list(zip(names, scores))?",
          "options": [
            {
              "icon": "",
              "label": "[('Al', 'Bo'), (10, 20)]"
            },
            {
              "icon": "",
              "label": "['Al', 10, 'Bo', 20]"
            },
            {
              "icon": "",
              "label": "[('Al', 10), ('Bo', 20)]"
            },
            {
              "icon": "",
              "label": "ValueError, כי zip דורש שלושה ארגומנטים או יותר"
            }
          ]
        },
        {
          "question": "class Dog: tricks = [] מחזיק רשימה ברמת המחלקה, ו-add_trick מוסיף ל-self.tricks. נוצרים d1 = Dog() ו-d2 = Dog(), ואז רץ d1.add_trick('sit'). מה מכיל d2.tricks?",
          "options": [
            {
              "icon": "",
              "label": "[] — כל מופע מקבל עותק עצמאי משלו של tricks"
            },
            {
              "icon": "",
              "label": "['sit'] — tricks היא רשימה ברמת המחלקה המשותפת לכל המופעים, כך שהשינוי של d1 נראה גם ב-d2"
            },
            {
              "icon": "",
              "label": "TypeError — מופעים לא יכולים להוסיף לתכונת מחלקה"
            },
            {
              "icon": "",
              "label": "['sit'] רק אחרי שמריצים מחדש d2 = Dog()"
            }
          ]
        },
        {
          "question": "class A מכיל def greet(self): return 'A'. class B(A) מכיל def greet(self): return 'B' + super().greet(). מה מחזיר B().greet()?",
          "options": [
            {
              "icon": "",
              "label": "'AB' — super() תמיד רץ לפני הקוד של תת-המחלקה עצמה"
            },
            {
              "icon": "",
              "label": "'B' — super().greet() מתעלם כי B כבר דורס את greet"
            },
            {
              "icon": "",
              "label": "'BA' — super().greet() קורא למתודה של A והתוצאה מצורפת ל-'B'"
            },
            {
              "icon": "",
              "label": "AttributeError, כי ל-A אין מתודת greet הנראית ל-B"
            }
          ]
        },
        {
          "question": "class Point שומר self.x ב-__init__ ולא מגדיר מתודות אחרות. p1 = Point(1) ו-p2 = Point(1). מה מחזיר p1 == p2 כברירת מחדל?",
          "options": [
            {
              "icon": "",
              "label": "True — Python משווה את כל התכונות התואמות כברירת מחדל"
            },
            {
              "icon": "",
              "label": "False — ללא __eq__ מותאם אישית, == חוזר להשוואת זהות, ו-p1 ו-p2 הם אובייקטים שונים"
            },
            {
              "icon": "",
              "label": "True, אבל רק כי שני האובייקטים נוצרו עם אותו ארגומנט"
            },
            {
              "icon": "",
              "label": "TypeError, כי Point לא מגדיר __eq__"
            }
          ]
        },
        {
          "question": "איזו פסוקית except מבין אלה תתפוס גם ZeroDivisionError: except ArithmeticError, except ValueError, או except KeyError?",
          "options": [
            {
              "icon": "",
              "label": "except ValueError — שגיאות חילוק מטופלות כערכים לא תקינים"
            },
            {
              "icon": "",
              "label": "except KeyError — כל שגיאת זמן ריצה שלא קשורה לטיפוס ספציפי חוזרת ל-KeyError"
            },
            {
              "icon": "",
              "label": "אף אחת מהן — רק except ZeroDivisionError עצמו יכול לתפוס אותה"
            },
            {
              "icon": "",
              "label": "except ArithmeticError — ZeroDivisionError היא תת-מחלקה של ArithmeticError"
            }
          ]
        },
        {
          "question": "פותחים קובץ עם open('data.txt') as f: וחריגה מועלית בזמן קריאה בתוך הבלוק. האם הקובץ עדיין נסגר?",
          "options": [
            {
              "icon": "",
              "label": "לא — הקובץ נשאר פתוח כי הבלוק לא הסתיים כרגיל"
            },
            {
              "icon": "",
              "label": "רק אם מוסיפים גם פסוקית finally סביב הצהרת with"
            },
            {
              "icon": "",
              "label": "כן — הצהרת with קוראת למתודת __exit__ של הקובץ, שסוגרת אותו, גם אם מתרחשת חריגה בתוך הבלוק"
            },
            {
              "icon": "",
              "label": "זה תלוי בסוג החריגה — רק חריגות שנתפסות במקום אחר מפעילות ניקוי"
            }
          ]
        },
        {
          "question": "x = [3, 1, 2] ו-y = x.sort(). מה מכיל y?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3] — sort() מחזיר את הרשימה הממוינת החדשה"
            },
            {
              "icon": "",
              "label": "None — list.sort() ממיין במקום ומחזיר None; x עצמו הופך ל-[1, 2, 3]"
            },
            {
              "icon": "",
              "label": "[3, 1, 2] — sort() מחזיר את הרשימה המקורית הלא ממוינת ורק משנה את הסדר הפנימי של x"
            },
            {
              "icon": "",
              "label": "TypeError, כי לא ניתן להשים את sort() למשתנה"
            }
          ]
        },
        {
          "question": "מה קורה כשמריצים 'Score: ' + 42?",
          "options": [
            {
              "icon": "",
              "label": "'Score: 42' — Python ממיר את המספר אוטומטית בתוך ביטוי +"
            },
            {
              "icon": "",
              "label": "'Score: ' — המספר נזרק בשקט"
            },
            {
              "icon": "",
              "label": "42 — המחרוזת מומרת למספר ומחוברת"
            },
            {
              "icon": "",
              "label": "TypeError — לא ניתן לשרשר str ו-int ישירות, יש להמיר את 42 עם str() קודם"
            }
          ]
        },
        {
          "question": "צריך לבדוק האם רשימה בשם results ריקה. מהי הדרך האידיומטית ב-Python: if results == []: , if len(results) == 0: , או if not results: ?",
          "options": [
            {
              "icon": "",
              "label": "if results == []: — זו הדרך האמינה היחידה לזהות רשימה ריקה"
            },
            {
              "icon": "",
              "label": "if len(results) == 0: — זה נדרש כי רשימות ריקות הן truthy ב-Python"
            },
            {
              "icon": "",
              "label": "כל השלוש לעולם לא משמשות בפועל; הגישה הסטנדרטית היא if results is None:"
            },
            {
              "icon": "",
              "label": "if not results: — האידיום של Python מסתמך על truthiness, ורשימה ריקה היא falsy"
            }
          ]
        }
      ],
      "optionOrderVersion": "92945565db6c55da"
    }
  }
}