Python mülakatları, şirketten şirkete değişse de şaşırtıcı derecede tekrar eden bir soru havuzuna sahiptir. Mülakatçılar genellikle üç şeyi ölçmek ister:

  1. Dili gerçekten anlıyor musun? (Sadece kullanmak değil, perde arkasını bilmek)
  2. Problem çözebiliyor musun? (Algoritma ve veri yapıları)
  3. Üretim ortamında güvenle kod yazabilir misin? (Performans, eşzamanlılık, okunabilirlik)

Bu makalede, teknik mülakatlarda en sık karşılaşılan soruları seviyelere göre ele alıyor, her birini çalışan kod örnekleriyle açıklıyoruz. Sonunda da canlı kodlama soruları ve mülakat günü için pratik ipuçları var.


1. Temel Seviye Sorular

1.1 Mutable ve immutable tipler arasındaki fark nedir?

Bu, neredeyse her Python mülakatının açılış sorusudur.

  • Immutable (değiştirilemez): int, float, bool, str, tuple, frozenset, bytes
  • Mutable (değiştirilebilir): list, dict, set, bytearray, kullanıcı tanımlı sınıfların çoğu
isim = "python"
# isim[0] = "P"        # TypeError: 'str' object does not support item assignment
isim = "P" + isim[1:]   # Yeni bir string nesnesi oluşturulur

sayilar = [1, 2, 3]
sayilar[0] = 99         # Aynı nesne yerinde değişir
print(sayilar)          # [99, 2, 3]

Mülakatçıyı etkileyecek detay: Immutable bir tuple, içinde mutable bir nesne barındırabilir.

t = ([1, 2], 3)
t[0].append(3)
print(t)  # ([1, 2, 3], 3)  -> Tuple değişmedi, içindeki liste değişti

Bu yüzden böyle bir tuple hashable değildir ve dict anahtarı olarak kullanılamaz.


1.2 list ile tuple arasındaki farklar nelerdir?

Özellik list tuple
Değiştirilebilirlik Mutable Immutable
Sözdizimi [1, 2, 3] (1, 2, 3)
Hashable Hayır Evet (içindekiler hashable ise)
dict anahtarı olabilir mi? Hayır Evet
Bellek kullanımı Daha fazla Daha az
Tipik kullanım Homojen, değişen koleksiyonlar Sabit yapıdaki kayıtlar (koordinat, satır vb.)

1.3 is ile == arasındaki fark nedir?

  • == → Değer eşitliği (__eq__ metodunu çağırır)
  • is → Kimlik eşitliği (iki değişken bellekte aynı nesneyi mi gösteriyor?)
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)  # True  -> Değerleri aynı
print(a is b)  # False -> Farklı nesneler
print(a is c)  # True  -> Aynı nesne

Altın kural: None, True, False gibi singleton'larla karşılaştırma yaparken is kullan: if x is None:.

CPython'da -5 ile 256 arasındaki tam sayılar önbelleğe alındığı için a = 256; b = 256; a is b ifadesi True döner, ama bu bir implementasyon detayıdır; asla buna güvenme.


1.4 Varsayılan argüman olarak mutable nesne kullanmak neden tehlikelidir?

Python'un en meşhur tuzaklarından biridir.

def ekle(eleman, liste=[]):
    liste.append(eleman)
    return liste

print(ekle(1))  # [1]
print(ekle(2))  # [1, 2]  -> Beklenen [2] değil!

Neden? Varsayılan değerler fonksiyon tanımlandığında bir kez oluşturulur, her çağrıda değil. Tüm çağrılar aynı listeyi paylaşır.

Doğru kullanım:

def ekle(eleman, liste=None):
    if liste is None:
        liste = []
    liste.append(eleman)
    return liste

1.5 *args ve **kwargs nedir?

  • *args → Değişken sayıda pozisyonel argümanı bir tuple olarak toplar.
  • **kwargs → Değişken sayıda isimli argümanı bir dict olarak toplar.
def bilgi(*args, **kwargs):
    print("args:", args)
    print("kwargs:", kwargs)

bilgi(1, 2, 3, isim="Ada", yas=30)
# args: (1, 2, 3)
# kwargs: {'isim': 'Ada', 'yas': 30}

