← Kursa Dön
📄 Text · 15 min

Yorum Satırları, Kod Stili ve PEP 8

Bir kod yazarken sadece "çalışması" yetmez. Kodun okunabilir, tutarlı ve bakımı kolay olması da en az o kadar önemlidir. İşte PEP 8 tam olarak bunu sağlamak için var.

Bu derste Python'ın resmi stil kılavuzunu öğreneceksin. Bu kurallar zorunlu değil — Python seni bu kurallara uymaya zorlamaz. Ama profesyonel Python dünyasında herkes bu kurallara uyar ve senden de uymanı bekler.

PEP 8 Nedir?

PEP, "Python Enhancement Proposal" (Python Geliştirme Önerisi) anlamına gelir. PEP'ler, Python diline yeni özellikler eklenmesini veya mevcut uygulamaların iyileştirilmesini öneren resmi belgelerdir.

PEP 8, bu öneriler arasında en ünlüsüdür. 2001 yılında Guido van Rossum, Barry Warsaw ve Nick Coghlan tarafından yazılmıştır. Tam adı: "Style Guide for Python Code" (Python Kodu için Stil Kılavuzu).

Neden Önemli?

# PEP 8'e UYMAYAN kod
def hesapla(x,y,z):
    sonuc=x*y+z
    if sonuc>100:
        print( "Büyük sayı" )
    return(sonuc)

# PEP 8'e UYAN kod
def hesapla(x, y, z):
    sonuc = x * y + z
    if sonuc > 100:
        print("Büyük sayı")
    return sonuc

İkisi de aynı işi yapar. Ama ikinci versiyonu okumak çok daha kolay. Şimdi düşün: bu fark 10 satırda bile belirginken, binlerce satırlık bir projede ne kadar önemli olurdu?

Analoji: PEP 8, trafik kuralları gibidir. Teknik olarak kırmızı ışıkta geçebilirsin — araba çalışır, gaz pedalı basar. Ama kurallara uyulduğunda herkes güvende olur ve trafik akıcı işler. PEP 8'e uyulduğunda herkesin kodu tutarlı ve okunabilir olur.

Temel Felsefe

PEP 8'in en önemli cümlesi şudur:

"Code is read much more often than it is written." (Kod, yazıldığından çok daha sık okunur.)

Bir kodu bir kere yazarsın ama onlarca, belki yüzlerce kere okursun. Bu yüzden okunabilirlik her şeyin üstünde.

İsimlendirme Kuralları

İsimlendirme, PEP 8'in en pratik bölümlerinden biridir. Doğru isimlendirme konvansiyonlarını kullanmak, kodun profesyonel görünmesini sağlar.

snake_case — Değişkenler ve Fonksiyonlar

Değişkenler ve fonksiyonlar snake_case ile yazılır: tüm harfler küçük, kelimeler alt çizgi ile ayrılır.

# Değişkenler
kullanici_adi = "ahmet"
toplam_fiyat = 150.75
ogrenci_sayisi = 42
son_giris_tarihi = "2024-01-15"

# Fonksiyonlar
def toplam_hesapla(a, b):
    return a + b

def kullanici_dogrula(isim, sifre):
    pass

def dosya_oku(dosya_yolu):
    pass

PascalCase — Sınıflar

Sınıf (class) isimleri PascalCase ile yazılır: her kelimenin ilk harfi büyük, arada boşluk veya alt çizgi yok.

# Sınıflar
class Ogrenci:
    pass

class BankaHesabi:
    pass

class HttpSunucu:
    pass

class VeriTabaniBaglantisi:
    pass

UPPER_CASE — Sabitler

Sabit (constant) değerler UPPER_CASE ile yazılır: tüm harfler büyük, kelimeler alt çizgi ile ayrılır.

# Sabitler
PI = 3.14159
MAX_DENEME_SAYISI = 5
VERITABANI_URL = "postgresql://localhost:5432/mydb"
VARSAYILAN_ZAMAN_ASIMI = 30
API_ANAHTARI = "abc123def456"

