Назначить аргументы функции `self`

Я разделяю ваше мнение о том, что шаблонный код — это плохо. Но в этом случае я не уверен, что может быть лучшая альтернатива. Рассмотрим возможности.

Если вы говорите всего о нескольких переменных, то легко читается последовательность из self.x = x строк. Фактически, я думаю, что его явность делает этот подход предпочтительным с точки зрения удобочитаемости. И хотя печатать может быть немного неудобно, одного этого недостаточно, чтобы оправдать новую языковую конструкцию, которая может скрыть то, что на самом деле происходит. Конечно, использование vars(self).update() махинаций в этом случае может привести к большей путанице, чем оно того стоит.

С другой стороны, если вы передаете девять, десять или более параметров в __init__, вам, вероятно, все равно придется провести рефакторинг. Таким образом, эта проблема действительно относится только к случаям, когда требуется передать, скажем, 5-8 параметров. Теперь я вижу, как восемь строк self.x = x будут раздражать как при вводе, так и при чтении; но я не уверен, что случай с 5-8 параметрами достаточно распространен или достаточно проблематичен, чтобы оправдать использование другого метода. Так что я думаю, что хотя проблема, о которой вы говорите, в принципе хорошая, на практике существуют другие ограничивающие факторы, которые делают ее неактуальной.

Чтобы конкретизировать этот момент, давайте рассмотрим функцию, которая принимает объект, словарь и список имен и присваивает значения из словаря именам из списка. Это гарантирует, что вы по-прежнему четко указываете, какие переменные присваиваются self. (Я бы никогда не предложил решение этой проблемы, которое не требовало бы явного перечисления присваиваемых переменных; это было бы магнитом для редкоземельных ошибок):

>>> def assign_attributes(obj, localdict, names):
...     for name in names:
...         setattr(obj, name, localdict[name])
...
>>> class SomeClass():
...     def __init__(self, a, b, c):
...         assign_attributes(self, vars(), ['a', 'b', 'c'])

Теперь, хотя это и не является ужасно непривлекательным, это все же сложнее понять, чем простую серию из self.x = x строк. И это также дольше и сложнее набирать, чем одну, две и, может быть, даже три или четыре строки, в зависимости от обстоятельств. Таким образом, вы получаете определенный выигрыш только начиная с пятипараметрического случая. Но это также точный момент, когда вы начинаете приближаться к пределу человеческого объема кратковременной памяти (= 7 +/- 2 "куска"). Итак, в этом случае ваш код уже немного сложен для чтения, и это только усложнит его.

Вы можете сделать это, что имеет достоинство простоты:

>>>  class C(object):
    def __init__(self, **kwargs):
        self.__dict__ = dict(kwargs)

Это оставляет за любым кодом, создающим экземпляр C, решать, какие атрибуты экземпляра будут после построения, например:

>>> c = C(a='a', b='b', c='c')
>>> c.a, c.b, c.c
('a', 'b', 'c')

Если вы хотите, чтобы все объекты C имели атрибуты a, b и c, этот подход не будет полезен.

(Кстати, этот паттерн исходит от Гвидо, его собственного плохого «я», как общее решение проблемы определения перечислений в Python. Создайте класс, подобный приведенному выше, с именем Enum, а затем вы можете написать код, подобный Colors = Enum(Red=0, Green=1, Blue=2), и впредь использовать Colors.Red, Colors.Green и Colors.Blue.)

Это полезное упражнение, чтобы выяснить, какие проблемы могут возникнуть, если вы установите self.__dict__ на kwargs вместо dict(kwargs).

Мод для ответа @pcperini:

>>> class SomeClass():
        def __init__(self, a, b=1, c=2):
            for name,value in vars().items():
                if name != 'self':
                    setattr(self,name,value)

>>> s = SomeClass(7,8)
>>> print s.a,s.b,s.c
7 8 2

Ваш конкретный случай также может быть обработан с помощью namedtuple:

>>> from collections import namedtuple
>>> SomeClass = namedtuple("SomeClass", "a b c")
>>> sc = SomeClass(1, "x", 200)
>>> print sc
SomeClass(a=1, b='x', c=200)
>>> print sc.a, sc.b, sc.c
1 x 200

Вы можете сделать это через setattr(), например:

[setattr(self, key, value) for key, value in kwargs.items()]

Не очень красиво, но может сэкономить место :)

Итак, вы получите:

  kwargs = { 'd':1, 'e': 2, 'z': 3, }

  class P():
     def __init__(self, **kwargs):
        [setattr(self, key, value) for key, value in kwargs.items()]

  x = P(**kwargs)
  dir(x)
  ['__doc__', '__init__', '__module__', 'd', 'e', 'z']

