python清除实例化类_防止类在Python中直接实例化

我有一个超类，其中的一个方法调用了仅在其子类中定义的其他方法。这就是为什么，当我创建一个超级类的实例并调用它的方法时，它找不到该方法并引发错误。

下面是一个例子：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37class SuperClass(object):

def method_one(self):

value = self.subclass_method()

print value

class SubClassOne(SuperClass):

def subclass_method(self):

return 'subclass 1'

class SubClassTwo(SuperClass):

def subclass_method(self):

return 'nubclass 2'

s1 = SubClassOne()

s1.method_one()

s2 = SubClassTwo()

s2.method_one()

c = SuperClass()

c.method_one()

# Results:

# subclass 1

# nubclass 2

# Traceback (most recent call last):

# File"abst.py", line 28, in

# c.method_one()

# File"abst.py", line 4, in method_one

# value = self.subclass_method()

# AttributeError: 'SuperClass' object has no attribute 'subclass_method'

在创建新实例时，我正在考虑更改super类的init并验证对象的类型。如果对象属于超级类，则引发错误。不过，我不太确定这是不是用了Python的方式。

有什么建议吗？

pythonic的方法是编写好的文档来解释如何使用类。

@ Chan:这在C++中是很常见的。他所做的基本上就是调用虚拟方法。如果它们是解决问题的正确方法，那么它们本身就没有什么问题。

我同意这不是很Python

@周：我有一个超级班和八个子班。所有子类共享一个方法，并且所有子类都将有一个同名的方法，但从共享方法调用的实现不同。你不认为我的方法是Python这种情况吗？

@chown您似乎暗示使用抽象类的模式是"一般来说是非编程的"，大多数OO程序员都不同意这一点。如果BaseClass定义subclass_method来提高NotImplementedError的值，而不是稍微好一点的错误消息，这会有什么不同呢？

@Chown使用抽象类几乎不是"百万分之一的场景"。它是OO编程的核心部分。Python不要求类被正式声明为抽象的；您所要做的只是不实现需要子类来实现的方法。但这是完全相同的模式。您声称在基类中引用一个未实现的抽象方法"一般来说是不可编程的"，但是在每一种OO语言中，它一直都是(并且鼓励)的。所有的操作都是为了检测抽象类的误用。

我将重写基类中的__new__()，如果它是基类，则根本无法实例化。

1

2

3

4

5

6class BaseClass(object):

def __new__(cls, *args, **kwargs):

if cls is BaseClass:

raise TypeError("base class may not be instantiated")

return object.__new__(cls, *args, **kwargs)

这比把它放在__init__()中要好一点，而且"失败得很快"。

abc模块可能适用于90%的情况，但这种技术在其他一些情况下很有用。我遇到过一些问题：1)你想要一个可重用的mixin类，但它实际上没有抽象的方法，所以ABCMeta不会阻止它被实例化；2)你定义了一个"基本"类或mixin，它实际上子类了其他的东西，但你不希望它直接是可实例化的。

这确实非常有用。我想补充一点，如果baseclass继承了verybaseclass，那么返回verybaseclass.uu new_uu()而不是object.uu new_uu()。

另外，在这种情况下，请注意，如果您重写__init__和overward__new__，那么您不能将额外的参数传递给__new__，您只能调用return object.__new__(cls)。

您的方法是典型的框架模式。

使用uuu init_uuu验证type(self) is not SuperClass是确保超类没有被直接实例化的合理方法。

另一种常见的方法是在调用时提供raise NotImplementedError的存根方法。这更可靠，因为它还验证子类是否重写了预期的方法。

您所说的是抽象基类，而Python语言本身不支持它们。

但是，在标准库中，有一个模块可以用来帮助您。查看ABC文档。

实际上，在python上实现his还有很多方法，但是我只需要导入abc模块并将类设置为抽象类。我注意到尽管我的类是抽象的，但我仍然可以在其中实现方法，这非常好。

我可以这样做：

1

2

3

4

5

6

7

8

9

10

11

12class SuperClass(object):

def __init__(self):

if type(self) == SuperClass:

raise Exception(" must be subclassed.")

# assert(type(self) == SuperClass)

class SubClass(SuperClass):

def __init__(self):

SuperClass.__init__(self)

subC = SubClassOne()

supC = SuperClass() # This line should throw an exception

运行时(引发异常！)：

1

2

3

4

5

6

7[ 18:32 jon@hozbox ~/so/python ]$ ./preventing-direct-instantiation.py

Traceback (most recent call last):

File"./preventing-direct-instantiation.py", line 15, in

supC = SuperClass()

File"./preventing-direct-instantiation.py", line 7, in __init__

raise Exception(" must be subclassed.")

Exception: must be subclassed.

编辑(来自注释)：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43[ 20:13 jon@hozbox ~/SO/python ]$ cat preventing-direct-instantiation.py

#!/usr/bin/python

class SuperClass(object):

def __init__(self):

if type(self) == SuperClass:

raise Exception(" must be subclassed.")

class SubClassOne(SuperClass):

def __init__(self):

SuperClass.__init__(self)

class SubSubClass(SubClassOne):

def __init__(self):

SubClassOne.__init__(self)

class SubClassTwo(SubClassOne, SuperClass):

def __init__(self):

SubClassOne.__init__(self)

SuperClass.__init__(self)

subC = SubClassOne()

try:

supC = SuperClass()

except Exception, e:

print"FAILED: supC = SuperClass() - %s" % e

else:

print"SUCCESS: supC = SuperClass()"

try:

subSubC = SubSubClass()

except Exception, e:

print"FAILED: subSubC = SubSubClass() - %s" % e

else:

print"SUCCESS: subSubC = SubSubClass()"

try:

subC2 = SubClassTwo()

except Exception, e:

print"FAILED: subC2 = SubClassTwo() - %s" % e

else:

print"SUCCESS: subC2 = SubClassTwo()"

印刷品：

1

2

3

4[ 20:12 jon@hozbox ~/SO/python ]$ ./preventing-direct-instantiation.py

FAILED: supC = SuperClass() - must be subclassed.

SUCCESS: subSubC = SubSubClass()

SUCCESS: subC2 = SubClassTwo()

不是说这不太酷，但我认为这正说明了为什么你不应该尝试做这种事情。我敢肯定这两个例子都失败了。

@SDOLAN I刚刚测试过，它实际上与class SubSubClass(SubClassOne):一起工作，从__init__调用SubClassOne.__init__(self)！

啊，很酷。感谢您进行更新。