Python OOP — new, call, and the Singleton Pattern Explained

The Story That Explains These Three Ideas 🚗इन तीन विचारों को समझाने वाली कहानी 🚗一个讲清这三个概念的故事 🚗

__new__ vs __init__ — The Full Lifecycle 🏗️__new__ बनाम __init__ — पूरा Lifecycle 🏗️__new__ vs __init__ — 完整的生命周期 🏗️

When you write Person("Alice", 30), two methods run in order. Almost every class only needs __init__ — Python's default __new__ does the creation quietly. Knowing both is what lets you build singletons and subclasses of immutable built-in types (and, later, metaclasses — an upcoming tutorial).

जब आप Person("Alice", 30) लिखते हैं, तो दो methods क्रम से चलते हैं। लगभग हर class को सिर्फ़ __init__ चाहिए — Python का default __new__ चुपचाप object बना देता है। दोनों को समझकर ही आप singletons और immutable built-in types की subclasses बना पाते हैं (और आगे metaclasses भी — आने वाले tutorial में)।

当你写 Person("Alice", 30) 时，两个方法会依次运行。几乎所有类都只需要 __init__ — Python 默认的 __new__ 会悄悄完成创建。理解这两者，才能写出单例和不可变内置类型的子类（以及之后的元类 — 后续教程）。

class Person:
    def __new__(cls, *args, **kwargs):
        print(f"  [__new__] creating a new Person object")
        instance = super().__new__(cls)      # let object create it for us
        return instance                      # MUST return the new object

    def __init__(self, name, age):
        print(f"  [__init__] filling in name={name!r}, age={age}")
        self.name = name
        self.age  = age

print("Creating Alice:")
alice = Person("Alice", 30)
print()
print("Creating Bob:")
bob = Person("Bob", 25)

👣 Simulator: Object Birth, Step by Step👣 Simulator: Object का जन्म, क़दम-दर-क़दम👣 模拟器：对象的诞生 · 逐步演示

Recorded with sys.settrace. Watch the call stack: first __new__ (with cls, no self), then __init__ (with self). Then try the two broken versions — when __new__ does not return a Person, __init__ never runs.

sys.settrace से रिकॉर्ड किया हुआ। Call stack देखिए: पहले __new__ (cls के साथ, self नहीं), फिर __init__ (self के साथ)। फिर दोनों टूटे versions आज़माइए — जब __new__ Person नहीं लौटाता, तो __init__ कभी नहीं चलता।

用 sys.settrace 录制。观察调用栈：先是 __new__（有 cls，没有 self），然后是 __init__（有 self）。再试试两个有问题的版本 — 当 __new__ 没有返回 Person 时，__init__ 根本不会运行。

When Do You Actually Override __new__? 🤔__new__ को असल में कब override करें? 🤔什么时候才需要重写 __new__？🤔

Almost no Python class touches __new__ — the default handles it. You reach for it only when you need to control which object comes back, or when you subclass an immutable built-in type.

लगभग कोई Python class __new__ को नहीं छूती — default काम कर देता है। इसकी ज़रूरत तभी पड़ती है जब आपको तय करना हो कि कौन-सा object लौटे, या जब आप किसी immutable built-in type की subclass बनाएँ।

几乎没有 Python 类会去碰 __new__ — 默认实现就够了。只有当你需要控制返回 哪个 对象，或者要继承不可变的内置类型时，才会用到它。

__call__ — Making an Instance Callable 📞__call__ — Instance को Callable बनाना 📞__call__ — 让实例可以被调用 📞

Functions are callable — len(), print(), your own calculate(). Objects usually are not. Defining __call__ changes that: now you can call your object with (), just like a function.

Functions callable होते हैं — len(), print(), आपका अपना calculate()। Objects आमतौर पर नहीं होते। __call__ define करने से यह बदल जाता है: अब आप अपने object को () से बुला सकते हैं, ठीक function की तरह।

函数是可调用的 — len()、print()、你自己的 calculate()。对象通常 不是。定义 __call__ 就改变了这一点：现在你可以像调用函数一样用 () 调用你的对象。

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    # -- This makes the instance callable --
    def __call__(self, x):
        return x * self.factor


double = Multiplier(2)
triple = Multiplier(3)

# Instances now behave like functions
print(double(10))    # 20   <- calls double.__call__(10)
print(triple(10))    # 30   <- calls triple.__call__(10)

# They can even be passed anywhere a function is expected
print(list(map(double, [1, 2, 3])))   # [2, 4, 6]

# They remain OBJECTS - you can inspect and change state
print(double.factor)          # 2
double.factor = 5
print(double(10))            # 50   <- same instance, new behaviour

🛠️ Simulator: Callable Workshop🛠️ Simulator: Callable Workshop🛠️ 模拟器：可调用对象工坊

