python-patterns

name python-patterns description Pythonic idiomlar, PEP 8 standartları, type hint'ler ve sağlam, verimli ve bakımı kolay Python uygulamaları oluşturmak için en iyi uygulamalar. origin ECC 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. # İ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. # İ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. # İ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 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 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 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 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 # İ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 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 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 # İ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 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: .4 f} seconds" ) # Kullanım with timer( "data processing" ): process_large_dataset() Context Manager Class'ları 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ı # İ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ı # İ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ı 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 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 @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 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ı 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: .4 f} 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 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 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 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 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 import asyncio async def fetch_async ( url: str ) -> str :