파이썬에서 추상 클래스와 인터페이스의 차이점은 무엇입니까?

때때로 다음과 같은 내용이 표시됩니다.

class Abstract1( object ):
    """Some description that tells you it's abstract,
    often listing the methods you're expected to supply."""
    def aMethod( self ):
        raise NotImplementedError( "Should have implemented this" )

파이썬은 공식적인 인터페이스 계약을 가지고 있지 않으며 필요하지 않기 때문에 추상화와 인터페이스 사이의 자바 스타일의 구별은 존재하지 않습니다. 누군가가 공식적인 인터페이스를 정의하려는 노력을한다면 추상 클래스가 될 것입니다. 유일한 차이점은 문서화 문자열에 명시된 의도에 있습니다.

그리고 오리와 타이핑을 할 때 초록과 인터페이스의 차이점은 번거 롭습니다.

Java는 다중 상속이 없기 때문에 인터페이스를 사용합니다.

파이썬에는 다중 상속이 있기 때문에 다음과 같이 보일 수도 있습니다.

class SomeAbstraction( object ):
    pass # lots of stuff - but missing something

class Mixin1( object ):
    def something( self ):
        pass # one implementation

class Mixin2( object ):
    def something( self ):
        pass # another

class Concrete1( SomeAbstraction, Mixin1 ):
    pass

class Concrete2( SomeAbstraction, Mixin2 ):
    pass

이것은 믹스 인과 함께 일종의 추상 슈퍼 클래스를 사용하여 분리 된 구체적인 서브 클래스를 만듭니다.

파이썬에서 추상 클래스와 인터페이스의 차이점은 무엇입니까?

객체의 인터페이스는 해당 객체의 메소드 및 속성 집합입니다.

파이썬에서는 추상 기본 클래스를 사용하여 인터페이스를 정의하고 시행 할 수 있습니다.

추상 기본 클래스 사용

예를 들어, collections모듈 에서 추상 기본 클래스 중 하나를 사용하려고한다고 가정하십시오 .

import collections
class MySet(collections.Set):
    pass

우리가 그것을 사용하려고하면 우리 TypeError가 만든 클래스가 예상되는 동작 집합을 지원하지 않기 때문에

>>> MySet()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class MySet with abstract methods
__contains__, __iter__, __len__

우리가에서 구현해야합니다 그래서 적어도 __contains__ , __iter__하고 __len__. 문서 에서이 구현 예제를 사용하십시오 .

class ListBasedSet(collections.Set):
    """Alternate set implementation favoring space over speed
    and not requiring the set elements to be hashable. 
    """
    def __init__(self, iterable):
        self.elements = lst = []
        for value in iterable:
            if value not in lst:
                lst.append(value)
    def __iter__(self):
        return iter(self.elements)
    def __contains__(self, value):
        return value in self.elements
    def __len__(self):
        return len(self.elements)

s1 = ListBasedSet('abcdef')
s2 = ListBasedSet('defghi')
overlap = s1 & s2

구현 : 추상 기본 클래스 생성

메타 클래스를 설정하고 관련 메소드 abc.ABCMeta에서 abc.abstractmethod데코레이터를 사용하여 자체 추상 기본 클래스를 만들 수 있습니다 . 메타 클래스는 장식 된 함수를 __abstractmethods__속성에 추가하여 정의 될 때까지 인스턴스화를 방지합니다.

import abc

예를 들어, "효과적인"은 단어로 표현할 수있는 것으로 정의됩니다. 파이썬 2에서 가능한 추상 기본 클래스를 정의하고 싶다고 가정 해보십시오.

