python-patterns

# Python Geliştirme Desenleri Sağlam, verimli ve bakımı kolay uygulamalar oluşturmak için idiomatic Python desenleri ve en iyi uygulamalar. ## Ne Zaman Etkinleştirmeli - Yeni Python kodu yazarken - Python kodunu gözden geçirirken - Mevcut Python kodunu refactor ederken - Python paketleri/modülleri tasarlarken ## Temel Prensipler ### 1. Okunabilirlik Önemlidir Python okunabilirliği önceliklendirir. Kod açık ve anlaşılması kolay olmalıdır. ```python # İyi: Açık ve okunabilir def get_active_users(users: list[User]) -> list[User]: """Sağlanan listeden sadece aktif kullanıcıları döndür.""" return [user for user in users if user.is_active] # Kötü: Zeki ama kafa karıştırıcı def get_active_users(u): return [x for x in u if x.a] ``` ### 2. Açık, Örtük Olandan Daha İyidir Sihirden kaçının; kodunuzun ne yaptığı konusunda açık olun. ```python # İyi: Açık yapılandırma import logging logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' ) # Kötü: Gizli yan etkiler import some_module some_module.setup() # Bu ne yapıyor? ``` ### 3. EAFP - Affederek Sormaktansa İzin İstemek Daha Kolaydır Python, koşulları kontrol etmek yerine exception handling'i tercih eder. ```python # İyi: EAFP stili def get_value(dictionary: dict, key: str, default_value: Any = None) -> Any: try: return dictionary[key] except KeyError: return default_value # Kötü: LBYL (Atlamadan Önce Bak) stili def get_value(dictionary: dict, key: str, default_value: Any = None) -> Any: if key in dictionary: return dictionary[key] else: return default_value ``` ## Type Hint'ler ### Temel Type Annotation'lar ```python from typing import Optional, List, Dict, Any def process_user( user_id: str, data: Dict[str, Any], active: bool = True ) -> Optional[User]: """Bir kullanıcıyı işle ve güncellenmiş User'ı veya None döndür.""" if not active: return None return User(user_id, data) ``` ### Modern Type Hint'ler (Python 3.9+) ```python # Python 3.9+ - Built-in tipleri kullan def process_items(items: list[str]) -> dict[str, int]: return {item: len(item) for item in items} # Python 3.8 ve öncesi - typing modülünü kullan from typing import List, Dict def process_items(items: List[str]) -> Dict[str, int]: return {item: len(item) for item in items} ``` ### Type Alias'ları ve TypeVar ```python from typing import TypeVar, Union # Karmaşık tipler için type alias JSON = Union[dict[str, Any], list[Any], str, int, float, bool, None] def parse_json(data: str) -> JSON: return json.loads(data) # Generic tipler T = TypeVar('T') def first(items: list[T]) -> T | None: """İlk öğeyi döndür veya liste boşsa None döndür.""" return items[0] if items else None ``` ### Protocol Tabanlı Duck Typing ```python from typing import Protocol class Renderable(Protocol): def render(self) -> str: """Nesneyi string'e render et.""" def render_all(items: list[Renderable]) -> str: """Renderable protocol'ünü implement eden tüm öğeleri render et.""" return "\n".join(item.render() for item in items) ``` ## Hata İşleme Desenleri ### Spesifik Exception Handling ```python # İyi: Spesifik exception'ları yakala def load_config(path: str) -> Config: try: with open(path) as f: return Config.from_json(f.read()) except FileNotFoundError as e: raise ConfigError(f"Config file not found: {path}") from e except json.JSONDecodeError as e: raise ConfigError(f"Invalid JSON in config: {path}") from e # Kötü: Bare except def load_config(path: str) -> Config: try: with open(path) as f: return Config.from_json(f.read()) except: return None # Sessiz hata! ``` ### Exception Chaining ```python def process_data(data: str) -> Result: try: parsed = json.loads(data) except json.JSONDecodeError as e: # Traceback'i korumak için exception'ları zincirleme raise ValueError(f"Failed to parse data: {data}") from e ``` ### Özel Exception Hiyerarşisi ```python class AppError(Exception): """Tüm uygulama hataları için base exception.""" pass class ValidationError(AppError): """Input validation başarısız olduğunda raise edilir.""" pass class NotFoundError(AppError): """İstenen kaynak bulunamadığında raise edilir.""" pass # Kullanım def get_user(user_id: str) -> User: user = db.find_user(user_id) if not user: raise NotFoundError(f"User not found: {user_id}") return user ``` ## Context Manager'lar ### Kaynak Yönetimi ```python # İyi: Context manager'ları kullanma def process_file(path: str) -> str: with open(path, 'r') as f: return f.read() # Kötü: Manuel kaynak yönetimi def process_file(path: str) -> str: f = open(path, 'r') try: return f.read() finally: f.close() ``` ### Özel Context Manager'lar ```python from contextlib import contextmanager @contextmanager def timer(name: str): """Bir kod bloğunu zamanlamak için context manager.""" start = time.perf_counter() yield elapsed = time.perf_counter() - start print(f"{name} took {elapsed:.4f} seconds") # Kullanım with timer("data processing"): process_large_dataset() ``` ### Context Manager Class'ları ```python class DatabaseTransaction: def __init__(self, connection): self.connection = connection def __enter__(self): self.connection.begin_transaction() return self def __exit__(self, exc_type, exc_val, exc_tb): if exc_type is None: self.connection.commit() else: self.connection.rollback() return False # Exception'ları suppress etme # Kullanım with DatabaseTransaction(conn): user = conn.create_user(user_data) conn.create_profile(user.id, profile_data) ``` ## Comprehension'lar ve Generator'lar ### List Comprehension'ları ```python # İyi: Basit dönüşümler için list comprehension names = [user.name for user in users if user.is_active] # Kötü: Manuel döngü names = [] for user in users: if user.is_active: names.append(user.name) # Karmaşık comprehension'lar genişletilmelidir # Kötü: Çok karmaşık result = [x * 2 for x in items if x > 0 if x % 2 == 0] # İyi: Bir generator fonksiyonu kullan def filter_and_transform(items: Iterable[int]) -> list[int]: result = [] for x in items: if x > 0 and x % 2 == 0: result.append(x * 2) return result ``` ### Generator Expression'ları ```python # İyi: Lazy evaluation için generator total = sum(x * x for x in range(1_000_000)) # Kötü: Büyük ara liste oluşturur total = sum([x * x for x in range(1_000_000)]) ``` ### Generator Fonksiyonları ```python def read_large_file(path: str) -> Iterator[str]: """Büyük bir dosyayı satır satır oku.""" with open(path) as f: for line in f: yield line.strip() # Kullanım for line in read_large_file("huge.txt"): process(line) ``` ## Data Class'lar ve Named Tuple'lar ### Data Class'lar ```python from dataclasses import dataclass, field from datetime import datetime @dataclass class User: """Otomatik __init__, __repr__ ve __eq__ ile User entity.""" id: str name: str email: str created_at: datetime = field(default_factory=datetime.now) is_active: bool = True # Kullanım user = User( id="123", name="Alice", email="alice@example.com" ) ``` ### Validation ile Data Class'lar ```python @dataclass class User: email: str age: int def __post_init__(self): # Email formatını validate et if "@" not in self.email: raise ValueError(f"Invalid email: {self.email}") # Yaş aralığını validate et if self.age < 0 or self.age > 150: raise ValueError(f"Invalid age: {self.age}") ``` ### Named Tuple'lar ```python from typing import NamedTuple class Point(NamedTuple): """Immutable 2D nokta.""" x: float y: float def distance(self, other: 'Point') -> float: return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5 # Kullanım p1 = Point(0, 0) p2 = Point(3, 4) print(p1.distance(p2)) # 5.0 ``` ## Decorator'lar ### Fonksiyon Decorator'ları ```python import functools import time def timer(func: Callable) -> Callable: """Fonksiyon yürütmesini zamanlamak için decorator.""" @functools.wraps(func) def wrapper(*args, **kwargs): start = time.perf_counter() result = func(*args, **kwargs) elapsed = time.perf_counter() - start print(f"{func.__name__} took {elapsed:.4f}s") return result return wrapper @timer def slow_function(): time.sleep(1) # slow_function() yazdırır: slow_function took 1.0012s ``` ### Parametreli Decorator'lar ```python def repeat(times: int): """Bir fonksiyonu birden çok kez tekrarlamak için decorator.""" def decorator(func: Callable) -> Callable: @functools.wraps(func) def wrapper(*args, **kwargs): results = [] for _ in range(times): results.append(func(*args, **kwargs)) return results return wrapper return decorator @repeat(times=3) def greet(name: str) -> str: return f"Hello, {name}!" # greet("Alice") döndürür ["Hello, Alice!", "Hello, Alice!", "Hello, Alice!"] ``` ### Class Tabanlı Decorator'lar ```python class CountCalls: """Bir fonksiyonun kaç kez çağrıldığını sayan decorator.""" def __init__(self, func: Callable): functools.update_wrapper(self, func) self.func = func self.count = 0 def __call__(self, *args, **kwargs): self.count += 1 print(f"{self.func.__name__} has been called {self.count} times") return self.func(*args, **kwargs) @CountCalls def process(): pass # Her process() çağrısı çağrı sayısını yazdırır ``` ## Eşzamanlılık Desenleri ### I/O-Bound Görevler için Threading ```python import concurrent.futures import threading def fetch_url(url: str) -> str: """Bir URL fetch et (I/O-bound operasyon).""" import urllib.request with urllib.request.urlopen(url) as response: return response.read().decode() def fetch_all_urls(urls: list[str]) -> dict[str, str]: """Thread'ler kullanarak birden fazla URL'yi eşzamanlı fetch et.""" with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor: future_to_url = {executor.submit(fetch_url, url): url for url in urls} results = {} for future in concurrent.futures.as_completed(future_to_url): url = future_to_url[future] try: results[url] = future.result() except Exception as e: results[url] = f"Error: {e}" return results ``` ### CPU-Bound Görevler için Multiprocessing ```python def process_data(data: list[int]) -> int: """CPU-yoğun hesaplama.""" return sum(x ** 2 for x in data) def process_all(datasets: list[list[int]]) -> list[int]: """Birden fazla process kullanarak birden fazla dataset işle.""" with concurrent.futures.ProcessPoolExecutor() as executor: results = list(executor.map(process_data, datasets)) return results ``` ### Eşzamanlı I/O için Async/Await ```python import asyncio async def fetch_async(url: str) -> str: