Bagaimanakah Kelas Asas Abstrak Boleh Membantu Mengatasi Gelagat Kamus dengan Sempurna?

Mengatasi Dict dengan Sempurna: Panduan menggunakan Kelas Asas Abstrak

Apabila mencipta subkelas jenis dict terbina dalam, mencapai yang sempurna pelaksanaan boleh mencabar. Daripada mengatasi keseluruhan kelas dict, pertimbangkan untuk menggunakan pendekatan alternatif menggunakan Abstract Base Classes (ABCs) daripada modul collections.abc.

Menggunakan MutableMapping ABC

The MutableMapping ABC menyediakan antara muka untuk kelas yang berkelakuan seperti kamus boleh ubah. Dengan melaksanakan antara muka ini, anda boleh mencipta objek yang berkelakuan seperti dict tanpa mensubkelaskannya secara langsung. Berikut ialah contoh minimum:

from collections.abc import MutableMapping

class TransformedDict(MutableMapping):
    def __init__(self, *args, **kwargs):
        self.store = dict()
        self.update(dict(*args, **kwargs))  # use the free update to set keys

    def __getitem__(self, key):
        return self.store[self._keytransform(key)]

    def __setitem__(self, key, value):
        self.store[self._keytransform(key)] = value

    def __delitem__(self, key):
        del self.store[self._keytransform(key)]

    def __iter__(self):
        return iter(self.store)

    def __len__(self):
        return len(self.store)

    def _keytransform(self, key):
        return key

Pelaksanaan ini menyediakan asas untuk memanipulasi kunci melalui kaedah _keytransform. Dengan mengatasi kaedah ini dalam subkelas, anda boleh menggunakan transformasi tersuai pada kunci.

Faedah menggunakan ABC

Melaksanakan antara muka MutableMapping menawarkan beberapa kelebihan:

• Kelengkapan: ABC memastikan anda telah melaksanakan semua kaedah yang diperlukan untuk kamus boleh ubah.
• Pengesahan automatik: ABC menyemak sama ada anda telah melaksanakan semua kaedah yang diperlukan, membolehkan anda menangkap pelaksanaan yang hilang lebih awal.
• Kaedah terbina: Anda secara automatik mendapat akses kepada kaedah seperti get, setdefault, pop dan lain-lain tanpa perlu melaksanakannya diri sendiri.

Contoh Penggunaan

Mencipta subkelas TransformedDict dan mentakrifkan kaedah _keytransform membolehkan anda menyesuaikan pengendalian kunci:

class MyTransformedDict(TransformedDict):
    def _keytransform(self, key):
        return key.lower()

s = MyTransformedDict([('Test', 'test')])
assert s.get('TEST') is s['test']
assert 'TeSt' in s

Subkelas ini membenarkan akses kunci tidak sensitif huruf besar dan pengambilan semula.

Nota Tambahan

• Penjerukan berfungsi dengan lancar dengan pendekatan ini, kerana anda pada asasnya bekerja dengan dict biasa secara dalaman.
• Ia biasanya tidak digalakkan untuk mensubkelaskan jenis terbina dalam seperti dict secara langsung, kerana ia boleh menyebabkan kekeliruan dan tidak dijangka tingkah laku.
• Menggunakan ABC menyediakan penyelesaian yang bersih dan boleh dikembangkan untuk mencipta objek yang melaksanakan antara muka tertentu.

Atas ialah kandungan terperinci Bagaimanakah Kelas Asas Abstrak Boleh Membantu Mengatasi Gelagat Kamus dengan Sempurna?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!