21. september 2025Dansk

Udforsk Python skabende designmønstre: Singleton, Factory, Abstract Factory, Builder og Prototype. Lær deres implementeringer, fordele og applikationer.

Python Design Patterns: En dybdegående undersøgelse af skabende designmønstre

Designmønstre er genanvendelige løsninger på almindeligt forekommende problemer inden for software design. De giver en skabelon for, hvordan man løser disse problemer, og fremmer genbrug af kode, vedligeholdelse og fleksibilitet. Skabende designmønstre omhandler specifikt objektets oprettelsesmekanismer og forsøger at oprette objekter på en måde, der passer til situationen. Denne artikel giver en omfattende udforskning af skabende designmønstre i Python, herunder detaljerede forklaringer, kodeeksempler og praktiske applikationer, der er relevante for et globalt publikum.

Hvad er skabende designmønstre?

Skabende designmønstre abstraherer instansieringsprocessen. De afkobler klientkoden fra de specifikke klasser, der instansieres, hvilket giver større fleksibilitet og kontrol over objektoprettelsen. Ved at bruge disse mønstre kan du oprette objekter uden at specificere den nøjagtige klasse af objekt, der skal oprettes. Denne adskillelse af ansvarsområder gør koden mere robust og lettere at vedligeholde.

Det primære mål med skabende mønstre er at abstrahere objektets instansieringsproces og skjule kompleksiteten ved objektoprettelse fra klienten. Dette giver udviklere mulighed for at fokusere på den overordnede logik i deres applikationer uden at blive tynget af de små detaljer i objektoprettelsen.

Typer af skabende designmønstre

Vi vil dække følgende skabende designmønstre i denne artikel:

Singleton: Sikrer, at en klasse kun har én instans og giver et globalt adgangspunkt til den.
Factory Method: Definerer en grænseflade til oprettelse af et objekt, men lader underklasser bestemme, hvilken klasse der skal instansieres.
Abstract Factory: Giver en grænseflade til oprettelse af familier af relaterede eller afhængige objekter uden at specificere deres konkrete klasser.
Builder: Adskiller konstruktionen af et komplekst objekt fra dets repræsentation, hvilket giver den samme konstruktionsproces mulighed for at skabe forskellige repræsentationer.
Prototype: Specificerer, hvilken type objekter der skal oprettes ved hjælp af en prototypisk instans, og opretter nye objekter ved at kopiere denne prototype.

1. Singleton Pattern

Singleton-mønsteret sikrer, at en klasse kun har én instans og giver et globalt adgangspunkt til den. Dette mønster er nyttigt, når der er brug for præcis ét objekt til at koordinere handlinger på tværs af systemet. Det bruges ofte til administration af ressourcer, logning eller konfigurationsindstillinger.

Implementering

Her er en Python-implementering af Singleton-mønsteret:

            
class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

# Eksempel på brug
s1 = Singleton()
s2 = Singleton()

print(s1 is s2) # Output: True

Forklaring:

_instance: Denne klassevariabel gemmer den enkelte instans af klassen.
__new__: Denne metode kaldes før __init__, når et objekt oprettes. Den kontrollerer, om der allerede findes en instans. Hvis ikke, opretter den en ny instans ved hjælp af super().__new__(cls) og gemmer den i _instance. Hvis der allerede findes en instans, returnerer den den eksisterende instans.

Anvendelsestilfælde

Databaseforbindelse: Sikring af, at kun én forbindelse til en database er åben ad gangen.
Konfigurationsstyring: Tilvejebringelse af et enkelt adgangspunkt til applikationskonfigurationsindstillinger.
Logger: Oprettelse af en enkelt logningsinstans til at håndtere alle logningsoperationer i applikationen.

Eksempel

Lad os overveje et simpelt eksempel på en konfigurationsstyring implementeret ved hjælp af Singleton-mønsteret:

            
class ConfigurationManager(Singleton):
    def __init__(self):
        if not hasattr(self, 'config'): # Sørg for, at __init__ kun kaldes én gang
            self.config = {}

    def set_config(self, key, value):
        self.config[key] = value

    def get_config(self, key):
        return self.config.get(key)

