# Veri Bilimi icin Python: 2026'da NumPy, Pandas ve Scikit-Learn Rehberi

> NumPy dizi islemleri, Pandas veri manipulasyonu ve Scikit-Learn model egitimini kapsayan uygulamali bir rehber. Ham CSV verisinden egitilmis modele uzanan eksiksiz bir veri hatti, uretim ortamina hazir Python kod ornekleriyle adim adim olusturulmaktadir.

- Published: 2026-04-07
- Updated: 2026-04-07
- Author: Anthony Fillion-Maillet
- Tags: data-science, python, numpy, pandas, scikit-learn, machine-learning, tutorial
- Reading time: 10 min

---

2026 yilinda Python veri bilimi ekosistemine hakim uc temel kutuphane, islerin buyuk bolumunu ustlenmektedir: sayisal hesaplamalar icin NumPy, tablo verisi manipulasyonu icin Pandas ve makine ogrenimi icin Scikit-Learn. Bu rehber, her uc kutuphanenin pratik kod ornekleriyle nasil kullanildigini adim adim ele almakta ve ham CSV verisinden egitilmis bir modele uzanan eksiksiz bir veri hatti olusturma surecini kapsamaktadir.

> **Bu Rehberde Kullanilan Surumler**
>
> Tum kod ornekleri Python 3.12+, NumPy 2.1, Pandas 2.2 ve Scikit-Learn 1.6 uzerinde calistirilmaktadir. API yuzeyinin kucuk surumler arasindaki kararliligi surdurulmekle birlikte, NumPy 2.x'teki performans iyilestirmeleri buyuk dizi islemleri icin yukseltmeyi karsilanabilir kilmaktadir.

## NumPy ile Verimli Dizi Islemleri

NumPy, Python listelerinin yerini bitisik bellek bloklari tarafindan desteklenen n-boyutlu dizilerle almaktadir. Performans farki kayda degerdir: 1 milyon eleman uzerinde vektorize edilmis bir NumPy islemi, esdeger bir Python dongusu ile karsilastirildiginda 50-100 kat daha hizli calismaktadir. Pandas DataFrame'leri ve Scikit-Learn modelleri de dahil olmak uzere tum veri bilimi araclari arka planda NumPy dizilerini kullanmaktadir.

```python
# numpy_basics.py
import numpy as np

# Create arrays from different sources
prices = np.array([29.99, 49.99, 19.99, 99.99, 39.99])
quantities = np.arange(1, 6)  # [1, 2, 3, 4, 5]

# Vectorized arithmetic — no loops needed
revenue = prices * quantities
print(revenue)  # [29.99, 99.98, 59.97, 399.96, 199.95]

# Statistical aggregations
print(f"Total revenue: ${revenue.sum():.2f}")   # $789.85
print(f"Mean price: ${prices.mean():.2f}")       # $47.99
print(f"Std deviation: ${prices.std():.2f}")     # $27.64

# Boolean indexing — filter without loops
premium_mask = prices > 40
premium_items = prices[premium_mask]  # [49.99, 99.99]
```

Boolean indeksleme, gercek veri bilimi kodlarinda en sik karsilasilan kaliptir. Donguler icinde `if` ifadeleri yazmak yerine, bir boolean maske tek bir islemde kosulu saglayan elemanlari secmektedir. Bu yaklasim hem okunabilirligi artirmakta hem de performansi onemli olcude iyilestirmektedir.

## NumPy'da Yeniden Sekillendirme ve Yayilim (Broadcasting)

Iki boyutlu islemler, NumPy'nin farkli sekillerdeki dizileri nasil yaydiginin anlasilmasini gerektirmektedir. Yayilim kurallari, acik bir kopyalama islemi yapmadan matris ile vektor arasinda islem yapilmasina olanak tanimaktadir.