Ters yönde de çalışır (unpacking):

def topla(a, b, c):
    return a + b + c

sayilar = [1, 2, 3]
ayarlar = {"a": 1, "b": 2, "c": 3}

print(topla(*sayilar))   # 6
print(topla(**ayarlar))  # 6

1.6 Shallow copy ile deep copy arasındaki fark nedir?

import copy

orijinal = [[1, 2], [3, 4]]
sig   = copy.copy(orijinal)      # Sadece dış liste kopyalanır
derin = copy.deepcopy(orijinal)  # Tüm iç içe nesneler kopyalanır

orijinal[0].append(99)

print(sig)    # [[1, 2, 99], [3, 4]]  -> İç listeler paylaşılıyor!
print(derin)  # [[1, 2], [3, 4]]      -> Tamamen bağımsız
  • Shallow copy: Yeni bir kap oluşturur, ama içindeki elemanlar aynı referanslardır. (list.copy(), lst[:], dict.copy() da shallow copy yapar.)
  • Deep copy: Nesneyi ve içindeki tüm nesneleri özyinelemeli olarak kopyalar.

1.7 List comprehension nedir? Ne zaman kullanılmamalıdır?

# Klasik döngü
kareler = []
for x in range(10):
    if x % 2 == 0:
        kareler.append(x ** 2)

# List comprehension
kareler = [x ** 2 for x in range(10) if x % 2 == 0]

# Dict ve set comprehension
kare_sozluk = {x: x ** 2 for x in range(5)}   # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
benzersiz   = {c.lower() for c in "MulaKat"}  # {'m', 'u', 'l', 'a', 'k', 't'} (sıra garanti değil)

# Generator expression (bellek dostu)
toplam = sum(x ** 2 for x in range(1_000_000))

Ne zaman kullanılmamalı? İç içe 2-3 seviyeyi geçen, okunması zorlaşan ifadelerde ya da sadece yan etki (ör. print) için. Okunabilirlik her zaman önce gelir.

🎯 Temel Seviye İçin İnteraktif Pratik Soruları

2. Orta Seviye Sorular

2.1 Decorator nedir? Kendi decorator'ını yazabilir misin?

Decorator, bir fonksiyonu alıp davranışını değiştirmeden genişleten bir fonksiyondur. Mülakatlarda genellikle "bir fonksiyonun çalışma süresini ölçen decorator yaz" şeklinde sorulur.

import functools
import time

def sure_olc(func):
    @functools.wraps(func)  # Orijinal fonksiyonun adını ve docstring'ini korur
    def wrapper(*args, **kwargs):
        baslangic = time.perf_counter()
        sonuc = func(*args, **kwargs)
        gecen = time.perf_counter() - baslangic
        print(f"{func.__name__} {gecen:.4f} saniye sürdü")
        return sonuc
    return wrapper

@sure_olc
def yavas_islem():
    time.sleep(1)
    return "bitti"

yavas_islem()  # yavas_islem 1.0012 saniye sürdü

Takip sorusu: Parametre alan decorator yazar mısın? Bunun için bir seviye daha sarmalamak gerekir:

def tekrarla(n):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(n):
                sonuc = func(*args, **kwargs)
            return sonuc
        return wrapper
    return decorator

@tekrarla(3)
def selam():
    print("Merhaba!")

selam()  # 3 kez "Merhaba!" yazar

@functools.wraps kullanmayı unutmak, mülakatçıların sıkça dikkat ettiği bir detaydır.


2.2 Generator nedir? yield ne işe yarar?

Generator, değerleri tek tek ve ihtiyaç duyuldukça (lazy) üreten bir iterator'dır. return fonksiyonu sonlandırırken, yield fonksiyonun durumunu dondurur ve bir sonraki çağrıda kaldığı yerden devam eder.

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

gen = fibonacci()
print([next(gen) for _ in range(10)])  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Neden önemli? Bellek verimliliği:

import sys

liste     = [x for x in range(1_000_000)]
generator = (x for x in range(1_000_000))

print(sys.getsizeof(liste))      # ~8 MB
print(sys.getsizeof(generator))  # ~200 byte

