Python 中的私有构造函数

Question

如何创建一个私有构造函数，该构造函数只能由类的静态函数调用，而不是从其他地方调用？

Answer 1

class MongoConn(object):
    @classmethod
    def instance(cls):
        if not hasattr(cls, '_instance'):
            cls._instance = cls()
        return cls._instance

    def __init__(self):
        assert not hasattr(self.__class__, '_instance'), 'Do not call constructor directly!'

如果您想要单个实例。

Answer 2

_ 和 __ 前缀不提供将对象实例化限制到特定“工厂”的解决方案，但是 Python 是一个强大的工具箱，所需的行为可以是通过不止一种方式实现（正如 Z 的 @Jesse W 所证明的那样）。
这是一个可能的解决方案，可以使类保持公开可见（允许 isinstance 等），但确保只能通过类方法进行构造：

class OnlyCreatable(object):

    __create_key = object()

    @classmethod
    def create(cls, value):
        return OnlyCreatable(cls.__create_key, value)

    def __init__(self, create_key, value):
        assert(create_key == OnlyCreatable.__create_key), \
            "OnlyCreatable objects must be created using OnlyCreatable.create"
        self.value = value

使用 create 类构造对象 -方法：

>>> OnlyCreatable.create("I'm a test") 
<__main__.OnlyCreatable object at 0x1023a6f60>

尝试在不使用 create 类方法的情况下构造对象时，由于断言，创建失败：

>>> OnlyCreatable(0, "I'm a test")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 11, in __init__
AssertionError: OnlyCreatable objects can only be created using OnlyCreatable.create

如果尝试通过模仿 create 类方法来创建对象
由于 OnlyCreatable.__createKey 的编译器损坏，创建失败。

>>> OnlyCreatable(OnlyCreatable.__createKey, "I'm a test")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'OnlyCreatable' has no attribute '__createKey'

在类方法之外构造 OnlyCreatable 的唯一方法是了解 OnlyCreatable.__create_key 的值。由于该类属性的值是在运行时生成的，并且其名称以 __ 为前缀，将其标记为不可访问，因此实际上“不可能”获取该值和/或构造对象。

Answer 3

如何创建私有构造函数？

从本质上讲，这是不可能，因为 python 并不像您来自其他 OOP 语言时所想象的那样使用构造函数，而且因为 python 不强制隐私，它只是有一个特定的语法来建议给定的方法/属性应该被视为私有的。让我详细说明一下...

首先：您可以在 python 中找到的最接近构造函数的是 __new__ 方法 但这很少使用（通常使用 __init__ ，它修改刚刚创建的对象（实际上它已经有 self作为第一个参数）。

无论如何，Python 是基于每个人都是一个假设的。 同意成人，因此私有/公共并不像其他一些

响应者提到的那样强制执行，意味着“私有”的方法通常前面加上一个或两个下划线：<。 code>_private 或 __private 两者的区别在于后者会打乱方法的名称，因此您将无法从对象实例化外部调用它，而前者没有。

例如，如果您的类 A 定义了 _private(self) 和 __private(self)：

>>> a = A()
>>> a._private()   # will work
>>> a.__private()  # will raise an exception

您通常希望使用单个下划线，如下所示- 特别是对于单元测试 - 有双下划线会让事情变得非常棘手......

HTH！

Answer 4

尽管 Python 中不存在严格的私有属性，但您可以使用元类来防止使用 MyClass() 语法来创建 MyClass 对象。

以下是改编自 Trio 项目的示例：

from typing import Type, Any, TypeVar


T = TypeVar("T")


class NoPublicConstructor(type):
    """Metaclass that ensures a private constructor

    If a class uses this metaclass like this:

        class SomeClass(metaclass=NoPublicConstructor):
            pass

    If you try to instantiate your class (`SomeClass()`),
    a `TypeError` will be thrown.
    """

    def __call__(cls, *args, **kwargs):
        raise TypeError(
            f"{cls.__module__}.{cls.__qualname__} has no public constructor"
        )

    def _create(cls: Type[T], *args: Any, **kwargs: Any) -> T:
        return super().__call__(*args, **kwargs)  # type: ignore

这是一个使用示例：

from math import cos, sin


class Point(metaclass=NoPublicConstructor):
     def __init__(self, x, y):
         self.x = x
         self.y = y

     @classmethod
     def from_cartesian(cls, x, y):
         return cls._create(x, y)
     
     @classmethod
     def from_polar(cls, rho, phi):
         return cls._create(rho * cos(phi), rho * sin(phi))

