Альтернативные конструкторы в Python: от @classmethod до Builder

class User:
def __init__(self, username, email):
self.username = username
self.email = email

# Этот метод перезапишет предыдущий __init__
def __init__(self, user_id):
self.user_id = user_id
self.username = None
self.email = None

# Всегда будет вызываться второй __init__
user = User("john_doe", "john@example.com") # TypeError

class User:
def __init__(self, username=None, email=None, user_id=None):
self.username = username
self.email = email
self.user_id = user_id

# Теперь можно создавать объекты по-разному
user1 = User(username="john", email="john@example.com")
user2 = User(user_id=42)

class Person:
def __init__(self, first_name, last_name, age):
self.first_name = first_name
self.last_name = last_name
self.age = age

@classmethod
def from_full_name(cls, full_name, age):
first_name, last_name = full_name.split(' ', 1)
return cls(first_name, last_name, age)

@classmethod
def from_dict(cls, data):
return cls(
data['first_name'],
data['last_name'],
data['age']
)

@classmethod
def from_database_record(cls, record):
return cls(
record.first_name,
record.last_name,
record.age
)

# Различные способы создания объекта Person
p1 = Person("John", "Doe", 30) # Стандартный конструктор
p2 = Person.from_full_name("Jane Smith", 25) # Альтернативный конструктор
p3 = Person.from_dict({"first_name": "Bob", "last_name": "Johnson", "age": 45})

class User:
def __init__(self, username, email, age):
self.username = username
self.email = email
self.age = age

@classmethod
def from_dict(cls, data):
# Валидация входных данных
if 'username' not in data or 'email' not in data:
raise ValueError("Missing required fields")

# Установка значений по умолчанию
age = data.get('age', 18)

return cls(data['username'], data['email'], age)

@classmethod
def from_json(cls, json_str):
import json
data = json.loads(json_str)
return cls.from_dict(data) # Повторное использование логики

class Document:
def __init__(self, content, metadata=None):
self.content = content
self.metadata = metadata or {}

@staticmethod
def create_text_document(text):
return Document(text, {"type": "text", "encoding": "utf-8"})

@staticmethod
def create_binary_document(binary_data, format_type):
return Document(binary_data, {
"type": "binary",
"format": format_type,
"size": len(binary_data)
})

# Использование
text_doc = Document.create_text_document("Hello, world!")
image_doc = Document.create_binary_document(b'\x89PNG\r\n\x1a\n', "png")

class Vehicle:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year

class Car(Vehicle):
def __init__(self, make, model, year, doors=4):
super().__init__(make, model, year)
self.doors = doors
self.vehicle_type = "car"

class Motorcycle(Vehicle):
def __init__(self, make, model, year, has_sidecar=False):
super().__init__(make, model, year)
self.has_sidecar = has_sidecar
self.vehicle_type = "motorcycle"

class VehicleFactory:
@staticmethod
def create_vehicle(vehicle_type, make, model, year, **kwargs):
if vehicle_type.lower() == "car":
return Car(make, model, year, **kwargs)
elif vehicle_type.lower() == "motorcycle":
return Motorcycle(make, model, year, **kwargs)
else:
raise ValueError(f"Unknown vehicle type: {vehicle_type}")

# Использование
car = VehicleFactory.create_vehicle("car", "Toyota", "Camry", 2022, doors=4)
bike = VehicleFactory.create_vehicle("motorcycle", "Harley-Davidson", "Sportster", 2021, has_sidecar=True)

from abc import ABC, abstractmethod

# Абстрактные продукты
class Button(ABC):
@abstractmethod
def render(self):
pass

class Checkbox(ABC):
@abstractmethod
def render(self):
pass

# Конкретные продукты
class WindowsButton(Button):
def render(self):
return "Rendering a Windows-style button"

class WindowsCheckbox(Checkbox):
def render(self):
return "Rendering a Windows-style checkbox"

class MacOSButton(Button):
def render(self):
return "Rendering a MacOS-style button"

class MacOSCheckbox(Checkbox):
def render(self):
return "Rendering a MacOS-style checkbox"

# Абстрактная фабрика
class UIFactory(ABC):
@abstractmethod
def create_button(self):
pass

@abstractmethod
def create_checkbox(self):
pass

# Конкретные фабрики
class WindowsUIFactory(UIFactory):
def create_button(self):
return WindowsButton()

def create_checkbox(self):
return WindowsCheckbox()

class MacOSUIFactory(UIFactory):
def create_button(self):
return MacOSButton()

def create_checkbox(self):
return MacOSCheckbox()

# Клиентский код
def create_ui(factory):
button = factory.create_button()
checkbox = factory.create_checkbox()
return button, checkbox

# Использование
windows_factory = WindowsUIFactory()
mac_factory = MacOSUIFactory()