Pick one of the three callable classes from this tutorial and press the buttons to run lines. Watch obj(…) turn into obj.__call__(…), and watch the object's own state change between calls. Checked against Python on 300 random sequences.

इस tutorial की तीन callable classes में से एक चुनिए और lines चलाने के लिए buttons दबाइए। देखिए obj(…) कैसे obj.__call__(…) बनता है, और calls के बीच object की अपनी state कैसे बदलती है। 300 random sequences पर Python से जाँचा गया।

从本教程的三个可调用类中选一个，按按钮运行代码。观察 obj(…) 如何变成 obj.__call__(…)，以及对象自身的状态在多次调用之间如何变化。已在 300 个随机序列上与 Python 对照。

Why Callable Classes Instead of Just Functions? 🤷सिर्फ़ Functions की जगह Callable Classes क्यों? 🤷为什么用可调用类而不只用函数？🤷

Common patterns that benefit from __call__:

__call__ से फ़ायदा पाने वाले आम patterns:

受益于 __call__ 的常见模式：

The Singleton Pattern — One Instance, Reused Forever ☀️Singleton Pattern — एक Instance, हमेशा दोबारा ☀️单例模式 — 只有一个实例，永远复用 ☀️

A singleton is a class that only ever produces one object. However many times you call Config(), you get the same Config object. It suits app-wide things — settings, database connections, logging, caches.

Singleton ऐसी class है जो हमेशा एक ही object बनाती है। Config() कितनी भी बार बुलाइए, वही Config object मिलता है। यह पूरे app की चीज़ों के लिए ठीक है — settings, database connections, logging, caches।

单例 是只会产生 一个对象 的类。无论调用 Config() 多少次，得到的都是 同一个 Config 对象。它适合全应用共享的东西 — 配置、数据库连接、日志、缓存。

class Config:
    _instance = None                       # class variable - the "one and only" slot

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            print("  [__new__] first call — creating THE instance")
            cls._instance = super().__new__(cls)
        else:
            print("  [__new__] already exists — returning the same instance")
        return cls._instance

    def __init__(self, filename=None):
        # NOTE: __init__ runs on EVERY Config(...) call - beware of overwriting
        if filename is not None:
            self.filename = filename


print("First call:")
a = Config("app.ini")

print("\nSecond call:")
b = Config()

print("\nThird call:")
c = Config("override.ini")

print()
print("a is b:", a is b)           # True - literally the same object
print("b is c:", b is c)           # True
print("a.filename:", a.filename)   # override.ini (the last __init__ overwrote it)

A Safer Singleton — Guard __init__ Too 🛡️सुरक्षित Singleton — __init__ को भी बचाएँ 🛡️更安全的单例 — 也要保护 __init__ 🛡️

Because __init__ runs on every construction call, you often want a flag so the real setup runs only once. This "initialised once" pattern is used in most real singletons.

क्योंकि __init__ हर बार object बनाने की call पर चलता है, अक्सर एक flag चाहिए ताकि असली setup सिर्फ़ एक बार चले। ज़्यादातर असली singletons में यही "एक बार initialise" pattern होता है।

由于 __init__ 在每次构造调用时都会运行，通常需要一个标志，让真正的初始化只执行一次。大多数真实的单例都使用这种"只初始化一次"的模式。

class ConfigManager:
    _instance = None
    _initialized = False

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

    def __init__(self, filename="app.ini"):
        # Guard: don't re-run on later construction calls
        if ConfigManager._initialized:
            return
        print(f"Loading {filename} — this runs ONCE")
        self.filename = filename
        self.settings = {"debug": True, "version": "2.4"}
        ConfigManager._initialized = True


a = ConfigManager("app.ini")             # prints "Loading app.ini..."
b = ConfigManager("different.ini")       # silent - already initialised

print(a.filename)                        # app.ini (still the first value)
print(a is b)                            # True

☀️ Simulator: Singleton Lab☀️ Simulator: Singleton Lab☀️ 模拟器：单例实验室

Press the call buttons to create up to six names. Compare three versions of Config: a normal class, the plain singleton from Section 06, and the guarded one from this section. Watch where each name points and what filename ends up as. Checked against Python on 300 random sequences.

Call buttons दबाकर छह तक नाम बनाइए। Config के तीन versions की तुलना कीजिए: सामान्य class, Section 06 वाला सादा singleton, और इस section वाला guarded singleton। देखिए हर नाम कहाँ इशारा करता है और filename आख़िर में क्या बनता है। 300 random sequences पर Python से जाँचा गया।

按调用按钮，最多创建六个名字。比较 Config 的三个版本：普通类、第 06 节的简单单例，以及本节带防护的单例。观察每个名字指向哪里，以及 filename 最终是什么。已在 300 个随机序列上与 Python 对照。