# Eksempel på brug
config_manager1 = ConfigurationManager()
config_manager1.set_config('database_url', 'localhost:5432')

config_manager2 = ConfigurationManager()
print(config_manager2.get_config('database_url')) # Output: localhost:5432

2. Factory Method Pattern

Factory Method-mønsteret definerer en grænseflade til oprettelse af et objekt, men lader underklasser bestemme, hvilken klasse der skal instansieres. Factory Method lader en klasse udskyde instansiering til underklasser. Dette mønster fremmer løs kobling og giver dig mulighed for at tilføje nye produkttyper uden at ændre eksisterende kode.

Implementering

Her er en Python-implementering af Factory Method-mønsteret:

            
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class AnimalFactory(ABC):
    @abstractmethod
    def create_animal(self):
        pass

class DogFactory(AnimalFactory):
    def create_animal(self):
        return Dog()

class CatFactory(AnimalFactory):
    def create_animal(self):
        return Cat()

# Klientkode
def get_animal(factory: AnimalFactory):
    animal = factory.create_animal()
    return animal.speak()


dog_sound = get_animal(DogFactory())
cat_sound = get_animal(CatFactory())

print(f"Dog says: {dog_sound}") # Output: Dog says: Woof!
print(f"Cat says: {cat_sound}") # Output: Cat says: Meow!

Forklaring:

Animal: En abstrakt basisklasse, der definerer grænsefladen for alle dyretyper.
Dog og Cat: Konkrete klasser, der implementerer Animal-grænsefladen.
AnimalFactory: En abstrakt basisklasse, der definerer grænsefladen til oprettelse af dyr.
DogFactory og CatFactory: Konkrete klasser, der implementerer AnimalFactory-grænsefladen, der er ansvarlige for at oprette henholdsvis Dog- og Cat-instanser.
get_animal: En klientfunktion, der bruger fabrikken til at oprette og bruge et dyr.

Anvendelsestilfælde

UI-rammer: Oprettelse af platformspecifikke UI-elementer (f.eks. knapper, tekstfelter) ved hjælp af forskellige fabrikker til forskellige operativsystemer.
Spiludvikling: Oprettelse af forskellige typer spilkarakterer eller objekter baseret på spilniveau eller brugervalg.
Dokumentbehandling: Oprettelse af forskellige typer dokumenter (f.eks. PDF, Word, HTML) ved hjælp af forskellige fabrikker baseret på det ønskede outputformat.

Eksempel

Overvej et scenario, hvor du vil oprette forskellige typer betalingsmetoder baseret på brugerens valg. Her er, hvordan du kan implementere dette ved hjælp af Factory Method-mønsteret:

            
from abc import ABC, abstractmethod

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

class CreditCardPayment(Payment):
    def process_payment(self, amount):
        return f"Processing credit card payment of ${amount}"

class PayPalPayment(Payment):
    def process_payment(self, amount):
        return f"Processing PayPal payment of ${amount}"

class PaymentFactory(ABC):
    @abstractmethod
    def create_payment_method(self):
        pass

class CreditCardPaymentFactory(PaymentFactory):
    def create_payment_method(self):
        return CreditCardPayment()

class PayPalPaymentFactory(PaymentFactory):
    def create_payment_method(self):
        return PayPalPayment()

# Klientkode
def process_payment(factory: PaymentFactory, amount):
    payment_method = factory.create_payment_method()
    return payment_method.process_payment(amount)


credit_card_payment = process_payment(CreditCardPaymentFactory(), 100)
paypal_payment = process_payment(PayPalPaymentFactory(), 50)

print(credit_card_payment) # Output: Processing credit card payment of $100
print(paypal_payment) # Output: Processing PayPal payment of $50

3. Abstract Factory Pattern

Abstract Factory-mønsteret giver en grænseflade til oprettelse af familier af relaterede eller afhængige objekter uden at specificere deres konkrete klasser. Det giver dig mulighed for at oprette objekter, der er designet til at fungere sammen, hvilket sikrer konsistens og kompatibilitet.

Implementering

Her er en Python-implementering af Abstract Factory-mønsteret:

            
from abc import ABC, abstractmethod

