{
  "assessmentTests": {
    "python_test": {
      "name": "Python Testi",
      "desc": "Python sözdizimine, işlevlere, veri yapılarına ve nesne davranışına ilişkin 30 senaryo sorusu — Python becerilerinizin iş ilanında \"Python yetkinliği\" ile ne kadar örtüştüğünü öğrenin.",
      "recommendation": "Python beceri profiliniz",
      "results": {
        "beginner": {
          "name": "Başlangıç",
          "desc": "Kısa bir komut dosyasını takip edebilir ve içindeki değerleri değiştirebilirsiniz, ancak kaçırdığınız sorular dilin genel mantığı değil kendi belirli davranışı etrafında kümelenir — bir kez oluşturulan ve çağrılar arasında yeniden kullanılan varsayılan bağımsız değişken, iki eşit görünen listenin karşılaştırılmasında \"is\" ile \"==\", bir işlevde herhangi bir yerde atama yapılan değişkenin o anda yerel hale gelmesi. Bu hiçbiri programcılık konusunda kötü olmakla ilgili değildir; bunlar diğer dillerden gelen insanları başlangıçlı kullanıcılar kadar sıkça çalıştıran Python'a özgü kurallarıdır. İş hayatında önemlidirler çünkü her biri bir hata bulunduran kodun ilk bakışta doğru görünen yerdir.",
          "recommendation": "Bu sırayla üç şeyle başlayın: değişken varsayılan bağımsız değişkenler (neden basket=[] tehlikeli), is ve == arasındaki fark ve işlev içinde değişken kapsamı nasıl çalışır. docs.python.org adresindeki resmi Python öğreticisi üçünü de doğrudan kapsar ve \"Python tuzakları\" terimini aratırsanız her birinin çalışılmış örneklerini bulursunuz."
        },
        "intermediate": {
          "name": "Orta Düzey",
          "desc": "Gündelik komut dosyası yazımını rahatça yönetirsiniz — veri yapıları, kontrol akışı, doğrudan işlevler — ve rutin bakım işleri veya mevcut bir kod tabanındaki küçük bir özellik tarafından yavaşlatılmayacaksınız. Buradan İleri Düzeye kadar olan boşluk çoğunlukla Python'un kolaylık özellikleri birbirleriyle etkileşime girdiğinde meydana gelen şeydir: iç içe verileri kopya alınmış olarak beklediğiniz halde paylaşılan kalan sığ kopya, bir oluşturucunun dönüş değeri sessizce çıktısının parçası haline gelmeyen değer, tasarımcılar geriye doğru alması kolay olan bir sırayla istiflenmiş. Bunlar senior yorum yapıcının on saniye içinde işaret ettiği ama başkaların bir saat takip ettiği tür hatalarıdır.",
          "recommendation": "Nesne ve yineleme içselleşmelerine odaklanın: sığ kopyaya karşı derin kopya, bir oluşturucu geri dönüşün gerçekte ne yaptığı ve tasarımcı istiflemesi sırasının nasıl çalıştığı. Sonra çoğu öğretici tarafından atlanılan sınıf temellerine — varsayılan eşitlik olmaksızın __eq__, ve değişken bir sınıf özniteliğinin neden her örnek arasında paylaşıldığı."
        },
        "advanced": {
          "name": "İleri Düzey",
          "desc": "Bu, çoğu iş ilanında \"güçlü Python\" ile kastedilen düzeydir. Bunu aramaksızın doğru aracı almaya yönelirsiniz, paylaşılan bir durumun neden değiştiğini sadece o değiştiği değil bilirsiniz ve başka birinin işlevini okuyabilir ve çıktısını doğru bir şekilde öngörebilirsiniz. Bu bandı en tepeden ayıran şey işin savunma tarafıdır: bir sınıf özniteliği, anahtar kelime argümanı veya istisna hiyerarşisi söz konusu olduğunda iki doğru görünen yaklaşımdan hangisinin hatalı davranacağını bilmek.",
          "recommendation": "Başka insanların da dokunduğu kod tabanını koruma parçalarına girmeye çalışın: API tasarım seçimi olarak anahtar kelime argümanları sözdizim merakı değil, istisna hiyerarşisi (except cümlelerinin sadece bir sınıfı değil doğru hata ailesini yakalaması için) ve bağlam yöneticileri temizlenmeyi garanti etmenin standart yolu olarak. Real Python'un derin dalış makaleleri üçünün hepsi için iyi bir sonraki duruş."
        },
        "expert": {
          "name": "Uzman",
          "desc": "Her bölümün en üst seviyesinde — temel sözdizim, işlevler ve kapsam, veri yapıları ve nesne yönelimli deyimler — puanlandınız. Pratik olarak, bu başka birinin dosyasını verebileceğiniz ve neden ürettiği çıktıyı sözdizimi ne söylese sadece ne söylese değil neden ürettğini açıklayabileceğiniz anlamına gelir, bu daha zor ve daha değerli beceridir. Bu seviyede ham dil nadiren işinizdeki sınırlayıcı faktördür; sınırı genellikle kod etrafındaki sistemin boyutu veya şekli belirler.",
          "recommendation": "Getiriler şimdi araçlar ve gözden geçirmede: mypy veya pyright ile statik tür denetimi, tahmin etmek yerine optimize etmeden önce profil oluşturma ve diğer insanların çekme istekleri okuması tam olarak bu kategori için — her testi geçen ama belirli bir giriş altında yanlış yapan olanlar. Bir rol için taranıyorsanız, başlangıçta dil özelliklerini adlandırıktan ziyade bulmak gibi bir hatayı açıklayın — akıl yürütmeyi gösterir, sadece kelime türü göstermez."
        }
      },
      "questions": [
        {
          "question": "def add_item(item, basket=[]): basket.append(item); return basket yazarsınız, sonra add_item('a') ve add_item('b') çağırırsınız, her iki sefer de basket'i atlarsınız. İkinci çağrı ne döndürür?",
          "options": [
            {
              "icon": "",
              "label": "['b'] — her çağrı varsayılan olarak yeni bir boş liste alır"
            },
            {
              "icon": "",
              "label": "TypeError — basket bağımsız değişkenini sağlamalısınız"
            },
            {
              "icon": "",
              "label": "['a', 'b'] — varsayılan liste bir kez oluşturulur ve çağrılar arasında yeniden kullanılır"
            },
            {
              "icon": "",
              "label": "['a'] sonra ['b'] iki bağımsız tek öğeli liste olarak"
            }
          ]
        },
        {
          "question": "a = [1, 2, 3] ve b = [1, 2, 3]. a == b ne döndürür, a is b ne döndürür?",
          "options": [
            {
              "icon": "",
              "label": "Her ikisi True — eşit listeler her zaman aynı nesnedir"
            },
            {
              "icon": "",
              "label": "== için True, is için False — eşit içerik ama bellekte farklı nesneler"
            },
            {
              "icon": "",
              "label": "Her ikisi False — ayrı değişmezler Python'da asla eşit değildir"
            },
            {
              "icon": "",
              "label": "is için True, == için False — is listeler için değer eşitliğini kontrol eder"
            }
          ]
        },
        {
          "question": "Python 3'te, 7 / 2 ne değerlendirilir, 7 // 2 ne değerlendirilir?",
          "options": [
            {
              "icon": "",
              "label": "3.5, sonra 3 — / her zaman float döndürür, // sonucu yuvarlar"
            },
            {
              "icon": "",
              "label": "3, sonra 3.5 — / kesir atar ve // float döndürür"
            },
            {
              "icon": "",
              "label": "3.5, sonra 3.5 — her iki işleç de Python 3'te float döndürür"
            },
            {
              "icon": "",
              "label": "3, sonra 3 — her iki işleç de Python 3'te sonucu yuvarlar"
            }
          ]
        },
        {
          "question": "s = 'hello', sonra s[0] = 'H' çalıştırırsınız. Ne olur?",
          "options": [
            {
              "icon": "",
              "label": "s 'Hello' olur"
            },
            {
              "icon": "",
              "label": "s 'Hhello' olur çünkü karakter değiştirilmiş değil eklenir"
            },
            {
              "icon": "",
              "label": "TypeError — dizeler değişmezdir ve öğe atamasını desteklemez"
            },
            {
              "icon": "",
              "label": "Hiçbir şey — atama sessizce yok sayılır ve s 'hello' kalır"
            }
          ]
        },
        {
          "question": "x = [10, 20, 30, 40, 50]. x[1:4] ne döndürür?",
          "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' ve age = 30. f'{name} is {age}' ne üretir?",
          "options": [
            {
              "icon": "",
              "label": "{name} is {age}"
            },
            {
              "icon": "",
              "label": "Ana is 30"
            },
            {
              "icon": "",
              "label": "name is age"
            },
            {
              "icon": "",
              "label": "f-dizeler format() yöntemi gerektirdiği için TypeError"
            }
          ]
        },
        {
          "question": "1 < 2 < 3 ne değerlendirilir?",
          "options": [
            {
              "icon": "",
              "label": "True — Python karşılaştırmaları (1 < 2) ve (2 < 3) olarak zincirler"
            },
            {
              "icon": "",
              "label": "False — zincir karşılaştırmalar kısa devreye almadan soldan sağa değerlendirilir, 1 < 2 < 3 -> 1 < True -> False verir"
            },
            {
              "icon": "",
              "label": "SyntaxError — karşılaştırmalar zincirlenemez"
            },
            {
              "icon": "",
              "label": "3 — Python zincirdeki son değeri döndürür"
            }
          ]
        },
        {
          "question": "bool([]) ne döndürür, bool([0]) ne döndürür?",
          "options": [
            {
              "icon": "",
              "label": "False, sonra False — sadece yanlış değerler içeren herhangi bir liste yanlıştır"
            },
            {
              "icon": "",
              "label": "False, sonra True — boş liste yanlış, bir öğe (hatta 0) içeren liste doğru"
            },
            {
              "icon": "",
              "label": "True, sonra True — None olmayan nesneler her zaman doğru"
            },
            {
              "icon": "",
              "label": "True, sonra False — bir liste sadece boş olduğunda doğru"
            }
          ]
        },
        {
          "question": "Modül düzeyinde count = 0 var. def increment() içinde: count += 1; return count, increment() çağırırsınız. Ne olur?",
          "options": [
            {
              "icon": "",
              "label": "UnboundLocalError — işlevde herhangi bir yere atama yapılması bunu yerel yapar, bu nedenle count += 1 yerel değişkeni atamadan önce okumaya çalışır"
            },
            {
              "icon": "",
              "label": "1 döndürür ve modül düzeyindeki count'u 1'e artırır"
            },
            {
              "icon": "",
              "label": "1 döndürür ama modül düzeyindeki count'u 0'da bırakır"
            },
            {
              "icon": "",
              "label": "NameError çıkarır çünkü işlev içinde count hiçbir zaman bildirilmemiş"
            }
          ]
        },
        {
          "question": "def f(*args, **kwargs): return args, kwargs. f(1, 2, x=3) ne döndürür?",
          "options": [
            {
              "icon": "",
              "label": "([1, 2], {'x': 3})"
            },
            {
              "icon": "",
              "label": "((1, 2), {'x': 3})"
            },
            {
              "icon": "",
              "label": "(1, 2, {'x': 3})"
            },
            {
              "icon": "",
              "label": "TypeError — konumsal ve anahtar kelime bağımsız değişkenleri bir çağrıda karıştırılamaz"
            }
          ]
        },
        {
          "question": "Bir döngüde funcs = [lambda: i for i in range(3)] oluşturursunuz. [f() for f in funcs] ne döndürür?",
          "options": [
            {
              "icon": "",
              "label": "[2, 2, 2] — her lambda çağrıldığında i'yi arar, bu noktada döngü i = 2'ye eşit olmuş olur"
            },
            {
              "icon": "",
              "label": "[0, 1, 2] — her lambda oluşturulduğunda i değerini yakalar"
            },
            {
              "icon": "",
              "label": "[0, 0, 0] — lambdalar her zaman bir değişkene atanan ilk değeri yakalar"
            },
            {
              "icon": "",
              "label": "NameError, çünkü döngü sona erdiğinde i artık yok"
            }
          ]
        },
        {
          "question": "Bir işlev @a doğrudan üstünde tanımlanır, @b da altında, def f(): pass en altta. Tasarımcılar f'ye hangi sırayla uygulanır?",
          "options": [
            {
              "icon": "",
              "label": "b f'yi sarıp sonra a b'nin sonucunu sarıp — işleve en yakın tasarımcı ilk çalışır"
            },
            {
              "icon": "",
              "label": "a f'yi sarıp sonra b sonucu sarıp — tasarımcılar üstten alta uygulanır"
            },
            {
              "icon": "",
              "label": "Her iki tasarımcı da f'yi bağımsız olarak sarıp sadece son tanımlanan etki alır"
            },
            {
              "icon": "",
              "label": "Tasarımcıların kodda konumlarına değil nasıl içe aktarıldığına bağlıdır"
            }
          ]
        },
        {
          "question": "def f(a, *, b): return a + b. Bu çağrılardan hangisi çalışır?",
          "options": [
            {
              "icon": "",
              "label": "f(1, b=2) — b anahtar kelime ile geçilmelidir çünkü imzada çıplak * sonrasında gelir"
            },
            {
              "icon": "",
              "label": "f(1, 2) — konumsal bağımsız değişkenler * ne olursa olsun soldan sağa parametreleri doldurur"
            },
            {
              "icon": "",
              "label": "f(a=1, 2) — anahtar kelime bağımsız değişkenleri ilk gelmelidir"
            },
            {
              "icon": "",
              "label": "f(1) — b isteğe bağlıdır çünkü * sonrasında gelir"
            }
          ]
        },
        {
          "question": "Bir oluşturucu işlev yield 1 yapıp yield 2 yapıp sonra return 99 yapar. list(the_generator()) ne içerir, 99'a ne olur?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 99] — bir oluşturucu içinde return bir daha yield gibi davranır"
            },
            {
              "icon": "",
              "label": "[99] — return hemen zaten verilen herhangi bir değeri geçersiz kılar"
            },
            {
              "icon": "",
              "label": "[1, 2] — bir oluşturucunun dönüş değeri çıkardığı StopIteration'a eklenmiş değer, verilmiş değil"
            },
            {
              "icon": "",
              "label": "RuntimeError, çünkü oluşturucular return deyimi içeremez"
            }
          ]
        },
        {
          "question": "outer() işlevinde x = 1 ayarlanır, sonra iç inner() nonlocal x; x += 1 yapar, ve outer() return x'ten önce inner() çağırır. outer() ne döndürür?",
          "options": [
            {
              "icon": "",
              "label": "1 — inner() x'in kendi yerel kopyası üzerinde çalışır, bu nedenle değişiklik devam etmez"
            },
            {
              "icon": "",
              "label": "UnboundLocalError, çünkü nonlocal deyiminden önce x inner() içinde bildirilmemiş"
            },
            {
              "icon": "",
              "label": "SyntaxError — nonlocal sadece sınıflar içinde kullanılabilir"
            },
            {
              "icon": "",
              "label": "2 — nonlocal inner()'nin yerel bir değişken oluşturmak yerine dış işlevin x'ini değiştirmesine izin verir"
            }
          ]
        },
        {
          "question": "d = {'a': 1, 'b': 2}. d.get('c', 0) ne döndürür, sözlüğe 'c' ekler mi?",
          "options": [
            {
              "icon": "",
              "label": "0, ve hayır — get() varsayılanı anahtar eklemeden döndürür"
            },
            {
              "icon": "",
              "label": "0, ve evet — get() anahtarı varsayılan değerle ekler"
            },
            {
              "icon": "",
              "label": "KeyError, çünkü 'c' yok"
            },
            {
              "icon": "",
              "label": "None, ve evet — get() her zaman eksik anahtarları None değeriyle ekler"
            }
          ]
        },
        {
          "question": "t = (1, 2, [3, 4]). t[2].append(5) çalıştırabilirim, t[0] = 10 çalıştırabilirim?",
          "options": [
            {
              "icon": "",
              "label": "Her ikisi çalışır — bir listeyi demete yuvalamak tüm demetini değişken yapar"
            },
            {
              "icon": "",
              "label": "Her ikisi TypeError çıkarır — demetin içindeki hiçbir şey değişemez"
            },
            {
              "icon": "",
              "label": "t[2].append(5) TypeError çıkarır ama t[0] = 10 çalışır çünkü demetler ilk öğesinin yeniden atanmasına izin verir"
            },
            {
              "icon": "",
              "label": "t[2].append(5) çalışır çünkü içindekilist değişkendir; t[0] = 10 TypeError çıkarır çünkü demetin kendisi değişmezdir"
            }
          ]
        },
        {
          "question": "Bu iki arasından hangisi tüm diziyi bellekte oluşturmak yerine değerleri tembelce hesaplayan bir yineleyici döndürür: [x*x for x in range(1000000)] veya (x*x for x in range(1000000))?",
          "options": [
            {
              "icon": "",
              "label": "Parantezli olan (x*x for x in range(1000000)) — o bir oluşturucu ifadesi"
            },
            {
              "icon": "",
              "label": "Kare parantez — liste içerikli anlamalar Python 3'te her zaman tembeldir"
            },
            {
              "icon": "",
              "label": "Her ikisi tembeldir — tek fark sonunda döndürülen tiptir"
            },
            {
              "icon": "",
              "label": "İkisi de değil — her ikisi de tam diziyi bellekte hemen oluşturur"
            }
          ]
        },
        {
          "question": "Bir try bloğu sıfıra bölünen, except ZeroDivisionError yanlışı 'a' yazdırıp ve finally yanlışı 'b' yazdırır. Ne yazdırılır, ne sırayla?",
          "options": [
            {
              "icon": "",
              "label": "b sonra a — finally her zaman herhangi bir except yanlışından önce çalışır"
            },
            {
              "icon": "",
              "label": "a sonra b — eşleşen except ilk çalışır, finally her zaman sonra çalışır karşı olsun"
            },
            {
              "icon": "",
              "label": "Sadece b — istisna gerçekte yakalanmadı, bu nedenle 'a' asla yazdırılmaz"
            },
            {
              "icon": "",
              "label": "Sadece a — istisna zaten işlenmiş olduğunda finally atlanır"
            }
          ]
        },
        {
          "question": "import copy; a = [[1, 2], [3, 4]]; b = copy.copy(a); b[0].append(99). a[0] da değişir mi?",
          "options": [
            {
              "icon": "",
              "label": "Hayır — copy.copy() her zaman iç içe nesneleri de çoğaltır"
            },
            {
              "icon": "",
              "label": "Hayır — b[0] için yeni bir liste oluşturur b[0]'a eklenir"
            },
            {
              "icon": "",
              "label": "Evet ama sadece copy.copy() deepcopy bağımsız değişkeni olmadan çağrılması nedeniyle"
            },
            {
              "icon": "",
              "label": "Evet — copy.copy() sığ kopya yapar, bu nedenle iç içe listeler a ve b arasında hala paylaşılır"
            }
          ]
        },
        {
          "question": "d = {'x': 1, 'y': 2}. 'x' in d neye karşı kontrol eder — anahtarlar, değerler veya ikisi?",
          "options": [
            {
              "icon": "",
              "label": "Değerlere — `in` 1 veya 2 eşittir mi 'x' kontrol eder"
            },
            {
              "icon": "",
              "label": "Hem anahtarlar hem de değerler kontrol edilir"
            },
            {
              "icon": "",
              "label": "İkisi de değil — sözlükte `in` her zaman TypeError çıkarır"
            },
            {
              "icon": "",
              "label": "Anahtarlara — sözlükte `in` üyelik anahtarlar arasında test eder, değerleri değil"
            }
          ]
        },
        {
          "question": "names = ['Al', 'Bo'] ve scores = [10, 20]. list(zip(names, scores)) ne döndürür?",
          "options": [
            {
              "icon": "",
              "label": "[('Al', 'Bo'), (10, 20)]"
            },
            {
              "icon": "",
              "label": "['Al', 10, 'Bo', 20]"
            },
            {
              "icon": "",
              "label": "[('Al', 10), ('Bo', 20)]"
            },
            {
              "icon": "",
              "label": "ValueError, çünkü zip üç veya daha fazla bağımsız değişken gerektirir"
            }
          ]
        },
        {
          "question": "class Dog: tricks = [] sınıf düzeyindeki bir liste tutar, add_trick self.tricks'e ekler. d1 = Dog() ve d2 = Dog() ikisi de oluşturulur, sonra d1.add_trick('sit') çalışır. d2.tricks ne içerir?",
          "options": [
            {
              "icon": "",
              "label": "[] — her örnek tricks'in kendi bağımsız kopyasını alır"
            },
            {
              "icon": "",
              "label": "['sit'] — tricks her örnek tarafından paylaşılan sınıf düzeyindeki bir listedir, bu nedenle d1'in değişikliği d2'de de görülebilir"
            },
            {
              "icon": "",
              "label": "TypeError — örnekler sınıf özniteliğine ekleyemez"
            },
            {
              "icon": "",
              "label": "['sit'] sadece d2 = Dog() yeniden çalıştırıldıktan sonra"
            }
          ]
        },
        {
          "question": "class A'nın def greet(self): return 'A' var. class B(A)'nın def greet(self): return 'B' + super().greet() var. B().greet() ne döndürür?",
          "options": [
            {
              "icon": "",
              "label": "'AB' — super() her zaman alt sınıfın kendi kodundan önce çalışır"
            },
            {
              "icon": "",
              "label": "'B' — super().greet() göz ardı edilir çünkü B zaten greet'i geçersiz kılar"
            },
            {
              "icon": "",
              "label": "'BA' — super().greet() A'nın yöntemi çağırır ve sonucu 'B'ye eklenir"
            },
            {
              "icon": "",
              "label": "AttributeError, çünkü A'nın B'ye görünür greet yöntemi yok"
            }
          ]
        },
        {
          "question": "class Point __init__ içinde self.x'i kaydedip başka yöntem tanımlamaz. p1 = Point(1) ve p2 = Point(1). p1 == p2 varsayılan olarak ne döndürür?",
          "options": [
            {
              "icon": "",
              "label": "True — Python tüm eşleşen öznitelikleri varsayılan olarak karşılaştırır"
            },
            {
              "icon": "",
              "label": "False — özel bir __eq__ olmaksızın == kimlik karşılaştırmasına geri döner, p1 ve p2 farklı nesneler"
            },
            {
              "icon": "",
              "label": "True, sadece çünkü her iki nesne de aynı bağımsız değişkenle oluşturulmuş"
            },
            {
              "icon": "",
              "label": "TypeError, çünkü Point __eq__ tanımlamaz"
            }
          ]
        },
        {
          "question": "Aşağıdaki except yanlışından hangisi de bir ZeroDivisionError yakalar: except ArithmeticError, except ValueError, veya except KeyError?",
          "options": [
            {
              "icon": "",
              "label": "except ValueError — bölüm hatalarıdır geçersiz değerler"
            },
            {
              "icon": "",
              "label": "except KeyError — belirli bir tipe bağlı olmayan herhangi bir çalışma zamanı hatası KeyError'a geri döner"
            },
            {
              "icon": "",
              "label": "Hiçbiri — sadece except ZeroDivisionError kendisi yakabilir"
            },
            {
              "icon": "",
              "label": "except ArithmeticError — ZeroDivisionError ArithmeticError'in alt sınıfı"
            }
          ]
        },
        {
          "question": "Bir dosya open('data.txt') as f: ile açıktan blok içinde okuma sırasında istisna ortaya çıkarsa. Dosya yine de kapatılır mı?",
          "options": [
            {
              "icon": "",
              "label": "Hayır — blok normal olarak bitmediği için dosya açık kalır"
            },
            {
              "icon": "",
              "label": "Sadece with deyiminin etrafına finally yanlışı da eklerseniz"
            },
            {
              "icon": "",
              "label": "Evet — with deyimi dosyanın __exit__ yöntemi çağırır, blok içinde istisna olsa da kapatan"
            },
            {
              "icon": "",
              "label": "İstisna türüne bağlıdır — sadece başka yerde yakalan istisnalar temizlenmeyi tetikler"
            }
          ]
        },
        {
          "question": "x = [3, 1, 2] ve y = x.sort(). y ne tutar?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3] — sort() yeni sıralı listeyi döndürür"
            },
            {
              "icon": "",
              "label": "None — list.sort() yerinde sıralar ve None döndürür; x kendisi [1, 2, 3] olur"
            },
            {
              "icon": "",
              "label": "[3, 1, 2] — sort() orijinal sıralanmamış listeyi döndürür ve sadece x'in iç sırasını değiştirir"
            },
            {
              "icon": "",
              "label": "TypeError, çünkü sort() bir değişkene atanamaz"
            }
          ]
        },
        {
          "question": "'Score: ' + 42 çalıştırdığınızda ne olur?",
          "options": [
            {
              "icon": "",
              "label": "'Score: 42' — Python sayıyı + ifadesi içinde otomatik dönüştürür"
            },
            {
              "icon": "",
              "label": "'Score: ' — sayı sessizce düşer"
            },
            {
              "icon": "",
              "label": "42 — dize sayıya zorlama yapılır ve eklenir"
            },
            {
              "icon": "",
              "label": "TypeError — str ve int doğrudan birleştiremez, 42 önce str() ile dönüşmelidir"
            }
          ]
        },
        {
          "question": "results adlı bir listenin boş olup olmadığını kontrol etmeniz gerek. Idiomatik Python yolu hangisi: if results == []: , if len(results) == 0: , veya if not results: ?",
          "options": [
            {
              "icon": "",
              "label": "if results == []: — boş bir listeyi algılamanın tek güvenilir yolu bu"
            },
            {
              "icon": "",
              "label": "if len(results) == 0: — boş listeler Python'da doğru olduğundan bu gereklidir"
            },
            {
              "icon": "",
              "label": "Üçü de pratikte asla kullanılmaz; standart yaklaşım if results is None:"
            },
            {
              "icon": "",
              "label": "if not results: — Python idiomy doğruluğuna dayanır ve boş liste yanlıştır"
            }
          ]
        }
      ],
      "optionOrderVersion": "92945565db6c55da"
    }
  }
}