Як я уникаю “self.x = x; self.y = y; self.z = z ”шаблон у __init__?

Я бачу подібні зразки

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

досить часто, часто з набагато більшими параметрами. Чи є хороший спосіб уникнути такого виснажливого повторення? Чи повинен наслідувати клас namedtupleзамість цього?

Редагувати: Якщо у вас пітон 3.7+, просто використовуйте класи даних

Рішення для декораторів, яке зберігає підпис:

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__))

Відмова: Мабуть, кілька людей стурбовані презентуванням цього рішення, тому я надам дуже чітку відмову від відповідальності. Не слід використовувати цей розчин. Я надаю це лише як інформацію, тож ви знаєте, що мова на це здатна. Решта відповіді - це лише показ мовних можливостей, а не підтримка їх використання таким чином.

Насправді немає нічого поганого в тому, щоб явно копіювати параметри в атрибути. Якщо у вас є занадто багато параметрів в ctor, іноді це вважається запахом коду, і, можливо, вам слід згрупувати ці парами на меншу кількість об'єктів. В інших випадках це потрібно і в цьому немає нічого поганого. У будь-якому випадку, це робити явно - це шлях.

Однак, оскільки ви запитуєте, ЯК це можна зробити (а не чи варто це робити), тоді одне рішення таке:

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

Як уже згадували інші, повторення непогано, але в деяких випадках названий набір може бути чудовим пристосуванням для такого типу питань. Це дозволяє уникнути використання місцевих жителів () або карворгів, що зазвичай є поганою ідеєю.

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

Я знайшов обмежене використання для нього, але ви можете успадкувати найменування nametuple, як і будь-який інший об'єкт (приклад продовжується):

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()

явне краще, ніж неявне ... тож переконайтеся, що ви можете зробити це більш стислим:

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

Питання краще, чи не варто?

... що сказав, що ви хочете назвати кортеж, я б рекомендував використовувати nametuple (пам’ятайте, кортежі мають до них певні умови) ... можливо, ви хочете впорядкований вирок або навіть просто наказ ...

Для розширення gruszczyвідповіді s я використав такий зразок:

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))

Мені подобається цей метод, тому що він:

• уникає повторення
• стійкий до друкарських помилок при побудові об’єкта
• добре працює з підкласифікацією (може просто super().__init(...))
• дозволяє документувати атрибути на рівні класу (куди вони належать), а не в X.__init__

До Python 3.6 це не контролює порядок встановлення атрибутів, що може бути проблемою, якщо деякі атрибути є властивостями із встановниками, які отримують доступ до інших атрибутів.

Можливо, це можна було б трохи покращити, але я єдиний користувач власного коду, тому мене не турбує будь-яка форма введення даних. Можливо, AttributeErrorбуло б більш доречним.

Ви також можете зробити:

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

Звичайно, вам доведеться імпортувати inspectмодуль.

Це рішення без додаткового імпорту.

Функція помічника

Невелика помічна функція робить його більш зручним та повторним у використанні:

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)

Застосування

Вам потрібно зателефонувати за допомогою locals():

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

Тест

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

Вихід:

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

Не змінюючись locals()

Якщо ви не любите змінювати, locals()скористайтеся цією версією:

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)

Цікава бібліотека, яка обробляє це (і уникає безлічі інших котельних плит) - attrs . Наприклад, ваш приклад можна звести до цього (припустимо, клас називається MyClass):

import attr

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

Вам навіть __init__метод більше не потрібен , якщо тільки це не робить і інші речі. Ось приємний вступ Гліфа Лефковіца .

Мої 0,02 $. Це дуже близька відповідь Джоран Біслі, але більш елегантна:

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)

Крім того, відповідь Майка Мюллера (найкращий на мій смак) можна зменшити за допомогою цієї методики:

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

І справедливий дзвінок auto_init(locals())від вашого__init__

Це природний спосіб робити речі в Python. Не намагайтеся вигадувати щось більш розумне, це призведе до надто розумного коду, який ніхто з вашої команди не зрозуміє. Якщо ви хочете бути гравцем команди, а потім продовжуйте писати так.

Python 3.7 і далі

У Python 3.7 ви можете (ab) використовувати dataclassдекоратор, доступний у dataclassesмодулі. З документації:

Цей модуль пропонує декоратор та функції автоматичного додавання створених спеціальних методів, таких як __init__()і__repr__() визначені користувачем класи. Спочатку було описано в PEP 557.

Змінні учасника, які використовуються в цих згенерованих методах, визначаються за допомогою анотацій типу PEP 526. Наприклад цей код:

@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

Додамо, серед іншого, такий, __init__()який виглядає так:

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

Зауважте, що цей метод автоматично додається до класу: він не вказаний безпосередньо у визначенні InventoryItem, показаному вище.

Якщо ваш клас великий і складний, використовувати його може бути недоречно dataclass. Я пишу це в день випуску Python 3.7.0, тому схеми використання ще не налагоджені.