12 Modüller, Paketler, Pip

import + pip install — ML kütüphane evrenine kapı

Bölüm bilgisi

Mosh’un videosu: Chapters 30 + 35 (Modules & Pip + Python Interpreter) (≈22 dk)
Bölüm aralığı: 3:28:16 — 3:43:58 + 4:20:46 — 4:26:47
Kaynaklar: Python docs — modules · PyPI · PEP 328 — imports
Okuma süresi: ≈45 dk

12.1 Bu Derste Ne Var?

Bu derste kodu organize etmeyi ve kütüphane evrenine açılmayı öğreneceğiz. Şimdiye kadar tek dosyada yazdık; gerçek dünyada Python kodu modüller halinde organize edilir, paketler halinde yükellenir, ve pip ile yüz binlerce dış kütüphane bu sisteme bağlanır.

flowchart LR
    A["Modül = .py"] --> B["import patterns"]
    B --> C["Built-in:<br/>math, json, os..."]
    B --> D["pip install"]
    D --> E["💎 PyPI 500K+"]
    E --> F["numpy / pandas /<br/>torch / transformers"]
    A --> G["REPL → IPython → Jupyter"]
    G --> H["ML araştırmacı evrim"]

    style E fill:#fce4ec,stroke:#c2185b,stroke-width:3px
    style F fill:#fff3e0,stroke:#f57c00,stroke-width:2px
    style H fill:#fff3e0,stroke:#f57c00,stroke-width:2px

Şekil 12.1: Ders 11’in akış haritası — modülden ML kütüphane evrenine

Dersin beş parçası:

Modül nedir? — Tek bir .py dosyası.
import pattern’ları. — import math, from math import sqrt, import numpy as np.
Yerleşik (built-in) modüller. — math, os, sys, json, datetime.
pip ve dış paketler. — pip install numpy. ML evrenine kapı.
REPL (Mosh Ch 35). — python komutuyla interaktif kabuk.

Builder Notu — Bu Dersin ML Köprüleri (Ders 1’in kapanış vaadi!)

pip install = ML kütüphane evrenine kapı. Mosh’un Ders 1’de “Python = ML lingua franca” dediğimiz şey buradan gerçekleşir: pip install numpy pandas torch transformers sklearn matplotlib jupyter ile binlerce ML mühendisinin yazdığı milyonlarca satır kod bir saniyede sistemine gelir.
PyPI = ML topluluk çatısı. Python Package Index (pypi.org) ~500K+ paket.
import torch as t ya da import numpy as np = ML alias standartları. Kısa, evrensel: np, pd, plt, torch, tf, jnp.
from X import Y = seçimli kütüphane kullanımı. from torch.nn import Linear, ReLU.
venv / conda / uv = proje izolasyonu.
requirements.txt / pyproject.toml = dependency reproducibility.
REPL = Jupyter notebook’un atası.
pip install -e . = editable install.
__name__ == "__main__" = script vs modül ayırımı.

12.2 Modül Nedir?

Mosh:

“bir modül aslında sadece yapabileceğimiz bir python dosyasıdır. içine ithalat Geçerli python dosyası” — Mosh (Türkçe dublaj), 3:28:16

Modül = bir Python dosyası (.py). İçindeki fonksiyon, değişken ve class’lar başka dosyadan import edilebilir.

12.2.1 Neden Modül?

Kod organizasyonu. 1000 satırlık tek dosya yerine, 10 modülden oluşan küçük dosyalar.
Yeniden kullanılabilirlik. Bir kez yaz, başka projelerinde import et.
Topluluk erişimi. PyPI’a (göreceğiz) — ML için zorunlu.

12.2.2 Mosh’un Örneği — `useful_tools.py`

# useful_tools.py
feet_in_mile = 5280
meters_in_kilometer = 1000

beatles = ["John", "Paul", "George", "Ringo"]

def get_file_extension(filename):
    """Bir dosya isminden uzanti dondurur."""
    return filename.split(".")[-1]

def roll_dice(num_sides):
    """num_sides yuzlu bir zar."""
    import random
    return random.randint(1, num_sides)

Başka dosyadan kullanım:

# app.py
import useful_tools

print(useful_tools.feet_in_mile)              # 5280
print(useful_tools.beatles)                    # ['John', 'Paul', 'George', 'Ringo']
print(useful_tools.get_file_extension("file.txt"))   # txt
print(useful_tools.roll_dice(10))             # 1-10 arasi

Mosh:

“useful_tools.nokta ve şimdi aslında erişebiliyorum Tüm bu nitelikler” — Mosh (Türkçe dublaj), 3:31:00

module.attribute syntax — noktayla erişim.

12.2.3 Avantaj — Kopya-Yapıştır Yok

yarattığın yer fark edeceksiniz Zorunda değildim herhangi bir işlevi veya değişkeni kopyala

useful_tools.py’ı bir kez yazdın; şimdi 10 farklı projede import edebilirsin.

12.2.4 ML Projesi Yapısı

Builder Notu — Modern ML Projesi

ML kodu modüller halinde:

my_ml_project/
├── config.py          # Hyperparameter'lar
├── data.py            # Dataset, DataLoader
├── model.py           # nn.Module sınıfları
├── train.py           # Eğitim döngüsü
├── evaluate.py        # Validation
├── utils.py           # Yardımcı fonksiyonlar
└── main.py            # Giriş noktası

main.py diğerleri import eder:

from config import CONFIG
from data import build_loaders
from model import build_model
from train import train
from evaluate import evaluate

if __name__ == "__main__":
    train_loader, val_loader = build_loaders(CONFIG)
    model = build_model(CONFIG)
    train(model, train_loader, val_loader, CONFIG)
    evaluate(model, val_loader)

Mosh’un useful_tools.py mikro örneği = profesyonel ML projesinin minyatür modeli.

12.3 `import` Pattern’ları

12.3.1 `import module`

import math

math.sqrt(16)    # 4.0
math.pi          # 3.141592653589793

Avantaj: namespace temiz, hangi modülden geldiği belli.

12.3.2 `from module import name`

from math import sqrt, pi, log

sqrt(16)    # math. prefix yok

Avantaj: kısa kod. Dezavantaj: namespace pollution riski.

12.3.3 `from module import *` — YASAK

from math import *    # YASAK

sqrt(16)   # math. sqrt mu yoksa baskasi mi?

Profesyonel kodda yer almaz.

12.3.4 `import module as alias`

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

ML topluluk standartları:

Modül	Standart Alias
numpy	`np`
pandas	`pd`
matplotlib.pyplot	`plt`
seaborn	`sns`
tensorflow	`tf`
torch	(yok, direkt `torch`)
jax.numpy	`jnp`

12.3.5 Hangi Pattern Ne Zaman?

# Genel kural - %90:
import numpy as np            # ML standardı
np.array(...)

# Eğer 1-2 isim:
from math import sqrt, pi
sqrt(16)

# REPL veya kısa script (üretimde YASAK):
from math import *
sqrt(16)

12.4 Built-in Modüller

Python kurulumu ~200 modülle gelir. pip install gerekmez.

# Matematik:
import math
math.sqrt(16)        # 4.0
math.pi              # 3.14159...
math.log(10)
math.factorial(5)    # 120

# Rastgele:
import random
random.random()             # 0.0 - 1.0
random.randint(1, 100)
random.choice([1, 2, 3])
random.shuffle(liste)
random.seed(42)              # reproducibility!

# Tarih/zaman:
from datetime import datetime, timedelta
now = datetime.now()
print(now.strftime("%Y-%m-%d"))

# OS:
import os
os.getcwd()
os.listdir(".")
os.path.exists("file.txt")
os.environ.get("PATH")

# JSON:
import json
data = {"ad": "Deniz", "yas": 35}
s = json.dumps(data)
loaded = json.loads(s)

with open("data.json", "w") as f:
    json.dump(data, f, indent=2)

# Collections (Ders 7'den):
from collections import Counter, defaultdict, namedtuple
c = Counter([1, 2, 2, 3, 3, 3])

# Sys:
import sys
sys.argv
sys.path

# Pathlib (modern dosya yolu):
from pathlib import Path
p = Path("data") / "train" / "img.jpg"
p.exists()
p.suffix      # .jpg

12.4.1 ML için Kritik Built-in’ler

Builder Notu — Günlük Kullanım

# 1. Datetime - logging:
from datetime import datetime
print(f"[{datetime.now().isoformat()}] Training started")

# 2. JSON - config:
import json
with open("config.json") as f:
    config = json.load(f)

# 3. Pathlib - data paths:
from pathlib import Path
data_dir = Path("data") / "train"
images = list(data_dir.glob("*.jpg"))

# 4. Collections - class distribution:
from collections import Counter
print(Counter(labels).most_common())

# 5. Random - data shuffling + reproducibility:
import random
random.seed(42)
random.shuffle(train_data)

# 6. Math - LR schedules:
import math
lr = base_lr * math.cos(epoch * math.pi / total_epochs)

12.5 `pip` — Dış Paketler ve ML Evrenine Kapı

12.5.1 PyPI

pypi.org — Python resmi paket deposu. ~500,000+ paket.

12.5.2 `pip install`

pip install numpy
pip install pandas
pip install torch
pip install transformers

# Tek seferde:
pip install numpy pandas torch matplotlib

# Belirli sürüm:
pip install "numpy>=1.24,<2.0"
pip install "torch==2.0.1"

12.5.3 `pip list` ve `pip show`

pip list
pip show numpy

12.5.4 Virtual Environment (proje izolasyonu)

python -m venv .venv               # sanal ortam yarat
source .venv/bin/activate          # Linux/Mac
.venv\Scripts\activate             # Windows

pip install numpy                  # SADECE .venv'e

Önerilen pratik: her projeye .venv.

12.5.5 `requirements.txt`

numpy>=1.24
pandas>=2.0
torch>=2.0
transformers>=4.30

pip install -r requirements.txt

Reproducibility.

12.5.6 Modern Alternatifler

pyproject.toml (PEP 518) — Python’un yeni standardı.
uv (2024+) — Rust ile yazılmış, pip’ten 10-100× hızlı.
conda — Anaconda ekosistemi.