Büyük dosyaları satır satır okumak, veri akışlarını işlemek (streaming) gibi senaryolarda generator'lar vazgeçilmezdir.


2.3 Iterable ile iterator arasındaki fark nedir?

  • Iterable: Üzerinde döngü kurulabilen nesne. __iter__() metoduna sahiptir. (list, str, dict...)
  • Iterator: Bir sonraki elemanı döndüren nesne. Hem __iter__() hem __next__() metoduna sahiptir. Elemanlar bitince StopIteration fırlatır.
class GeriSayim:
    def __init__(self, baslangic):
        self.mevcut = baslangic

    def __iter__(self):
        return self

    def __next__(self):
        if self.mevcut <= 0:
            raise StopIteration
        self.mevcut -= 1
        return self.mevcut + 1

for sayi in GeriSayim(3):
    print(sayi)  # 3, 2, 1

Her iterator bir iterable'dır, ama her iterable bir iterator değildir. iter([1, 2, 3]) bir listeden iterator üretir.


2.4 Context manager nedir? with ifadesi nasıl çalışır?

Context manager, bir kaynağın güvenli bir şekilde açılıp kapatılmasını garanti eder; hata oluşsa bile temizlik yapılır.

with open("veri.txt") as dosya:
    icerik = dosya.read()
# Burada dosya otomatik olarak kapanmıştır

Sınıf ile kendi context manager'ını yazmak:

class Zamanlayici:
    def __enter__(self):
        import time
        self.baslangic = time.perf_counter()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        import time
        print(f"Geçen süre: {time.perf_counter() - self.baslangic:.4f} sn")
        return False  # Hata varsa yukarı fırlatılmaya devam etsin

contextlib ile daha kısa yol:

from contextlib import contextmanager

@contextmanager
def gecici_dizin_degistir(yol):
    import os
    eski = os.getcwd()
    os.chdir(yol)
    try:
        yield
    finally:
        os.chdir(eski)

2.5 GIL (Global Interpreter Lock) nedir?

Senior pozisyonlarda neredeyse kesin sorulan bir sorudur.

GIL, CPython yorumlayıcısında aynı anda yalnızca bir thread'in Python bytecode'u çalıştırmasına izin veren bir kilittir. CPython'un referans sayma tabanlı bellek yönetimini thread-safe tutmak için vardır.

Sonuçları:

  • CPU-bound işlerde (matematik hesaplamaları, görüntü işleme) threading gerçek paralellik sağlamaz.
  • I/O-bound işlerde (ağ istekleri, dosya okuma, veritabanı) thread'ler bekleme sırasında GIL'i bıraktığı için threading hâlâ çok faydalıdır.

Güncel bilgi: Python 3.13 ile deneysel olarak gelen free-threaded (GIL'siz) build (PEP 703), Python 3.14 ile resmi olarak desteklenen bir seçenek hâline geldi (PEP 779). Ancak varsayılan CPython build'i hâlâ GIL'li. Bu bilgiyi vermek, güncel olduğunu gösterir.


2.6 threading, multiprocessing ve asyncio arasındaki farklar nelerdir?

threading multiprocessing asyncio
Model Çoklu thread Çoklu süreç (process) Tek thread, event loop
GIL'den etkilenir mi? Evet Hayır (her süreç kendi GIL'ine sahip) — (tek thread)
En uygun iş tipi I/O-bound CPU-bound Çok sayıda eşzamanlı I/O
Bellek paylaşımı Ortak bellek Ayrı bellek (IPC gerekir) Ortak bellek
Ek yük Düşük Yüksek Çok düşük
import asyncio

async def veri_getir(id):
    await asyncio.sleep(1)  # Ağ isteğini simüle eder
    return f"veri-{id}"

async def main():
    sonuclar = await asyncio.gather(*(veri_getir(i) for i in range(5)))
    print(sonuclar)  # ~1 saniyede 5 sonuç (5 saniye değil!)

asyncio.run(main())

2.7 @staticmethod, @classmethod ve instance method arasındaki fark nedir?