Point(1, 2) # raises a type error
Point.from_cartesian(1, 2) # OK
Point.from_polar(1, 2) # OK

Answer 5

您可以对哪些名称在哪些范围内可见有相当大的控制权——并且有很多可用的范围。这里有两种三种其他方法来将类的构造限制为工厂方法：

#Define the class within the factory method
def factory():
  class Foo:
    pass
  return Foo()

OR

#Assign the class as an attribute of the factory method
def factory():
  return factory.Foo()
class Foo:
  pass
factory.Foo = Foo
del Foo

（注意：这仍然允许从外部引用该类（对于isinstance 检查，例如），但很明显您不应该直接实例化它。）

或者

#Assign the class to a local variable of an outer function
class Foo:
  pass
def factory_maker():
  inner_Foo=Foo
  def factory():
    return inner_Foo()
  return factory
factory = factory_maker()
del Foo
del factory_maker

这使得它不可能（至少，不使用至少一个神奇的（双下划线）属性）来访问Foo 类，但仍然允许多个函数使用它（通过在删除全局 Foo 名称之前定义它们）。

Answer 6

如果使用模块级函数而不是静态方法就可以...

将整个类设为私有，将 API 作为抽象类公开，并使用函数来实例化您的私有类

class Foo(ABC):
    @abstractmethod
    def bar(self) -> int:
        ...


class _SpecificFoo(Foo):
    def __init__(self, bar: int):
        self._bar = bar

    def bar(self) -> int:
        return self._bar


def specific_foo(bar: int) -> Foo:
    return _SpecificFoo(bar)

注意

• _SpecificFoo() 和 specific_foo() 可以有不同的签名
• specific_foo() 返回一个 Foo。 API 没有提及 _SpecificFoo

这与 Jesse 的第一个选项非常相似，但每次调用 specific_foo 时不会重新定义该类，并且类接口是静态类型的。

Answer 7

引用 Python 风格指南 (PEP 8)：

此外，以下使用前导或尾随的特殊形式
下划线被识别（这些通常可以与任何情况组合
约定）：

• _single_leading_underscore：弱“内部使用”指示器。例如“来自 M
import *" 不会导入名称以下划线开头的对象。

• single_trailing_underscore_：按惯例使用以避免与
  Python 关键字，例如
  Tkinter.Toplevel(master, class_='ClassName')

• __double_leading_underscore：命名类属性时，调用 name
  损坏（在 FooBar 类中，__boo 变为 _FooBar__boo；见下文）。

• __double_leading_and_trailing_underscore__：“神奇”对象或
  存在于用户控制的命名空间中的属性。例如__init__，
  __import__ 或 __file__。永远不要发明这样的名字；只使用它们
  如文档所述。

Answer 8

首先，“构造函数”这个术语不适用于Python，因为尽管__init__()方法起到了一个作用，但它只是一个在创建对象时调用的方法。并且需要初始化。

Python 中类的每个方法都是公共的。通常程序员在方法名称中使用 _ 或 __ 标记“私有”方法，例如：

# inheriting from object is relevant for Python 2.x only
class MyClass(object): 
    # kinda "constructor"
    def __init__(self):
        pass

    # here is a "private" method
    def _some_method(self):
        pass

    # ... and a public one
    def another_method(self):
        pass

Answer 9

其他答案提到Python中不存在“私有”构造函数（或一般的访问修饰符）之类的东西。虽然这是事实，但您仍然可以利用 __ 前缀行为，通过使用双下划线前缀“隐藏”嵌套类中的实际实现来实现相同的最终效果：

class MyPublicClassWithPrivateConstructor:

    class __Implementation:
        def __init__(self, *args, **kwargs):
            # do the things
            self.args = args
            self.kwargs = kwargs

    @classmethod
    def make_my_thing(cls, *args, **kwargs)
        return cls.__Implementation(*args, **kwargs)

    def __new__(cls, *args, **kwargs):
        raise Exception("MyPublicClassWithPrivateConstructor cannot be initialized directly, use MyPublicClassWithPrivateConstructor.make_my_thing")

# elsewhere
from whateva import MyPublicClassWithPrivateConstructor

MyPublicClassWithPrivateConstructor.__Implementation  # type object 'MyPublicClassWithPrivateConstructor' has no attribute '__Implementation'
MyPublicClassWithPrivateConstructor.make_my_thing  # <bound method MyPublicClassWithPrivateConstructor.make_my_thing of <class 'whateva. MyPublicClassWithPrivateConstructor'>>
           