12.5.7 ML Stack Setup

# Adim 1: Yeni proje
mkdir my_ml_project
cd my_ml_project

# Adim 2: Sanal ortam
python -m venv .venv
source .venv/bin/activate

# Adim 3: Temel ML stack:
pip install numpy pandas matplotlib scikit-learn jupyter

# Adim 4: Deep learning:
pip install torch torchvision

# Adim 5: LLM:
pip install transformers datasets accelerate

# Adim 6: Bağımlılık kaydet
pip freeze > requirements.txt

12.5.8 ML Kütüphane Evreni Haritası

Builder Notu — pip install Sonrası Açılan Evren

# === Temel Bilimsel ===
import numpy as np            # array, linear algebra
import scipy                  # istatistik

# === Veri ===
import pandas as pd           # DataFrame
import polars                 # pandas alternative (Rust, hızlı)

# === Klasik ML ===
import sklearn                # random forest, SVM
import xgboost                # gradient boosting

# === Derin Öğrenme ===
import torch                  # PyTorch
import torch.nn as nn
import tensorflow as tf
import jax
import jax.numpy as jnp

# === NLP / LLM ===
from transformers import AutoModel, AutoTokenizer
import langchain
import openai
import anthropic

# === Computer Vision ===
import torchvision
import PIL
import cv2                    # OpenCV

# === Görselleştirme ===
import matplotlib.pyplot as plt
import seaborn as sns

# === Notebook ===
import jupyter
import ipython

# === Production ===
import fastapi
import wandb                  # experiment tracking
import mlflow                 # ML lifecycle

Yukarıdaki her satır = binlerce saat yazılmış kod. pip install ile saniyede senin elinde.

Şekil 12.2: `pip install` ile açılan ML evrenı — Mosh’un `import useful_tools` mikro örneğinden binlerce paket

12.6 REPL — `python` ile İnteraktif Kabuk

Mosh’un son chapter’ı, kursun finalinde kısa bir konsept.

12.6.1 REPL Nedir?

REPL = Read-Eval-Print-Loop.

$ python
Python 3.13.0 (main, ...)
>>>

>>> 2 + 2
4
>>> x = 10
>>> x * 5
50
>>> [i**2 for i in range(5)]
[0, 1, 4, 9, 16]
>>> import math
>>> math.sqrt(144)
12.0
>>> exit()

12.6.2 Niye Kullanılır?

Hızlı deneme — bir fonksiyonun nasıl çalıştığını dene.
help(...) — docs aç.
Hesap makinesi — math.sqrt(2), 2**10.
API keşfi — dir(obj).

12.6.3 IPython — Enhanced REPL

pip install ipython
ipython

In [1]: x = 5
In [2]: x?           # docs gösterir
In [3]: %timeit sum(range(1000))    # benchmarking
In [4]: !ls          # shell komutu

ML pratiğinin standardı.

12.6.4 Jupyter Notebook

pip install jupyter
jupyter notebook

Tarayıcıda hücre-bazlı REPL. Markdown + kod + görselleştirme. Modern ML araştırmasının %70-80’i Jupyter’da yapılır.

12.6.5 REPL → IPython → Jupyter → VS Code

Builder Notu — Evrim Yolu

python REPL — başlangıç.
IPython — günlük (renkli, magic commands).
Jupyter Notebook — eğitim, prototip.
JupyterLab — Jupyter gelişmiş.
VS Code Notebooks — modern alternatif (Git-friendly).
Google Colab / Kaggle — bulut Jupyter, ücretsiz GPU.

ML araştırmacısı için Jupyter standardır. Production kodu .py’de, deney notebook’ta.

12.7 Bu Dersin Özeti

Modül = .py dosyası. Import edilebilir.
import X, from X import Y, import X as Z — üç ana pattern.
Built-in modüller — Python kurulumuyla gelir.
pip install — PyPI’dan dış paket.
venv — proje izolasyonu.
requirements.txt — reproducibility.
REPL — interaktif kabuk.
IPython, Jupyter — REPL’in evrimi.

Tek Bir Cümle

Modül (.py dosyası) Python’un kodu organize etme birimi — Mosh’un useful_tools.py mikro örneği, modern ML projelerinin config.py + data.py + model.py + train.py yapısının atasıdır; pip install Python ekosisteminin asıl gücüdür — PyPI’daki 500K+ paket (numpy, pandas, torch, transformers, langchain) bir komutla sisteme gelir, ve bu Ders 1’de “Python = ML lingua franca” diye vurguladığımız şeyin gerçek olduğu yer; sanal ortam (venv) ve requirements.txt ML deneyimlerinin reproducibility’sini garanti eder; REPL → IPython → Jupyter hattı, Mosh’un başlangıç noktasından modern ML araştırmacısının günlük aracına uzanan evrim yoludur.

12.8 Egzersizler

Egzersiz 1. Kendi useful_tools.py’yi yaz:

# useful_tools.py
PI = 3.14159
GUNLER = ["Pzt", "Sal", "Car", "Per", "Cum", "Cmt", "Paz"]

def cember_alani(yaricap):
    return PI * yaricap ** 2

def gun_adi(idx):
    return GUNLER[idx]