windows_ui = create_ui(windows_factory)
mac_ui = create_ui(mac_factory)

print(windows_ui[0].render()) # "Rendering a Windows-style button"
print(mac_ui[0].render()) # "Rendering a MacOS-style button"

class UserFactory:
factories = {
"admin": lambda username: AdminUser(username),
"regular": lambda username: RegularUser(username),
"guest": lambda username: GuestUser(username),
}

@classmethod
def create_user(cls, user_type, username):
if user_type not in cls.factories:
raise ValueError(f"Unknown user type: {user_type}")
return cls.factories[user_type](username)

class Email:
def __init__(self):
self.sender = None
self.recipients = []
self.subject = None
self.body = None
self.attachments = []
self.cc = []
self.bcc = []
self.priority = "normal"

def validate(self):
if not self.sender:
raise ValueError("Sender is required")
if not self.recipients:
raise ValueError("At least one recipient is required")
if not self.subject:
raise ValueError("Subject is required")
if not self.body:
raise ValueError("Body is required")

class EmailBuilder:
def __init__(self):
self.email = Email()

def from_sender(self, sender):
self.email.sender = sender
return self

def to_recipient(self, recipient):
self.email.recipients.append(recipient)
return self

def to_recipients(self, recipients):
self.email.recipients.extend(recipients)
return self

def with_subject(self, subject):
self.email.subject = subject
return self

def with_body(self, body):
self.email.body = body
return self

def with_attachment(self, attachment):
self.email.attachments.append(attachment)
return self

def with_cc(self, cc_recipient):
self.email.cc.append(cc_recipient)
return self

def with_bcc(self, bcc_recipient):
self.email.bcc.append(bcc_recipient)
return self

def with_priority(self, priority):
self.email.priority = priority
return self

def build(self):
email = self.email
email.validate()
return email

# Использование
email = (EmailBuilder()
.from_sender("sender@example.com")
.to_recipient("recipient1@example.com")
.to_recipient("recipient2@example.com")
.with_subject("Important meeting")
.with_body("Please join us for the meeting tomorrow.")
.with_cc("manager@example.com")
.with_priority("high")
.build())

class QueryBuilder:
def __init__(self):
self.select_fields = []
self.from_tables = []
self.where_conditions = []
self.group_by = []
self.order_by = []
self.limit = None

def select(self, *fields):
self.select_fields.extend(fields)
return self

def from_table(self, *tables):
self.from_tables.extend(tables)
return self

def where(self, condition):
self.where_conditions.append(condition)
return self

def group_by_fields(self, *fields):
self.group_by.extend(fields)
return self

def order_by_fields(self, *fields):
self.order_by.extend(fields)
return self

def limit_results(self, limit):
self.limit = limit
return self

def build(self):
if not self.select_fields:
self.select_fields = ["*"]

if not self.from_tables:
raise ValueError("No table specified")

query = f"SELECT {', '.join(self.select_fields)}"
query += f" FROM {', '.join(self.from_tables)}"

if self.where_conditions:
query += f" WHERE {' AND '.join(self.where_conditions)}"

if self.group_by:
query += f" GROUP BY {', '.join(self.group_by)}"

if self.order_by:
query += f" ORDER BY {', '.join(self.order_by)}"

if self.limit is not None:
query += f" LIMIT {self.limit}"

return query

class QueryDirector:
@staticmethod
def create_count_query(table, condition=None):
builder = QueryBuilder()
builder.select("COUNT(*)")
builder.from_table(table)

if condition:
builder.where(condition)

return builder.build()

@staticmethod
def create_latest_records_query(table, date_field, limit=10):
return (QueryBuilder()
.select("*")
.from_table(table)
.order_by_fields(f"{date_field} DESC")
.limit_results(limit)
.build())

# Использование
# 1. Прямое использование Builder
query1 = (QueryBuilder()
.select("id", "name", "email")
.from_table("users")
.where("status = 'active'")
.order_by_fields("created_at DESC")
.limit_results(20)
.build())

# 2. Использование через Director
query2 = QueryDirector.create_count_query("orders", "status = 'completed'")
query3 = QueryDirector.create_latest_records_query("articles", "published_at", 5)

class Configuration:
def __init__(self, settings):
self.settings = settings

@classmethod
def from_json(cls, json_path):
import json
with open(json_path, 'r') as f:
settings = json.load(f)
return cls(settings)

@classmethod
def from_yaml(cls, yaml_path):
import yaml
with open(yaml_path, 'r') as f:
settings = yaml.safe_load(f)
return cls(settings)

@classmethod
def from_env_vars(cls, prefix):
import os
settings = {}
for key, value in os.environ.items():
if key.startswith(prefix):
settings[key[len(prefix):].lower()] = value
return cls(settings)

