"AI mühendisi" ilanlarının sayısı son iki yılda katlanarak arttı. Ancak mülakat masasında karşılaşılan gerçek şu: Şirketler openai.chat.completions.create() çağırabilen birini değil, o çağrının etrafındaki sistemi kurabilen birini arıyor. Vektör araması neden yavaşladı? Model neden aynı cümleyi tekrar ediyor? Türkçe metin neden İngilizceden daha pahalıya geliyor? RAG neden alakasız doküman getiriyor?
Bu soruların hepsinin cevabı, kütüphanelerin arkasında sessizce çalışan birkaç temel algoritmada saklı. Bu rehberde LLM, RAG ve vektör arama sistemlerinin omurgasını oluşturan 10 algoritmayı harici kütüphane kullanmadan, saf Python ile yazıyoruz. Her bölümde algoritmanın AI sistemindeki yerini, çalışan kodunu, karmaşıklığını ve mülakatta karşınıza çıkabilecek takip sorusunu bulacaksınız.
Neden saf Python? Üretimde elbette NumPy, FAISS veya Hugging Face kullanacaksınız. Ama mülakatta "bunu kütüphanesiz yaz" dendiğinde mekanizmayı bilen aday ile API ezberleyen aday anında ayrışır.
Hızlı Bakış: 10 Algoritma ve AI Sistemindeki Yeri
| # | Algoritma | AI Sistemindeki Rolü | Karmaşıklık |
|---|---|---|---|
| 1 | Kosinüs Benzerliği | Embedding karşılaştırma | O(d) |
| 2 | Heap ile Top-K | Vektör aramada en yakın K sonuç | O(n log k) |
| 3 | Kararlı Softmax + Top-p | LLM token örnekleme | O(V log V) |
| 4 | BPE Tokenizasyon | Metni token'a çevirme | O(m · n) |
| 5 | Örtüşmeli Pencere Chunking | RAG doküman parçalama | O(n) |
| 6 | BM25 | Anahtar kelime tabanlı arama | O(N · q) |
| 7 | Reciprocal Rank Fusion | Hibrit arama birleştirme | O(Σ L) |
| 8 | Beam Search | Dizi üretimi / decoding | O(T · B · V) |
| 9 | Gradyan İnişi | Model eğitimi | O(E · n · d) |
| 10 | K-Means (IVF) | Vektör indeksleme | O(I · n · k · d) |
1. Kosinüs Benzerliği (Cosine Similarity)
Her RAG sisteminin kalbi şudur: Kullanıcının sorusu bir vektöre (embedding) dönüştürülür ve doküman vektörleriyle karşılaştırılır. Bu karşılaştırmanın standart ölçüsü kosinüs benzerliğidir: İki vektörün büyüklüğünden bağımsız olarak, aralarındaki açıyı ölçer.
import math
def dot(a: list[float], b: list[float]) -> float:
return sum(x * y for x, y in zip(a, b))
def norm(a: list[float]) -> float:
return math.sqrt(dot(a, a))
def cosine_similarity(a: list[float], b: list[float]) -> float:
na, nb = norm(a), norm(b)
if na == 0 or nb == 0:
return 0.0 # sıfır vektör: benzerlik tanımsız, güvenli varsayılan
return dot(a, b) / (na * nb)
print(cosine_similarity([1, 2, 3], [2, 4, 6])) # 1.0 (aynı yön)
print(cosine_similarity([1, 0], [0, 1])) # 0.0 (dik)
Karmaşıklık: Boyut d için O(d).
Üretim İpucu: Vektörleri indekslerken bir kez normalize ederseniz (uzunluklarını 1 yaparsanız), sorgu anında kosinüs benzerliği basit bir iç çarpıma (dot product) dönüşür. FAISS'in IndexFlatIP ile kosinüs araması yapmasının sırrı budur.
Mülakat Sorusu: "Öklid mesafesi yerine neden kosinüs kullanıyoruz?" → Metin embedding'lerinde anlam vektörün yönünde kodlanır; uzun bir doküman daha büyük normlu bir vektör üretebilir ama anlamı değişmez. Normalize edilmiş vektörlerde ikisi aynı sıralamayı verir: ‖a − b‖² = 2 − 2·cos(a, b).
2. Heap ile Top-K Seçimi
Bir milyon doküman vektörünüz var ve en benzer 5 tanesini istiyorsunuz. Hepsini sıralamak O(n log n) maliyet demektir. Oysa boyutu K ile sınırlı bir min-heap ile bunu O(n log k)'ya indirebilirsiniz, üstelik bellekte sadece K eleman tutarak.
import heapq
def top_k(query: list[float], docs: list[tuple[str, list[float]]], k: int = 3):
"""docs: (doc_id, vektör) çiftleri. En benzer k dokümanı döndürür."""
heap: list[tuple[float, str]] = [] # min-heap: kökte en ZAYIF aday
for doc_id, vec in docs:
score = cosine_similarity(query, vec)
if len(heap) < k:
heapq.heappush(heap, (score, doc_id))
elif score > heap[0][0]:
heapq.heapreplace(heap, (score, doc_id)) # en zayıfı at, yeniyi ekle
return sorted(heap, reverse=True)
docs = [("python", [0.9, 0.1]), ("java", [0.5, 0.5]), ("yemek", [0.0, 1.0])]
print(top_k([1.0, 0.0], docs, k=2))
# [(0.99..., 'python'), (0.70..., 'java')]
Neden min-heap? Kökte her zaman "şu an elimdeki en kötü aday" durur. Yeni skor ondan iyiyse tek bir O(log k) işlemiyle değiştiririz. Bu kalıp, akan veri (streaming) üzerinde de çalışır, çünkü tüm veriyi belleğe almanız gerekmez.
Mülakat Sorusu: "10 milyar vektörde bu yine de yavaş, ne yaparsın?" → Tam (exact) aramadan yaklaşık en yakın komşu (ANN) aramasına geçilir: IVF (bkz. Algoritma 10), HNSW grafları veya Product Quantization.
3. Kararlı Softmax, Temperature ve Top-p Örnekleme
Bir LLM her adımda kelime dağarcığındaki (vocabulary) her token için ham bir skor (logit) üretir. Bu skorlar softmax ile olasılığa çevrilir ve bir sonraki token örneklenir. temperature ve top_p parametreleri tam olarak bu adımı kontrol eder.
import math
import random
def softmax(logits: list[float], temperature: float = 1.0) -> list[float]:
if temperature <= 0:
raise ValueError("temperature pozitif olmalı (greedy için argmax kullanın)")
scaled = [x / temperature for x in logits]
m = max(scaled) # sayısal kararlılık hilesi
exps = [math.exp(x - m) for x in scaled]
total = sum(exps)
return [e / total for e in exps]
def top_p_sample(logits, p=0.9, temperature=1.0, rng=random):
probs = softmax(logits, temperature)
ranked = sorted(enumerate(probs), key=lambda t: t[1], reverse=True)
nucleus, cumulative = [], 0.0
for idx, prob in ranked: # olasılık kütlesi p'ye ulaşana kadar al
nucleus.append((idx, prob))
cumulative += prob
if cumulative >= p:
break
total = sum(prob for _, prob in nucleus) # çekirdeği yeniden normalize et
r = rng.random() * total
acc = 0.0
for idx, prob in nucleus:
acc += prob
if r < acc:
return idx
return nucleus[-1][0]
logits = [2.0, 1.0, 0.1, -3.0]
print(softmax(logits, temperature=0.5)) # daha "keskin" dağılım
print(softmax(logits, temperature=2.0)) # daha "düz" dağılım
Kritik Detay: x - max. math.exp(1000) bir OverflowError fırlatır. Tüm logitlerden maksimumu çıkarmak sonucu matematiksel olarak değiştirmez (pay ve payda aynı e^-m ile çarpılır), ama en büyük üssü 0'a sabitleyerek taşmayı önler. Mülakatçılar bu satırı özellikle arar.
Mülakat Sorusu: "Temperature 0'a yaklaşınca ne olur?" → Dağılım en yüksek logite yoğunlaşır ve örnekleme greedy decoding'e (argmax) dönüşür. Bu yüzden deterministik çıktı isteyen sistemlerde temperature=0 kullanılır.
4. BPE (Byte Pair Encoding) Tokenizasyonu
GPT, Llama ve benzeri modeller metni kelimelerle değil alt kelime (subword) token'larıyla işler. Bu token'ların çoğu BPE ile öğrenilir: En sık yan yana gelen iki sembolü tekrar tekrar birleştirerek yeni bir sembol oluşturursunuz.
from collections import Counter
def get_pair_counts(ids: list[int]) -> Counter:
return Counter(zip(ids, ids[1:]))
def merge(ids: list[int], pair: tuple[int, int], new_id: int) -> list[int]:
out, i = [], 0
while i < len(ids):
if i < len(ids) - 1 and (ids[i], ids[i + 1]) == pair:
out.append(new_id)
i += 2
else:
out.append(ids[i])
i += 1
return out
def train_bpe(text: str, num_merges: int):
ids = list(text.encode("utf-8")) # başlangıç: 256 olası byte
merges: dict[tuple[int, int], int] = {}
for step in range(num_merges):
counts = get_pair_counts(ids)
if not counts:
break
pair = max(counts, key=counts.get) # en sık çift
new_id = 256 + step
ids = merge(ids, pair, new_id)
merges[pair] = new_id
return merges, ids
text = "düşünüyorum düşündüm düşünce"
merges, ids = train_bpe(text, num_merges=10)
print(len(text.encode("utf-8")), "->", len(ids)) # byte sayısı -> token sayısı
Türkçe İçin Neden Önemli? ş, ü, ğ gibi karakterler UTF-8'de 2 byte yer kaplar. Ağırlıklı olarak İngilizce veriyle eğitilmiş bir tokenizer, Türkçe ekleri iyi birleştiremez; aynı anlamdaki Türkçe metin İngilizcesinden daha fazla token tutar. Bu da daha yüksek API maliyeti ve daha dar context penceresi demektir.
Mülakat Sorusu: "Kelime bazlı tokenizasyon yerine neden BPE?" → Kelime bazlı yaklaşımda sözlükte olmayan kelimeler (OOV) <UNK> olur. Byte seviyesinde başlayan BPE her metni temsil edebilir; nadir kelimeler parçalara bölünür, sık kelimeler tek token olur.
5. Örtüşmeli Kayan Pencere ile Chunking
RAG sistemlerinde bir PDF'i olduğu gibi embedding'e veremezsiniz; hem modelin token limiti vardır hem de devasa bir vektör anlamı "sulandırır". Doküman parçalara (chunk) bölünür. Ama keskin sınırlarla bölerseniz, bir cümle iki parça arasında ikiye ayrılır ve anlam kaybolur. Çözüm: örtüşme (overlap).
def chunk_tokens(tokens: list, size: int = 512, overlap: int = 64) -> list[list]:
if not 0 <= overlap < size:
raise ValueError("overlap, 0 ile size arasında olmalı")
step = size - overlap
chunks = []
for start in range(0, len(tokens), step):
chunks.append(tokens[start:start + size])
if start + size >= len(tokens): # son parça metnin sonuna ulaştı
break
return chunks
tokens = list(range(10))
print(chunk_tokens(tokens, size=4, overlap=1))
# [[0, 1, 2, 3], [3, 4, 5, 6], [6, 7, 8, 9]]
Karmaşıklık: O(n). Bu, PyMülakat'taki İki Gösterici ve Kayan Pencere modülündeki kalıbın birebir üretim versiyonudur.
Mülakat Sorusu: "overlap >= size olursa ne olur?" → step sıfır veya negatif olur ve döngü ya hiç ilerlemez ya da range boş döner. Bu yüzden ilk satırdaki doğrulama, sonsuz döngü/sessiz hata riskini engeller. Sınır durumlarını sorgulamak mülakatta artı puandır.
6. BM25: Anahtar Kelime Aramasının Altın Standardı
Embedding araması anlamı yakalar ama tam eşleşmede zayıftır: HTTP 429, ERR_CERT_COMMON_NAME_INVALID veya bir ürün kodu gibi terimleri kaçırabilir. Elasticsearch ve OpenSearch'ün varsayılan sıralama fonksiyonu olan BM25 burada devreye girer.
import heapq
import math
from collections import Counter
class BM25:
def __init__(self, corpus: list[str], k1: float = 1.5, b: float = 0.75):
self.k1, self.b = k1, b
self.docs = [doc.lower().split() for doc in corpus]
self.N = len(self.docs)
self.avgdl = sum(len(d) for d in self.docs) / self.N
self.tfs = [Counter(d) for d in self.docs]
df = Counter(term for d in self.docs for term in set(d))
self.idf = {
t: math.log(1 + (self.N - n + 0.5) / (n + 0.5)) for t, n in df.items()
}
def score(self, query: str, i: int) -> float:
tf, dl = self.tfs[i], len(self.docs[i])
s = 0.0
for term in query.lower().split():
if term not in tf:
continue
f = tf[term]
denom = f + self.k1 * (1 - self.b + self.b * dl / self.avgdl)
s += self.idf[term] * f * (self.k1 + 1) / denom
return s
def search(self, query: str, k: int = 5):
scores = [(self.score(query, i), i) for i in range(self.N)]
return heapq.nlargest(k, scores)
bm25 = BM25([
"python ile hız sınırlayıcı yazmak",
"fastapi 429 too many requests hatası",
"python generator ve yield kullanımı",
])
print(bm25.search("429 hatası", k=1)) # 2. doküman (indeks 1)
İki Parametrenin Sezgisi:
k1(terim doygunluğu): Bir kelimenin 10. tekrarı, 1. tekrarı kadar değerli değildir.k1bu azalan getiriyi kontrol eder.b(uzunluk normalizasyonu): Uzun dokümanlar doğal olarak daha çok kelime içerir;bonları cezalandırarak kısa ve odaklı dokümanlara şans tanır.
Mülakat Sorusu: "TF-IDF'ten farkı ne?" → TF-IDF'te terim frekansı doğrusal büyür; BM25'te doyuma ulaşır ve doküman uzunluğuna göre normalize edilir.
7. Reciprocal Rank Fusion (RRF): Hibrit Aramanın Yapıştırıcısı
Elinizde iki sıralı liste var: biri vektör aramasından, diğeri BM25'ten. Skorları doğrudan toplayamazsınız, çünkü kosinüs skoru [-1, 1], BM25 skoru ise [0, ∞) aralığındadır. RRF skorları tamamen yok sayar ve sadece sıralamaya (rank) bakar.
from collections import defaultdict
def reciprocal_rank_fusion(rankings: list[list[str]], k: int = 60):
scores: dict[str, float] = defaultdict(float)
for ranking in rankings:
for rank, doc_id in enumerate(ranking, start=1):
scores[doc_id] += 1.0 / (k + rank)
return sorted(scores.items(), key=lambda t: t[1], reverse=True)
vector_results = ["doc_a", "doc_b", "doc_c"]
bm25_results = ["doc_c", "doc_a", "doc_d"]
print(reciprocal_rank_fusion([vector_results, bm25_results]))
# doc_a ve doc_c her iki listede de üst sıralarda -> en üste çıkar
k = 60 neden? Orijinal makalede (Cormack vd., 2009) deneysel olarak bulunan bu sabit, 1. sıra ile 2. sıra arasındaki farkın aşırı baskın olmasını önler. Böylece her iki listede de iyi olan dokümanlar, sadece birinde birinci olanları geçer.
Mülakat Sorusu: "Skorları min-max normalize edip toplasak olmaz mı?" → Olur, ama aykırı değerlere (outlier) karşı kırılgandır ve her sorguda dağılım değişir. RRF parametresizdir ve kalibrasyon gerektirmez.
8. Beam Search: Greedy'den Daha Akıllı Decoding
Greedy decoding her adımda en olası token'ı seçer, ama yerel olarak en iyi seçim, global olarak en iyi cümleyi garantilemez. Beam search her adımda en iyi B adayı canlı tutar.
import heapq
import math
def beam_search(step_fn, start: str, beam_width: int = 3,
max_len: int = 10, eos: str = "<eos>"):
"""step_fn(seq) -> {token: olasılık} döndüren bir 'model'."""
beams = [(0.0, [start])] # (log-olasılık, dizi)
finished = []
for _ in range(max_len):
candidates = []
for logp, seq in beams:
for token, p in step_fn(seq).items():
if p > 0:
candidates.append((logp + math.log(p), seq + [token]))
if not candidates:
break
beams = []
for logp, seq in heapq.nlargest(beam_width, candidates, key=lambda c: c[0]):
(finished if seq[-1] == eos else beams).append((logp, seq))
if not beams:
break
finished.extend(beams)
# uzunluk normalizasyonu: kısa dizilerin haksız avantajını kaldır
return max(finished, key=lambda c: c[0] / len(c[1]))
Neden log-olasılık? 0.1 olasılığı 50 kez çarparsanız 1e-50 elde edersiniz ve float hassasiyeti çöker (underflow). Logaritma, çarpımı toplamaya çevirerek sayısal kararlılık sağlar.
Mülakat Sorusu: "ChatGPT neden beam search kullanmıyor?" → Açık uçlu sohbette beam search tekrarlı ve "sıkıcı" metin üretme eğilimindedir. Çeviri ve özetleme gibi tek doğru cevaba yakın görevlerde beam search, yaratıcı üretimde ise top-p/temperature örneklemesi (Algoritma 3) tercih edilir.
9. Gradyan İnişi (Gradient Descent)
Milyar parametreli bir transformer da, iki parametreli bir lojistik regresyon da aynı temel fikirle eğitilir: Kaybın (loss) gradyanını hesapla, ters yönde küçük bir adım at. Bunu bir kez sıfırdan yazmak, loss.backward() satırının ne yaptığını gerçekten anlamanızı sağlar.
import math
def sigmoid(z: float) -> float:
if z >= 0:
return 1 / (1 + math.exp(-z))
e = math.exp(z) # negatif z'de taşmayı önleyen form
return e / (1 + e)
def train_logreg(X: list[list[float]], y: list[int], lr: float = 0.1, epochs: int = 200):
w = [0.0] * len(X[0])
b = 0.0
n = len(X)
for _ in range(epochs):
gw = [0.0] * len(w)
gb = 0.0
for xi, yi in zip(X, y):
pred = sigmoid(sum(wj * xj for wj, xj in zip(w, xi)) + b)
err = pred - yi # BCE kaybının z'ye göre türevi
for j, xj in enumerate(xi):
gw[j] += err * xj
gb += err
w = [wj - lr * g / n for wj, g in zip(w, gw)]
b -= lr * gb / n
return w, b
X = [[0.5], [1.5], [3.0], [4.0]]
y = [0, 0, 1, 1]
w, b = train_logreg(X, y, lr=0.5, epochs=500)
print(sigmoid(w[0] * 3.5 + b) > 0.5) # True
Zarif Detay: Sigmoid + ikili çapraz entropi (BCE) birlikte kullanıldığında gradyan sadeleşerek tahmin − gerçek olur. Bu yüzden err = pred - yi satırı bu kadar basittir.
Mülakat Sorusu: "Learning rate çok büyükse ne olur?" → Kayıp minimumun etrafında salınır veya ıraksar (NaN). Çok küçükse eğitim aşırı yavaşlar. Üretimde Adam gibi adaptif optimizer'lar ve learning rate scheduler'lar kullanılır.
10. K-Means ve IVF İndeksleme
Algoritma 2'deki Top-K araması tüm vektörleri tarar. Milyonlarca vektörde bu kabul edilemez. IVF (Inverted File Index), vektörleri önce K-Means ile kümelere ayırır; sorgu anında sadece sorguya en yakın birkaç kümeye bakar.
import random
def squared_dist(a: list[float], b: list[float]) -> float:
return sum((x - y) ** 2 for x, y in zip(a, b))
def kmeans(points: list[list[float]], k: int, iters: int = 20, seed: int = 42):
rng = random.Random(seed)
centroids = rng.sample(points, k)
for _ in range(iters):
clusters = [[] for _ in range(k)]
for p in points: # 1) atama adımı
idx = min(range(k), key=lambda c: squared_dist(p, centroids[c]))
clusters[idx].append(p)
new_centroids = []
for c, members in enumerate(clusters): # 2) güncelleme adımı
if members:
new_centroids.append([sum(dim) / len(members) for dim in zip(*members)])
else:
new_centroids.append(centroids[c]) # boş küme: eski merkezi koru
if new_centroids == centroids:
break # yakınsadı
centroids = new_centroids
return centroids
def ivf_search(query, centroids, buckets, nprobe=2, k=3):
"""buckets[i]: i. kümeye atanmış (doc_id, vektör) listesi."""
nearest = sorted(range(len(centroids)),
key=lambda c: squared_dist(query, centroids[c]))[:nprobe]
candidates = [doc for c in nearest for doc in buckets[c]]
return top_k(query, candidates, k) # Algoritma 2'yi yeniden kullan
Ödünleşim (Trade-off): nprobe arttıkça doğruluk (recall) artar ama hız düşer. nprobe = küme sayısı olursa tam aramaya geri dönersiniz. Bu, mülakatta "doğruluk mu, gecikme mi?" tartışmasının klasik örneğidir.
Mülakat Sorusu: "K-Means'in zayıf noktaları neler?" → K'nın önceden bilinmesi gerekir, başlangıç merkezlerine duyarlıdır (çözüm: k-means++) ve küresel olmayan kümelerde başarısız olur.
Bu 10 Algoritma Bir RAG Sisteminde Nasıl Birleşir?
Tek tek öğrendiğiniz parçalar, gerçek bir üretim sisteminde şu sırayla birbirine bağlanır:
- Hazırlık (Offline): Dokümanlar BPE ile token'a çevrilir (4) → örtüşmeli chunk'lara bölünür (5) → embedding'leri çıkarılır → K-Means/IVF ile indekslenir (10). Paralel olarak bir BM25 indeksi kurulur (6).
- Sorgu (Online): Soru embedding'e çevrilir → IVF ile aday kümeler bulunur → kosinüs benzerliği (1) ve heap ile Top-K (2) uygulanır → BM25 sonuçlarıyla RRF ile birleştirilir (7).
- Üretim: Bulunan parçalar prompt'a eklenir → LLM softmax + top-p (3) veya beam search (8) ile cevabı üretir.
- İyileştirme: Embedding modeli veya reranker, gradyan inişi (9) ile alana özel veriyle ince ayar yapılır.
Bu akışı bir mülakatta beyaz tahtada çizebiliyorsanız, "AI mühendisi" unvanını hak eden adayların arasındasınız demektir.
Sonuç: Kütüphane Değil, Mekanizma
AI araçları her altı ayda bir değişiyor. LangChain'in API'si değişir, yeni bir vektör veritabanı popüler olur, yeni bir model çıkar. Ama kosinüs benzerliği, heap, softmax, BPE ve gradyan inişi on yıllardır aynı ve önümüzdeki on yıl da aynı kalacak.
Bu algoritmaların temelini oluşturan veri yapılarını pekiştirmek için:
- Hash map ve frekans sayımı (BPE, BM25): Diziler ve Hashing modülü
- Kayan pencere (chunking): İki Gösterici ve Kayan Pencere modülü
- Heap ve öncelik kuyruğu (Top-K, beam search): Soru kataloğu
Teoriyi okumak yetmez: PyMülakat'ın canlı kodlama ortamında bu kalıpları çözün ve AI mülakatçınızla zaman/bellek karmaşıklığınızı tartışın.
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.
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.
Python Mülakat Soruları ve Cevapları Türkçe (2026)
Python mülakatlarında en sık sorulan teknik sorular, tuzak sorular ve çalışan kod örnekleri. Junior'dan senior'a mülakata girmeden önce rehberi oku.