Not: Python'da gerçek anlamda "sabit" yoktur — teknik olarak bu değişkenlerin değerini değiştirebilirsin. UPPER_CASE sadece bir konvansiyon: "Bu değeri değiştirme!" mesajı verir.

Tam Tablo

TürKonvansiyonÖrnek
Değişkensnake_casekullanici_adi
Fonksiyonsnake_casetoplam_hesapla()
Metotsnake_caseself.veri_al()
SınıfPascalCaseBankaHesabi
SabitUPPER_CASEMAX_BOYUT
Modülsnake_caseveri_isleme.py
Paketsnake_case (kısa)mypackage
Özel (internal)_snake_case_dahili_fonksiyon()

Kaçınılması Gereken İsimler

# KÖTÜ — tek harfli ve anlamsız isimler
x = 25
a = "İstanbul"
t = True

# İYİ — anlamlı isimler
yas = 25
sehir = "İstanbul"
aktif_mi = True

# KÖTÜ — yerleşik isimleri gölgeleme (shadowing)
# list = [1, 2, 3]     # Tehlikeli! Python'ın list fonksiyonunu gölgeler
# type = "admin"        # Tehlikeli! type() fonksiyonunu gölgeler
# id = 42               # Tehlikeli! id() fonksiyonunu gölgeler
# input = "veri"        # Tehlikeli! input() fonksiyonunu gölgeler

# İYİ — farklı isimler kullan
veri_listesi = [1, 2, 3]
kullanici_tipi = "admin"
kullanici_id = 42
kullanici_girdisi = "veri"

⚠️ Dikkat: Python'ın yerleşik fonksiyon isimlerini (list, dict, type, id, input, print vb.) değişken adı olarak kullanma. Teknik olarak çalışır ama o fonksiyonu artık kullanamazsın — çünkü kendi değişkenin onu "gölgeler" (shadow). Bu, bulması çok zor hatalara yol açabilir.

Satır Uzunluğu

PEP 8, bir satırın 79 karakterden uzun olmamasını önerir. Birçok modern proje bu limiti 120 karaktere çıkarmıştır.

Neden Satır Limiti?

  • Yan yana iki dosyayı karşılaştırabilmek için

  • Küçük ekranlarda yatay kaydırma yapmamak için

  • Kod review'larında kolaylık için

  • Okunabilirlik — çok uzun satırları göz takip edemez

Uzun Satırları Bölme

# KÖTÜ — çok uzun satır
sonuc = birinci_degisken + ikinci_degisken + ucuncu_degisken + dorduncu_degisken + besinci_degisken

# İYİ — parantez içinde bölme
sonuc = (birinci_degisken + ikinci_degisken +
         ucuncu_degisken + dorduncu_degisken +
         besinci_degisken)

# İYİ — operatör satır başında (PEP 8 önerisi)
sonuc = (birinci_degisken
         + ikinci_degisken
         + ucuncu_degisken
         + dorduncu_degisken
         + besinci_degisken)

Uzun Fonksiyon Çağrıları

# KÖTÜ — tek satırda çok uzun
sonuc = cok_uzun_fonksiyon_adi(birinci_parametre, ikinci_parametre, ucuncu_parametre, dorduncu_parametre)

# İYİ — parametre başına satır
sonuc = cok_uzun_fonksiyon_adi(
    birinci_parametre,
    ikinci_parametre,
    ucuncu_parametre,
    dorduncu_parametre,
)

Uzun String'ler

# KÖTÜ
mesaj = "Bu çok uzun bir mesajdır ve bir satıra sığmadığı için okunması zor bir hal almaktadır ve gözler satırın sonunu bulmakta zorlanmaktadır."

# İYİ — parantez içinde birleştirme
mesaj = (
    "Bu çok uzun bir mesajdır ve "
    "bir satıra sığmadığı için "
    "birden fazla satıra bölünmüştür."
)

Docstring ve Yorum Satırları

Docstring'ler ve yorum satırları için de satır limiti geçerlidir: 72 karakter önerilir (79 değil).