```python
# numpy_reshape.py
import numpy as np

# Monthly sales data: 4 products x 3 months
sales = np.array([
    [120, 150, 130],  # Product A
    [200, 180, 220],  # Product B
    [90, 110, 95],    # Product C
    [300, 280, 310],  # Product D
])

# Column-wise mean (average per month)
monthly_avg = sales.mean(axis=0)  # [177.5, 180.0, 188.75]

# Row-wise sum (total per product)
product_totals = sales.sum(axis=1)  # [400, 600, 295, 890]

# Normalize each product relative to its own max
normalized = sales / sales.max(axis=1, keepdims=True)
# keepdims=True preserves the shape for broadcasting
print(normalized[0])  # [0.8, 1.0, 0.867] — Product A relative to its peak

# Reshape for Scikit-Learn (requires 2D input)
flat_sales = sales.flatten()  # 1D array of 12 values
reshaped = flat_sales.reshape(-1, 1)  # 12x1 column vector
```

`axis` parametresi toplamanin yonunu kontrol etmektedir: `axis=0` satirlari daraltir (sutun bazinda islem yapar), `axis=1` ise sutunlari daraltir (satir bazinda islem yapar). `keepdims=True` argumani yayilim sirasinda sekil uyumsuzluklarini onlemektedir. Bu kavramlar, veri bilimi mulakat sorularinda siklikla karsilasilan konular arasinda yer almaktadir.

## Pandas ile DataFrame Manipulasyonu ve Veri Temizleme

Pandas, NumPy dizilerini etiketli eksenler ve SQL benzeri islemlerle sarmaktadir. DataFrame, merkezi veri yapisi olarak her sutunun farkli bir veri tipi tasiyabildigi bir tablo gorevi gormektedir. Pandas 2.2, varsayilan olarak PyArrow destekli string sutunlari kullanmakta ve bu da object-dtype string'lere kiyasla bellek kullanimini onemli olcude azaltmaktadir.

```python
# pandas_cleaning.py
import pandas as pd
import numpy as np

# Load and inspect raw data
df = pd.read_csv("candidates.csv")
print(df.shape)       # (1500, 8)
print(df.dtypes)      # Check column types
print(df.isna().sum()) # Count missing values per column

# Clean in a reproducible chain
df_clean = (
    df
    .dropna(subset=["salary", "experience_years"])      # Drop rows missing critical fields
    .assign(
        salary=lambda x: x["salary"].clip(lower=20000, upper=500000),  # Cap outliers
        experience_years=lambda x: x["experience_years"].astype(int),
        hired_date=lambda x: pd.to_datetime(x["hired_date"], errors="coerce"),
    )
    .drop_duplicates(subset=["email"])                  # Remove duplicate candidates
    .query("experience_years >= 0")                     # Filter invalid entries
    .reset_index(drop=True)
)

print(f"Cleaned: {len(df)} -> {len(df_clean)} rows")
```

`.assign()` ile metot zincirleme, donusumleri okunabilir ve tekrarlanabilir kilmaktadir. Her adim, neyin neden degistigini acikca belgelemektedir. `.assign()` icindeki `lambda x:` kalibinin zincirdeki o noktadaki DataFrame'e referans vermesi, eski verilere atifta bulunma riskini ortadan kaldirmaktadir.

> **Pandas 2.2 Copy-on-Write Ozelligi**
>
> Pandas 2.2, Copy-on-Write mekanizmasini varsayilan olarak etkinlestirmektedir. Bu ozellik, `SettingWithCopyWarning` uyarisini tamamen ortadan kaldirmakta ve zincirli islemleri daha guvenli hale getirmektedir. Bir dilim uzerindeki degisiklikler artik orijinal DataFrame'i sessizce degistirmemekte, Pandas yalnizca bir yazma islemi gerceklestiginde kopya olusturmaktadir.

## Pandas ile GroupBy Toplamalari ve Ozellik Muhendisligi

GroupBy islemi, veriyi alt kumelere bolmekte, her alt kumeye bir fonksiyon uygulamakta ve sonuclari birlestirmektedir. Bu kalip, tablo tabanli makine ogrenimindeki ozellik muhendisligi is akislarinin buyuk cogulugunu yonlendirmektedir.