Для этого простого варианта использования я должен сказать, что мне нравится указывать вещи явно (используя Ctrl+1 из PyDev), но иногда я также заканчиваю тем, что использую групповую реализацию, но с классом, в котором принятые атрибуты создаются из предварительно объявленных атрибутов. в классе, чтобы я знал, что ожидается (и мне это нравится больше, чем именованный кортеж, поскольку я нахожу его более читабельным - и это не будет путать статический анализ кода или завершение кода).

Я разместил рецепт по адресу: http://code.activestate.com/recipes/577999-bunch-class-created-from-attributes-in-class/

Основная идея заключается в том, что вы объявляете свой класс как подкласс Bunch, и он создаст эти атрибуты в экземпляре (либо из значений по умолчанию, либо из значений, переданных в конструкторе):

class Point(Bunch):
    x = 0
    y = 0

p0 = Point()
assert p0.x == 0
assert p0.y == 0

p1 = Point(x=10, y=20)
assert p1.x == 10
assert p1.y == 20

Кроме того, Алекс Мартелли также предоставил реализацию связки: http://code.activestate.com/recipes/52308-the-simple-but-handy-collector-of-a-bunch-of-named/ с идеей обновления instance из аргументов, но это запутает статический анализ кода (и IMO может затруднить отслеживание), поэтому я бы использовал этот подход только для экземпляра, созданного локально и выброшенного внутри той же области, не передавая его куда-либо еще).

Магия декоратора!!

>>> class SomeClass():
        @ArgsToSelf
        def __init__(a, b=1, c=2, d=4, e=5):
            pass

>>> s=SomeClass(6,b=7,d=8)
>>> print s.a,s.b,s.c,s.d,s.e
6 7 2 8 5

при определении:

>>> import inspect
>>> def ArgsToSelf(f):
    def act(self, *args, **kwargs):
        arg_names,_,_,defaults = inspect.getargspec(f)
        defaults=list(defaults)
        for arg in args:
            setattr(self, arg_names.pop(0),arg)
        for arg_name,arg in kwargs.iteritems():
            setattr(self, arg_name,arg)
            defaults.pop(arg_names.index(arg_name))
            arg_names.remove(arg_name)
        for arg_name,arg in zip(arg_names,defaults):
            setattr(self, arg_name,arg)
        return f(*args, **kwargs)
    return act

Конечно, вы можете определить этот декоратор один раз и использовать его в своем проекте.
Кроме того, этот декоратор работает с любой функцией объекта, а не только с __init__.

Я решил это для себя, используя locals() и __dict__:

>>> class Test:
...     def __init__(self, a, b, c):
...         l = locals()
...         for key in l:
...             self.__dict__[key] = l[key]
... 
>>> t = Test(1, 2, 3)
>>> t.a
1
>>> 

Отказ от ответственности

Не используйте это: я просто пытался создать ответ, наиболее близкий к первоначальным намерениям ОП. Как указано в комментариях, это зависит от полностью неопределенного поведения и явно запрещенных модификаций таблицы символов.

Однако он работает и был протестирован в чрезвычайно простых условиях.

Решение

class SomeClass():
    def __init__(self, a, b, c):
        vars(self).update(dict((k,v) for k,v in vars().iteritems() if (k != 'self')))

sc = SomeClass(1, 2, 3)
# sc.a == 1
# sc.b == 2
# sc.c == 3

Используя встроенную функцию vars(), этот фрагмент перебирает все переменные, доступные в методе __init__ (которые на данный момент должны быть просто self, a, b и c), и, очевидно, устанавливает переменные self равными одному и тому же. игнорируя аргумент-ссылку на self (потому что self.self кажется плохим решением.)

Одна из проблем с ответом @ user3638162 заключается в том, что locals() содержит переменную 'self'. Следовательно, вы получаете дополнительный self.self. Если человек не возражает против дополнительного «я», это решение может быть просто

class X:
    def __init__(self, a, b, c):
        self.__dict__.update(locals())

x = X(1, 2, 3)
print(x.a, x.__dict__)

self может быть удален после строительства с помощью del self.__dict__['self']

В качестве альтернативы, можно удалить self во время построения, используя понимание словаря, введенное в Python3.

class X:
    def __init__(self, a, b, c):
        self.__dict__.update(l for l in locals().items() if l[0] != 'self')

x = X(1, 2, 3)
print(x.a, x.__dict__)