Python中是否有类似Ruby的单例类操作方法？单例模式如何简洁实现？

一、给单个实例添加专属方法（对应 Ruby 的 singleton class） #

在 Python 里，你不需要专门的“单例类”概念，就能直接给单个实例绑定专属方法，实现和 Ruby 中修改实例 singleton class 类似的效果，具体有几种方式：

• 用 types.MethodType 绑定方法
  先定义普通函数，再通过 types.MethodType 将其绑定到目标实例，这个方法就只属于该实例：

  import types
  
  class MyClass:
      pass
  
  def custom_instance_method(self):
      print(f"这个方法只属于实例 {self}")
  
  obj1 = MyClass()
  obj2 = MyClass()
  
  # 仅给 obj1 绑定专属方法
  obj1.my_method = types.MethodType(custom_instance_method, obj1)
  
  obj1.my_method()  # 正常执行
  # obj2.my_method()  # 报错，obj2 没有该方法
  

• lambda 快速绑定简单逻辑
  如果方法逻辑简单，直接用 lambda 赋值给实例属性即可：

  obj1.greet = lambda: print(f"你好，我是实例 {obj1}")
  obj1.greet()
  

• 直接操作实例的 __dict__
  Python 实例的属性都存在 __dict__ 中，直接给它添加方法属性也能实现相同效果：

  obj1.another_method = lambda self=self: print(f"这是 {self} 的另一个专属方法")
  obj1.another_method()
  

二、简洁的单例模式实现 #

如果你的需求是保证一个类始终只有一个实例，Python 有几种极简实现方式：

1. 装饰器实现（灵活复用） #

用装饰器包裹类，控制实例的创建和缓存，这个装饰器可以复用在多个类上：

def singleton(cls):
    instances = {}
    def wrapper(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return wrapper

@singleton
class AppConfig:
    def __init__(self, env):
        self.env = env

# 测试
config1 = AppConfig("dev")
config2 = AppConfig("prod")
print(config1.env)  # 输出 dev
print(config1 is config2)  # 输出 True

2. 重写 __new__ 方法（类内实现） #

直接在类内部重写 __new__ 方法，控制实例的创建逻辑：

class DatabaseConnection:
    _instance = None

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

    def __init__(self, db_url):
        # 避免重复初始化，加个判断
        if not hasattr(self, 'initialized'):
            self.db_url = db_url
            self.initialized = True

conn1 = DatabaseConnection("mysql://localhost:3306/db")
conn2 = DatabaseConnection("postgresql://localhost:5432/db")
print(conn1.db_url)  # 输出 mysql://localhost:3306/db
print(conn1 is conn2)  # 输出 True

3. 模块实现（最简单） #

Python 的模块本身就是天然单例——模块在第一次导入后会被缓存，后续导入的都是同一个实例：

# singleton_module.py
class Logger:
    def __init__(self):
        self.log_file = "app.log"

logger_instance = Logger()

在其他文件中导入使用：

from singleton_module import logger_instance

log1 = logger_instance
log2 = logger_instance
print(log1 is log2)  # 输出 True

这种方式最简洁，适合不需要动态创建实例的场景。

内容的提问来源于stack exchange，提问作者Alex