Mengapa menggunakan Abstrak Base Classes di Python?

Karena saya terbiasa dengan cara lama mengetik bebek dengan Python, saya gagal memahami kebutuhan akan ABC (kelas dasar abstrak). The bantuan baik tentang bagaimana untuk menggunakannya.

Saya mencoba membaca alasan di PEP , tetapi itu terlintas di kepala saya. Jika saya sedang mencari wadah urutan bisa berubah, saya akan memeriksa __setitem__, atau lebih mungkin mencoba menggunakannya ( EAFP ). Saya belum menemukan penggunaan nyata untuk modul angka , yang memang menggunakan ABC, tapi itulah yang paling dekat saya harus mengerti.

Adakah yang bisa menjelaskan alasannya kepada saya?

Versi pendek

ABC menawarkan tingkat kontrak semantik yang lebih tinggi antara klien dan kelas yang diimplementasikan.

Versi panjang

Ada kontrak antara kelas dan peneleponnya. Kelas berjanji untuk melakukan hal-hal tertentu dan memiliki sifat-sifat tertentu.

Ada beberapa level kontrak.

Pada level yang sangat rendah, kontrak mungkin menyertakan nama metode atau jumlah parameternya.

Dalam bahasa yang diketik secara statis, kontrak itu sebenarnya akan diberlakukan oleh kompiler. Dengan Python, Anda bisa menggunakan EAFP atau mengetik introspeksi untuk mengonfirmasi bahwa objek yang tidak diketahui memenuhi kontrak yang diharapkan ini.

Tetapi ada juga janji semantik tingkat tinggi dalam kontrak.

Sebagai contoh, jika ada __str__()metode, diharapkan untuk mengembalikan representasi string objek. Itu bisa menghapus semua konten objek, melakukan transaksi dan mengeluarkan halaman kosong dari printer ... tetapi ada pemahaman umum tentang apa yang harus dilakukan, dijelaskan dalam manual Python.

Itu adalah kasus khusus, di mana kontrak semantik dijelaskan dalam manual. Apa yang harus print()dilakukan metode ini? Haruskah itu menulis objek ke printer atau garis ke layar, atau yang lain? Tergantung - Anda perlu membaca komentar untuk memahami kontrak lengkap di sini. Sepotong kode klien yang hanya memeriksa bahwa print()metode yang ada telah mengkonfirmasi bagian dari kontrak - bahwa panggilan metode dapat dibuat, tetapi tidak ada kesepakatan tentang semantik tingkat tinggi dari panggilan tersebut.

Mendefinisikan Kelas Basis Abstrak (ABC) adalah cara menghasilkan kontrak antara pelaksana kelas dan penelepon. Ini bukan hanya daftar nama metode, tetapi pemahaman bersama tentang apa yang harus dilakukan metode tersebut. Jika Anda mewarisi dari ABC ini, Anda berjanji untuk mengikuti semua aturan yang dijelaskan dalam komentar, termasuk semantik dari print()metode ini.

Mengetik bebek Python memiliki banyak keunggulan dalam fleksibilitas dibandingkan pengetikan statis, tetapi tidak menyelesaikan semua masalah. ABC menawarkan solusi perantara antara bentuk bebas Python dan ikatan-dan-disiplin bahasa yang diketik secara statis.

@ Jawaban Oddthinking ini tidak salah, tapi saya pikir itu merindukan nyata , praktis alasan Python memiliki ABC di dunia bebek-mengetik.

Metode abstrak rapi, tetapi menurut saya mereka tidak benar-benar mengisi kasus penggunaan yang belum tercakup oleh mengetik bebek. Kekuatan nyata kelas dasar abstrak terletak pada cara mereka memungkinkan Anda untuk menyesuaikan perilaku isinstancedanissubclass . ( __subclasshook__pada dasarnya adalah API ramah di atas Python __instancecheck__dan__subclasscheck__ kait.) Menyesuaikan konstruksi built-in untuk bekerja pada jenis kustom adalah sangat banyak bagian dari filosofi Python.

Kode sumber Python adalah contoh. Berikut adalah bagaimana collections.Containerdidefinisikan di perpustakaan standar (pada saat penulisan):

