{
  "assessmentTests": {
    "python_test": {
      "name": "Python Test",
      "desc": "30 pertanyaan skenario tentang sintaks, fungsi, struktur data dan perilaku objek — cari tahu apakah keterampilan Python Anda sesuai dengan apa yang dimaksud oleh posting pekerjaan dengan profisiensi Python.",
      "recommendation": "Profil keterampilan Python Anda",
      "results": {
        "beginner": {
          "name": "Pemula",
          "desc": "Anda dapat mengikuti skrip pendek dan mengubah nilai di dalamnya, tetapi pertanyaan yang Anda lewatkan mengelompok di sekitar perilaku khusus bahasa itu sendiri daripada logika umum — argumen default yang dibangun sekali dan digunakan ulang, adalah versus == pada dua daftar yang terlihat sama, variabel yang menjadi lokal pada saat Anda menetapkan ke mana saja di fungsi. Tidak ada yang berkaitan dengan pemrograman yang buruk; ini adalah aturan khusus Python yang membuat orang dari bahasa lain terbentur sama sering dengan pemula. Ini penting di tempat kerja karena masing-masing adalah tempat bug bersembunyi dalam kode yang terlihat benar sekilas.",
          "recommendation": "Mulai dengan tiga hal, dalam urutan ini: argumen default yang dapat berubah (mengapa basket=[] berbahaya), perbedaan antara adalah dan ==, dan cara kerja ruang lingkup variabel di dalam fungsi. Tutorial Python resmi di docs.python.org mencakup ketiga-tiganya secara langsung, dan istilah \"Python gotchas\" menghasilkan contoh kerja masing-masing."
        },
        "intermediate": {
          "name": "Menengah",
          "desc": "Anda menangani skrip sehari-hari dengan nyaman — struktur data, aliran kontrol, fungsi mudah — dan tidak akan diperlambat oleh pekerjaan pemeliharaan rutin atau fitur kecil di basis kode yang ada. Kesenjangan antara di sini dan Lanjutan sebagian besar dalam apa yang terjadi ketika fitur kenyamanan Python berinteraksi satu sama lain: salinan dangkal meninggalkan data bersarang bersama ketika Anda mengharapkan duplikat, nilai pengembalian generator yang diam-diam tidak menjadi bagian dari output-nya, dekorator bertumpuk dalam urutan yang mudah dibalik. Itulah jenis bug yang ditandai oleh reviewer senior dalam sepuluh detik dan semua orang lainnya menghabiskan waktu satu jam mengejar.",
          "recommendation": "Fokus pada internal objek dan iterasi: salinan dangkal versus dalam, apa yang sebenarnya dilakukan generator dengan kembali, dan cara kerja urutan penumpukan dekorator. Kemudian dasar kelas yang sebagian besar tutorial lewatkan — kesetaraan default tanpa __eq__, dan mengapa atribut kelas yang dapat berubah dibagikan di setiap instance."
        },
        "advanced": {
          "name": "Lanjutan",
          "desc": "Ini adalah tingkat yang paling dimaksudkan oleh posting pekerjaan dengan \"Python yang kuat.\" Anda menjangkau alat yang tepat tanpa mencarinya, Anda tahu mengapa sepotong keadaan bersama berubah daripada hanya bahwa itu berubah, dan Anda dapat membaca fungsi orang lain dan memprediksi output-nya dengan benar. Apa yang memisahkan band ini dari puncak adalah sisi defensif pekerjaan: mengetahui mana dari dua pendekatan yang terlihat benar akan salah perilaku setelah atribut kelas, argumen hanya kata kunci, atau hierarki pengecualian terlibat.",
          "recommendation": "Dorong ke bagian yang melindungi basis kode yang orang lain juga sentuh: argumen khusus kata kunci sebagai pilihan desain API daripada keingintahuan sintaks, hierarki pengecualian (sehingga klausa kecuali menangkap keluarga kesalahan yang benar, bukan hanya satu kelas), dan pengelola konteks sebagai cara standar untuk menjamin pembersihan. Artikel penggalian mendalam Real Python adalah henti berikutnya yang baik untuk ketiga-tiganya."
        },
        "expert": {
          "name": "Ahli",
          "desc": "Anda mencetak gol di puncak setiap bagian — sintaks inti, fungsi dan ruang lingkup, struktur data, dan idiom berorientasi objek. Secara praktis, itu berarti Anda dapat diserahkan file orang asing dan jelaskan mengapa itu menghasilkan output yang itu lakukan, bukan hanya apa yang dikatakan sintaks seharusnya dilakukan, yang merupakan keterampilan yang lebih sulit dan lebih berharga. Pada level ini bahasa mentah jarang menjadi faktor pembatas dalam pekerjaan Anda; batasnya biasanya ukuran atau bentuk sistem di sekitar kode.",
          "recommendation": "Pengembalian sekarang dalam peralatan dan ulasan: pemeriksaan tipe statis dengan mypy atau pyright, profil sebelum mengoptimalkan daripada menebak, dan membaca permintaan tarik orang lain untuk kategori bug yang tepat ini — yang lulus setiap tes dan masih melakukan hal yang salah di bawah input tertentu. Jika Anda disaring untuk peran, jelaskan bug seperti ini yang Anda temukan daripada menamai fitur bahasa — itu menunjukkan penalaran, bukan hanya kosakata."
        }
      },
      "questions": [
        {
          "question": "Anda menulis def add_item(item, basket=[]): basket.append(item); return basket, lalu memanggil add_item('a') dan add_item('b'), kedua kali tanpa memberikan argumen basket. Apa yang dikembalikan pemanggilan kedua?",
          "options": [
            {
              "icon": "",
              "label": "['b'] — setiap pemanggilan mendapat daftar kosong yang baru sebagai default"
            },
            {
              "icon": "",
              "label": "TypeError — Anda harus memberikan argumen basket"
            },
            {
              "icon": "",
              "label": "['a', 'b'] — daftar default dibuat sekali dan digunakan ulang di semua pemanggilan"
            },
            {
              "icon": "",
              "label": "['a'] lalu ['b'] sebagai dua daftar item tunggal yang independen"
            }
          ]
        },
        {
          "question": "a = [1, 2, 3] dan b = [1, 2, 3]. Apa yang dikembalikan oleh a == b, dan apa yang dikembalikan oleh a is b?",
          "options": [
            {
              "icon": "",
              "label": "True untuk keduanya — daftar yang identik selalu objek yang sama"
            },
            {
              "icon": "",
              "label": "True untuk ==, False untuk is — isi yang sama tetapi objek berbeda di memori"
            },
            {
              "icon": "",
              "label": "False untuk keduanya — literal terpisah tidak pernah sama di Python"
            },
            {
              "icon": "",
              "label": "True untuk is, False untuk == — is memeriksa kesetaraan nilai untuk daftar"
            }
          ]
        },
        {
          "question": "Di Python 3, apa yang dievaluasi oleh 7 / 2, dan apa yang dievaluasi oleh 7 // 2?",
          "options": [
            {
              "icon": "",
              "label": "3.5, lalu 3 — / selalu mengembalikan float, // membulatkan hasil"
            },
            {
              "icon": "",
              "label": "3, lalu 3.5 — / memotong dan // mengembalikan float"
            },
            {
              "icon": "",
              "label": "3.5, lalu 3.5 — kedua operator mengembalikan float di Python 3"
            },
            {
              "icon": "",
              "label": "3, lalu 3 — kedua operator membulatkan hasil di Python 3"
            }
          ]
        },
        {
          "question": "s = 'hello', lalu Anda menjalankan s[0] = 'H'. Apa yang terjadi?",
          "options": [
            {
              "icon": "",
              "label": "s menjadi 'Hello'"
            },
            {
              "icon": "",
              "label": "s menjadi 'Hhello' karena karakter dimasukkan, bukan diganti"
            },
            {
              "icon": "",
              "label": "TypeError — string bersifat immutable dan tidak mendukung penugasan item"
            },
            {
              "icon": "",
              "label": "Tidak ada — penugasan dibisukan dan s tetap 'hello'"
            }
          ]
        },
        {
          "question": "x = [10, 20, 30, 40, 50]. Apa yang dikembalikan oleh 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' dan age = 30. Apa yang dihasilkan oleh f'{name} is {age}'?",
          "options": [
            {
              "icon": "",
              "label": "{name} is {age}"
            },
            {
              "icon": "",
              "label": "Ana is 30"
            },
            {
              "icon": "",
              "label": "name is age"
            },
            {
              "icon": "",
              "label": "TypeError, karena f-string memerlukan metode format()"
            }
          ]
        },
        {
          "question": "Apa yang dievaluasi oleh 1 < 2 < 3?",
          "options": [
            {
              "icon": "",
              "label": "True — Python merantai perbandingan sebagai (1 < 2) dan (2 < 3)"
            },
            {
              "icon": "",
              "label": "False — perbandingan berantai dievaluasi dari kiri ke kanan tanpa short-circuiting, memberikan 1 < 2 < 3 -> 1 < True -> False"
            },
            {
              "icon": "",
              "label": "SyntaxError — perbandingan tidak dapat dirantai"
            },
            {
              "icon": "",
              "label": "3 — Python mengembalikan nilai terakhir dalam rantai"
            }
          ]
        },
        {
          "question": "Apa yang dikembalikan oleh bool([]), dan apa yang dikembalikan oleh bool([0])?",
          "options": [
            {
              "icon": "",
              "label": "False, lalu False — setiap daftar yang berisi hanya nilai falsy adalah falsy"
            },
            {
              "icon": "",
              "label": "False, lalu True — daftar kosong adalah falsy, daftar yang berisi satu elemen (bahkan 0) adalah truthy"
            },
            {
              "icon": "",
              "label": "True, lalu True — objek non-None selalu truthy"
            },
            {
              "icon": "",
              "label": "True, lalu False — daftar truthy hanya ketika kosong"
            }
          ]
        },
        {
          "question": "Ada count = 0 level modul. Di dalam def increment(): count += 1; return count, Anda memanggil increment(). Apa yang terjadi?",
          "options": [
            {
              "icon": "",
              "label": "UnboundLocalError — menetapkan ke count di mana saja di fungsi membuatnya lokal, jadi count += 1 mencoba membaca variabel lokal sebelum itu ditugaskan"
            },
            {
              "icon": "",
              "label": "Ini mengembalikan 1 dan menambah count level modul menjadi 1"
            },
            {
              "icon": "",
              "label": "Ini mengembalikan 1 tetapi meninggalkan count level modul pada 0"
            },
            {
              "icon": "",
              "label": "Ini menimbulkan NameError karena count tidak pernah dideklarasikan di dalam fungsi"
            }
          ]
        },
        {
          "question": "def f(*args, **kwargs): return args, kwargs. Apa yang dikembalikan oleh 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 — argumen posisional dan kata kunci tidak dapat dicampur dalam satu panggilan"
            }
          ]
        },
        {
          "question": "Anda membuat funcs = [lambda: i for i in range(3)] dalam loop. Apa yang dikembalikan oleh [f() for f in funcs]?",
          "options": [
            {
              "icon": "",
              "label": "[2, 2, 2] — setiap lambda mencari i ketika dipanggil, dan pada saat itu loop selesai dengan i sama dengan 2"
            },
            {
              "icon": "",
              "label": "[0, 1, 2] — setiap lambda menangkap nilai i pada waktu ia dibuat"
            },
            {
              "icon": "",
              "label": "[0, 0, 0] — lambda selalu menangkap nilai pertama yang ditetapkan ke variabel"
            },
            {
              "icon": "",
              "label": "NameError, karena i tidak lagi ada setelah loop berakhir"
            }
          ]
        },
        {
          "question": "Fungsi didefinisikan dengan @a langsung di atas @b, yang terletak langsung di atas def f(): pass. Dalam urutan apa dekorator diterapkan pada f?",
          "options": [
            {
              "icon": "",
              "label": "b membungkus f terlebih dahulu, lalu a membungkus hasil b — dekorator terdekat dengan fungsi berjalan terlebih dahulu"
            },
            {
              "icon": "",
              "label": "a membungkus f terlebih dahulu, lalu b membungkus hasilnya — dekorator berlaku dari atas ke bawah"
            },
            {
              "icon": "",
              "label": "Kedua dekorator membungkus f secara independen dan hanya yang terakhir didefinisikan yang berlaku"
            },
            {
              "icon": "",
              "label": "Ini tergantung pada urutan dekorator diimpor, bukan posisi mereka di kode"
            }
          ]
        },
        {
          "question": "def f(a, *, b): return a + b. Manakah dari panggilan ini yang berhasil?",
          "options": [
            {
              "icon": "",
              "label": "f(1, b=2) — b harus dilewatkan oleh kata kunci karena datang setelah * kosong dalam tanda tangan"
            },
            {
              "icon": "",
              "label": "f(1, 2) — argumen posisional mengisi parameter dari kiri ke kanan terlepas dari *"
            },
            {
              "icon": "",
              "label": "f(a=1, 2) — argumen kata kunci harus datang terlebih dahulu"
            },
            {
              "icon": "",
              "label": "f(1) — b bersifat opsional karena mengikuti *"
            }
          ]
        },
        {
          "question": "Fungsi generator yields 1, lalu yields 2, lalu melakukan return 99. Apa yang berisi list(the_generator()), dan apa yang terjadi pada 99?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 99] — return di dalam generator berperilaku seperti satu yield lagi"
            },
            {
              "icon": "",
              "label": "[99] — return segera menimpa nilai apa pun yang sudah di-yield"
            },
            {
              "icon": "",
              "label": "[1, 2] — nilai pengembalian generator menjadi nilai yang terlampir pada StopIteration yang dimunculkannya, itu tidak di-yield"
            },
            {
              "icon": "",
              "label": "RuntimeError, karena generator tidak dapat berisi pernyataan return"
            }
          ]
        },
        {
          "question": "Di fungsi outer(), x = 1 ditetapkan, lalu nested inner() melakukan nonlocal x; x += 1, dan outer() memanggil inner() sebelum mengembalikan x. Apa yang dikembalikan oleh outer()?",
          "options": [
            {
              "icon": "",
              "label": "1 — inner() beroperasi pada salinan lokal x-nya sendiri, jadi perubahan tidak bertahan"
            },
            {
              "icon": "",
              "label": "UnboundLocalError, karena x tidak dideklarasikan di dalam inner() sebelum pernyataan nonlocal"
            },
            {
              "icon": "",
              "label": "SyntaxError — nonlocal hanya dapat digunakan di dalam kelas"
            },
            {
              "icon": "",
              "label": "2 — nonlocal membiarkan inner() memodifikasi x fungsi outer daripada membuat variabel lokal baru"
            }
          ]
        },
        {
          "question": "d = {'a': 1, 'b': 2}. Apa yang dikembalikan oleh d.get('c', 0), dan apakah itu menambahkan 'c' ke kamus?",
          "options": [
            {
              "icon": "",
              "label": "0, dan tidak — get() mengembalikan default tanpa memasukkan kunci"
            },
            {
              "icon": "",
              "label": "0, dan ya — get() memasukkan kunci dengan nilai default"
            },
            {
              "icon": "",
              "label": "KeyError, karena 'c' tidak ada"
            },
            {
              "icon": "",
              "label": "None, dan ya — get() selalu menambahkan kunci yang hilang dengan nilai None"
            }
          ]
        },
        {
          "question": "t = (1, 2, [3, 4]). Bisakah Anda menjalankan t[2].append(5), dan bisakah Anda menjalankan t[0] = 10?",
          "options": [
            {
              "icon": "",
              "label": "Keduanya bekerja — bersarang daftar di dalam tuple membuat seluruh tuple dapat berubah"
            },
            {
              "icon": "",
              "label": "Kedua raise TypeError — tidak ada apa pun di dalam tuple yang dapat pernah diubah"
            },
            {
              "icon": "",
              "label": "t[2].append(5) raises TypeError, tetapi t[0] = 10 bekerja karena tuple memungkinkan penugasan ulang elemen pertamanya"
            },
            {
              "icon": "",
              "label": "t[2].append(5) bekerja karena daftar di dalamnya dapat berubah; t[0] = 10 raises TypeError karena tuple itu sendiri bersifat immutable"
            }
          ]
        },
        {
          "question": "Mana dari ini yang mengembalikan iterator yang menghitung nilai dengan malas daripada membangun seluruh urutan dalam memori sekaligus: [x*x for x in range(1000000)] atau (x*x for x in range(1000000))?",
          "options": [
            {
              "icon": "",
              "label": "Yang dengan tanda kurung, (x*x for x in range(1000000)) — itu adalah ekspresi generator"
            },
            {
              "icon": "",
              "label": "Yang dengan tanda kurung siku — list comprehensions selalu malas di Python 3"
            },
            {
              "icon": "",
              "label": "Keduanya malas — satu-satunya perbedaan adalah tipe yang dikembalikan di akhir"
            },
            {
              "icon": "",
              "label": "Tidak ada — keduanya membangun urutan penuh dalam memori segera"
            }
          ]
        },
        {
          "question": "Blok try membagi dengan nol, klausa except ZeroDivisionError mencetak 'a', dan klausa finally mencetak 'b'. Apa yang dicetak, dan dalam urutan apa?",
          "options": [
            {
              "icon": "",
              "label": "b lalu a — finally selalu berjalan sebelum klausa except apa pun"
            },
            {
              "icon": "",
              "label": "a lalu b — except yang cocok berjalan terlebih dahulu, dan finally selalu berjalan setelahnya terlepas"
            },
            {
              "icon": "",
              "label": "Hanya b — pengecualian tidak benar-benar ditangkap, jadi 'a' tidak pernah dicetak"
            },
            {
              "icon": "",
              "label": "Hanya a — finally dilewatkan setelah pengecualian sudah ditangani"
            }
          ]
        },
        {
          "question": "import copy; a = [[1, 2], [3, 4]]; b = copy.copy(a); b[0].append(99). Apakah a[0] juga berubah?",
          "options": [
            {
              "icon": "",
              "label": "Tidak — copy.copy() selalu menduplikasi objek bersarang juga"
            },
            {
              "icon": "",
              "label": "Tidak — menambahkan ke b[0] membuat daftar merek-baru untuk b[0] saja"
            },
            {
              "icon": "",
              "label": "Ya, tetapi hanya karena copy.copy() dipanggil tanpa argumen deepcopy"
            },
            {
              "icon": "",
              "label": "Ya — copy.copy() membuat salinan dangkal, jadi daftar bersarang masih dibagikan antara a dan b"
            }
          ]
        },
        {
          "question": "d = {'x': 1, 'y': 2}. Apa yang memeriksa 'x' in d — kunci, nilai, atau keduanya?",
          "options": [
            {
              "icon": "",
              "label": "Nilai — `in` memeriksa apakah 1 atau 2 sama dengan 'x'"
            },
            {
              "icon": "",
              "label": "Baik kunci maupun nilai diperiksa"
            },
            {
              "icon": "",
              "label": "Tidak ada — `in` di kamus selalu menimbulkan TypeError"
            },
            {
              "icon": "",
              "label": "Kunci — `in` di kamus menguji keanggotaan di antara kuncinya, bukan nilainya"
            }
          ]
        },
        {
          "question": "names = ['Al', 'Bo'] dan scores = [10, 20]. Apa yang dikembalikan oleh 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, karena zip memerlukan tiga atau lebih argumen"
            }
          ]
        },
        {
          "question": "class Dog: tricks = [] menampung daftar level kelas, dan add_trick menambahkan ke self.tricks. d1 = Dog() dan d2 = Dog() keduanya dibuat, lalu d1.add_trick('sit') berjalan. Apa yang berisi d2.tricks?",
          "options": [
            {
              "icon": "",
              "label": "[] — setiap instance mendapat salinannya sendiri yang independen dari tricks"
            },
            {
              "icon": "",
              "label": "['sit'] — tricks adalah daftar level kelas yang dibagikan oleh setiap instance, jadi perubahan d1 terlihat pada d2 juga"
            },
            {
              "icon": "",
              "label": "TypeError — instance tidak dapat menambahkan ke atribut kelas"
            },
            {
              "icon": "",
              "label": "['sit'] hanya setelah d2 = Dog() dijalankan kembali"
            }
          ]
        },
        {
          "question": "class A memiliki def greet(self): return 'A'. class B(A) memiliki def greet(self): return 'B' + super().greet(). Apa yang dikembalikan oleh B().greet()?",
          "options": [
            {
              "icon": "",
              "label": "'AB' — super() selalu berjalan sebelum kode subclass itu sendiri"
            },
            {
              "icon": "",
              "label": "'B' — super().greet() diabaikan karena B sudah menimpa greet"
            },
            {
              "icon": "",
              "label": "'BA' — super().greet() memanggil metode A dan hasilnya ditambahkan ke 'B'"
            },
            {
              "icon": "",
              "label": "AttributeError, karena A tidak memiliki metode greet yang terlihat oleh B"
            }
          ]
        },
        {
          "question": "class Point menyimpan self.x di __init__ dan tidak mendefinisikan metode lainnya. p1 = Point(1) dan p2 = Point(1). Apa yang dikembalikan oleh p1 == p2 secara default?",
          "options": [
            {
              "icon": "",
              "label": "True — Python membandingkan semua atribut yang cocok secara default"
            },
            {
              "icon": "",
              "label": "False — tanpa __eq__ khusus, == jatuh kembali ke perbandingan identitas, dan p1 dan p2 adalah objek berbeda"
            },
            {
              "icon": "",
              "label": "True, tetapi hanya karena kedua objek dibuat dengan argumen yang sama"
            },
            {
              "icon": "",
              "label": "TypeError, karena Point tidak mendefinisikan __eq__"
            }
          ]
        },
        {
          "question": "Mana dari klausa except di bawah ini yang juga akan menangkap ZeroDivisionError: except ArithmeticError, except ValueError, atau except KeyError?",
          "options": [
            {
              "icon": "",
              "label": "except ValueError — kesalahan divisi diperlakukan sebagai nilai yang tidak valid"
            },
            {
              "icon": "",
              "label": "except KeyError — kesalahan runtime apa pun yang tidak terikat pada jenis tertentu jatuh kembali ke KeyError"
            },
            {
              "icon": "",
              "label": "Tidak ada satu pun — hanya except ZeroDivisionError itu sendiri yang dapat menangkapnya"
            },
            {
              "icon": "",
              "label": "except ArithmeticError — ZeroDivisionError adalah subkelas dari ArithmeticError"
            }
          ]
        },
        {
          "question": "Anda membuka file dengan open('data.txt') as f: dan pengecualian dimunculkan saat membaca di dalam blok. Apakah file masih ditutup?",
          "options": [
            {
              "icon": "",
              "label": "Tidak — file tetap terbuka karena blok tidak selesai secara normal"
            },
            {
              "icon": "",
              "label": "Hanya jika Anda juga menambahkan klausa finally di sekitar pernyataan with"
            },
            {
              "icon": "",
              "label": "Ya — pernyataan with memanggil metode __exit__ file, yang menutupnya, bahkan jika pengecualian terjadi di dalam blok"
            },
            {
              "icon": "",
              "label": "Itu tergantung pada jenis pengecualian — hanya pengecualian yang ditangkap di tempat lain yang memicu pembersihan"
            }
          ]
        },
        {
          "question": "x = [3, 1, 2] dan y = x.sort(). Apa yang disimpan y?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3] — sort() mengembalikan daftar yang baru diurutkan"
            },
            {
              "icon": "",
              "label": "None — list.sort() mengurutkan di tempat dan mengembalikan None; x itu sendiri menjadi [1, 2, 3]"
            },
            {
              "icon": "",
              "label": "[3, 1, 2] — sort() mengembalikan daftar asli yang tidak diurutkan dan hanya mengubah urutan internal x"
            },
            {
              "icon": "",
              "label": "TypeError, karena sort() tidak dapat ditetapkan ke variabel"
            }
          ]
        },
        {
          "question": "Apa yang terjadi ketika Anda menjalankan 'Score: ' + 42?",
          "options": [
            {
              "icon": "",
              "label": "'Score: 42' — Python mengkonversi angka secara otomatis di dalam ekspresi +"
            },
            {
              "icon": "",
              "label": "'Score: ' — angka dibisukan"
            },
            {
              "icon": "",
              "label": "42 — string dipaksa menjadi angka dan ditambahkan"
            },
            {
              "icon": "",
              "label": "TypeError — Anda tidak dapat menggabungkan str dan int secara langsung, 42 harus dikonversi dengan str() terlebih dahulu"
            }
          ]
        },
        {
          "question": "Anda perlu memeriksa apakah daftar yang disebut results kosong. Manakah cara idiomatik Python: if results == []: , if len(results) == 0: , atau if not results: ?",
          "options": [
            {
              "icon": "",
              "label": "if results == []: — ini adalah satu-satunya cara yang andal untuk mendeteksi daftar kosong"
            },
            {
              "icon": "",
              "label": "if len(results) == 0: — ini diperlukan karena daftar kosong adalah truthy di Python"
            },
            {
              "icon": "",
              "label": "Ketiga-tiganya sama sekali tidak pernah digunakan dalam praktik; pendekatan standar adalah if results is None:"
            },
            {
              "icon": "",
              "label": "if not results: — idiom Python mengandalkan truthiness, dan daftar kosong adalah falsy"
            }
          ]
        }
      ],
      "optionOrderVersion": "92945565db6c55da"
    }
  }
}