Bagaimana untuk Melaksanakan Perbandingan Kesamaan dalam Kelas Python dengan Elegan?

Pendekatan Elegan untuk Perbandingan Kesamaan dalam Kelas Python

Cabaran

Mentakrifkan kelas tersuai dalam Python selalunya memerlukan pelaksanaan perbandingan kesamaan melalui penggunaan kaedah khas , eq dan ne__. Pendekatan biasa melibatkan membandingkan atribut __dict bagi kejadian.

Melihat lebih dekat dict Kaedah Perbandingan

Membandingkan __dict__s menyediakan cara mudah untuk menyemak kesaksamaan:

def __eq__(self, other):
    if isinstance(other, self.__class__):
        return self.__dict__ == other.__dict__
    else:
        return False

Walaupun pendekatan ini mudah, ia mungkin mempunyai kelemahan:

• Warisi daripada dict: Membandingkan dict pada asasnya menganggap kelas anda sebagai kamus lanjutan.
• Konflik cincang: Objek dengan dikt yang serupa mungkin mempunyai perbezaan cincang, mempengaruhi set dan tingkah laku kamus.

Pendekatan Alternatif

Terdapat alternatif yang lebih elegan untuk menggunakan perbandingan dikt:

1. Takrifkan __slot__:

Isytihar slot dalam kelas anda untuk mengehadkan atribut contoh kepada yang khusus:

class Foo:
    __slots__ = ['item']
    def __init__(self, item):
        self.item = item

Ini memastikan perbandingan adalah cekap dan menghalang penambahan sewenang-wenangnya atribut kepada kejadian.

2. Gunakan nametuple:

Gunakan nametuple Python untuk menentukan kelas dengan cepat dengan atribut yang dipratentukan:

from collections import namedtuple
Foo = namedtuple('Foo', ['item'])

namedtuples menyokong perbandingan kesamaan di luar kotak.

3. Tentukan cincang dan __eq__:

Timpa cincang untuk mengembalikan cincang berdasarkan atribut kelas yang penting, memastikan cincang unik untuk objek yang sama. Kemudian, laksanakan eq untuk membandingkan objek berdasarkan atributnya, bukan cincangnya:

class Foo:
    def __init__(self, item):
        self.item = item
    def __hash__(self):
        return hash(self.item)
    def __eq__(self, other):
        return self.item == other.item

4. Gunakan metaclasses:

Metaclasses membolehkan anda mencipta kelas secara dinamik dengan gelagat tersuai. Anda boleh mencipta metaclass yang secara automatik mentakrifkan kaedah eq dan ne berdasarkan atribut kelas:

class MyMeta(type):
    def __new__(cls, name, bases, dct):
        attributes = tuple(dct.keys())
        def __eq__(self, other):
            return all(getattr(self, attr) == getattr(other, attr) for attr in attributes)
        dct['__eq__'] = __eq__
        return super().__new__(cls, name, bases, dct)

5. Warisan daripada Kelas Asas Tersuai:

Buat kelas asas dengan eq dan cincang sudah ditentukan untuk gelagat yang diingini. Kelas lain boleh mewarisi daripada kelas asas ini untuk mendapat manfaat daripada fungsi perbandingan kesamarataannya.

Kesimpulan

Walaupun membandingkan __dict__s boleh menjadi penyelesaian yang mudah, terdapat pendekatan yang lebih elegan dan cekap tersedia untuk melaksanakan perbandingan kesamaan dalam kelas Python. Pilihan kaedah bergantung pada keperluan khusus permohonan anda.

Atas ialah kandungan terperinci Bagaimana untuk Melaksanakan Perbandingan Kesamaan dalam Kelas Python dengan Elegan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!