Answer 10

如果模块级函数而不是静态方法可以，请参阅我的其他答案

您可以通过以下方式实现此效果一个抽象类。任何需要在“私有构造函数”中定义的实例属性都可以是抽象属性。然后，您的工厂类方法通过填充这些抽象属性以及执行任何其他初始化工作（例如数据验证）来构建自己的具体类。

from abc import ABC, abstractmethod

class Foo(ABC):
    @property
    @abstractmethod
    def _a(self) -> int:
        pass

    def bar(self) -> int:
        return self._a + 1

    @classmethod
    def from_values(cls, a: int) -> 'Foo':
        class _Foo(cls):
            def __init__(self, __a):
                self.__a = __a

            @property
            def _a(self):
                return self.__a
        
        return _Foo(a)

Foo()  # TypeError: Can't instantiate abstract class ...
Foo.from_values(1).bar()  # 1

如果您发现 Foo 不需要抽象属性，则在调用 Foo() 时不会出现 TypeError。在这种情况下，您可以依赖 ABC 的继承作为文档，或者定义一个虚拟属性以确保安全。

可选调整

• 需要可变实例属性？添加设置器。
• 不关心类属性和实例属性之间的区别吗？简化为

  类 _Foo(cls):
      _a=a
  
  返回 _Foo()
  

Answer 11

如果您只是想要一种简单的方法来表明不应直接使用构造函数，则可以遵循以下模式以使构造函数的默认用法引发异常：

class Foo:
    def __init__(self, arg, __private=False):
        assert __private, "Constructor shouldn't be called directly"
        self.arg = arg

    @classmethod
    def from_bar(cls, bar: Bar):
        return cls(bar.arg, __private=True)

    @classmethod
    def from_baz(cls, baz: Baz):
         return cls(baz.arg, __private=True)

当然，任何人仍然可以执行 Foo ('abc', __private=True) 但它会发出一个明确的信号，表明不支持这种行为，这遵循 Python 的一般设计。

Answer 12

我知道，我迟到了，但我们可以这样做来创建私有构造函数。

class MyClass:
    __instance = None
    __private = False

    @staticmethod
    def get_instance():

        MyClass.__private = True
        __instance = MyClass()
        MyClass.__private = False
        return MyClass.__instance
     
    def __init__(self):

        if MyClass.__private == False:
             raise Exception("Its a private method. Please use get_instance method")
        

Answer 13

另一种解决方案是让 __init__ 请求一种只有工厂方法才能知道的私有秘密。

请参阅下面的示例：

from __future__ import annotations

class Foo:
    name: str

    def __init__(self, check_private_constructor: str):
        if check_private_constructor != "from_within":
            raise RuntimeError("Please use named constructors!")

    @staticmethod
    def from_name(name: str) -> Foo:
        r = Foo("from_within")
        r.name = name
        return r

    @staticmethod
    def from_index(index: int) -> Foo:
        r = Foo("from_within")
        r.name = str(index)
        return r
        
    def __str__(self):
        return "Foo.name=" + self.name


# a = Foo("eee")    # will raise an exception
a = Foo.from_name("Bob")
print(a)
b = Foo.from_index(3)
print(b)

Answer 14

一个清晰且轻量级的解决方案是使构造函数参数成为必需的但“私有”。只有当您也将它们设置为仅限关键字时，这才真正有效，否则很容易错过

class Foo:
    def __init__(self, *, _x: int):
        self._x = _x

    @classmethod
    def create(cls, x: int) -> Foo:
        return Foo(_x=x)

这里，Foo(_x=1) 表明我们滥用了 API。

create 中的 Foo(_x=x) 是否违反了类自己的契约是有争议的。

Answer 15

我认为这可能是一种更直接的方法。

class Test:

    def __init__(self, value):
        self.value =  value
    
        caller_frame = inspect.stack()[1]
        caller_module = inspect.getmodule(caller_frame[0])
        caller_name = caller_frame.function
        assert caller_name == 'create', 'use Test.create instead'
        print(f'new Test instantiated using {caller_name}')
    
    @classmethod
    def create(cls, value):
        return Test(value)

现在，如果我调用，

> Test("example")

将返回以下 AssertionError

Traceback (most recent call last):
  ...
  File "<input>", line 1, in <module>
  File "<input>", line 9, in __init__
AssertionError: use Test.create instead

如果我调用，

> Test.create("example_two")

将返回以下内容：

new Test instantiated using create
<__main__.Test object at 0x00000275393E7BE0>