8 Sözlükler ve Setler

{k: v} ve {a, b} — state_dict, vocab, data leakage check

Bölüm bilgisi

Mosh’un videosu: Chapter 19 (Dictionaries) (≈7 dk) + Mosh’un göstermediği: Set
Bölüm aralığı: 2:07:20 — 2:14:16 (+ Set bu derste eklendi)
Kaynaklar: Python docs — dict · Python docs — set
Okuma süresi: ≈35 dk

8.1 Bu Derste Ne Var?

Python’un dört temel koleksiyon yapısının ikincisi ve üçüncüsünü öğreneceksin: dictionary (dict) ve set. Liste sıralı koleksiyondu (Ders 4); dict anahtar-değer eşlemesi, set ise unique elemanların sırasız koleksiyonu.

flowchart LR
    A["dict {k: v}"] --> B["d[key], .get()"]
    A --> C["methods<br/>.keys, .values, .items"]
    A --> D["💎 state_dict"]
    A --> E["Counter, defaultdict"]
    F["set {1, 2, 3}"] --> G["Unique + O(1) lookup"]
    G --> H["💎 NLP vocabulary"]
    F --> I["union | intersect &"]
    I --> J["➡️ Data leakage check"]

    style D fill:#fce4ec,stroke:#c2185b,stroke-width:3px
    style H fill:#fce4ec,stroke:#c2185b,stroke-width:3px
    style J fill:#fce4ec,stroke:#c2185b,stroke-width:3px

Şekil 8.1: Ders 7’nin akış haritası — dict ve set’in ML evreni

Dersin beş parçası:

Dictionary (sözlük). — {"anahtar": "değer"}. Mosh’un ay-isim dönüştürücüsü.
Dict erişim ve metodlar. — dict[k], .get(), .keys(), .values(), .items().
Set (küme). — {1, 2, 3}. Unique elemanlar.
Set operasyonları. — |, &, -, ^.
Dört koleksiyon karşılaştırması. — list/tuple/dict/set.

Builder Notu — Bu Dersin ML Köprüleri

Dict = JSON config / hyperparameter config. ML eğitim kodlarının %90’ında config = {"lr": 1e-3, "batch_size": 64, "epochs": 100}. JSON dosyaları zaten dict olarak yüklenir (json.load(...)).
Dict = PyTorch model.state_dict(). Modelin tüm ağırlıkları ad-tensor map’i. Model kaydetme/yükleme bu dict üzerinden işler.
Dict = HuggingFace tokenizer vocab. tokenizer.vocab her tokeni id’sine map’ler: {"hello": 7592, "world": 2088, ...}. LLM’lerin temeli bu dict’tir.
Set = unique label collection. ML’de “kaç tane benzersiz sınıf var?” → len(set(labels)). Vocabulary oluşturma.
Set = duplicate filtering. list(set(items)) yinelenenleri ayıkla.
Set operations = data filtering venn. Train set vs val set vs test set kelime kesişimi, örütme kontrolü.
collections.Counter, defaultdict. Standart dict’in güçlü kardeşleri. Counter(labels) ML class imbalance kontrolü için günlük pratik.

8.2 Dictionary — Anahtar-Değer Eşlemesi

Mosh:

“bir sözlük python’da bilgi depolamamıza izin veren özel bir yapıdır. ne denir anahtar değer çiftleri.” — Mosh (Türkçe dublaj), 2:07:31

8.2.1 Günlük Hayat Analojisi

Mosh kelimenin kendisinden faydalanıyor: “sözlük” gibi.

“kelime benzersiz bir şekilde tanımlayana benzer Sözlüğün içinde, ve sonra değer gerçek tanım olacaktır.” — Mosh (Türkçe dublaj), 2:08:02

Kelime → anahtar (key).
Tanım → değer (value).

8.2.2 Motivasyon — Ay Kısaltma Dönüştürücüsü

List ile (kötü):

kisaltmalar = ["Jan", "Feb", "Mar", ...]
tam_isimler = ["January", "February", "March", ...]

idx = kisaltmalar.index("Mar")
print(tam_isimler[idx])

İki ayrı liste, indekslerin denkleşmesini elle sağlaman gerek. Kırılgan.

Dict ile (iyi):

ay_donusumleri = {
    "Jan": "January",
    "Feb": "February",
    "Mar": "March",
}

print(ay_donusumleri["Mar"])    # March

8.2.3 Sentaks

“açık ve kapalı kıvrımlı parantez” — Mosh (Türkçe dublaj), 2:09:08

sozluk_adi = {
    anahtar1: deger1,
    anahtar2: deger2,
    anahtar3: deger3,
}

Küme parantezi { } ile. Her giriş anahtar: değer. Aralarında virgül.

8.2.4 Anahtar Kuralları

“anahtarların hepsinin benzersiz olması gerekiyor.” — Mosh (Türkçe dublaj), 2:10:15

Üç kural:

Unique — aynı anahtar iki kere yazılamaz.
Immutable tip — anahtar str, int, float, tuple, bool, frozenset olabilir. List/dict/set olamaz.
Hashable — yukarıdaki kısıtlamanın teknik adı.

# OK:
d = {"key": 1}                  # str
d = {42: "answer"}              # int
d = {(3, 5): "point"}           # tuple (Ders 4'te bu nedenle tuple gerekiyordu!)