class Tarih:
    def __init__(self, gun, ay, yil):
        self.gun, self.ay, self.yil = gun, ay, yil

    # Instance method: nesneye (self) erişir
    def goster(self):
        return f"{self.gun:02d}.{self.ay:02d}.{self.yil}"

    # Class method: sınıfa (cls) erişir, genellikle alternatif constructor olarak kullanılır
    @classmethod
    def metinden(cls, metin):
        gun, ay, yil = map(int, metin.split("."))
        return cls(gun, ay, yil)

    # Static method: ne nesneye ne sınıfa erişir, mantıksal olarak sınıfa ait yardımcı fonksiyon
    @staticmethod
    def artik_yil_mi(yil):
        return yil % 4 == 0 and (yil % 100 != 0 or yil % 400 == 0)

t = Tarih.metinden("18.10.2026")
print(t.goster())              # 18.10.2026
print(Tarih.artik_yil_mi(2024))  # True

classmethod'un cls parametresi kalıtımda alt sınıfı temsil eder; bu yüzden alternatif constructor'lar için staticmethod yerine classmethod tercih edilir.


2.8 LEGB kuralı nedir? global ve nonlocal ne işe yarar?

Python bir değişkeni şu sırayla arar:

  1. Local – Fonksiyonun içi
  2. Enclosing – Dış (kapsayan) fonksiyon
  3. Global – Modül seviyesi
  4. Built-in – len, print gibi yerleşik isimler
def sayac_olustur():
    sayi = 0
    def arttir():
        nonlocal sayi   # Enclosing scope'taki değişkeni değiştir
        sayi += 1
        return sayi
    return arttir

sayac = sayac_olustur()
print(sayac(), sayac(), sayac())  # 1 2 3

Bu örnek aynı zamanda bir closure örneğidir: arttir fonksiyonu, sayac_olustur bittikten sonra bile sayi değişkenini "hatırlar".


2.9 Dunder (magic) metotlar nedir? __str__ ile __repr__ farkı nedir?

Çift alt çizgiyle başlayıp biten metotlar, Python'un yerleşik operatörleri ve fonksiyonlarıyla nesnelerin nasıl davranacağını belirler.

class Vektor:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):   # Geliştirici için: belirsizlik içermeyen temsil
        return f"Vektor({self.x}, {self.y})"

    def __str__(self):    # Kullanıcı için: okunabilir temsil
        return f"({self.x}, {self.y})"

    def __add__(self, diger):
        return Vektor(self.x + diger.x, self.y + diger.y)

    def __eq__(self, diger):
        return (self.x, self.y) == (diger.x, diger.y)

    def __len__(self):
        return 2

v = Vektor(1, 2) + Vektor(3, 4)
print(v)        # (4, 6)
print(repr(v))  # Vektor(4, 6)
print(len(v))   # 2

İyi bir __repr__, mümkünse eval(repr(obj)) == obj olacak şekilde yazılır. __str__ tanımlı değilse Python __repr__'ı kullanır.


2.10 Çoklu kalıtım ve MRO (Method Resolution Order) nedir?

class A:
    def selam(self): return "A"

class B(A):
    def selam(self): return "B"

class C(A):
    def selam(self): return "C"

class D(B, C):
    pass

print(D().selam())                     # B
print([k.__name__ for k in D.__mro__])  # ['D', 'B', 'C', 'A', 'object']

Python, metot arama sırasını C3 linearization algoritmasıyla belirler. Bu "elmas problemi"ni (diamond problem) çözer ve super() çağrılarının her sınıfı yalnızca bir kez ziyaret etmesini garanti eder.

🎯 Orta Seviye İçin İnteraktif Pratik Soruları

3. İleri Seviye Sorular

3.1 Python'da bellek yönetimi nasıl çalışır?

CPython iki mekanizma kullanır:

  1. Referans sayma (reference counting): Her nesne, kendisine kaç referans olduğunu tutar. Sayı sıfıra düştüğünde nesne anında bellekten silinir.
  2. Döngüsel çöp toplayıcı (cyclic garbage collector): Birbirine referans veren ama dışarıdan erişilemeyen nesneleri (döngüleri) tespit edip temizler. gc modülüyle kontrol edilebilir.