Alternative Singleton Patterns 🔀Singleton के दूसरे Patterns 🔀其他单例写法 🔀

The __new__ approach is the most direct, but Python offers other ways to get the same effect. Each suits a different style.

__new__ वाला तरीक़ा सबसे सीधा है, पर Python यही असर पाने के दूसरे तरीक़े भी देता है। हर एक अलग style के लिए ठीक है।

__new__ 的方式最直接，但 Python 还提供了其他方式来达到同样的效果，各自适合不同的风格。

Pattern 1 — DecoratorPattern 1 — Decorator写法 1 — 装饰器

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


@singleton
class Database:
    def __init__(self, host):
        self.host = host

db1 = Database("localhost")
db2 = Database("other-host")
print(db1 is db2)   # True
print(db1.host)     # localhost (the second call was ignored)
print(Database)     # the name now points to the wrapper function, not the class

Pattern 2 — Module-Level (the Pythonic Default)Pattern 2 — Module-Level (Pythonic default)写法 2 — 模块级（Python 风格的默认做法）

# In config.py - the module itself IS the singleton
settings = {"debug": True, "version": "2.4"}

def get(key):
    return settings.get(key)

# Anywhere else:
# from config import settings, get
# Every import gets the same module -> the same settings dict - a natural singleton

Practical Example — A Callable Counter With State 🔢Practical Example — State वाला Callable Counter 🔢实战示例 — 带状态的可调用计数器 🔢

A class that acts like a function but remembers how many times it has been called. A classic __call__ use. Try it in the Callable Workshop (Section 04) with Counter().

ऐसी class जो function की तरह चलती है पर याद रखती है कि उसे कितनी बार बुलाया गया। __call__ का क्लासिक इस्तेमाल। Callable Workshop (Section 04) में Counter() से आज़माइए।

一个像函数一样工作、却能记住自己被调用了多少次的类。这是 __call__ 的经典用法。到可调用对象工坊（第 04 节）选 Counter() 试试。

class Counter:
    def __init__(self, start=0):
        self.count = start

    def __call__(self):
        self.count += 1
        return self.count

    def reset(self):
        self.count = 0

    def __repr__(self):
        return f"Counter(count={self.count})"


c = Counter()
print(c())     # 1  <- called like a function
print(c())     # 2
print(c())     # 3

# Still an object - you can inspect and reset
print(c)       # Counter(count=3)
c.reset()
print(c())     # 1 (started over)

# Several independent counters - each carries its own state
hits    = Counter()
misses  = Counter()
hits(); hits(); hits()
misses()
print(f"hits={hits.count}, misses={misses.count}")   # hits=3, misses=1

Practical Example — A Callable Validator ✅Practical Example — Callable Validator ✅实战示例 — 可调用的校验器 ✅

Combine __call__ with settings stored in __init__ to build small, reusable validation objects. Set up once, call anywhere.

__call__ को __init__ में रखी settings के साथ मिलाकर छोटे, दोबारा इस्तेमाल होने वाले validation objects बनाइए। एक बार set up, कहीं भी call।

把 __call__ 和 __init__ 中保存的配置结合起来，构建小巧、可复用的校验对象。配置一次，随处调用。

class MinLengthValidator:
    def __init__(self, min_length):
        self.min_length = min_length

    def __call__(self, value):
        # Uses the setting from __init__ every time it is called
        if len(value) < self.min_length:
            raise ValueError(
                f"{value!r} must be at least {self.min_length} chars"
            )
        return value


# Build once, use everywhere
username_valid = MinLengthValidator(3)
password_valid = MinLengthValidator(8)

# Call the instances like functions
print(username_valid("alice"))       # alice
print(password_valid("SecureP@ss"))  # SecureP@ss

try:
    password_valid("abc")
except ValueError as e:
    print("Blocked:", e)

# A callable object can be passed to higher-order functions like map()
inputs = ["alice", "bob", "chandra"]
valid_names = list(map(username_valid, inputs))
print(valid_names)

Common Mistakes (and Fixes) 🩹आम ग़लतियाँ (और उनके हल) 🩹常见错误（及修正）🩹

🩺 Simulator: Bug Doctor🩺 Simulator: Bug Doctor🩺 模拟器：Bug 医生

Five of these mistakes, run for real. Buggy code on the left, fixed code on the right, changed lines marked.

इनमें से पाँच ग़लतियाँ, असली run में। बाईं ओर buggy code, दाईं ओर ठीक किया हुआ, बदली lines चिह्नित।

其中五个错误的真实运行。左边是有 bug 的代码，右边是修正后的代码，改动的行已标出。

Quick Reference 📋Quick Reference 📋速查表 📋

Golden Rules and Quiz 🏆सुनहरे नियम और Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题