# YANLIS:
d = {[1, 2]: "list"}            # TypeError: unhashable

8.2.5 Dict ML’in DNA’sı

Builder Notu — 10 ML Pattern

ML kodunda dict 10+ farklı yerde:

# 1. Hyperparameter config:
config = {"lr": 1e-3, "batch_size": 64, "device": "cuda"}

# 2. JSON yükleme:
import json
with open("config.json") as f:
    cfg = json.load(f)              # cfg bir dict!

# 3. Model state_dict:
import torch
state = model.state_dict()           # OrderedDict[str, Tensor]
torch.save(state, "model.pt")

# 4. Tokenizer vocab:
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
vocab = tokenizer.get_vocab()        # dict[str, int]
print(vocab["hello"])                # 7592

# 5. Dataset sample:
sample = {"image": tensor, "label": 7, "path": "img.jpg"}

# 6. Metric tracking:
metrics = {"loss": [], "acc": [], "f1": []}

# 7. Model outputs (HuggingFace):
outputs = model(input_ids)
print(outputs.logits)                # dict-like cikti

Mosh’un “ay-isim dönüştürücüsü” mikro örneği, yukarıdaki tüm pattern’ların çekirdeği. Tek bir kavram, on farklı görünüm.

8.3 Dict Erişim — `[]` ve `.get()`

8.3.1 Bracket Access

ay_donusumleri = {
    "Jan": "January",
    "Feb": "February",
    "Nov": "November",
}

ay_donusumleri["Nov"]    # 'November'
ay_donusumleri["Luc"]    # KeyError: 'Luc'

8.3.2 `.get()` — Güvenli Erişim

“get işlevini kullanmanın nesi harika Aslında kullanmak istediğim varsayılan bir değer belirtebilirim. eğer bu anahtarlar bulamazsa” — Mosh (Türkçe dublaj), 2:12:22

ay_donusumleri.get("Nov")                # 'November'
ay_donusumleri.get("Luc")                # None (hata yok!)
ay_donusumleri.get("Luc", "Bilinmeyen")  # 'Bilinmeyen'

Pratik:

# Sert (anahtar olmalı):
lr = config["learning_rate"]

# Yumusak (default ile):
lr = config.get("learning_rate", 1e-3)

ML hyperparameter okuma çoğu zaman .get(...) ile default’lu.

8.3.3 Ekle / Değiştir / Sil

kullanici = {"ad": "Deniz", "yas": 35}

kullanici["sehir"] = "Istanbul"      # ekle
kullanici["yas"] = 36                # değiştir
del kullanici["sehir"]               # sil
yas = kullanici.pop("yas")           # sil ve değeri al

8.3.4 `in` Üyelik

"Jan" in ay_donusumleri    # True
"XYZ" in ay_donusumleri    # False

in dict için anahtarı kontrol eder.

8.4 Dict Metodları

ay = {"Jan": "January", "Feb": "February", "Mar": "March"}

# Anahtarlar / değerler / çiftler:
ay.keys()       # dict_keys(['Jan', 'Feb', 'Mar'])
ay.values()     # dict_values(['January', 'February', 'March'])
ay.items()      # dict_items([('Jan', 'January'), ...])

# Iteration:
for anahtar, deger in ay.items():
    print(f"{anahtar} -> {deger}")

# Birleştir:
a = {"x": 1, "y": 2}
b = {"y": 99, "z": 3}
a.update(b)     # a artik {"x": 1, "y": 99, "z": 3}

# Modern (Python 3.9+):
c = a | b       # yeni dict

8.4.1 Dict Comprehension

kareler = {x: x**2 for x in range(1, 6)}
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

kullanici = {"ad": "Deniz", "yas": 35}
buyuk_dict = {k.upper(): str(v).upper() for k, v in kullanici.items()}

8.5 `Counter` ve `defaultdict` — Dict’in Güçlü Kardeşleri

8.5.1 `Counter` — Sayma

from collections import Counter

labels = ["kedi", "kopek", "kedi", "kus", "kedi", "kopek"]
counter = Counter(labels)
# Counter({'kedi': 3, 'kopek': 2, 'kus': 1})

counter.most_common(2)
# [('kedi', 3), ('kopek', 2)]

ML class imbalance kontrolü:

from collections import Counter

class_counts = Counter(dataset_labels)

for cls, count in class_counts.most_common():
    pct = count / len(dataset_labels) * 100
    print(f"  {cls}: {count} ({pct:.1f}%)")

8.5.2 `defaultdict` — Otomatik Initialize

from collections import defaultdict

# Normal dict (uzun):
gruplar = {}
for n in [1, 2, 3, 4, 5]:
    grup = "cift" if n % 2 == 0 else "tek"
    if grup not in gruplar:
        gruplar[grup] = []
    gruplar[grup].append(n)

# defaultdict (kısa):
gruplar = defaultdict(list)
for n in [1, 2, 3, 4, 5]:
    grup = "cift" if n % 2 == 0 else "tek"
    gruplar[grup].append(n)

8.6 Set — Unique Elemanlar

Mosh göstermez ama Python ekosisteminin temel parçası.

8.6.1 Set Nedir?

Set: sırasız + unique elemanlar.