# main.py
import useful_tools
print(useful_tools.cember_alani(5))    # 78.53975
print(useful_tools.gun_adi(2))         # Car

Egzersiz 2. Üç import pattern’i:

# (a) import random
import random
print(random.randint(1, 100))

# (b) from random import randint, choice
from random import randint, choice
print(randint(1, 10))
print(choice([1, 2, 3]))

# (c) import random as r
import random as r
print(r.random())

Egzersiz 3. Python docs’tan 5 yeni built-in modül keşfet (bisect, heapq, statistics, functools, itertools). Her biri ne işe yarar?

Egzersiz 4. Sanal ortam:

python -m venv .venv
.venv\Scripts\activate    # Windows
source .venv/bin/activate # Linux/Mac

pip install numpy pandas matplotlib
pip freeze > requirements.txt

cat requirements.txt

numpy bağımlılık olarak ne çağrılıyor?

Egzersiz 5. (Builder eksen — ilk ML import) REPL’de çalıştır:

import numpy as np
import torch

x_np = np.array([1, 2, 3, 4, 5])
x_torch = torch.tensor([1, 2, 3, 4, 5])

print(f"NumPy: {x_np}")
print(f"Tensor: {x_torch}")

# Mosh'un Ders 2'sini tensor üzerinde:
print(f"x + 10 = {x_torch + 10}")
print(f"x ** 2 = {x_torch ** 2}")

# Mosh'un Ders 4'ünü:
print(f"x[1:4] = {x_torch[1:4]}")
print(f"len = {len(x_torch)}")

Mosh’un öğrettiği tüm pattern’ların — +, **, [1:4], len — PyTorch tensor’da birebir çalıştığı.

12.9 Sonraki Ders İçin Hazırlık

Ders 12: Nesne Yönelimli Programlama (OOP) — FİNAL

Mosh’un dört chapter’ı (Classes, Quiz, Methods, Inheritance). Python’un en güçlü kavramı: class. Modern AI’nın yapı taşı.

Mosh’un Ch 31-34’ünü izle (3:43:58-4:20:46, ~37 dk).
Şu cümleyi içselleştir: “Class = veri + davranış paketi; bir kalıp, ondan birden fazla instance üretebilirsin.”

Bu dersten tek bir şey alıp gideceksen

pip install Python’un asıl gücüdür — PyPI’daki 500K+ paket bir komutla sisteme gelir, ve Ders 1’de “Python = ML lingua franca” diye vurguladığımız şeyin gerçek olduğu yer; modüller (.py) ile kodu organize edersin, paketler (__init__.py ile klasörler) ile organizasyonu hiyerarşik hale getirirsin, venv ile her projeyi izole edersin; Mosh’un öğrettiği import mikro mekanizması, modern ML araştırmacısının her gün yaptığı import torch.nn as nn deyimi ile birebir aynı yapıdır; bir sonraki ders (OOP) bu evrenin yapı taşlarını oluşturan class kavramını öğretecek, böylece class MyModel(nn.Module): deyimi anlamlı olacak.