```python
# pandas_groupby.py
import pandas as pd

# Aggregate candidate stats by department
dept_stats = (
    df_clean
    .groupby("department")
    .agg(
        avg_salary=("salary", "mean"),
        median_experience=("experience_years", "median"),
        headcount=("email", "count"),
        max_salary=("salary", "max"),
    )
    .sort_values("avg_salary", ascending=False)
)
print(dept_stats.head())

# Create features for ML: encode categorical + add aggregated stats
df_features = (
    df_clean
    .assign(
        # Ratio of individual salary to department average
        salary_ratio=lambda x: x["salary"] / x.groupby("department")["salary"].transform("mean"),
        # Time since hire in days
        tenure_days=lambda x: (pd.Timestamp.now() - x["hired_date"]).dt.days,
        # Binary encoding
        is_senior=lambda x: (x["experience_years"] >= 5).astype(int),
    )
)
```

`.transform()` metodu, orijinal indeksle hizalanmis bir Series dondurdugu icin `.assign()` icinde guvenle kullanilabilmektedir. Bu yaklasim, toplanmis sonuclarin orijinal DataFrame'e manuel olarak birlestirilmesi seklindeki yaygin hatayi onlemektedir.

## Sifirdan Scikit-Learn Pipeline Olusturma

Scikit-Learn pipeline'lari, on-isleme adimlarini ve modeli tek bir nesne icinde zincirlemektedir. Pipeline, donusturuculeri yalnizca egitim verisi uzerinde fit ederek ve ayni donusumleri test verisine uygulayarak veri sizintisini onlemektedir. Bu yaklasim, gozetimli ogrenme gorevleri icin standart kalip olarak kabul edilmektedir.

```python
# sklearn_pipeline.py
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
import pandas as pd

# Define column groups
numeric_features = ["salary", "experience_years", "salary_ratio", "tenure_days"]
categorical_features = ["department", "role_level"]
target = "promoted"

# Split before any preprocessing
X = df_features[numeric_features + categorical_features]
y = df_features[target]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Build the preprocessing + model pipeline
preprocessor = ColumnTransformer(
    transformers=[
        ("num", StandardScaler(), numeric_features),           # Scale numeric columns
        ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_features),  # Encode categories
    ]
)

pipeline = Pipeline([
    ("preprocessor", preprocessor),
    ("classifier", GradientBoostingClassifier(
        n_estimators=200,
        learning_rate=0.1,
        max_depth=4,
        random_state=42,
    )),
])

# Train and evaluate
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print(classification_report(y_test, y_pred))
```

`ColumnTransformer`, farkli sutun tiplerine farkli on-islemleri tek bir adimda uygulamaktadir. `StandardScaler` sayisal ozellikleri sifir ortalama ve birim varyansa normalize etmektedir. `OneHotEncoder` ise kategorik stringleri ikili sutunlara donusturmektedir. `handle_unknown="ignore"` parametresi, test verisinin egitim verisinde bulunmayan kategoriler icermesi durumunda pipeline'in hata vermemesini garanti altina almaktadir.

## Capraz Dogrulama ve Hiperparametre Optimizasyonu

Tek bir egitim/test bolunmesi, hangi orneklerin hangi kume icinde yer aldigina bagli olarak yaniltici sonuclar uretebilmektedir. Capraz dogrulama, birden fazla bolunme uzerinde calisarak skorlarin ortalamasini almakta ve boylece daha guvenilir bir performans tahmini sunmaktadir.

```python
# sklearn_tuning.py
from sklearn.model_selection import cross_val_score, GridSearchCV
import numpy as np

# 5-fold cross-validation on the full pipeline
scores = cross_val_score(pipeline, X_train, y_train, cv=5, scoring="f1")
print(f"F1 scores: {scores}")
print(f"Mean F1: {scores.mean():.3f} (+/- {scores.std() * 2:.3f})")

# Grid search over hyperparameters
param_grid = {
    "classifier__n_estimators": [100, 200, 300],
    "classifier__max_depth": [3, 4, 5],
    "classifier__learning_rate": [0.05, 0.1, 0.2],
}

grid_search = GridSearchCV(
    pipeline,
    param_grid,
    cv=5,
    scoring="f1",
    n_jobs=-1,      # Use all CPU cores
    verbose=1,
)

grid_search.fit(X_train, y_train)
print(f"Best params: {grid_search.best_params_}")
print(f"Best F1: {grid_search.best_score_:.3f}")

# Evaluate the best model on held-out test set
best_model = grid_search.best_estimator_
print(classification_report(y_test, best_model.predict(X_test)))
```