def fonksiyon():
    """Bu fonksiyon bir işlem yapar.

    Daha uzun açıklama burada yer alır. Bu açıklama
    72 karakteri geçmemelidir çünkü bazı araçlar
    docstring'leri bu genişlikte görüntüler.
    """
    pass

Boşluk Kuralları (Whitespace)

Boşluklar, kodun okunabilirliğini doğrudan etkiler. PEP 8, boşluk kullanımı konusunda detaylı kurallar belirler.

Operatörler Etrafında Boşluk

# İYİ — operatörler etrafında boşluk
x = 5
y = x + 3
z = x * y - 10
sonuc = (a + b) * (c - d)
kontrol = x == y
mantik = a and b or c

# KÖTÜ — boşluk yok
x=5
y=x+3
z=x*y-10

İstisna: Öncelik Belirtme

Matematiksel önceliği vurgulamak için iç boşluklar kaldırılabilir:

# Kabul edilebilir — önceliği vurgular
hipotenuz = a*a + b*b
y = x*2 + 1

# Ama bu da doğru
hipotenuz = a * a + b * b
y = x * 2 + 1

Fonksiyon Parametrelerinde Boşluk

# İYİ
def fonksiyon(a, b, c):
    pass

fonksiyon(1, 2, 3)

# KÖTÜ — parantez içinde gereksiz boşluk
def fonksiyon( a, b, c ):    # Parantez iç boşlukları kötü
    pass

fonksiyon( 1, 2, 3 )        # Kötü

Varsayılan Değerlerde Boşluk

# İYİ — varsayılan değerlerde boşluk YOK
def baglanti_kur(host="localhost", port=5432):
    pass

baglanti_kur(host="192.168.1.1", port=8080)

# KÖTÜ — gereksiz boşluk
def baglanti_kur(host = "localhost", port = 5432):
    pass

Virgüllerden Sonra Boşluk

# İYİ
liste = [1, 2, 3, 4, 5]
sozluk = {"a": 1, "b": 2}
fonksiyon(x, y, z)

# KÖTÜ
liste = [1,2,3,4,5]
sozluk = {"a":1,"b":2}
fonksiyon(x,y,z)

İki Nokta (:) ve Dilim (Slice) Kuralları

# İYİ — sözlükte iki noktadan sonra boşluk
sozluk = {"isim": "Ayşe", "yas": 25}

# İYİ — dilimlerde (slice) boşluk YOK
liste = [1, 2, 3, 4, 5]
alt_liste = liste[1:3]
alt_liste = liste[::2]
alt_liste = liste[1:4:2]

# KÖTÜ
alt_liste = liste[1 : 3]
alt_liste = liste[1: 3]

Satır Sonu Boşlukları (Trailing Whitespace)

Satır sonunda gereksiz boşluk olmamalıdır. Gözle görünmese de versiyon kontrol sistemlerinde (Git) sorun yaratabilir.

VS Code'da bu boşlukları otomatik silmek için:

  • Settings → "Trim Trailing Whitespace" → ✅ Aktif et

Boş Satırlar (Blank Lines)

Boş satırlar, kodun bölümlerini görsel olarak ayırmak için kullanılır.

Üst Düzey Tanımlar: 2 Boş Satır

Fonksiyonlar ve sınıflar arasında 2 boş satır bırak:

import os


def birinci_fonksiyon():
    return "bir"


def ikinci_fonksiyon():
    return "iki"


class BirSinif:
    pass


class BaskabirSinif:
    pass

Metot Tanımları: 1 Boş Satır

Sınıf içindeki metotlar arasında 1 boş satır bırak:

class Hesap:

    def __init__(self, bakiye):
        self.bakiye = bakiye

    def para_yatir(self, miktar):
        self.bakiye += miktar

    def para_cek(self, miktar):
        self.bakiye -= miktar

Mantıksal Bölümler: 1 Boş Satır (İsteğe Bağlı)

Fonksiyon içinde mantıksal olarak farklı bölümleri ayırmak için boş satır kullanabilirsin:

def rapor_olustur(veriler):
    # Veriyi hazırla
    temiz_veri = veriyi_temizle(veriler)
    sirali_veri = sorted(temiz_veri)

    # Hesaplamaları yap
    toplam = sum(sirali_veri)
    ortalama = toplam / len(sirali_veri)

    # Raporu oluştur
    rapor = f"Toplam: {toplam}, Ortalama: {ortalama}"
    return rapor

Import Kuralları

Import sıralama kuralları, projenin bağımlılıklarını hızlıca anlamak için önemlidir.

Import Sırası

PEP 8, import'ların şu sırayla olmasını önerir:

# 1. Standart kütüphane (Python ile birlikte gelir)
import os
import sys
import json
from datetime import datetime
from pathlib import Path

# 2. Üçüncü parti kütüphaneler (pip ile yüklenenler)
import requests
import numpy as np
import pandas as pd
from flask import Flask, render_template

# 3. Yerel (proje içi) modüller
from myproject.utils import helper
from myproject.models import User
import myproject.config as config

Her grup arasında 1 boş satır bırakılır.

Import Stilleri

# İYİ — her import ayrı satırda
import os
import sys
import json

# KÖTÜ — birden fazla modül aynı satırda
import os, sys, json

# İYİ — aynı modülden birden fazla import
from os.path import join, exists, dirname

# İYİ — uzun import listesi
from mymodule import (
    birinci_fonksiyon,
    ikinci_fonksiyon,
    ucuncu_fonksiyon,
)

Wildcard Import'tan Kaçın

# KÖTÜ — wildcard import
from math import *    # Ne import edildi belli değil!
from os import *      # İsim çakışması riski!

# İYİ — açık import
from math import sqrt, pi, ceil
from os import path, listdir

from modül import * kullanmak:

  • Hangi isimlerin geldiğini belirsiz kılar

  • İsim çakışmalarına (name collision) yol açabilir

  • Kod okuyucusu hangi fonksiyonun nereden geldiğini anlayamaz

Takma Ad (Alias)

Bazı kütüphanelerde yaygın kullanılan takma adlar (alias) vardır:

import numpy as np           # Herkes np kullanır
import pandas as pd          # Herkes pd kullanır
import matplotlib.pyplot as plt  # Herkes plt kullanır
import seaborn as sns        # Herkes sns kullanır

Bu takma adlar topluluğun kabul ettiği standartlardır. Farklı bir takma ad kullanmak kafa karıştırır.

Docstring Yazma

Docstring, fonksiyonları, sınıfları ve modülleri belgelemek için kullanılan özel yorum formatıdır. """ (üç çift tırnak) ile yazılır.

Tek Satırlık Docstring

Basit fonksiyonlar için:

def kare(x):
    """Verilen sayının karesini döndürür."""
    return x ** 2

def selamla(isim):
    """Verilen isimle selamlama mesajı yazdırır."""
    print(f"Merhaba {isim}!")

Kurallar:

  • Üç çift tırnak kullanılır (tek tırnak da olur ama çift tırnak tercih edilir)

  • Kapanış tırnağı aynı satırda

  • Cümle büyük harfle başlar, noktayla biter

  • Fonksiyonun ne yaptığını anlatır (nasıl yaptığını değil)

Çok Satırlık Docstring

Karmaşık fonksiyonlar için:

def bolme(bolunen, bolen):
    """İki sayıyı böler ve sonucu döndürür.

    Sıfıra bölme durumunda None döndürür ve
    bir uyarı mesajı yazdırır.

    Args:
        bolunen: Bölünecek sayı (float veya int).
        bolen: Bölen sayı (float veya int).

    Returns:
        Bölme sonucu (float) veya None.

    Examples:
        >>> bolme(10, 3)
        3.3333333333333335
        >>> bolme(10, 0)
        Uyarı: Sıfıra bölme!
    """
    if bolen == 0:
        print("Uyarı: Sıfıra bölme!")
        return None
    return bolunen / bolen

Google Stili Docstring (Popüler)

def kullanici_olustur(isim, email, yas=None):
    """Yeni bir kullanıcı oluşturur.

    Args:
        isim: Kullanıcının tam adı.
        email: Kullanıcının e-posta adresi.
        yas: Kullanıcının yaşı (isteğe bağlı).

    Returns:
        Oluşturulan kullanıcı sözlüğü.

    Raises:
        ValueError: Email formatı geçersizse.
    """
    if "@" not in email:
        raise ValueError("Geçersiz email formatı")

    return {"isim": isim, "email": email, "yas": yas}

Modül Docstring

Her Python dosyasının başında bir modül docstring'i olabilir:

"""Kullanıcı yönetimi modülü.