class Button(ABC):
    @abstractmethod
    def paint(self):
        pass

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

class GUIFactory(ABC):
    @abstractmethod
    def create_button(self):
        pass

    @abstractmethod
    def create_checkbox(self):
        pass

class WinFactory(GUIFactory):
    def create_button(self):
        return WinButton()

    def create_checkbox(self):
        return WinCheckbox()

class MacFactory(GUIFactory):
    def create_button(self):
        return MacButton()

    def create_checkbox(self):
        return MacCheckbox()

class WinButton(Button):
    def paint(self):
        return "Rendering a Windows button"

class MacButton(Button):
    def paint(self):
        return "Rendering a Mac button"

class WinCheckbox(Checkbox):
    def paint(self):
        return "Rendering a Windows checkbox"

class MacCheckbox(Checkbox):
    def paint(self):
        return "Rendering a Mac checkbox"

# Klientkode
def paint_ui(factory: GUIFactory):
    button = factory.create_button()
    checkbox = factory.create_checkbox()
    return button.paint(), checkbox.paint()

win_button, win_checkbox = paint_ui(WinFactory())
mac_button, mac_checkbox = paint_ui(MacFactory())

print(win_button) # Output: Rendering a Windows button
print(win_checkbox) # Output: Rendering a Windows checkbox
print(mac_button) # Output: Rendering a Mac button
print(mac_checkbox) # Output: Rendering a Mac checkbox

Forklaring:

Button og Checkbox: Abstrakte basisklasser, der definerer grænsefladerne til UI-elementer.
WinButton, MacButton, WinCheckbox og MacCheckbox: Konkrete klasser, der implementerer UI-elementgrænsefladerne til Windows- og Mac-platforme.
GUIFactory: En abstrakt basisklasse, der definerer grænsefladen til oprettelse af familier af UI-elementer.
WinFactory og MacFactory: Konkrete klasser, der implementerer GUIFactory-grænsefladen, der er ansvarlige for at oprette UI-elementer til henholdsvis Windows- og Mac-platforme.
paint_ui: En klientfunktion, der bruger fabrikken til at oprette og male UI-elementer.

Anvendelsestilfælde

UI-rammer: Oprettelse af UI-elementer, der er konsistente med udseendet og funktionaliteten af et specifikt operativsystem eller en platform.
Spiludvikling: Oprettelse af spilobjekter, der er konsistente med stilen i et specifikt spilniveau eller tema.
Dataadgang: Oprettelse af dataadgangsobjekter, der er kompatible med en specifik database eller datakilde.

Eksempel

Overvej et scenario, hvor du vil oprette forskellige typer møbler (f.eks. stole, borde) med forskellige stilarter (f.eks. moderne, victoriansk). Her er, hvordan du kan implementere dette ved hjælp af Abstract Factory-mønsteret:

            
from abc import ABC, abstractmethod

class Chair(ABC):
    @abstractmethod
    def create(self):
        pass

class Table(ABC):
    @abstractmethod
    def create(self):
        pass

class FurnitureFactory(ABC):
    @abstractmethod
    def create_chair(self):
        pass

    @abstractmethod
    def create_table(self):
        pass

class ModernFurnitureFactory(FurnitureFactory):
    def create_chair(self):
        return ModernChair()

    def create_table(self):
        return ModernTable()

class VictorianFurnitureFactory(FurnitureFactory):
    def create_chair(self):
        return VictorianChair()

    def create_table(self):
        return VictorianTable()

class ModernChair(Chair):
    def create(self):
        return "Creating a modern chair"

class VictorianChair(Chair):
    def create(self):
        return "Creating a Victorian chair"

class ModernTable(Table):
    def create(self):
        return "Creating a modern table"

class VictorianTable(Table):
    def create(self):
        return "Creating a Victorian table"

# Klientkode
def create_furniture(factory: FurnitureFactory):
    chair = factory.create_chair()
    table = factory.create_table()
    return chair.create(), table.create()


modern_chair, modern_table = create_furniture(ModernFurnitureFactory())
victorian_chair, victorian_table = create_furniture(VictorianFurnitureFactory())