# Использование
config1 = Configuration.from_json("config.json")
config2 = Configuration.from_yaml("config.yaml")
config3 = Configuration.from_env_vars("APP_")

class ReportBuilder:
def __init__(self):
self.report = {
"title": None,
"period": None,
"data_source": None,
"filters": [],
"columns": [],
"sort_by": None,
"group_by": None,
"format": "pdf",
"include_charts": False,
"include_summary": False,
}

def with_title(self, title):
self.report["title"] = title
return self

def for_period(self, start_date, end_date):
self.report["period"] = (start_date, end_date)
return self

def from_data_source(self, source):
self.report["data_source"] = source
return self

def with_filter(self, field, operator, value):
self.report["filters"].append((field, operator, value))
return self

def with_columns(self, *columns):
self.report["columns"].extend(columns)
return self

def sorted_by(self, field, descending=False):
self.report["sort_by"] = (field, descending)
return self

def grouped_by(self, field):
self.report["group_by"] = field
return self

def in_format(self, format_type):
self.report["format"] = format_type
return self

def include_charts(self, include=True):
self.report["include_charts"] = include
return self

def include_summary(self, include=True):
self.report["include_summary"] = include
return self

def build(self):
if not self.report["title"]:
raise ValueError("Report must have a title")

if not self.report["data_source"]:
raise ValueError("Report must have a data source")

return self.report

# Использование
report = (ReportBuilder()
.with_title("Monthly Sales Report")
.for_period("2023-01-01", "2023-01-31")
.from_data_source("sales_db")
.with_filter("region", "=", "North")
.with_columns("date", "product", "quantity", "revenue")
.sorted_by("revenue", descending=True)
.grouped_by("product")
.include_charts()
.in_format("excel")
.build())

from abc import ABC, abstractmethod

class PaymentProcessor(ABC):
@abstractmethod
def process_payment(self, amount):
pass

class CreditCardProcessor(PaymentProcessor):
def __init__(self, card_number, expiry, cvv):
self.card_number = card_number
self.expiry = expiry
self.cvv = cvv

def process_payment(self, amount):
# Логика обработки платежа кредитной картой
return f"Processing ${amount} payment via Credit Card ending with {self.card_number[-4:]}"

class PayPalProcessor(PaymentProcessor):
def __init__(self, email):
self.email = email

def process_payment(self, amount):
# Логика обработки платежа через PayPal
return f"Processing ${amount} payment via PayPal account {self.email}"

class BankTransferProcessor(PaymentProcessor):
def __init__(self, account_number, routing_number):
self.account_number = account_number
self.routing_number = routing_number

def process_payment(self, amount):
# Логика обработки банковского перевода
return f"Processing ${amount} payment via Bank Transfer to account {self.account_number}"

class PaymentProcessorFactory:
@staticmethod
def create_processor(payment_type, **kwargs):
if payment_type == "credit_card":
required = {"card_number", "expiry", "cvv"}
if not required.issubset(kwargs.keys()):
missing = required – set(kwargs.keys())
raise ValueError(f"Missing required parameters for credit card: {missing}")
return CreditCardProcessor(
kwargs["card_number"],
kwargs["expiry"],
kwargs["cvv"]
)
elif payment_type == "paypal":
if "email" not in kwargs:
raise ValueError("Email is required for PayPal")
return PayPalProcessor(kwargs["email"])
elif payment_type == "bank_transfer":
required = {"account_number", "routing_number"}
if not required.issubset(kwargs.keys()):
missing = required – set(kwargs.keys())
raise ValueError(f"Missing required parameters for bank transfer: {missing}")
return BankTransferProcessor(
kwargs["account_number"],
kwargs["routing_number"]
)
else:
raise ValueError(f"Unknown payment type: {payment_type}")

# Использование
cc_processor = PaymentProcessorFactory.create_processor(
"credit_card",
card_number="4111111111111111",
expiry="12/25",
cvv="123"
)

paypal_processor = PaymentProcessorFactory.create_processor(
"paypal",
email="customer@example.com"
)

bank_processor = PaymentProcessorFactory.create_processor(
"bank_transfer",
account_number="12345678",
routing_number="87654321"
)

print(cc_processor.process_payment(99.99))
print(paypal_processor.process_payment(99.99))
print(bank_processor.process_payment(99.99))

# Пример комбинирования Factory Method и Builder

class ReportFactory:
@staticmethod
def create_report(report_type):
if report_type == "sales":
return SalesReportBuilder()
elif report_type == "inventory":
return InventoryReportBuilder()
elif report_type == "financial":
return FinancialReportBuilder()
else:
raise ValueError(f"Unknown report type: {report_type}")

# Использование
sales_report = (ReportFactory.create_report("sales")
.with_title("Q3 Sales Report")
.for_period("2023-07-01", "2023-09-30")
.with_filter("region", "=", "West")
.build())