import sys

a = []
print(sys.getrefcount(a))  # 2 (a + getrefcount'a geçen geçici argüman)

b = a
print(sys.getrefcount(a))  # 3
# Referans sayma ile temizlenemeyen döngü örneği
class Dugum:
    def __init__(self):
        self.diger = None

x, y = Dugum(), Dugum()
x.diger, y.diger = y, x   # Döngü oluştu
del x, y                  # Referans sayıları 0'a düşmez -> gc modülü temizler

3.2 __slots__ nedir ve ne zaman kullanılır?

Varsayılan olarak her nesne, niteliklerini bir __dict__ içinde saklar. __slots__ tanımlanırsa bu sözlük oluşturulmaz:

class Nokta:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x, self.y = x, y

p = Nokta(1, 2)
# p.z = 3  # AttributeError: 'Nokta' object has no attribute 'z'

Avantajları: Daha az bellek kullanımı ve biraz daha hızlı nitelik erişimi. Milyonlarca küçük nesne oluşturulan durumlarda ciddi fark yaratır. Dezavantajı: Dinamik nitelik eklenemez.


3.3 Metaclass nedir?

"Sınıflar nesneleri oluşturur; metaclass'lar sınıfları oluşturur."

Python'da sınıflar da birer nesnedir ve varsayılan metaclass'ları type'tır. Mülakatlarda genellikle Singleton örneğiyle sorulur:

class Singleton(type):
    _ornekler = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._ornekler:
            cls._ornekler[cls] = super().__call__(*args, **kwargs)
        return cls._ornekler[cls]

class Ayarlar(metaclass=Singleton):
    pass

print(Ayarlar() is Ayarlar())  # True

Bonus cevap: "Metaclass'lar güçlüdür ama çoğu zaman __init_subclass__, class decorator'lar veya basit bir modül seviyesi nesne yeterlidir." demek, deneyimli olduğunu gösterir.


3.4 dataclass nedir? Normal sınıftan farkı ne?

from dataclasses import dataclass, field

@dataclass(frozen=True)
class Calisan:
    isim: str
    maas: float
    yetenekler: list[str] = field(default_factory=list)

c = Calisan("Ada", 50_000)
print(c)  # Calisan(isim='Ada', maas=50000, yetenekler=[])

@dataclass, __init__, __repr__ ve __eq__ metotlarını otomatik üretir. frozen=True nesneyi immutable yapar, default_factory ise mutable varsayılan argüman tuzağından (bkz. 1.4) korur.

🎯 İleri Seviye & Sistem Mimarisi İçin İnteraktif Sorular

4. "Çıktıyı Tahmin Et" Tuzak Soruları

Mülakatçıların en sevdiği soru tipidir. Cevaplara bakmadan önce kendin tahmin etmeye çalış!

Soru 1: Liste çarpımı

x = [[0] * 3] * 3
x[0][0] = 1
print(x)
Cevap
[[1, 0, 0], [1, 0, 0], [1, 0, 0]]

* 3 dış listeyi oluştururken aynı iç listeye üç referans koyar. Doğru yol: x = [[0] * 3 for _ in range(3)]

Soru 2: Lambda ve geç bağlama (late binding)

fonksiyonlar = [lambda: i for i in range(3)]
print([f() for f in fonksiyonlar])
Cevap
[2, 2, 2]

Closure'lar değişkenin değerini değil, kendisini yakalar. Lambda'lar çağrıldığında i'nin son değeri 2'dir. Çözüm: lambda i=i: i

Soru 3: Tek elemanlı tuple

a = (1)
b = (1,)
print(type(a), type(b))
Cevap
<class 'int'> <class 'tuple'>

Tuple'ı parantezler değil, virgül oluşturur.

Soru 4: Ondalık sayılar

print(0.1 + 0.2 == 0.3)
Cevap
False

Kayan noktalı sayılar ikili sistemde tam temsil edilemez (0.1 + 0.2 == 0.30000000000000004). Karşılaştırma için math.isclose(), finansal hesaplar için decimal.Decimal kullanılmalıdır.

Soru 5: try / finally ve return

def f():
    try:
        return "try"
    finally:
        return "finally"