--- title: "Modüller, Paketler, Pip" subtitle: "`import` + `pip install` — ML kütüphane evrenine kapı" --- ::: {.callout-note title="Bölüm bilgisi"} - **Mosh'un videosu:** [Chapters 30 + 35 (Modules & Pip + Python Interpreter)](https://www.youtube.com/watch?v=rfscVS0vtbw&t=12496s) (≈22 dk) - **Bölüm aralığı:** 3:28:16 — 3:43:58 + 4:20:46 — 4:26:47 - **Kaynaklar:** [Python docs — modules](https://docs.python.org/3/tutorial/modules.html) · [PyPI](https://pypi.org/) · [PEP 328 — imports](https://peps.python.org/pep-0328/) - **Okuma süresi:** ≈45 dk ::: ## Bu Derste Ne Var? {#sec-bu-derste-11} Bu derste **kodu organize** etmeyi ve **kütüphane evrenine** açılmayı öğreneceğiz. Şimdiye kadar tek dosyada yazdık; gerçek dünyada Python kodu **modüller** halinde organize edilir, **paketler** halinde yükellenir, ve **pip** ile yüz binlerce dış kütüphane bu sisteme bağlanır. ```{mermaid} %%| label: fig-akis-11 %%| fig-cap: "Ders 11'in akış haritası — modülden ML kütüphane evrenine" flowchart LR A["Modül = .py"] --> B["import patterns"] B --> C["Built-in:<br/>math, json, os..."] B --> D["pip install"] D --> E["💎 PyPI 500K+"] E --> F["numpy / pandas /<br/>torch / transformers"] A --> G["REPL → IPython → Jupyter"] G --> H["ML araştırmacı evrim"] style E fill:#fce4ec,stroke:#c2185b,stroke-width:3px style F fill:#fff3e0,stroke:#f57c00,stroke-width:2px style H fill:#fff3e0,stroke:#f57c00,stroke-width:2px ``` **Dersin beş parçası:** 1. **Modül nedir?** — Tek bir `.py` dosyası. 2. **`import` pattern'ları.** — `import math`, `from math import sqrt`, `import numpy as np`. 3. **Yerleşik (built-in) modüller.** — `math`, `os`, `sys`, `json`, `datetime`. 4. **`pip` ve dış paketler.** — `pip install numpy`. **ML evrenine kapı.** 5. **REPL (Mosh Ch 35).** — `python` komutuyla interaktif kabuk. ::: {.callout-tip title="Builder Notu — Bu Dersin ML Köprüleri (Ders 1'in kapanış vaadi!)"} - **`pip install` = ML kütüphane evrenine kapı.** Mosh'un Ders 1'de "Python = ML lingua franca" dediğimiz şey buradan gerçekleşir: `pip install numpy pandas torch transformers sklearn matplotlib jupyter` ile binlerce ML mühendisinin yazdığı milyonlarca satır kod bir saniyede sistemine gelir. - **PyPI = ML topluluk çatısı.** Python Package Index (pypi.org) ~500K+ paket. - **`import torch as t` ya da `import numpy as np`** = ML alias standartları. Kısa, evrensel: `np`, `pd`, `plt`, `torch`, `tf`, `jnp`. - **`from X import Y` = seçimli kütüphane kullanımı.** `from torch.nn import Linear, ReLU`. - **`venv` / `conda` / `uv`** = proje izolasyonu. - **`requirements.txt` / `pyproject.toml`** = dependency reproducibility. - **REPL = Jupyter notebook'un atası.** - **`pip install -e .`** = editable install. - **`__name__ == "__main__"`** = script vs modül ayırımı. ::: ## Modül Nedir? {#sec-modul} Mosh: > *"bir modül aslında sadece yapabileceğimiz bir python dosyasıdır. içine ithalat Geçerli python dosyası"* — Mosh (Türkçe dublaj), 3:28:16 **Modül = bir Python dosyası (.py)**. İçindeki fonksiyon, değişken ve class'lar başka dosyadan **import edilebilir**. ### Neden Modül? 1. **Kod organizasyonu.** 1000 satırlık tek dosya yerine, 10 modülden oluşan küçük dosyalar. 2. **Yeniden kullanılabilirlik.** Bir kez yaz, başka projelerinde import et. 3. **Topluluk erişimi.** PyPI'a (göreceğiz) — ML için zorunlu. ### Mosh'un Örneği — `useful_tools.py` ```python # useful_tools.py feet_in_mile = 5280 meters_in_kilometer = 1000 beatles = ["John", "Paul", "George", "Ringo"] def get_file_extension(filename): """Bir dosya isminden uzanti dondurur.""" return filename.split(".")[-1] def roll_dice(num_sides): """num_sides yuzlu bir zar.""" import random return random.randint(1, num_sides) ``` Başka dosyadan kullanım: ```python # app.py import useful_tools print(useful_tools.feet_in_mile) # 5280 print(useful_tools.beatles) # ['John', 'Paul', 'George', 'Ringo'] print(useful_tools.get_file_extension("file.txt")) # txt print(useful_tools.roll_dice(10)) # 1-10 arasi ``` Mosh: > *"`useful_tools.nokta` ve şimdi aslında erişebiliyorum Tüm bu nitelikler"* — Mosh (Türkçe dublaj), 3:31:00 `module.attribute` syntax — noktayla erişim. ### Avantaj — Kopya-Yapıştır Yok ``` yarattığın yer fark edeceksiniz Zorunda değildim herhangi bir işlevi veya değişkeni kopyala ``` `useful_tools.py`'ı bir kez yazdın; şimdi 10 farklı projede import edebilirsin. ### ML Projesi Yapısı ::: {.callout-tip title="Builder Notu — Modern ML Projesi"} ML kodu modüller halinde: ``` my_ml_project/ ├── config.py # Hyperparameter'lar ├── data.py # Dataset, DataLoader ├── model.py # nn.Module sınıfları ├── train.py # Eğitim döngüsü ├── evaluate.py # Validation ├── utils.py # Yardımcı fonksiyonlar └── main.py # Giriş noktası ``` `main.py` diğerleri import eder: ```python from config import CONFIG from data import build_loaders from model import build_model from train import train from evaluate import evaluate if __name__ == "__main__": train_loader, val_loader = build_loaders(CONFIG) model = build_model(CONFIG) train(model, train_loader, val_loader, CONFIG) evaluate(model, val_loader) ``` Mosh'un `useful_tools.py` mikro örneği = profesyonel ML projesinin minyatür modeli. ::: ## `import` Pattern'ları {#sec-import-patterns} ### `import module` ```python import math math.sqrt(16) # 4.0 math.pi # 3.141592653589793 ``` **Avantaj:** namespace temiz, hangi modülden geldiği belli. ### `from module import name` ```python from math import sqrt, pi, log sqrt(16) # math. prefix yok ``` **Avantaj:** kısa kod. **Dezavantaj:** namespace pollution riski. ### `from module import *` — YASAK ```python from math import * # YASAK sqrt(16) # math. sqrt mu yoksa baskasi mi? ``` Profesyonel kodda yer almaz. ### `import module as alias` ```python import numpy as np import pandas as pd import matplotlib.pyplot as plt ``` ML topluluk standartları: | Modül | Standart Alias | |---|---| | numpy | `np` | | pandas | `pd` | | matplotlib.pyplot | `plt` | | seaborn | `sns` | | tensorflow | `tf` | | torch | (yok, direkt `torch`) | | jax.numpy | `jnp` | ### Hangi Pattern Ne Zaman? ```python # Genel kural - %90: import numpy as np # ML standardı np.array(...) # Eğer 1-2 isim: from math import sqrt, pi sqrt(16) # REPL veya kısa script (üretimde YASAK): from math import * sqrt(16) ``` ## Built-in Modüller {#sec-builtin} Python kurulumu ~200 modülle gelir. `pip install` gerekmez. ```python # Matematik: import math math.sqrt(16) # 4.0 math.pi # 3.14159... math.log(10) math.factorial(5) # 120 # Rastgele: import random random.random() # 0.0 - 1.0 random.randint(1, 100) random.choice([1, 2, 3]) random.shuffle(liste) random.seed(42) # reproducibility! # Tarih/zaman: from datetime import datetime, timedelta now = datetime.now() print(now.strftime("%Y-%m-%d")) # OS: import os os.getcwd() os.listdir(".") os.path.exists("file.txt") os.environ.get("PATH") # JSON: import json data = {"ad": "Deniz", "yas": 35} s = json.dumps(data) loaded = json.loads(s) with open("data.json", "w") as f: json.dump(data, f, indent=2) # Collections (Ders 7'den): from collections import Counter, defaultdict, namedtuple c = Counter([1, 2, 2, 3, 3, 3]) # Sys: import sys sys.argv sys.path # Pathlib (modern dosya yolu): from pathlib import Path p = Path("data") / "train" / "img.jpg" p.exists() p.suffix # .jpg ``` ### ML için Kritik Built-in'ler ::: {.callout-tip title="Builder Notu — Günlük Kullanım"} ```python # 1. Datetime - logging: from datetime import datetime print(f"[{datetime.now().isoformat()}] Training started") # 2. JSON - config: import json with open("config.json") as f: config = json.load(f) # 3. Pathlib - data paths: from pathlib import Path data_dir = Path("data") / "train" images = list(data_dir.glob("*.jpg")) # 4. Collections - class distribution: from collections import Counter print(Counter(labels).most_common()) # 5. Random - data shuffling + reproducibility: import random random.seed(42) random.shuffle(train_data) # 6. Math - LR schedules: import math lr = base_lr * math.cos(epoch * math.pi / total_epochs) ``` ::: ## `pip` — Dış Paketler ve ML Evrenine Kapı {#sec-pip} ### PyPI [pypi.org](https://pypi.org) — Python resmi paket deposu. **~500,000+ paket**. ### `pip install` ```bash pip install numpy pip install pandas pip install torch pip install transformers # Tek seferde: pip install numpy pandas torch matplotlib # Belirli sürüm: pip install "numpy>=1.24,<2.0" pip install "torch==2.0.1" ``` ### `pip list` ve `pip show` ```bash pip list pip show numpy ``` ### Virtual Environment (proje izolasyonu) ```bash python -m venv .venv # sanal ortam yarat source .venv/bin/activate # Linux/Mac .venv\Scripts\activate # Windows pip install numpy # SADECE .venv'e ``` **Önerilen pratik:** her projeye `.venv`. ### `requirements.txt` ``` numpy>=1.24 pandas>=2.0 torch>=2.0 transformers>=4.30 ``` ```bash pip install -r requirements.txt ``` **Reproducibility.** ### Modern Alternatifler - **`pyproject.toml`** (PEP 518) — Python'un yeni standardı. - **`uv`** (2024+) — Rust ile yazılmış, pip'ten 10-100× hızlı. - **`conda`** — Anaconda ekosistemi. ### ML Stack Setup ```bash # Adim 1: Yeni proje mkdir my_ml_project cd my_ml_project # Adim 2: Sanal ortam python -m venv .venv source .venv/bin/activate # Adim 3: Temel ML stack: pip install numpy pandas matplotlib scikit-learn jupyter # Adim 4: Deep learning: pip install torch torchvision # Adim 5: LLM: pip install transformers datasets accelerate # Adim 6: Bağımlılık kaydet pip freeze > requirements.txt ``` ### ML Kütüphane Evreni Haritası ::: {.callout-tip title="Builder Notu — `pip install` Sonrası Açılan Evren"} ```python # === Temel Bilimsel === import numpy as np # array, linear algebra import scipy # istatistik # === Veri === import pandas as pd # DataFrame import polars # pandas alternative (Rust, hızlı) # === Klasik ML === import sklearn # random forest, SVM import xgboost # gradient boosting # === Derin Öğrenme === import torch # PyTorch import torch.nn as nn import tensorflow as tf import jax import jax.numpy as jnp # === NLP / LLM === from transformers import AutoModel, AutoTokenizer import langchain import openai import anthropic # === Computer Vision === import torchvision import PIL import cv2 # OpenCV # === Görselleştirme === import matplotlib.pyplot as plt import seaborn as sns # === Notebook === import jupyter import ipython # === Production === import fastapi import wandb # experiment tracking import mlflow # ML lifecycle ``` Yukarıdaki her satır = **binlerce saat yazılmış kod**. `pip install` ile saniyede senin elinde. ::: ```{python} #| label: fig-pip-evreni #| fig-cap: "`pip install` ile açılan ML evrenı — Mosh'un `import useful_tools` mikro örneğinden binlerce paket" #| fig-width: 11 #| fig-height: 5 import matplotlib.pyplot as plt import matplotlib.patches as patches fig, ax = plt.subplots(figsize=(11, 5)) # Mosh'un kursunun bitiş noktası mosh = patches.FancyBboxPatch((0.02, 0.4), 0.18, 0.2, boxstyle="round,pad=0.02", edgecolor="#3776ab", facecolor="#e3f2fd", linewidth=2) ax.add_patch(mosh) ax.text(0.11, 0.55, "import useful_tools", ha="center", fontsize=10, family="monospace", color="#1a3a5c") ax.text(0.11, 0.46, "(Mosh)", ha="center", fontsize=10, color="#3776ab", fontweight="bold") # Pip install bridge ax.annotate("", xy=(0.28, 0.5), xytext=(0.22, 0.5), arrowprops=dict(arrowstyle="->", lw=3, color="#f57c00")) ax.text(0.25, 0.55, "pip install", ha="center", fontsize=11, color="#f57c00", fontweight="bold") # ML evreni (kümeler) clusters = [ ("Bilimsel", ["numpy", "scipy", "sympy"], 0.4, 0.85), ("Veri", ["pandas", "polars"], 0.55, 0.85), ("Klasik ML", ["sklearn", "xgboost", "lightgbm"], 0.4, 0.55), ("Derin\nÖğrenme", ["torch", "tensorflow", "jax"], 0.55, 0.55), ("NLP/LLM", ["transformers", "langchain", "openai"], 0.7, 0.85), ("Vision", ["PIL", "cv2", "torchvision"], 0.7, 0.55), ("Görsel", ["matplotlib", "seaborn"], 0.4, 0.25), ("Notebook", ["jupyter", "ipython"], 0.55, 0.25), ("Production", ["fastapi", "wandb", "mlflow"], 0.7, 0.25), ] for name, libs, cx, cy in clusters: box = patches.FancyBboxPatch((cx - 0.07, cy - 0.06), 0.14, 0.12, boxstyle="round,pad=0.01", edgecolor="#c2185b", facecolor="#fce4ec", linewidth=1.5) ax.add_patch(box) ax.text(cx, cy + 0.025, name, ha="center", fontsize=9, fontweight="bold", color="#c2185b") ax.text(cx, cy - 0.025, "\n".join(libs[:2]), ha="center", fontsize=7.5, family="monospace", color="#1a3a5c") # 500K+ uyarısı ax.text(0.87, 0.5, "+ 500K\npaket\n(PyPI)", ha="center", fontsize=13, color="#306998", fontweight="bold", bbox=dict(boxstyle="round,pad=0.5", edgecolor="#306998", facecolor="#fff3e0", linewidth=2)) ax.text(0.5, 0.05, "Mosh'un kursu bitiyor — buradan modern ML mühendisliği başlıyor", ha="center", fontsize=11, style="italic", color="#4a5568") ax.set_xlim(0, 1); ax.set_ylim(0, 1) ax.axis("off") plt.tight_layout() plt.show() ``` ## REPL — `python` ile İnteraktif Kabuk {#sec-repl} Mosh'un son chapter'ı, kursun finalinde kısa bir konsept. ### REPL Nedir? **REPL** = **R**ead-**E**val-**P**rint-**L**oop. ```bash $ python Python 3.13.0 (main, ...) >>> ``` ``` >>> 2 + 2 4 >>> x = 10 >>> x * 5 50 >>> [i**2 for i in range(5)] [0, 1, 4, 9, 16] >>> import math >>> math.sqrt(144) 12.0 >>> exit() ``` ### Niye Kullanılır? 1. **Hızlı deneme** — bir fonksiyonun nasıl çalıştığını dene. 2. **`help(...)`** — docs aç. 3. **Hesap makinesi** — `math.sqrt(2)`, `2**10`. 4. **API keşfi** — `dir(obj)`. ### IPython — Enhanced REPL ```bash pip install ipython ipython ``` ``` In [1]: x = 5 In [2]: x? # docs gösterir In [3]: %timeit sum(range(1000)) # benchmarking In [4]: !ls # shell komutu ``` ML pratiğinin standardı. ### Jupyter Notebook ```bash pip install jupyter jupyter notebook ``` Tarayıcıda **hücre-bazlı** REPL. Markdown + kod + görselleştirme. **Modern ML araştırmasının %70-80'i** Jupyter'da yapılır. ### REPL → IPython → Jupyter → VS Code ::: {.callout-tip title="Builder Notu — Evrim Yolu"} 1. **`python` REPL** — başlangıç. 2. **IPython** — günlük (renkli, magic commands). 3. **Jupyter Notebook** — eğitim, prototip. 4. **JupyterLab** — Jupyter gelişmiş. 5. **VS Code Notebooks** — modern alternatif (Git-friendly). 6. **Google Colab / Kaggle** — bulut Jupyter, ücretsiz GPU. ML araştırmacısı için Jupyter standardır. Production kodu `.py`'de, **deney** notebook'ta. ::: ## Bu Dersin Özeti {#sec-ozet-11} 1. **Modül = `.py` dosyası.** Import edilebilir. 2. **`import X`, `from X import Y`, `import X as Z`** — üç ana pattern. 3. **Built-in modüller** — Python kurulumuyla gelir. 4. **`pip install`** — PyPI'dan dış paket. 5. **`venv`** — proje izolasyonu. 6. **`requirements.txt`** — reproducibility. 7. **REPL** — interaktif kabuk. 8. **IPython, Jupyter** — REPL'in evrimi. ::: {.callout-important title="Tek Bir Cümle"} Modül (`.py` dosyası) Python'un kodu organize etme birimi — Mosh'un `useful_tools.py` mikro örneği, modern ML projelerinin `config.py + data.py + model.py + train.py` yapısının atasıdır; **`pip install` Python ekosisteminin asıl gücüdür** — PyPI'daki 500K+ paket (numpy, pandas, torch, transformers, langchain) bir komutla sisteme gelir, ve bu Ders 1'de "Python = ML lingua franca" diye vurguladığımız şeyin **gerçek olduğu yer**; sanal ortam (`venv`) ve `requirements.txt` ML deneyimlerinin reproducibility'sini garanti eder; REPL → IPython → Jupyter hattı, Mosh'un başlangıç noktasından modern ML araştırmacısının günlük aracına uzanan evrim yoludur. ::: ## Egzersizler {#sec-egzersizler-11} **Egzersiz 1.** Kendi `useful_tools.py`'yi yaz: ```python # useful_tools.py PI = 3.14159 GUNLER = ["Pzt", "Sal", "Car", "Per", "Cum", "Cmt", "Paz"] def cember_alani(yaricap): return PI * yaricap ** 2 def gun_adi(idx): return GUNLER[idx] ``` ```python # main.py import useful_tools print(useful_tools.cember_alani(5)) # 78.53975 print(useful_tools.gun_adi(2)) # Car ``` **Egzersiz 2.** Üç import pattern'i: ```python # (a) import random import random print(random.randint(1, 100)) # (b) from random import randint, choice from random import randint, choice print(randint(1, 10)) print(choice([1, 2, 3])) # (c) import random as r import random as r print(r.random()) ``` **Egzersiz 3.** Python docs'tan **5 yeni built-in modül** keşfet (`bisect`, `heapq`, `statistics`, `functools`, `itertools`). Her biri ne işe yarar? **Egzersiz 4.** Sanal ortam: ```bash python -m venv .venv .venv\Scripts\activate # Windows source .venv/bin/activate # Linux/Mac pip install numpy pandas matplotlib pip freeze > requirements.txt cat requirements.txt ``` `numpy` bağımlılık olarak ne çağrılıyor? **Egzersiz 5.** (Builder eksen — ilk ML import) REPL'de çalıştır: ```python import numpy as np import torch x_np = np.array([1, 2, 3, 4, 5]) x_torch = torch.tensor([1, 2, 3, 4, 5]) print(f"NumPy: {x_np}") print(f"Tensor: {x_torch}") # Mosh'un Ders 2'sini tensor üzerinde: print(f"x + 10 = {x_torch + 10}") print(f"x ** 2 = {x_torch ** 2}") # Mosh'un Ders 4'ünü: print(f"x[1:4] = {x_torch[1:4]}") print(f"len = {len(x_torch)}") ``` Mosh'un öğrettiği tüm pattern'ların — `+`, `**`, `[1:4]`, `len` — PyTorch tensor'da birebir çalıştığı. ## Sonraki Ders İçin Hazırlık **Ders 12: Nesne Yönelimli Programlama (OOP) — FİNAL** Mosh'un dört chapter'ı (Classes, Quiz, Methods, Inheritance). **Python'un en güçlü** kavramı: **class**. Modern AI'nın yapı taşı. - **Mosh'un Ch 31-34'ünü izle** (3:43:58-4:20:46, ~37 dk). - **Şu cümleyi içselleştir:** "Class = veri + davranış paketi; bir kalıp, ondan birden fazla instance üretebilirsin." ::: {.callout-tip title="Bu dersten tek bir şey alıp gideceksen"} `pip install` Python'un asıl gücüdür — PyPI'daki 500K+ paket bir komutla sisteme gelir, ve Ders 1'de "Python = ML lingua franca" diye vurguladığımız şeyin **gerçek olduğu yer**; modüller (`.py`) ile kodu organize edersin, paketler (`__init__.py` ile klasörler) ile organizasyonu hiyerarşik hale getirirsin, `venv` ile her projeyi izole edersin; Mosh'un öğrettiği `import` mikro mekanizması, modern ML araştırmacısının her gün yaptığı `import torch.nn as nn` deyimi ile **birebir** aynı yapıdır; **bir sonraki ders (OOP) bu evrenin yapı taşlarını oluşturan `class` kavramını öğretecek**, böylece `class MyModel(nn.Module):` deyimi anlamlı olacak. :::