Bu modül kullanıcı oluşturma, güncelleme ve silme
işlemlerini gerçekleştiren fonksiyonları içerir.

Örnek kullanım:
    from kullanici import kullanici_olustur
    yeni_kullanici = kullanici_olustur("Ayşe", "ayse@mail.com")
"""

import json
from datetime import datetime

# ... kodun geri kalanı

Sınıf Docstring

class BankaHesabi:
    """Basit bir banka hesabı temsil eder.

    Attributes:
        sahip: Hesap sahibinin adı.
        bakiye: Hesaptaki mevcut bakiye (TL).
    """

    def __init__(self, sahip, bakiye=0):
        """BankaHesabi nesnesini başlatır.

        Args:
            sahip: Hesap sahibinin adı.
            bakiye: Başlangıç bakiyesi (varsayılan 0).
        """
        self.sahip = sahip
        self.bakiye = bakiye

Linter Araçları: Otomatik Kalite Kontrolü

Manuel olarak PEP 8 kurallarına uymak zor olabilir. Neyse ki bu işi otomatik yapan araçlar var. Bunlara linter denir.

flake8 — Hata ve Stil Kontrolü

flake8, en yaygın kullanılan Python linter'ıdır. Hem söz dizimi hatalarını hem de PEP 8 ihlallerini yakalar.

# Kurulum
pip3 install flake8

# Kullanım
flake8 dosya.py
flake8 proje_klasoru/

Örnek çıktı:

dosya.py:3:1: E302 expected 2 blank lines, found 1
dosya.py:5:12: E225 missing whitespace around operator
dosya.py:8:80: E501 line too long (95 > 79 characters)

Her satır bir uyarı: dosya adı, satır numarası, sütun numarası, hata kodu ve açıklama.

pylint — Kapsamlı Analiz

pylint, flake8'den daha kapsamlıdır. Stil kontrolünün yanı sıra potansiyel hataları, kullanılmayan değişkenleri ve karmaşıklığı da kontrol eder.

# Kurulum
pip3 install pylint

# Kullanım
pylint dosya.py

pylint bir puan verir (10 üzerinden):

Your code has been rated at 8.50/10 (previous run: 7.20/10, +1.30)

black — Otomatik Formatlama

black, kodu otomatik olarak PEP 8'e uygun formata dönüştürür. Tartışmayı ortadan kaldırır — "kodu black'e ver, o halleder."

# Kurulum
pip3 install black

# Kullanım — dosyayı otomatik formatla
black dosya.py

# Önizleme (değişiklik yapmadan göster)
black --diff dosya.py

# Tüm projeyi formatla
black proje_klasoru/

Önce:

x=1+2
y =    3*   4
liste=[1,2,3,4,5]
def f(a,b,c):
    return a+b+c

Sonra (black uygulandıktan sonra):

x = 1 + 2
y = 3 * 4
liste = [1, 2, 3, 4, 5]


def f(a, b, c):
    return a + b + c

isort — Import Sıralama

isort, import'ları otomatik olarak PEP 8 kurallarına göre sıralar:

# Kurulum
pip3 install isort

# Kullanım
isort dosya.py

VS Code Entegrasyonu

Bu araçları VS Code'a entegre etmek çok kolay:

  1. Settings → "Format On Save" → ✅ aktif et

  2. Default Formatter → "Black Formatter" seç

  3. Linting → "flake8" veya "pylint" aktif et

Böylece dosyayı her kaydettiğinde otomatik olarak formatlanır.

💡 İpucu: Yeni başlarken black formatter'ı kur ve "Format On Save" özelliğini aktif et. Böylece PEP 8 kurallarını ezberlemene gerek kalmaz — black senin yerine halleder. Zamanla kuralları doğal olarak öğrenirsin.

Type Hints (Tip İpuçları) — Kısa Bakış

Python dinamik tipli bir dil olsa da, Python 3.5'ten itibaren type hints (tip ipuçları) desteği var. Bu, değişkenlerin ve fonksiyonların beklenen tiplerini belirtmeni sağlar.

Neden Type Hints?

Type hints zorunlu değildir — Python bunları çalışma zamanında kontrol etmez. Ama birçok avantajı var:

  • IDE'lerin daha iyi otomatik tamamlama yapmasını sağlar

  • Kodun okunabilirliğini artırır

  • Statik analiz araçları (mypy) ile hataları erken yakalar

  • Belgeleme görevi görür

Basit Örnekler

# Type hint olmadan
def topla(a, b):
    return a + b

# Type hint ile
def topla(a: int, b: int) -> int:
    return a + b

# Değişkenlerde type hint
isim: str = "Ayşe"
yas: int = 25
boy: float = 1.72
aktif: bool = True

Fonksiyon Type Hints

def selamla(isim: str) -> str:
    """İsme göre selamlama mesajı döndürür."""
    return f"Merhaba {isim}!"

def ortalama_hesapla(sayilar: list[float]) -> float:
    """Sayıların ortalamasını hesaplar."""
    return sum(sayilar) / len(sayilar)

def kullanici_bul(user_id: int) -> dict | None:
    """Kullanıcıyı ID'ye göre bulur, yoksa None döndürür."""
    # veritabanı sorgusu...
    pass