sayilar = {1, 2, 3, 4, 5}
print(type(sayilar))  # <class 'set'>

karisik = {1, 2, 2, 3, 3, 3, 4}
print(karisik)        # {1, 2, 3, 4}  - yinelenenler kayboldu

Liste ile farklar:

Sıra yok — set[0] çalışmaz.
Unique — yinelenenler otomatik filtrelenir.

8.6.2 Sentaks Tuzağı

# Boş set:
bos = set()        # bos set
yine_bos = {}      # boş DICT! (set değil)

# Dolu:
sayilar = {1, 2, 3}

# Liste'den (deduplication):
from_list = set([1, 2, 2, 3, 3, 4])   # {1, 2, 3, 4}

{} boş dict, set() boş set — Python tasarım kararı.

8.6.3 Set Metodları

sayilar = {1, 2, 3}

sayilar.add(4)         # {1, 2, 3, 4}
sayilar.add(2)         # zaten var, hicbir sey olmaz
sayilar.remove(2)      # {1, 3, 4}
sayilar.discard(100)   # OK (remove → KeyError)
n = sayilar.pop()      # rastgele eleman çıkar

len({1, 2, 3, 4, 5})   # 5
3 in {1, 2, 3}         # True

8.6.4 Set’in Süper Gücü — `in` O(1)

import time

n = 1_000_000
liste = list(range(n))
kume = set(liste)

# Liste'de arama: O(n)
start = time.time()
print(n - 1 in liste)
print(f"List: {time.time() - start:.4f}s")
# 0.0150s

# Set'te arama: O(1)
start = time.time()
print(n - 1 in kume)
print(f"Set: {time.time() - start:.7f}s")
# 0.0000003s

50,000 kat hızlı. Set hash table kullanır.

Şekil 8.2: Set vs List performans — `in` operasyonu için 50K kat hız farkı

8.7 Set Operasyonları — Küme Matematiği

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}

a | b    # {1, 2, 3, 4, 5, 6, 7, 8}   birleşim
a & b    # {4, 5}                       kesişim
a - b    # {1, 2, 3}                    fark
a ^ b    # {1, 2, 3, 6, 7, 8}           simetrik fark

# Alt-küme:
{1, 2} <= {1, 2, 3}    # True
{1, 2} <  {1, 2}       # False (esit, oz degil)

8.7.1 Vocabulary Oluşturma (NLP)

Builder Notu — NLP Vocab

documents = [
    "the cat sat on the mat",
    "the dog ate the bone",
    "a cat and a dog",
]

vocab = set()
for doc in documents:
    vocab.update(doc.split())

print(f"Vocab size: {len(vocab)}")    # 10

8.7.2 Train/Val/Test Data Leakage Check

Builder Notu — Data Leakage

Üretim ML’inde kritik kontrol:

# Test ID'leri train'de var mı? (data leakage)
train_ids = set(train_df["id"])
test_ids = set(test_df["id"])

leakage = train_ids & test_ids
if leakage:
    print(f"WARNING: {len(leakage)} ID train+test'te")

# Val'da train'de görünmemiş kelimeler:
train_vocab = set(...)
val_vocab = set(...)
unseen_val = val_vocab - train_vocab

Milyon kayıt için saniyede biter.

8.8 Dört Koleksiyon — Karşılaştırma

Özellik	list `[1, 2]`	tuple `(1, 2)`	dict `{a: 1}`	set `{1, 2}`
Sıralı	Evet	Evet	Evet (3.7+)	Hayır
Değişebilir	Evet	Hayır	Evet	Evet
Yinelenen OK	Evet	Evet	Anahtar değil	Hayır
Erişim	`l[i]`	`t[i]`	`d[key]`	`in`
Hashable mi?	Hayır	Evet	Hayır	Hayır (frozenset evet)
Sentaks	`[a, b]`	`(a, b)`	`{a: 1}`	`{a, b}`

8.8.1 Karar Akışı

Sıralı mı olmalı?
├── HAYIR → Set (unique + üyelik kontrolü hızlı)
└── EVET:
    └── Anahtar-değer mi?
        ├── EVET → Dict
        └── HAYIR:
            └── Değişecek mi?
                ├── EVET → List
                └── HAYIR → Tuple

8.8.2 Pratik

# List:
losses = [0.5, 0.4, 0.3]            # epoch sirasi onemli
friends = ["Kevin", "Karen"]         # eklenebilir

# Tuple:
input_shape = (3, 224, 224)         # tensor boyutu
rgb = (255, 0, 0)                    # sabit

# Dict:
config = {"lr": 1e-3, "batch_size": 64}

# Set:
seen_ids = {1, 5, 23, 7}            # bir id gorduk mu?

8.9 Bu Dersin Özeti

Dict ({}): anahtar-değer eşlemesi. Anahtarlar unique + hashable.
Erişim: d[k] sert, .get(k, default) yumuşak.
Iteration: .keys(), .values(), .items().
in dict için anahtarı kontrol.
Set ({...} / set()): unique + sırasız + hızlı in.
Set ops: |, &, -, ^.
{} boş dict, set() boş set.
Counter, defaultdict — collections güçlü kardeşler.
ML eki: dict her yerde (config/state_dict/vocab), set vocab+dedup+filter için kritik.

Tek Bir Cümle

8.10 Egzersizler