print(modern_chair) # Output: Creating a modern chair
print(modern_table) # Output: Creating a modern table
print(victorian_chair) # Output: Creating a Victorian chair
print(victorian_table) # Output: Creating a Victorian table

4. Builder Pattern

Builder-mønsteret adskiller konstruktionen af et komplekst objekt fra dets repræsentation, hvilket giver den samme konstruktionsproces mulighed for at skabe forskellige repræsentationer. Det er nyttigt, når du har brug for at oprette komplekse objekter med flere valgfrie komponenter og vil undgå at oprette et stort antal konstruktører eller konfigurationsparametre.

Implementering

Her er en Python-implementering af Builder-mønsteret:

            
class Pizza:
    def __init__(self):
        self.dough = None
        self.sauce = None
        self.topping = None

    def __str__(self):
        return f"Pizza with dough: {self.dough}, sauce: {self.sauce}, and topping: {self.topping}"

class PizzaBuilder:
    def __init__(self):
        self.pizza = Pizza()

    def set_dough(self, dough):
        self.pizza.dough = dough
        return self

    def set_sauce(self, sauce):
        self.pizza.sauce = sauce
        return self

    def set_topping(self, topping):
        self.pizza.topping = topping
        return self

    def build(self):
        return self.pizza

# Klientkode
pizza_builder = PizzaBuilder()
pizza = pizza_builder.set_dough("Thin crust").set_sauce("Tomato").set_topping("Pepperoni").build()

print(pizza) # Output: Pizza with dough: Thin crust, sauce: Tomato, and topping: Pepperoni

Forklaring:

Pizza: En klasse, der repræsenterer det komplekse objekt, der skal bygges.
PizzaBuilder: En builder-klasse, der indeholder metoder til at indstille de forskellige komponenter i Pizza-objektet.

Anvendelsestilfælde

Dokumentgenerering: Oprettelse af komplekse dokumenter (f.eks. rapporter, fakturaer) med forskellige sektioner og formateringsmuligheder.
Spiludvikling: Oprettelse af komplekse spilobjekter (f.eks. karakterer, niveauer) med forskellige attributter og komponenter.
Databehandling: Oprettelse af komplekse datastrukturer (f.eks. grafer, træer) med forskellige noder og relationer.

Eksempel

Overvej et scenario, hvor du vil bygge forskellige typer computere med forskellige komponenter (f.eks. CPU, RAM, lager). Her er, hvordan du kan implementere dette ved hjælp af Builder-mønsteret:

            
class Computer:
    def __init__(self):
        self.cpu = None
        self.ram = None
        self.storage = None
        self.graphics_card = None

    def __str__(self):
        return f"Computer with CPU: {self.cpu}, RAM: {self.ram}, Storage: {self.storage}, Graphics Card: {self.graphics_card}"

class ComputerBuilder:
    def __init__(self):
        self.computer = Computer()

    def set_cpu(self, cpu):
        self.computer.cpu = cpu
        return self

    def set_ram(self, ram):
        self.computer.ram = ram
        return self

    def set_storage(self, storage):
        self.computer.storage = storage
        return self

    def set_graphics_card(self, graphics_card):
        self.computer.graphics_card = graphics_card
        return self

    def build(self):
        return self.computer

# Klientkode
computer_builder = ComputerBuilder()
computer = computer_builder.set_cpu("Intel i7").set_ram("16GB").set_storage("1TB SSD").set_graphics_card("Nvidia RTX 3080").build()

print(computer)
# Output: Computer with CPU: Intel i7, RAM: 16GB, Storage: 1TB SSD, Graphics Card: Nvidia RTX 3080

5. Prototype Pattern

Prototype-mønsteret specificerer, hvilken type objekter der skal oprettes ved hjælp af en prototypisk instans, og opretter nye objekter ved at kopiere denne prototype. Det giver dig mulighed for at oprette nye objekter ved at klone et eksisterende objekt og undgå behovet for at oprette objekter fra bunden. Dette kan være nyttigt, når det er dyrt eller kompliceret at oprette objekter.

Implementering

Her er en Python-implementering af Prototype-mønsteret:

            
import copy

