Ngăn chặn một lớp từ instantiation trực tiếp trong Python

Question

Tôi có một lớp siêu với một phương thức gọi các phương thức khác chỉ được định nghĩa trong các lớp con của nó. Đó là lý do tại sao, khi tôi tạo một thể hiện của lớp siêu của tôi và gọi phương thức của nó, nó không thể tìm ra phương thức và đưa ra một lỗi.

Dưới đây là một ví dụ:

class 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 <module> 
#  c.method_one() 
# File "abst.py", line 4, in method_one 
#  value = self.subclass_method() 
# AttributeError: 'SuperClass' object has no attribute 'subclass_method' 

Tôi đã suy nghĩ về việc thay đổi init của siêu lớp và xác minh các loại đối tượng, khi một trường hợp mới được tạo ra. Nếu đối tượng thuộc về super class thì sẽ gây ra lỗi. Tuy nhiên, tôi không chắc chắn nếu đó là cách Pythonic làm việc đó.

Bất kỳ đề xuất nào?

Answer 1

Bạn đang nói về Lớp cơ sở trừu tượng và ngôn ngữ Python không hỗ trợ chúng nguyên bản.

Tuy nhiên, trong thư viện chuẩn, có một mô-đun bạn có thể sử dụng để trợ giúp bạn. Xem tài liệu abc.

Answer 2

Cách tiếp cận của bạn là điển hình framework pattern.

Sử dụng __init__ để xác minh rằng type(self) is not SuperClass là cách hợp lý để đảm bảo SuperClass chưa được tạo trực tiếp.

Cách tiếp cận phổ biến khác là cung cấp các phương pháp sơ khai là raise NotImplementedError khi được gọi. Điều đó đáng tin cậy hơn vì nó cũng xác nhận rằng các lớp con đã ghi đè các phương thức dự kiến.

Answer 3

Đây là những gì tôi có thể làm:

class SuperClass(object): 
    def __init__(self): 
     if type(self) == SuperClass: 
      raise Exception("<SuperClass> 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 

Khi chạy (ngoại lệ được ném!):

[ 18:32 jon@hozbox ~/so/python ]$ ./preventing-direct-instantiation.py 
Traceback (most recent call last): 
    File "./preventing-direct-instantiation.py", line 15, in <module> 
    supC = SuperClass() 
    File "./preventing-direct-instantiation.py", line 7, in __init__ 
    raise Exception("<SuperClass> must be subclassed.") 
Exception: <SuperClass> must be subclassed. 

---

Chỉnh sửa (từ bình luận):

[ 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("<SuperClass> 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()" 

Bản in:

[ 20:12 jon@hozbox ~/SO/python ]$ ./preventing-direct-instantiation.py 
FAILED: supC = SuperClass() - <SuperClass> must be subclassed. 
SUCCESS: subSubC = SubSubClass() 
SUCCESS: subC2 = SubClassTwo() 

Answer 4

Tôi sẽ ghi đè __new__() trong lớp cơ sở và chỉ đơn giản là không khởi tạo được nếu đó là lớp cơ sở.

class 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) 

Điều này tách mối quan tâm tốt hơn một chút so với việc có trong __init__() và "không nhanh".