print(f())
Cevap
finally

finally bloğu her zaman çalışır ve oradaki return, try içindekini ezer. Bu kafa karıştırıcı davranış yüzünden Python 3.14'ten itibaren finally içindeki return bir SyntaxWarning üretir (PEP 765).

Soru 6: Bool aritmetiği

print(True + True + False)
print(isinstance(True, int))
Cevap
2
True

bool, int'in bir alt sınıfıdır: True == 1, False == 0.

🎯 Algoritmik Tuzaklar & Hata Yakalama Pratikleri

5. Canlı Kodlama Soruları

Canlı kodlamada mülakatçı sadece doğru cevaba değil, düşünce sürecine ve Pythonic yazıp yazmadığına bakar.

5.1 Palindrom kontrolü

def palindrom_mu(metin: str) -> bool:
    temiz = "".join(c.lower() for c in metin if c.isalnum())
    return temiz == temiz[::-1]

print(palindrom_mu("Ey Edip Adana'da pide ye"))  # True

💡 İnteraktif Çöz: İki gösterici (two pointers) tekniğiyle bellek kopyalaması yapmadan çözmek için istasyonda test et: K17: Palindrom mu?

5.2 Anagram kontrolü

from collections import Counter

def anagram_mi(a: str, b: str) -> bool:
    return Counter(a.replace(" ", "").lower()) == Counter(b.replace(" ", "").lower())

print(anagram_mi("Listen", "Silent"))  # True

💡 İnteraktif Çöz: Kelimeleri karakter frekansına göre kümeleyen gelişmiş mülakat varyasyonu için çöz: Z18: Anagram Grupları

5.3 Two Sum (O(n) çözüm)

Bir listede toplamı hedef sayıyı veren iki elemanın indekslerini bul.

def iki_toplam(sayilar: list[int], hedef: int) -> list[int]:
    gorulen = {}  # sayı -> indeks
    for i, sayi in enumerate(sayilar):
        tamamlayici = hedef - sayi
        if tamamlayici in gorulen:
            return [gorulen[tamamlayici], i]
        gorulen[sayi] = i
    return []

print(iki_toplam([2, 7, 11, 15], 9))  # [0, 1]

İç içe iki döngüyle yazılan O(n²) çözümü önce söyleyip ardından sözlükle O(n)'e optimize etmek, mülakatçıların görmek istediği klasik akıştır.

💡 İnteraktif Çöz: Dizi sıralı olduğunda iki gösterici ile O(1) alanda çözmek için: K18: Sıralı Dizide İki Toplam

5.4 Sırayı koruyarak tekrar edenleri kaldırma

def tekrarlari_kaldir(liste):
    return list(dict.fromkeys(liste))

print(tekrarlari_kaldir([3, 1, 3, 2, 1]))  # [3, 1, 2]

list(set(liste)) sırayı korumaz. Python 3.7+ sürümlerinde dict ekleme sırasını garanti eder.

💡 İnteraktif Çöz: Sıralı bir dizide ekstra bellek kullanmadan O(1) alan karmaşıklığıyla eleman silmek canlı kodlamada çok sık istenir: K11: Sıralı Dizide Tekrarları Temizle

5.5 En sık geçen eleman

from collections import Counter

kelimeler = "elma armut elma kiraz elma armut".split()
print(Counter(kelimeler).most_common(2))  # [('elma', 3), ('armut', 2)]

5.6 İç içe listeyi düzleştirme

def duzlestir(liste):
    for eleman in liste:
        if isinstance(eleman, list):
            yield from duzlestir(eleman)
        else:
            yield eleman

print(list(duzlestir([1, [2, [3, 4]], 5])))  # [1, 2, 3, 4, 5]

5.7 Memoization ile Fibonacci

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n: int) -> int:
    return n if n < 2 else fib(n - 1) + fib(n - 2)

print(fib(100))  # 354224848179261915075

Önbelleksiz özyinelemeli çözüm O(2ⁿ) iken, lru_cache ile O(n)'e iner.

🎯 Canlı Kodlama Mülakatlarının En Çok Sorulan Algoritmaları

6. Zaman Karmaşıklığı Kopya Kâğıdı