Şimdilik Bu Kadar!

Type hints konusu geniştir ve ilerleyen derslerde (B11) detaylı olarak ele alacağız. Şimdilik "böyle bir şey var" bilgisi yeterli.

# Şimdilik böyle yazabilirsin — ikisi de geçerli
def topla(a, b):           # Type hint yok — sorun değil
    return a + b

def topla(a: int, b: int) -> int:  # Type hint var — daha iyi
    return a + b

Yorum Yazma Kuralları

PEP 8, yorumlar konusunda da kurallar belirler.

Blok Yorumlar

# Bu bir blok yorumdur.
# Birden fazla satırdan oluşabilir.
# Her satır # ile başlar ve bir boşluk bırakılır.
x = 10

Satır İçi (Inline) Yorumlar

x = 10  # Bu bir satır içi yorumdur

# İYİ — koddan en az 2 boşluk uzakta
sonuc = x * 2  # Sonucu iki katına çıkar

# KÖTÜ — çok yakın
sonuc = x * 2 # Boşluk yetersiz

Gereksiz Yorumlardan Kaçın

# KÖTÜ — bariz olanı tekrarlıyor
x = x + 1  # x'i 1 artır
liste.append(eleman)  # Listeye eleman ekle
return True  # True döndür

# İYİ — neden açıklıyor
x = x + 1  # Sayaç her iterasyonda artmalı (API limiti)
retry_count += 1  # 3 denemeden sonra timeout hatası fırlatılacak

PEP 8 Hızlı Kontrol Listesi

Günlük kullanım için hızlı referans:

# ✅ Girintileme: 4 boşluk
if True:
    print("OK")

# ✅ Satır uzunluğu: max 79 (veya 120) karakter
kisa_satir = "Bu uygun uzunlukta"

# ✅ İsimlendirme
degisken_adi = "snake_case"      # değişken
def fonksiyon_adi():              # fonksiyon
    pass
class SinifAdi:                   # sınıf
    pass
SABIT_DEGER = 42                  # sabit

# ✅ Boşluklar
x = 1 + 2                        # Operatör etrafında
fonksiyon(a, b, c)               # Virgülden sonra
sozluk = {"a": 1, "b": 2}        # İki noktadan sonra