Egzersiz 1. Öğrenci sicil dict — 5 öğrenci, notlar list:

sicil = {
    "Deniz": [85, 90, 78],
    ???
}

# (a) "Aylin" ekle, notları [95, 88, 92]
# (b) "Deniz"in notuna 80 ekle
# (c) "Mosh"un ortalaması
# (d) Tüm ortalamalar

Egzersiz 2. Kelime sayma — manuel + Counter:

cumle = "the quick brown fox jumps over the lazy dog the dog naps"

# Manuel:
kelime_sayilari = {}
for kelime in cumle.split():
    kelime_sayilari[kelime] = kelime_sayilari.get(kelime, 0) + 1

# Counter (tek satır):
from collections import Counter
sayilar = Counter(cumle.split())

Egzersiz 3. Liste kesişim/fark — set ile:

a = [1, 2, 3, 4, 5, 6]
b = [4, 5, 6, 7, 8, 9]

kesisim_set = set(a) & set(b)
fark_set = set(a) - set(b)

print(kesisim_set)   # {4, 5, 6}
print(fark_set)      # {1, 2, 3}

1 milyon eleman için hangisi pratik?

Egzersiz 4. ML config güvenli erişim:

config = {
    "model": "resnet18",
    "lr": 1e-3,
    "batch_size": 64,
}

# Zorunlu:
model_name = config["model"]
lr = config["lr"]

# Opsiyonel:
epochs = config.get(???)        # default 100
device = config.get(???)        # default "cpu"
weight_decay = config.get(???)  # default 0.0

Egzersiz 5. (Builder eksen — model state JSON)

import json

model_state = {
    "layer1.weight": [[0.1, 0.2], [0.3, 0.4]],
    "layer1.bias": [0.0, 0.0],
    "layer2.weight": [[0.5, 0.6], [0.7, 0.8]],
    "layer2.bias": [0.1, 0.1],
}

# Kaydet:
with open("model.json", "w") as f:
    json.dump(model_state, f)

# Yükle:
with open("model.json") as f:
    loaded = json.load(f)

# Anahtar-shape print:
for name, weights in loaded.items():
    if isinstance(weights[0], list):
        shape = (len(weights), len(weights[0]))
    else:
        shape = (len(weights),)
    print(f"  {name}: shape={shape}")

PyTorch torch.save / torch.load mekanizmasının JSON versiyonu.

8.11 Sonraki Ders İçin Hazırlık

Ders 8: Döngüler

Bu kursun en kritik dersi. Mosh dört chapter’da (While, Guessing Game, For, 2D Lists). for batch in dataloader: modern AI’nın ana motoru.

Mosh’un Ch 20-22 ve Ch 24’ünü izle (2:14:16-2:52:44, ~38 dk).
Şu cümleyi içselleştir: “Döngü = tekrar etme = bir grup veri üzerinde aynı işi yapma.”

Bu dersten tek bir şey alıp gideceksen

Dict ({anahtar: değer}) anahtarla hızlı arama yapar — Mosh’un ay-isim örneği aslında PyTorch’taki model.state_dict(), HuggingFace tokenizer vocab’ı, ve JSON config dosyalarının ata-formudur; set ({1, 2, 3}) unique elemanları sırasız tutar ve in kontrolünü O(1)’e indirir — NLP vocabulary, label dedup, ve train/val data leakage kontrolünün günlük aracı; Python’un dört koleksiyon yapısı (list, tuple, dict, set) artık tam senin elinde, ve modern ML kodunun her satırı bu dördünden birinin üzerinde inşa edilmiş.

