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:
- Dili gerçekten anlıyor musun? (Sadece kullanmak değil, perde arkasını bilmek)
- Problem çözebiliyor musun? (Algoritma ve veri yapıları)
- Ü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ştiBu yüzden böyle bir tuple hashable değildir ve
dictanahtarı 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,Falsegibi singleton'larla karşılaştırma yaparkeniskullan:if x is None:.CPython'da
-5ile256arasındaki tam sayılar önbelleğe alındığı içina = 256; b = 256; a is bifadesiTruedö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ı birtupleolarak toplar.**kwargs→ Değişken sayıda isimli argümanı birdictolarak 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.
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.wrapskullanmayı 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 bitinceStopIterationfı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)
threadinggerç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
threadinghâ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'unclsparametresi kalıtımda alt sınıfı temsil eder; bu yüzden alternatif constructor'lar içinstaticmethodyerineclassmethodtercih edilir.
2.8 LEGB kuralı nedir? global ve nonlocal ne işe yarar?
Python bir değişkeni şu sırayla arar:
- Local – Fonksiyonun içi
- Enclosing – Dış (kapsayan) fonksiyon
- Global – Modül seviyesi
- Built-in –
len,printgibi 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ünseeval(repr(obj)) == objolacak ş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.
3. İleri Seviye Sorular
3.1 Python'da bellek yönetimi nasıl çalışır?
CPython iki mekanizma kullanır:
- Referans sayma (reference counting): Her nesne, kendisine kaç referans olduğunu tutar. Sayı sıfıra düştüğünde nesne anında bellekten silinir.
- 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.
gcmodü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.
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.
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ümlerindedictekleme 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.
- K01 • Ortalama Üstü Paketler (Isınma & Dizi Manipülasyonu) Ücretsiz
- K11 • Sıralı Dizide Tekrarları Temizle (In-place İki Gösterici) Ücretsiz
- O24 • Asteroid Çarpışması (Canlı Kodlama Yığın Simülasyonu) Orta
- K18 • İki Toplam (Two Sum - Hash Map & Two Pointers) Ücretsiz
- K17 • Palindrom mu? (Karakter Temizleme & Pointer Eşleme) Ücretsiz
- O17 • Tekrarsız En Uzun Alt Dizi (Kayan Pencere Klasiği) Orta
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 listekontrolü yapıyorsan, listeyiset'e çevirmek çoğu zaman en hızlı optimizasyondur. Başa sık ekleme/çıkarma gerekiyorsacollections.dequekullan.
7. Mülakat Günü İçin İpuçları
- Sesli düşün. Sessizce 10 dakika kod yazmak yerine, yaklaşımını anlatarak ilerle. Mülakatçı yanlış yöne gittiğinde seni yönlendirebilir.
- Ö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.
- Önce çalışan, sonra optimize. Kaba kuvvet (brute force) çözümü söyle, karmaşıklığını belirt, sonra iyileştir.
- Pythonic yaz.
range(len(liste))yerineenumerate, manuel sayaç yerineCounter, manuel dosya kapatma yerinewithkullan. - Uç durumları test et. Boş liste, tek eleman, tekrarlanan değerler, çok büyük girdiler.
- Standart kütüphaneyi tanı.
collections(Counter,defaultdict,deque),itertools,functools,heapqvebisectmodülleri seni birçok sorudan kurtarır. - "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
-
isvs== - Mutable varsayılan argüman tuzağı
- Shallow copy vs deep copy
- Decorator yazma (
functools.wrapsdahil) - Generator,
yieldve iterator protokolü - Context manager (
__enter__/__exit__) - GIL ve
threading/multiprocessing/asyncioseçimi -
staticmethodvsclassmethod - 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! 🐍
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.
Diğer Python Rehberleri ve Makaleler
Python for Döngüsü: Liste, range ve Harf Notu
Python for döngüsü bir listenin her elemanını sırayla dolaşır. range, indeks ve not listesini harfe çeviren örnek. Sonunda Not Harfleri sorusu.
Python if, elif, else: Koşul Sırası ve Harf Notu
Python if, elif ve else ilk doğru dalı çalıştırır. Harf notunda 90'dan önce 80 yazılırsa 95 BA olur. Not Harfleri sorusu bu sırayı test eder.
Python Veri Yapıları Rehberi: Yığınlar (Stacks), Ağaçlar (Trees) ve Graflar (Graphs) ile Mülakat Soruları
Python'da yığın (stack, monotonik yığın, heap), ikili ağaç (binary tree, BST) ve graf (BFS, DFS, topolojik sıralama, Dijkstra) veri yapılarını çalışan kod şablonları ve 30+ interaktif mülakat sorusuyla adım adım öğrenin.
Python while Döngüsü: Sayaç, Koşul ve Not Listesi
Python while döngüsü koşul doğru kaldıkça tekrar eder. Sayaç, sonsuz döngü ve not listesini indeksle gezmek. Aynı ölçek Not Harfleri sorusunda.
AI Mühendisi Olmak İsteyen Bir Pythoncunun Bilmesi Gereken 10 Temel Algoritma (2026)
Kosinüs benzerliğinden BPE tokenizasyonuna, BM25'ten beam search'e: AI mühendisliği mülakatlarında sorulan ve LLM/RAG sistemlerinin arkasında çalışan 10 temel algoritmayı saf Python kodlarıyla öğrenin.
Orta Seviye Python Kursları ve Kitap Önerileri: Udemy, Coursera ve Yol Haritası (2026)
Orta seviye (intermediate) Python geliştiriciler için 10 dakikalık kapsamlı kaynak rehberi. En iyi Udemy ve Coursera Python kursları, başucu kitap önerileri ve 8 haftalık çalışma planı.
Orta Seviye Python Proje Fikirleri: Portfolyo ve Mülakat İçin 8 Gerçek Mühendislik Projesi (2026)
Basit hesap makinesi ve yapılacaklar listesi (To-Do) projelerini geride bırakın. Orta seviye (intermediate) Python geliştiriciler için mimari kod örnekleri, asenkron veri hatları ve özel veri yapıları içeren 8 gerçek proje fikri.