# ✅ Import sırası
import os                         # 1. Standart kütüphane
import requests                   # 2. Üçüncü parti
from myapp import utils           # 3. Yerel

# ✅ Boş satırlar
# 2 boş satır: fonksiyonlar/sınıflar arası
# 1 boş satır: metotlar arası

Gerçek Dünya Örneği

Tüm kuralları bir arada görelim:

"""Basit bir not defteri uygulaması.

Bu modül, kullanıcıların not oluşturmasını,
listelemesini ve silmesini sağlayan fonksiyonları içerir.
"""

from datetime import datetime


MAX_NOT_UZUNLUGU = 500
VARSAYILAN_KATEGORI = "genel"


def not_olustur(baslik: str, icerik: str, kategori: str = VARSAYILAN_KATEGORI) -> dict:
    """Yeni bir not oluşturur ve sözlük olarak döndürür.

    Args:
        baslik: Notun başlığı.
        icerik: Notun içeriği.
        kategori: Notun kategorisi (varsayılan: 'genel').

    Returns:
        Not bilgilerini içeren sözlük.

    Raises:
        ValueError: İçerik maksimum uzunluğu aşarsa.
    """
    if len(icerik) > MAX_NOT_UZUNLUGU:
        raise ValueError(
            f"Not içeriği {MAX_NOT_UZUNLUGU} karakteri aşamaz. "
            f"Mevcut: {len(icerik)} karakter."
        )

    return {
        "baslik": baslik,
        "icerik": icerik,
        "kategori": kategori,
        "tarih": datetime.now().isoformat(),
    }


def notlari_listele(notlar: list[dict], kategori: str | None = None) -> None:
    """Notları ekrana listeler.

    Args:
        notlar: Not sözlüklerinin listesi.
        kategori: Filtrelenecek kategori (None ise tümünü gösterir).
    """
    for i, not_bilgisi in enumerate(notlar, start=1):
        if kategori and not_bilgisi["kategori"] != kategori:
            continue

        print(f"{i}. {not_bilgisi['baslik']}")
        print(f"   Kategori: {not_bilgisi['kategori']}")
        print(f"   Tarih: {not_bilgisi['tarih']}")
        print()

Bu kod:

  • ✅ Modül docstring'i var

  • ✅ Import'lar düzgün sırada

  • ✅ Sabitler UPPER_CASE

  • ✅ Fonksiyonlar snake_case

  • ✅ Type hints kullanılmış

  • ✅ Docstring'ler eksiksiz

  • ✅ Boşluk kurallarına uygun

  • ✅ Boş satır kurallarına uygun

Özet

  • 📜 PEP 8, Python'ın resmi stil kılavuzudur. Kodun okunabilir ve tutarlı olmasını sağlayan kurallar bütünüdür.

  • 🏷️ İsimlendirme: Değişkenler ve fonksiyonlar snake_case, sınıflar PascalCase, sabitler UPPER_CASE ile yazılır.

  • 📏 Satır uzunluğu 79 karakter (veya 120) ile sınırlandırılmalıdır. Uzun satırlar parantez içinde bölünür.

  • ⬜ Boşluk kuralları: Operatörler etrafında boşluk var, fonksiyon parantezi içinde boşluk yok, virgülden sonra boşluk var.

  • 📦 Import sırası: Standart kütüphane → üçüncü parti → yerel modüller. Her grup arasında boş satır bırakılır.

  • 🔧 Linter araçları (flake8, pylint) ve formatlayıcılar (black, isort) PEP 8 uyumunu otomatik kontrol eder ve düzeltir. VS Code'da "Format On Save" ile entegre edebilirsin.

*Bu dersle birlikte B01 bölümünü tamamladın! Python'ı tanıdın, kurdun, ilk kodlarını yazdın, söz dizimi kurallarını öğrendin ve profesyonel stil kılavuzuyla tanıştın. Bir sonraki bölümde değişkenler ve veri tiplerine dalacağız. Temelin sağlam — devam et!* 🎓