Mülakatçılar sık sık "Bu kodun zaman karmaşıklığı nedir?" diye sorar. Yerleşik veri yapılarının maliyetlerini bilmek şarttır:

İşlem list dict / set
Sona ekleme (append / add) O(1)* O(1)*
Başa ekleme (insert(0, x)) O(n) —
İndeksle erişim (lst[i]) O(1) —
Anahtarla erişim (d[k]) — O(1)*
Üyelik kontrolü (x in ...) O(n) O(1)*
Silme (pop() sondan) O(1) —
Silme (pop(0) / remove(x)) O(n) O(1)*
Sıralama (sort) O(n log n) —

* Ortalama / amortize maliyet.

İpucu: Bir listede sürekli x in liste kontrolü yapıyorsan, listeyi set'e çevirmek çoğu zaman en hızlı optimizasyondur. Başa sık ekleme/çıkarma gerekiyorsa collections.deque kullan.

🎯 Karmaşıklık (Big-O) Optimizasyonu İçin İnteraktif Sorular

7. Mülakat Günü İçin İpuçları

  1. Sesli düşün. Sessizce 10 dakika kod yazmak yerine, yaklaşımını anlatarak ilerle. Mülakatçı yanlış yöne gittiğinde seni yönlendirebilir.
  2. Önce soruyu netleştir. Girdi boş olabilir mi? Negatif sayılar var mı? Büyük/küçük harf duyarlı mı? Soru sormak bir zayıflık değil, profesyonelliktir.
  3. Önce çalışan, sonra optimize. Kaba kuvvet (brute force) çözümü söyle, karmaşıklığını belirt, sonra iyileştir.
  4. Pythonic yaz. range(len(liste)) yerine enumerate, manuel sayaç yerine Counter, manuel dosya kapatma yerine with kullan.
  5. Uç durumları test et. Boş liste, tek eleman, tekrarlanan değerler, çok büyük girdiler.
  6. Standart kütüphaneyi tanı. collections (Counter, defaultdict, deque), itertools, functools, heapq ve bisect modülleri seni birçok sorudan kurtarır.
  7. "Bilmiyorum" demekten korkma. "Bunu tam bilmiyorum ama şöyle düşünürdüm..." demek, uydurmaktan her zaman daha iyidir.

Son Kontrol Listesi ✅

Mülakattan önce aşağıdaki konuları rahatça açıklayabildiğinden emin ol:

  • Mutable / immutable tipler ve hashability
  • is vs ==
  • Mutable varsayılan argüman tuzağı
  • Shallow copy vs deep copy
  • Decorator yazma (functools.wraps dahil)
  • Generator, yield ve iterator protokolü
  • Context manager (__enter__ / __exit__)
  • GIL ve threading / multiprocessing / asyncio seçimi
  • staticmethod vs classmethod
  • LEGB, closure ve nonlocal
  • Dunder metotlar ve MRO
  • Referans sayma ve garbage collection
  • Temel veri yapılarının zaman karmaşıklıkları

Sonuç

Python mülakatları ezber değil, anlama üzerine kuruludur. Bu makaledeki soruların her birini sadece okumakla kalma; kodları kendi bilgisayarında çalıştır, değiştir, bozmaya çalış. Bir kavramı başkasına anlatabildiğin noktada, mülakatta da rahatça anlatabilirsin.

Teoriyi pratiğe dökmek için 200 Soruluk Soru Kataloğumuzda ve Uzmanlık Modüllerinde yer alan problemleri interaktif tarayıcı stüdyosunda test senaryolarıyla çözebilir, hazırlığına hemen ilk sorudan başlayabilirsin: K01: Ortalama Üstü Paketler. Bol şans! 🐍

İnteraktif Pratik İstasyonu

Teoriyi Gerçek Sınav Ortamında Test Etmeye Hazır mısın?

PyMülakat platformunda 10 uzmanlık modülü ve 200 özgün Python mülakat sorusu seni bekliyor. Tarayıcıda kodunu hemen yaz, çalıştır ve gizli sınır testleriyle kendini sına.

İlk Soruyu Çöz (K01) →Modülleri İncele