Bagaimana saya menghindari "self.x = x; self.y = y; self.z = z ”pola di __init__?

Saya melihat pola suka

def __init__(self, x, y, z):
    ...
    self.x = x
    self.y = y
    self.z = z
    ...

cukup sering, sering dengan lebih banyak parameter. Apakah ada cara yang baik untuk menghindari pengulangan yang membosankan seperti ini? Haruskah kelas mewarisi dari namedtuplegantinya?

Sunting: Jika Anda memiliki python 3.7+ gunakan dataclasses

Solusi dekorator yang menyimpan tanda tangan:

import decorator
import inspect
import sys


@decorator.decorator
def simple_init(func, self, *args, **kws):
    """
    @simple_init
    def __init__(self,a,b,...,z)
        dosomething()

    behaves like

    def __init__(self,a,b,...,z)
        self.a = a
        self.b = b
        ...
        self.z = z
        dosomething()
    """

    #init_argumentnames_without_self = ['a','b',...,'z']
    if sys.version_info.major == 2:
        init_argumentnames_without_self = inspect.getargspec(func).args[1:]
    else:
        init_argumentnames_without_self = tuple(inspect.signature(func).parameters.keys())[1:]

    positional_values = args
    keyword_values_in_correct_order = tuple(kws[key] for key in init_argumentnames_without_self if key in kws)
    attribute_values = positional_values + keyword_values_in_correct_order

    for attribute_name,attribute_value in zip(init_argumentnames_without_self,attribute_values):
        setattr(self,attribute_name,attribute_value)

    # call the original __init__
    func(self, *args, **kws)


class Test():
    @simple_init
    def __init__(self,a,b,c,d=4):
        print(self.a,self.b,self.c,self.d)

#prints 1 3 2 4
t = Test(1,c=2,b=3)
#keeps signature
#prints ['self', 'a', 'b', 'c', 'd']
if sys.version_info.major == 2:
    print(inspect.getargspec(Test.__init__).args)
else:
    print(inspect.signature(Test.__init__))

Penafian: Tampaknya beberapa orang khawatir tentang menghadirkan solusi ini, jadi saya akan memberikan penafian yang sangat jelas. Anda sebaiknya tidak menggunakan solusi ini. Saya hanya menyediakannya sebagai informasi, sehingga Anda tahu bahasanya mampu melakukannya. Jawaban lainnya hanya menunjukkan kemampuan bahasa, bukan mendukung menggunakannya dengan cara ini.

Tidak ada yang salah dengan menyalin parameter ke atribut secara eksplisit. Jika Anda memiliki terlalu banyak parameter dalam ctor, terkadang dianggap sebagai bau kode dan mungkin Anda harus mengelompokkan params ini menjadi objek yang lebih sedikit. Di lain waktu, itu perlu dan tidak ada yang salah dengan itu. Bagaimanapun, melakukannya secara eksplisit adalah cara untuk melakukannya.

Namun, karena Anda bertanya BAGAIMANA itu bisa dilakukan (dan bukan apakah itu harus dilakukan), maka salah satu solusinya adalah ini:

class A:
    def __init__(self, **kwargs):
        for key in kwargs:
          setattr(self, key, kwargs[key])

a = A(l=1, d=2)
a.l # will return 1
a.d # will return 2

Seperti yang telah disebutkan orang lain, pengulangan itu tidak buruk, tetapi dalam beberapa kasus, namesupuple sangat cocok untuk jenis masalah ini. Ini menghindari penggunaan lokal () atau kwargs, yang biasanya merupakan ide yang buruk.

from collections import namedtuple
# declare a new object type with three properties; x y z
# the first arg of namedtuple is a typename
# the second arg is comma-separated or space-separated property names
XYZ = namedtuple("XYZ", "x, y, z")

# create an object of type XYZ. properties are in order
abc = XYZ("one", "two", 3)
print abc.x
print abc.y
print abc.z

Saya telah menemukan penggunaan terbatas untuk itu, tetapi Anda dapat mewarisi nama named seperti dengan objek lain (contoh lanjutan):

class MySuperXYZ(XYZ):
    """ I add a helper function which returns the original properties """
    def properties(self):
        return self.x, self.y, self.z

abc2 = MySuperXYZ(4, "five", "six")
print abc2.x
print abc2.y
print abc2.z
print abc2.properties()

eksplisit lebih baik daripada implisit ... jadi pastikan Anda bisa membuatnya lebih ringkas:

def __init__(self,a,b,c):
    for k,v in locals().items():
        if k != "self":
             setattr(self,k,v)

Pertanyaan yang lebih baik adalah seharusnya Anda?

... yang mengatakan jika Anda ingin nama tuple saya akan merekomendasikan menggunakan namatuple (ingat tuple memiliki kondisi tertentu yang menyertainya) ... mungkin Anda ingin memesan atau bahkan hanya perintah ...

Untuk memperluas gruszczyjawaban s, saya telah menggunakan pola seperti:

class X:
    x = None
    y = None
    z = None
    def __init__(self, **kwargs):
        for (k, v) in kwargs.items():
            if hasattr(self, k):
                setattr(self, k, v)
            else:
                raise TypeError('Unknown keyword argument: {:s}'.format(k))

Saya suka metode ini karena:

• menghindari pengulangan
• tahan terhadap kesalahan ketik saat membangun objek
• bekerja dengan baik dengan subclassing (bisa saja super().__init(...))
• memungkinkan dokumentasi atribut pada tingkat kelas (di mana mereka berada) daripada di X.__init__

Sebelum Python 3.6, ini tidak memberikan kontrol atas urutan atribut ditetapkan, yang bisa menjadi masalah jika beberapa atribut adalah properti dengan setter yang mengakses atribut lainnya.

Mungkin bisa ditingkatkan sedikit, tapi saya satu-satunya pengguna kode saya sendiri jadi saya tidak khawatir tentang segala bentuk sanitasi input. Mungkin AttributeErrorakan lebih tepat.

Anda juga bisa:

locs = locals()
for arg in inspect.getargspec(self.__init__)[0][1:]:
    setattr(self, arg, locs[arg])

Tentu saja, Anda harus mengimpor inspectmodul.

Ini adalah solusi tanpa impor tambahan.

Fungsi pembantu

Fungsi pembantu kecil membuatnya lebih nyaman dan dapat digunakan kembali:

def auto_init(local_name_space):
    """Set instance attributes from arguments.
    """
    self = local_name_space.pop('self')
    for name, value in local_name_space.items():
        setattr(self, name, value)

Aplikasi

Anda perlu menyebutnya dengan locals():

class A:
    def __init__(self, x, y, z):
        auto_init(locals())

Uji

a = A(1, 2, 3)
print(a.__dict__)

Keluaran:

{'y': 2, 'z': 3, 'x': 1}

Tanpa berubah locals()

Jika Anda tidak ingin mengubah, locals()gunakan versi ini:

def auto_init(local_name_space):
    """Set instance attributes from arguments.
    """
    for name, value in local_name_space.items():
        if name != 'self': 
            setattr(local_name_space['self'], name, value)

Pustaka menarik yang menangani ini (dan menghindari banyak pelat ketel lainnya) adalah attrs . Contoh Anda, misalnya, dapat direduksi menjadi ini (anggap kelasnya dipanggil MyClass):

import attr

@attr.s
class MyClass:
    x = attr.ib()
    y = attr.ib()
    z = attr.ib()

Anda bahkan tidak perlu __init__metode lagi, kecuali itu melakukan hal-hal lain juga. Ini pengantar yang bagus dari Glyph Lefkowitz .

$ 0,02 saya Sangat dekat dengan jawaban Joran Beasley, tetapi lebih elegan:

def __init__(self, a, b, c, d, e, f):
    vars(self).update((k, v) for k, v in locals().items() if v is not self)

Selain itu, jawaban Mike Müller (yang terbaik untuk seleraku) dapat dikurangi dengan teknik ini:

def auto_init(ns):
    self = ns.pop('self')
    vars(self).update(ns)

Dan telepon auto_init(locals())dari Anda__init__

Ini adalah cara alami untuk melakukan sesuatu dengan Python. Jangan mencoba untuk menciptakan sesuatu yang lebih pintar, itu akan mengarah pada kode yang terlalu pintar sehingga tidak seorang pun di tim Anda akan mengerti. Jika Anda ingin menjadi pemain tim dan terus menulis seperti ini.

Python 3.7 dan seterusnya

Dalam Python 3.7, Anda dapat (ab) menggunakan dataclassdekorator, tersedia dari dataclassesmodul. Dari dokumentasi:

Modul ini menyediakan dekorator dan fungsi untuk secara otomatis menambahkan metode khusus yang dihasilkan seperti __init__()dan __repr__()ke kelas yang ditentukan pengguna. Awalnya dijelaskan dalam PEP 557.

Variabel anggota untuk digunakan dalam metode yang dihasilkan ini didefinisikan menggunakan penjelasan jenis PEP 526. Misalnya kode ini:

@dataclass
class InventoryItem:
    '''Class for keeping track of an item in inventory.'''
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost(self) -> float:
        return self.unit_price * self.quantity_on_hand

Akan menambahkan, antara lain, __init__()yang terlihat seperti:

def __init__(self, name: str, unit_price: float, quantity_on_hand: int=0):
      self.name = name
      self.unit_price = unit_price
      self.quantity_on_hand = quantity_on_hand

Perhatikan bahwa metode ini secara otomatis ditambahkan ke kelas: itu tidak secara langsung ditentukan dalam definisi InventoryItem yang ditunjukkan di atas.

Jika kelas Anda besar dan kompleks, mungkin tidak pantas menggunakan a dataclass. Saya menulis ini pada hari rilis Python 3.7.0, jadi pola penggunaannya belum mapan.