class Effable(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def __str__(self):
        raise NotImplementedError('users must define __str__ to use this base class')

또는 파이썬 3에서는 메타 클래스 선언이 약간 변경되었습니다.

class Effable(object, metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def __str__(self):
        raise NotImplementedError('users must define __str__ to use this base class')

이제 인터페이스를 구현하지 않고 유효한 객체를 만들려고하면 :

class MyEffable(Effable): 
    pass

그것을 인스턴스화하려고 시도하십시오.

>>> MyEffable()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class MyEffable with abstract methods __str__

우리는 일을 끝내지 않았다고 들었습니다.

이제 예상 인터페이스를 제공하여 준수한다면 :

class MyEffable(Effable): 
    def __str__(self):
        return 'expressable!'

그런 다음 추상 클래스에서 파생 된 구체적인 버전의 클래스를 사용할 수 있습니다.

>>> me = MyEffable()
>>> print(me)
expressable!

이미 이러한 인터페이스를 구현하는 가상 서브 클래스 등록과 같은 다른 작업도 가능하지만이 질문의 범위를 벗어난 것으로 생각합니다. 그러나 여기에 설명 된 다른 방법은 abc모듈을 사용하여이 방법을 조정해야합니다 .

결론

우리는 추상 기본 클래스의 생성이 파이썬에서 커스텀 객체에 대한 인터페이스를 정의한다는 것을 증명했습니다.

Python> = 2.6에는 추상 기본 클래스가 있습니다.

추상 기본 클래스 (약어 ABC)는 hasattr ()과 같은 다른 기술이 서투른 경우 인터페이스를 정의하는 방법을 제공하여 오리 타이핑을 보완합니다. Python에는 데이터 구조 (컬렉션 모듈), 숫자 (숫자 모듈) 및 스트림 (io 모듈)을위한 많은 내장 ABC가 제공됩니다. abc 모듈을 사용하여 고유 한 ABC를 만들 수 있습니다.

Zope Interface 모듈 도 있습니다. 이것은 Zope 외부의 프로젝트에서 트위스트처럼 사용됩니다. 나는 정말 익숙하지 해요,하지만 위키 페이지가있어 여기에 그 힘의 도움.

일반적으로 추상 클래스 또는 파이썬의 인터페이스 개념이 필요하지 않습니다 (편집-자세한 내용은 S.Lott의 답변 참조).

파이썬에는 실제로 두 가지 개념이 없습니다.

오리 타이핑을 사용하여 인터페이스가 필요하지 않습니다 (적어도 컴퓨터 :-))

Python <= 2.5 : 기본 클래스는 분명히 존재하지만 메소드를 '순수 가상'으로 표시하는 명시적인 방법은 없으므로 클래스가 실제로 추상적이지는 않습니다.

Python> = 2.6 : 추상 기본 클래스가 존재합니다 ( http://docs.python.org/library/abc.html ). 또한 서브 클래스에서 구현해야하는 메소드를 지정할 수 있습니다. 나는 구문을 좋아하지 않지만 그 기능이 있습니다. 대부분의 경우 '사용'클라이언트 쪽에서 오리 타이핑을 사용하는 것이 좋습니다.

보다 기본적인 설명 : 인터페이스는 빈 머핀 팬과 비슷합니다. 코드가없는 메소드 정의 세트가있는 클래스 파일입니다.

추상 클래스는 동일하지만 모든 함수가 비어 있어야하는 것은 아닙니다. 일부는 코드를 가질 수 있습니다. 비어 있지는 않습니다.

차별화 이유 : 파이썬에는 실질적인 차이가 크지 않지만 대규모 프로젝트의 계획 수준에서는 코드가 없기 때문에 인터페이스에 대해 이야기하는 것이 더 일반적 일 수 있습니다. 특히이 용어에 익숙한 Java 프로그래머와 함께 작업하는 경우.

일반적으로 인터페이스는 단일 상속 클래스 모델을 사용하는 언어로만 사용됩니다. 이러한 단일 상속 언어에서 클래스는 특정 메소드 또는 메소드 세트를 사용할 수있는 경우 인터페이스가 일반적으로 사용됩니다. 또한 이러한 단일 상속 언어에서 추상 클래스는 하나 이상의 메소드 외에 클래스 변수를 정의하거나 단일 상속 모델을 사용하여 메소드 세트를 사용할 수있는 클래스 범위를 제한하는 데 사용됩니다.

다중 상속 모델을 지원하는 언어는 인터페이스가 아닌 클래스 또는 추상 기본 클래스 만 사용하는 경향이 있습니다. 파이썬은 다중 상속을 지원하기 때문에 인터페이스를 사용하지 않으며 기본 클래스 또는 추상 기본 클래스를 사용하려고합니다.

http://docs.python.org/library/abc.html

추상 클래스는 하나 이상의 추상 메소드를 포함하는 클래스입니다. 추상 메소드와 함께 추상 클래스는 정적, 클래스 및 인스턴스 메소드를 가질 수 있습니다. 그러나 인터페이스의 경우 추상 메소드 만 가질 수 있습니다. 따라서 추상 클래스를 상속해야하는 것은 아니지만 인터페이스를 상속해야합니다.

완벽을 기하기 위해 ABC가 소개되고 인터페이스와 비교 된 PEP3119 및 원래 Talin의 의견을 언급해야합니다.

추상 클래스는 완벽한 인터페이스가 아닙니다.

• 상속 계층에 속합니다
• 변하기 쉬워

그러나 당신이 그것을 자신의 방식으로 쓰는 것을 고려한다면 :

def some_function(self):
     raise NotImplementedError()

interface = type(
    'your_interface', (object,),
    {'extra_func': some_function,
     '__slots__': ['extra_func', ...]
     ...
     '__instancecheck__': your_instance_checker,
     '__subclasscheck__': your_subclass_checker
     ...
    }
)

ok, rather as a class
or as a metaclass
and fighting with python to achieve the immutable object
and doing refactoring
...

휠을 발명하여 궁극적으로 달성하고 있음을 매우 빨리 알 수 있습니다. abc.ABCMeta

abc.ABCMeta 누락 된 인터페이스 기능을 유용하게 추가하여 제안되었으며 파이썬과 같은 언어로 충분합니다.

확실히, 버전 3을 작성하고 새로운 구문과 변경 불가능한 인터페이스 개념을 추가하는 동안 더 향상 될 수있었습니다 ...

결론:

The abc.ABCMeta IS "pythonic" interface in python