Singleton、Factory和Observer是Python中常用的三種設計模式，分別用於解決對象實例化、創(chuàng)建抽象和依賴通知問題。 1. Singleton通過確保一個類只有一個實例並提供全局訪問點來協(xié)調系統(tǒng)操作，例如配置管理；2. Factory通過封裝對象創(chuàng)建邏輯使代碼更靈活，便於擴展不同類型的對象創(chuàng)建；3. Observer允許對像在狀態(tài)變化時自動通知依賴對象，適用於事件驅動系統(tǒng)如GUI更新或日誌系統(tǒng)。這些模式有助於提升代碼的可維護性和可擴展性。

When people start learning about software design patterns, they often hear terms like Singleton, Factory, and Observer. These are some of the most commonly used design patterns in Python (and other object-oriented languages), and each solves a specific kind of problem. Let's break down what they are and how to implement them in Python.

What is the Singleton pattern and when should you use it?

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it. This is useful when exactly one object is needed to coordinate actions across a system — for example, a configuration manager or a logging service.

How to implement it in Python:

One simple way is by using a module-level variable since modules are only loaded once. But if you want to stick with classes, here's a basic implementation:

 class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

Now, every time you create an instance of Singleton , it will return the same object.

Note: This is a minimal version. In real-world applications, you might need to handle edge cases like thread safety or subclassing.

How does the Factory pattern help with object creation?

The Factory pattern abstracts the object creation process. Instead of calling a constructor directly, you call a method that returns an instance of a class — possibly based on input parameters. This makes your code more flexible and easier to extend.

Example scenario: You have different types of users (AdminUser, GuestUser), and you want to create the correct user type based on a string input.

 class AdminUser:
    def greet(self):
        return "Hello Admin!"

class GuestUser:
    def greet(self):
        return "Hello Guest!"

def user_factory(user_type):
    if user_type == "admin":
        return AdminUser()
    elif user_type == "guest":
        return GuestUser()

Now, you can create users like this:

 user = user_factory("admin")
print(user.greet()) # Output: Hello Admin!

This keeps object creation logic centralized and clean.

Some benefits:

• Decouples your code from concrete classes.
• Makes adding new types easier without modifying existing code.

Why use the Observer pattern and how does it work?

The Observer pattern allows an object (called the subject) to maintain a list of dependents (observers) and notify them automatically of any state changes. It's especially useful in event-driven systems like GUIs or message queues.

How to implement it in Python:

Here's a simple version:

 class Subject:
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        self._observers.append(observer)

    def detach(self, observer):
        self._observers.remove(observer)

    def notify(self):
        for observer in self._observers:
            observer.update(self)

class Observer:
    def update(self, subject):
        print("Observer got notified!")

# Usage
subject = Subject()
observer1 = Observer()
observer2 = Observer()

subject.attach(observer1)
subject.attach(observer2)

subject.notify()
# Output:
# Observer got notified!
# Observer got notified!

This structure lets you plug in various behaviors that react to changes in the subject.

Use cases include:

• UI updates triggered by data changes.
• Event listeners in frameworks.
• Logging or auditing systems.

Summary

Design patterns like Singleton, Factory, and Observer provide reusable solutions to common problems in object-oriented programming. Using them appropriately can make your code cleaner, more scalable, and easier to maintain.

Each pattern serves a different purpose:

• Singleton : Ensures one instance exists.
• Factory : Abstracts object creation.
• Observer : Enables one-to-many dependency relationships.

They're not overly complex, but knowing when and how to apply them makes a big difference.基本上就這些。

以上是哪些常見的設計模式（例如Singleton，F(xiàn)actory，Observer）以及如何在Python中實施？的詳細內容。更多資訊請關注PHP中文網(wǎng)其他相關文章！