--- title: "Sözlükler ve Setler" subtitle: "`{k: v}` ve `{a, b}` — `state_dict`, vocab, data leakage check" --- ::: {.callout-note title="Bölüm bilgisi"} - **Mosh'un videosu:** [Chapter 19 (Dictionaries)](https://www.youtube.com/watch?v=rfscVS0vtbw&t=7640s) (≈7 dk) + **Mosh'un göstermediği:** Set - **Bölüm aralığı:** 2:07:20 — 2:14:16 (+ Set bu derste eklendi) - **Kaynaklar:** [Python docs — dict](https://docs.python.org/3/tutorial/datastructures.html#dictionaries) · [Python docs — set](https://docs.python.org/3/tutorial/datastructures.html#sets) - **Okuma süresi:** ≈35 dk ::: ## Bu Derste Ne Var? {#sec-bu-derste-7} Python'un dört temel koleksiyon yapısının ikincisi ve üçüncüsünü öğreneceksin: **dictionary (dict)** ve **set**. Liste sıralı koleksiyondu (Ders 4); dict **anahtar-değer eşlemesi**, set ise **unique elemanların sırasız koleksiyonu**. ```{mermaid} %%| label: fig-akis-7 %%| fig-cap: "Ders 7'nin akış haritası — dict ve set'in ML evreni" flowchart LR A["dict {k: v}"] --> B["d[key], .get()"] A --> C["methods<br/>.keys, .values, .items"] A --> D["💎 state_dict"] A --> E["Counter, defaultdict"] F["set {1, 2, 3}"] --> G["Unique + O(1) lookup"] G --> H["💎 NLP vocabulary"] F --> I["union | intersect &"] I --> J["➡️ Data leakage check"] style D fill:#fce4ec,stroke:#c2185b,stroke-width:3px style H fill:#fce4ec,stroke:#c2185b,stroke-width:3px style J fill:#fce4ec,stroke:#c2185b,stroke-width:3px ``` **Dersin beş parçası:** 1. **Dictionary (sözlük).** — `{"anahtar": "değer"}`. Mosh'un ay-isim dönüştürücüsü. 2. **Dict erişim ve metodlar.** — `dict[k]`, `.get()`, `.keys()`, `.values()`, `.items()`. 3. **Set (küme).** — `{1, 2, 3}`. **Unique** elemanlar. 4. **Set operasyonları.** — `|`, `&`, `-`, `^`. 5. **Dört koleksiyon karşılaştırması.** — list/tuple/dict/set. ::: {.callout-tip title="Builder Notu — Bu Dersin ML Köprüleri"} - **Dict = JSON config / hyperparameter config.** ML eğitim kodlarının %90'ında `config = {"lr": 1e-3, "batch_size": 64, "epochs": 100}`. JSON dosyaları zaten dict olarak yüklenir (`json.load(...)`). - **Dict = PyTorch `model.state_dict()`.** Modelin tüm ağırlıkları ad-tensor map'i. Model kaydetme/yükleme bu dict üzerinden işler. - **Dict = HuggingFace tokenizer vocab.** `tokenizer.vocab` her tokeni id'sine map'ler: `{"hello": 7592, "world": 2088, ...}`. LLM'lerin temeli bu dict'tir. - **Set = unique label collection.** ML'de "kaç tane benzersiz sınıf var?" → `len(set(labels))`. Vocabulary oluşturma. - **Set = duplicate filtering.** `list(set(items))` yinelenenleri ayıkla. - **Set operations = data filtering venn.** Train set vs val set vs test set kelime kesişimi, örütme kontrolü. - **`collections.Counter`, `defaultdict`.** Standart `dict`'in güçlü kardeşleri. `Counter(labels)` ML class imbalance kontrolü için günlük pratik. ::: ## Dictionary — Anahtar-Değer Eşlemesi {#sec-dict} Mosh: > *"bir sözlük python'da bilgi depolamamıza izin veren özel bir yapıdır. ne denir anahtar değer çiftleri."* — Mosh (Türkçe dublaj), 2:07:31 ### Günlük Hayat Analojisi Mosh kelimenin kendisinden faydalanıyor: "sözlük" gibi. > *"kelime benzersiz bir şekilde tanımlayana benzer Sözlüğün içinde, ve sonra değer gerçek tanım olacaktır."* — Mosh (Türkçe dublaj), 2:08:02 - **Kelime** → anahtar (key). - **Tanım** → değer (value). ### Motivasyon — Ay Kısaltma Dönüştürücüsü **List ile (kötü):** ```python kisaltmalar = ["Jan", "Feb", "Mar", ...] tam_isimler = ["January", "February", "March", ...] idx = kisaltmalar.index("Mar") print(tam_isimler[idx]) ``` İki ayrı liste, indekslerin denkleşmesini elle sağlaman gerek. Kırılgan. **Dict ile (iyi):** ```python ay_donusumleri = { "Jan": "January", "Feb": "February", "Mar": "March", } print(ay_donusumleri["Mar"]) # March ``` ### Sentaks > *"açık ve kapalı kıvrımlı parantez"* — Mosh (Türkçe dublaj), 2:09:08 ```python sozluk_adi = { anahtar1: deger1, anahtar2: deger2, anahtar3: deger3, } ``` Küme parantezi `{ }` ile. Her giriş `anahtar: değer`. Aralarında virgül. ### Anahtar Kuralları > *"anahtarların hepsinin benzersiz olması gerekiyor."* — Mosh (Türkçe dublaj), 2:10:15 Üç kural: 1. **Unique** — aynı anahtar iki kere yazılamaz. 2. **Immutable tip** — anahtar `str`, `int`, `float`, `tuple`, `bool`, `frozenset` olabilir. List/dict/set **olamaz**. 3. **Hashable** — yukarıdaki kısıtlamanın teknik adı. ```python # OK: d = {"key": 1} # str d = {42: "answer"} # int d = {(3, 5): "point"} # tuple (Ders 4'te bu nedenle tuple gerekiyordu!) # YANLIS: d = {[1, 2]: "list"} # TypeError: unhashable ``` ### Dict ML'in DNA'sı ::: {.callout-tip title="Builder Notu — 10 ML Pattern"} ML kodunda dict 10+ farklı yerde: ```python # 1. Hyperparameter config: config = {"lr": 1e-3, "batch_size": 64, "device": "cuda"} # 2. JSON yükleme: import json with open("config.json") as f: cfg = json.load(f) # cfg bir dict! # 3. Model state_dict: import torch state = model.state_dict() # OrderedDict[str, Tensor] torch.save(state, "model.pt") # 4. Tokenizer vocab: from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") vocab = tokenizer.get_vocab() # dict[str, int] print(vocab["hello"]) # 7592 # 5. Dataset sample: sample = {"image": tensor, "label": 7, "path": "img.jpg"} # 6. Metric tracking: metrics = {"loss": [], "acc": [], "f1": []} # 7. Model outputs (HuggingFace): outputs = model(input_ids) print(outputs.logits) # dict-like cikti ``` Mosh'un "ay-isim dönüştürücüsü" mikro örneği, yukarıdaki tüm pattern'ların çekirdeği. **Tek bir kavram, on farklı görünüm.** ::: ## Dict Erişim — `[]` ve `.get()` {#sec-dict-erisim} ### Bracket Access ```python ay_donusumleri = { "Jan": "January", "Feb": "February", "Nov": "November", } ay_donusumleri["Nov"] # 'November' ay_donusumleri["Luc"] # KeyError: 'Luc' ``` ### `.get()` — Güvenli Erişim > *"get işlevini kullanmanın nesi harika Aslında kullanmak istediğim varsayılan bir değer belirtebilirim. eğer bu anahtarlar bulamazsa"* — Mosh (Türkçe dublaj), 2:12:22 ```python ay_donusumleri.get("Nov") # 'November' ay_donusumleri.get("Luc") # None (hata yok!) ay_donusumleri.get("Luc", "Bilinmeyen") # 'Bilinmeyen' ``` **Pratik:** ```python # Sert (anahtar olmalı): lr = config["learning_rate"] # Yumusak (default ile): lr = config.get("learning_rate", 1e-3) ``` ML hyperparameter okuma çoğu zaman `.get(...)` ile default'lu. ### Ekle / Değiştir / Sil ```python kullanici = {"ad": "Deniz", "yas": 35} kullanici["sehir"] = "Istanbul" # ekle kullanici["yas"] = 36 # değiştir del kullanici["sehir"] # sil yas = kullanici.pop("yas") # sil ve değeri al ``` ### `in` Üyelik ```python "Jan" in ay_donusumleri # True "XYZ" in ay_donusumleri # False ``` `in` dict için **anahtarı** kontrol eder. ## Dict Metodları {#sec-dict-methods} ```python ay = {"Jan": "January", "Feb": "February", "Mar": "March"} # Anahtarlar / değerler / çiftler: ay.keys() # dict_keys(['Jan', 'Feb', 'Mar']) ay.values() # dict_values(['January', 'February', 'March']) ay.items() # dict_items([('Jan', 'January'), ...]) # Iteration: for anahtar, deger in ay.items(): print(f"{anahtar} -> {deger}") # Birleştir: a = {"x": 1, "y": 2} b = {"y": 99, "z": 3} a.update(b) # a artik {"x": 1, "y": 99, "z": 3} # Modern (Python 3.9+): c = a | b # yeni dict ``` ### Dict Comprehension ```python kareler = {x: x**2 for x in range(1, 6)} # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25} kullanici = {"ad": "Deniz", "yas": 35} buyuk_dict = {k.upper(): str(v).upper() for k, v in kullanici.items()} ``` ## `Counter` ve `defaultdict` — Dict'in Güçlü Kardeşleri {#sec-counter} ### `Counter` — Sayma ```python from collections import Counter labels = ["kedi", "kopek", "kedi", "kus", "kedi", "kopek"] counter = Counter(labels) # Counter({'kedi': 3, 'kopek': 2, 'kus': 1}) counter.most_common(2) # [('kedi', 3), ('kopek', 2)] ``` ML class imbalance kontrolü: ```python from collections import Counter class_counts = Counter(dataset_labels) for cls, count in class_counts.most_common(): pct = count / len(dataset_labels) * 100 print(f" {cls}: {count} ({pct:.1f}%)") ``` ### `defaultdict` — Otomatik Initialize ```python from collections import defaultdict # Normal dict (uzun): gruplar = {} for n in [1, 2, 3, 4, 5]: grup = "cift" if n % 2 == 0 else "tek" if grup not in gruplar: gruplar[grup] = [] gruplar[grup].append(n) # defaultdict (kısa): gruplar = defaultdict(list) for n in [1, 2, 3, 4, 5]: grup = "cift" if n % 2 == 0 else "tek" gruplar[grup].append(n) ``` ## Set — Unique Elemanlar {#sec-set} Mosh göstermez ama Python ekosisteminin temel parçası. ### Set Nedir? **Set:** sırasız + unique elemanlar. ```python sayilar = {1, 2, 3, 4, 5} print(type(sayilar)) # <class 'set'> karisik = {1, 2, 2, 3, 3, 3, 4} print(karisik) # {1, 2, 3, 4} - yinelenenler kayboldu ``` Liste ile farklar: - **Sıra yok** — `set[0]` çalışmaz. - **Unique** — yinelenenler otomatik filtrelenir. ### Sentaks Tuzağı ```python # Boş set: bos = set() # bos set yine_bos = {} # boş DICT! (set değil) # Dolu: sayilar = {1, 2, 3} # Liste'den (deduplication): from_list = set([1, 2, 2, 3, 3, 4]) # {1, 2, 3, 4} ``` `{}` boş **dict**, `set()` boş **set** — Python tasarım kararı. ### Set Metodları ```python sayilar = {1, 2, 3} sayilar.add(4) # {1, 2, 3, 4} sayilar.add(2) # zaten var, hicbir sey olmaz sayilar.remove(2) # {1, 3, 4} sayilar.discard(100) # OK (remove → KeyError) n = sayilar.pop() # rastgele eleman çıkar len({1, 2, 3, 4, 5}) # 5 3 in {1, 2, 3} # True ``` ### Set'in Süper Gücü — `in` O(1) ```python import time n = 1_000_000 liste = list(range(n)) kume = set(liste) # Liste'de arama: O(n) start = time.time() print(n - 1 in liste) print(f"List: {time.time() - start:.4f}s") # 0.0150s # Set'te arama: O(1) start = time.time() print(n - 1 in kume) print(f"Set: {time.time() - start:.7f}s") # 0.0000003s ``` **50,000 kat hızlı.** Set hash table kullanır. ```{python} #| label: fig-set-vs-list #| fig-cap: "Set vs List performans — `in` operasyonu için 50K kat hız farkı" #| fig-width: 11 #| fig-height: 4 import matplotlib.pyplot as plt import numpy as np fig, axes = plt.subplots(1, 2, figsize=(11, 4)) # Sol: zaman karşılaştırması (log scale) sizes = [10, 100, 1000, 10000, 100000, 1000000] list_times = [s * 1e-7 for s in sizes] # O(n) lineer set_times = [3e-7 for _ in sizes] # O(1) sabit axes[0].loglog(sizes, list_times, "o-", color="#3776ab", linewidth=2, markersize=8, label="List: O(n)") axes[0].loglog(sizes, set_times, "s-", color="#c2185b", linewidth=2, markersize=8, label="Set: O(1)") axes[0].set_xlabel("Eleman sayısı", fontsize=12) axes[0].set_ylabel("Süre (saniye)", fontsize=12) axes[0].set_title("`in` operasyonu — List vs Set", fontsize=12) axes[0].legend(fontsize=11) axes[0].grid(True, which="both", alpha=0.3) # Sağ: bar chart - 1M eleman örneği labels = ["List\n(1M elements)", "Set\n(1M elements)"] times_ms = [15.0, 0.0003] # ms colors = ["#3776ab", "#c2185b"] bars = axes[1].bar(labels, times_ms, color=colors, alpha=0.7, edgecolor="black") axes[1].set_yscale("log") axes[1].set_ylabel("Süre (ms, log scale)", fontsize=12) axes[1].set_title("1M elemanda `999_999 in koleksiyon`", fontsize=12) axes[1].grid(True, axis="y", alpha=0.3) # Değer etiketleri axes[1].text(0, 15.0 * 1.5, "15.0 ms", ha="center", fontsize=11, fontweight="bold") axes[1].text(1, 0.0003 * 3, "0.0003 ms", ha="center", fontsize=11, fontweight="bold") axes[1].text(0.5, 5e-2, "50,000×\nhızlı!", ha="center", fontsize=14, color="#f57c00", fontweight="bold") plt.tight_layout() plt.show() ``` ## Set Operasyonları — Küme Matematiği {#sec-set-ops} ```python a = {1, 2, 3, 4, 5} b = {4, 5, 6, 7, 8} a | b # {1, 2, 3, 4, 5, 6, 7, 8} birleşim a & b # {4, 5} kesişim a - b # {1, 2, 3} fark a ^ b # {1, 2, 3, 6, 7, 8} simetrik fark # Alt-küme: {1, 2} <= {1, 2, 3} # True {1, 2} < {1, 2} # False (esit, oz degil) ``` ### Vocabulary Oluşturma (NLP) ::: {.callout-tip title="Builder Notu — NLP Vocab"} ```python documents = [ "the cat sat on the mat", "the dog ate the bone", "a cat and a dog", ] vocab = set() for doc in documents: vocab.update(doc.split()) print(f"Vocab size: {len(vocab)}") # 10 ``` ::: ### Train/Val/Test Data Leakage Check ::: {.callout-important title="Builder Notu — Data Leakage"} Üretim ML'inde kritik kontrol: ```python # Test ID'leri train'de var mı? (data leakage) train_ids = set(train_df["id"]) test_ids = set(test_df["id"]) leakage = train_ids & test_ids if leakage: print(f"WARNING: {len(leakage)} ID train+test'te") # Val'da train'de görünmemiş kelimeler: train_vocab = set(...) val_vocab = set(...) unseen_val = val_vocab - train_vocab ``` Milyon kayıt için saniyede biter. ::: ## Dört Koleksiyon — Karşılaştırma {#sec-karsi} | Özellik | list `[1, 2]` | tuple `(1, 2)` | dict `{a: 1}` | set `{1, 2}` | |---|---|---|---|---| | Sıralı | Evet | Evet | Evet (3.7+) | Hayır | | Değişebilir | Evet | **Hayır** | Evet | Evet | | Yinelenen OK | Evet | Evet | Anahtar değil | **Hayır** | | Erişim | `l[i]` | `t[i]` | `d[key]` | `in` | | Hashable mi? | Hayır | **Evet** | Hayır | Hayır (frozenset evet) | | Sentaks | `[a, b]` | `(a, b)` | `{a: 1}` | `{a, b}` | ### Karar Akışı ``` Sıralı mı olmalı? ├── HAYIR → Set (unique + üyelik kontrolü hızlı) └── EVET: └── Anahtar-değer mi? ├── EVET → Dict └── HAYIR: └── Değişecek mi? ├── EVET → List └── HAYIR → Tuple ``` ### Pratik ```python # List: losses = [0.5, 0.4, 0.3] # epoch sirasi onemli friends = ["Kevin", "Karen"] # eklenebilir # Tuple: input_shape = (3, 224, 224) # tensor boyutu rgb = (255, 0, 0) # sabit # Dict: config = {"lr": 1e-3, "batch_size": 64} # Set: seen_ids = {1, 5, 23, 7} # bir id gorduk mu? ``` ## Bu Dersin Özeti {#sec-ozet-7} 1. **Dict (`{}`):** anahtar-değer eşlemesi. Anahtarlar **unique** + **hashable**. 2. **Erişim:** `d[k]` sert, `.get(k, default)` yumuşak. 3. **Iteration:** `.keys()`, `.values()`, `.items()`. 4. **`in`** dict için anahtarı kontrol. 5. **Set (`{...}` / `set()`):** unique + sırasız + hızlı `in`. 6. **Set ops:** `|`, `&`, `-`, `^`. 7. **`{}` boş dict, `set()` boş set.** 8. **`Counter`, `defaultdict`** — `collections` güçlü kardeşler. 9. **ML eki:** dict her yerde (config/state_dict/vocab), set vocab+dedup+filter için kritik. ::: {.callout-important title="Tek Bir Cümle"} Dict (`{anahtar: değer}`) anahtarla hızlı arama yapar — Mosh'un ay-isim örneği aslında PyTorch'taki `model.state_dict()`, HuggingFace tokenizer vocab'ı, ve JSON config dosyalarının ata-formudur; set (`{1, 2, 3}`) unique elemanları sırasız tutar ve `in` kontrolünü O(1)'e indirir — NLP vocabulary, label dedup, ve train/val data leakage kontrolünün günlük aracı. ::: ## Egzersizler {#sec-egzersizler-7} **Egzersiz 1.** Öğrenci sicil dict — 5 öğrenci, notlar list: ```python sicil = { "Deniz": [85, 90, 78], ??? } # (a) "Aylin" ekle, notları [95, 88, 92] # (b) "Deniz"in notuna 80 ekle # (c) "Mosh"un ortalaması # (d) Tüm ortalamalar ``` **Egzersiz 2.** Kelime sayma — manuel + Counter: ```python cumle = "the quick brown fox jumps over the lazy dog the dog naps" # Manuel: kelime_sayilari = {} for kelime in cumle.split(): kelime_sayilari[kelime] = kelime_sayilari.get(kelime, 0) + 1 # Counter (tek satır): from collections import Counter sayilar = Counter(cumle.split()) ``` **Egzersiz 3.** Liste kesişim/fark — set ile: ```python a = [1, 2, 3, 4, 5, 6] b = [4, 5, 6, 7, 8, 9] kesisim_set = set(a) & set(b) fark_set = set(a) - set(b) print(kesisim_set) # {4, 5, 6} print(fark_set) # {1, 2, 3} ``` 1 milyon eleman için hangisi pratik? **Egzersiz 4.** ML config güvenli erişim: ```python config = { "model": "resnet18", "lr": 1e-3, "batch_size": 64, } # Zorunlu: model_name = config["model"] lr = config["lr"] # Opsiyonel: epochs = config.get(???) # default 100 device = config.get(???) # default "cpu" weight_decay = config.get(???) # default 0.0 ``` **Egzersiz 5.** (Builder eksen — model state JSON) ```python import json model_state = { "layer1.weight": [[0.1, 0.2], [0.3, 0.4]], "layer1.bias": [0.0, 0.0], "layer2.weight": [[0.5, 0.6], [0.7, 0.8]], "layer2.bias": [0.1, 0.1], } # Kaydet: with open("model.json", "w") as f: json.dump(model_state, f) # Yükle: with open("model.json") as f: loaded = json.load(f) # Anahtar-shape print: for name, weights in loaded.items(): if isinstance(weights[0], list): shape = (len(weights), len(weights[0])) else: shape = (len(weights),) print(f" {name}: shape={shape}") ``` PyTorch `torch.save` / `torch.load` mekanizmasının **JSON versiyonu**. ## Sonraki Ders İçin Hazırlık **Ders 8: Döngüler** Bu kursun **en kritik dersi**. Mosh dört chapter'da (While, Guessing Game, For, 2D Lists). `for batch in dataloader:` modern AI'nın ana motoru. - **Mosh'un Ch 20-22 ve Ch 24'ünü izle** (2:14:16-2:52:44, ~38 dk). - **Şu cümleyi içselleştir:** "Döngü = tekrar etme = bir grup veri üzerinde aynı işi yapma." ::: {.callout-tip title="Bu dersten tek bir şey alıp gideceksen"} Dict (`{anahtar: değer}`) anahtarla hızlı arama yapar — Mosh'un ay-isim örneği aslında PyTorch'taki `model.state_dict()`, HuggingFace tokenizer vocab'ı, ve JSON config dosyalarının ata-formudur; set (`{1, 2, 3}`) unique elemanları sırasız tutar ve `in` kontrolünü O(1)'e indirir — NLP vocabulary, label dedup, ve train/val data leakage kontrolünün günlük aracı; Python'un dört koleksiyon yapısı (list, tuple, dict, set) artık tam senin elinde, ve modern ML kodunun her satırı bu dördünden birinin üzerinde inşa edilmiş. :::