class Prototype:
    def __init__(self):
        self._objects = {}

    def register_object(self, name, obj):
        self._objects[name] = obj

    def unregister_object(self, name):
        del self._objects[name]

    def clone(self, name, **attrs):
        obj = copy.deepcopy(self._objects.get(name))
        if attrs:
            obj.__dict__.update(attrs)
        return obj

class Car:
    def __init__(self):
        self.name = ""
        self.color = ""
        self.options = []

    def __str__(self):
        return f"Car: Name={self.name}, Color={self.color}, Options={self.options}"

# Klientkode
prototype = Prototype()
car = Car()
car.name = "Generic Car"
car.color = "White"
car.options = ["AC", "GPS"]

prototype.register_object("generic", car)

car1 = prototype.clone("generic", name="Sports Car", color="Red", options=["AC", "GPS", "Spoiler"])
car2 = prototype.clone("generic", name="Family Car", color="Blue", options=["AC", "GPS", "Sunroof"])

print(car1)
# Output: Car: Name=Sports Car, Color=Red, Options=['AC', 'GPS', 'Spoiler']
print(car2)
# Output: Car: Name=Family Car, Color=Blue, Options=['AC', 'GPS', 'Sunroof']

Forklaring:

Prototype: En klasse, der administrerer prototyperne og giver en metode til at klone dem.
Car: En klasse, der repræsenterer det objekt, der skal klones.

Anvendelsestilfælde

Spiludvikling: Oprettelse af spilobjekter, der ligner hinanden, såsom fjender eller power-ups.
Dokumentbehandling: Oprettelse af dokumenter, der er baseret på en skabelon.
Konfigurationsstyring: Oprettelse af konfigurationsobjekter, der er baseret på en standardkonfiguration.

Eksempel

Overvej et scenario, hvor du vil oprette forskellige typer medarbejdere med forskellige attributter (f.eks. navn, rolle, afdeling). Her er, hvordan du kan implementere dette ved hjælp af Prototype-mønsteret:

            
import copy

class Employee:
    def __init__(self):
        self.name = None
        self.role = None
        self.department = None

    def __str__(self):
        return f"Employee: Name={self.name}, Role={self.role}, Department={self.department}"

class Prototype:
    def __init__(self):
        self._objects = {}

    def register_object(self, name, obj):
        self._objects[name] = obj

    def unregister_object(self, name):
        del self._objects[name]

    def clone(self, name, **attrs):
        obj = copy.deepcopy(self._objects.get(name))
        if attrs:
            obj.__dict__.update(attrs)
        return obj


# Klientkode
prototype = Prototype()
employee = Employee()
employee.name = "Generic Employee"
employee.role = "Developer"
employee.department = "IT"

prototype.register_object("generic", employee)

employee1 = prototype.clone("generic", name="John Doe", role="Senior Developer")
employee2 = prototype.clone("generic", name="Jane Smith", role="Project Manager", department="Management")

print(employee1)
# Output: Employee: Name=John Doe, Role=Senior Developer, Department=IT
print(employee2)
# Output: Employee: Name=Jane Smith, Role=Project Manager, Department=Management

Konklusion

Skabende designmønstre giver stærke værktøjer til styring af objektoprettelse på en fleksibel og vedligeholdelsesvenlig måde. Ved at forstå og anvende disse mønstre kan du skrive renere og mere robust kode, der er lettere at udvide og tilpasse til ændrede krav. Denne artikel har udforsket fem vigtige skabende mønstre - Singleton, Factory Method, Abstract Factory, Builder og Prototype - med praktiske eksempler og virkelige anvendelsestilfælde. Beherskelse af disse mønstre er et vigtigt skridt i at blive en dygtig Python-udvikler.

Husk, at valget af det rigtige mønster afhænger af det specifikke problem, du forsøger at løse. Overvej kompleksiteten af objektoprettelsen, behovet for fleksibilitet og potentialet for fremtidige ændringer, når du vælger et skabende mønster til dit projekt. Ved at gøre det kan du udnytte styrken i designmønstre til at skabe elegante og effektive løsninger på almindelige software design udfordringer.