class Container(metaclass=ABCMeta):
    __slots__ = ()

    @abstractmethod
    def __contains__(self, x):
        return False

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Container:
            if any("__contains__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

Definisi ini __subclasshook__mengatakan bahwa setiap kelas dengan __contains__atribut dianggap sebagai subkelas dari Kontainer, bahkan jika itu bukan subkelas secara langsung. Jadi saya bisa menulis ini:

class ContainAllTheThings(object):
    def __contains__(self, item):
        return True

>>> issubclass(ContainAllTheThings, collections.Container)
True
>>> isinstance(ContainAllTheThings(), collections.Container)
True

Dengan kata lain, jika Anda mengimplementasikan antarmuka yang tepat, Anda adalah subkelas! ABC memberikan cara formal untuk mendefinisikan antarmuka dengan Python, sambil tetap setia pada semangat mengetik-bebek. Selain itu, ini bekerja dengan cara yang menghormati Prinsip Terbuka-Tertutup .

Model objek Python terlihat sangat mirip dengan sistem OO yang lebih "tradisional" (yang saya maksudkan Java *) - kita mendapatkan kelas, objek, dan metode Anda - tetapi ketika Anda menggores permukaan, Anda akan menemukan sesuatu yang jauh lebih kaya dan lebih fleksibel. Demikian pula, gagasan Python tentang kelas dasar abstrak dapat dikenali oleh pengembang Java, tetapi dalam praktiknya mereka dimaksudkan untuk tujuan yang sangat berbeda.

Kadang-kadang saya menemukan diri saya menulis fungsi polimorfik yang dapat bertindak pada satu item atau kumpulan item, dan saya menemukan isinstance(x, collections.Iterable)lebih banyak dibaca daripada hasattr(x, '__iter__')atau try...exceptblok yang setara . (Jika Anda tidak tahu Python, yang mana dari ketiganya akan membuat maksud kode menjadi paling jelas?)

Yang mengatakan, saya menemukan bahwa saya jarang perlu menulis ABC saya sendiri dan saya biasanya menemukan kebutuhan untuk itu melalui refactoring. Jika saya melihat fungsi polimorfik melakukan banyak pemeriksaan atribut, atau banyak fungsi membuat pemeriksaan atribut yang sama, bau itu menunjukkan keberadaan ABC yang menunggu untuk diekstraksi.

_{* tanpa masuk ke perdebatan apakah Jawa adalah sistem OO "tradisional" ...}

Tambahan : Meskipun kelas dasar abstrak dapat mengesampingkan perilaku isinstancedan issubclass, itu masih tidak memasukkan MRO dari subkelas virtual. Ini adalah jebakan potensial untuk klien: tidak setiap objek yang isinstance(x, MyABC) == Truememiliki metode didefinisikan MyABC.

class MyABC(metaclass=abc.ABCMeta):
    def abc_method(self):
        pass
    @classmethod
    def __subclasshook__(cls, C):
        return True

class C(object):
    pass

# typical client code
c = C()
if isinstance(c, MyABC):  # will be true
    c.abc_method()  # raises AttributeError

Sayangnya ini salah satu dari perangkap "hanya jangan lakukan itu" (yang hanya dimiliki sedikit oleh Python!): Hindari mendefinisikan ABC dengan __subclasshook__metode a dan non-abstrak. Selain itu, Anda harus membuat definisi Anda __subclasshook__konsisten dengan serangkaian metode abstrak yang didefinisikan oleh ABC Anda.

Fitur praktis dari ABC adalah bahwa jika Anda tidak menerapkan semua metode (dan properti) yang diperlukan, Anda mendapatkan kesalahan saat instantiasi, dan bukannya AttributeError, berpotensi jauh di kemudian hari, ketika Anda benar-benar mencoba menggunakan metode yang hilang.

from abc import ABCMeta, abstractmethod

# python2
class Base(object):
    __metaclass__ = ABCMeta

    @abstractmethod
    def foo(self):
        pass

    @abstractmethod
    def bar(self):
        pass

# python3
class Base(object, metaclass=ABCMeta):
    @abstractmethod
    def foo(self):
        pass

    @abstractmethod
    def bar(self):
        pass

class Concrete(Base):
    def foo(self):
        pass

    # We forget to declare `bar`


c = Concrete()
# TypeError: "Can't instantiate abstract class Concrete with abstract methods bar"

Contoh dari https://dbader.org/blog/abstract-base-classes-in-python

Edit: untuk memasukkan sintaks python3, terima kasih @PandasRocks

Ini akan membuat menentukan apakah suatu objek mendukung protokol yang diberikan tanpa harus memeriksa keberadaan semua metode dalam protokol atau tanpa memicu pengecualian jauh di dalam wilayah "musuh" karena non-dukungan jauh lebih mudah.

Metode abstrak pastikan bahwa apa pun metode yang Anda panggil di kelas induk harus muncul di kelas anak. Di bawah ini adalah cara biasa memanggil dan menggunakan abstrak. Program ini ditulis dalam python3

Cara panggilan biasa

class Parent:
def methodone(self):
    raise NotImplemented()

def methodtwo(self):
    raise NotImplementedError()

class Son(Parent):
   def methodone(self):
       return 'methodone() is called'

c = Son()
c.methodone()

'Methodone () disebut'

c.methodtwo()

NotImplementedError

Dengan metode abstrak

from abc import ABCMeta, abstractmethod

class Parent(metaclass=ABCMeta):
    @abstractmethod
    def methodone(self):
        raise NotImplementedError()
    @abstractmethod
    def methodtwo(self):
        raise NotImplementedError()

class Son(Parent):
    def methodone(self):
        return 'methodone() is called'

c = Son()

TypeError: Tidak dapat membuat instance kelas abstrak Son dengan metode abstrak methodtwo.

Karena methodtwo tidak dipanggil di kelas anak kami mendapat kesalahan. Implementasi yang tepat di bawah ini

from abc import ABCMeta, abstractmethod

class Parent(metaclass=ABCMeta):
    @abstractmethod
    def methodone(self):
        raise NotImplementedError()
    @abstractmethod
    def methodtwo(self):
        raise NotImplementedError()

class Son(Parent):
    def methodone(self):
        return 'methodone() is called'
    def methodtwo(self):
        return 'methodtwo() is called'

c = Son()
c.methodone()

'Methodone () disebut'