Cift alt cizgi sozdizimi (`classifier__max_depth`) pipeline icindeki ic ice gecmis parametrelere referans vermektedir. `n_jobs=-1` aramalayi tum mevcut CPU cekirdekleri uzerinde paralellestirmekte ve bu da ayarlama suresini cok cekirdekli makinelerde saatlerden dakikalara indirebilmektedir.

> **Capraz Dogrulamada Veri Sizintisi Riski**
>
> Olcekleyicinin bolunmeden once tum veri seti uzerinde fit edilmesi, dogrulama katmanlarindan egitim katlanlarina bilgi sizmasina neden olmaktadir. Olcekleyicinin bir Pipeline icine yerlestirilmesi, olceklemenin yalnizca her katlamanin egitim bolumu uzerinde gerceklestirilmesini garanti etmektedir. Bu durum, makine ogrenimi mulakat sorularinda en sik karsilasilan hatalar arasinda yer almaktadir.

## Modelleri Kaydetme ve Uretim Ortamina Tasima

Egitilmis bir pipeline'in dagitim icin seriletirilmesi gerekmektedir. `joblib` kutuphanesi, NumPy dizilerini Python'un yerlesik `pickle` modulu ile karsilastirildiginda daha verimli bir sekilde islemektedir.

```python
# sklearn_export.py
import joblib
from pathlib import Path

# Save the complete pipeline (preprocessor + model)
model_dir = Path("models")
model_dir.mkdir(exist_ok=True)
joblib.dump(best_model, model_dir / "promotion_model_v1.joblib")

# Load and predict in a different process
loaded_model = joblib.load(model_dir / "promotion_model_v1.joblib")
new_data = pd.DataFrame({
    "salary": [75000],
    "experience_years": [4],
    "salary_ratio": [1.05],
    "tenure_days": [730],
    "department": ["Engineering"],
    "role_level": ["Mid"],
})

prediction = loaded_model.predict(new_data)
probability = loaded_model.predict_proba(new_data)[:, 1]
print(f"Promoted: {bool(prediction[0])}, Confidence: {probability[0]:.2%}")
```

Yalnizca model yerine tum pipeline'in kaydedilmesi, on-isleme adimlarinin cikarim zamaninda birebir ayni sekilde uygulanmasini saglamaktadir. Model dosyasinin egitim betigiyle birlikte surumlendirilmesi tekrarlanabilirligi korumaktadir. Resmi [Scikit-Learn kalicilik dokumantasyonu](https://scikit-learn.org/stable/model_persistence.html), guvenilir olmayan model dosyalarinin yuklenmesiyle ilgili guvenlik hususlarini kapsamaktadir.

## Sonuc

- NumPy vektorize islemleri, Python dongularini 50-100 kat daha hizli dizi hesaplamalariyla degistirmektedir; boolean indeksleme ve yayilim, filtreleme ve donusum ihtiyaclarinin buyuk bolumunu karsilamaktadir
- Pandas'ta `.assign()` ve `.transform()` ile metot zincirleme, okunabilir ve tekrarlanabilir veri temizleme hatlari olusturmaktadir; Pandas 2.2'deki Copy-on-Write ozelligi sessiz mutasyon hatalarini ortadan kaldirmaktadir
- Scikit-Learn Pipeline'lari on-isleme ve modellemeyi tek bir nesne icinde birlestirimekte ve egitim ile test kumeleri arasinda veri sizintisini onlemektedir
- `GridSearchCV` ile capraz dogrulama, guvenilir performans tahminleri saglamakta ve hiperparametre optimizasyonunu tum CPU cekirdekleri uzerinde otomatiklestirmektedir
- Tum pipeline'in `joblib` ile seriletirilmesi, egitim ve cikarim zamaninda birebir ayni on-islemenin uygulanmasini garanti etmektedir
- Bu kaliplari, hem kodlama yetkinligini hem de istatistiksel temellerin kavranmasini test eden [veri bilimi mulakat sorulari](/technologies/data-science) ile pratik yapmak tavsiye edilmektedir

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/tr/blog/data-science/python-data-science-numpy-pandas-scikit-learn-2026