Python decorator for automatic binding init arguments

Question

Is there a way to automatically bind to self (some of) the arguments of the __init__ method?

I mean something like:

class Person:
    @lazy_init
    def __init__(self, name, age, address):
        ...

... instead of:

class Person:
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        self.address = address
        ...

I wonder if there is something similar that people already use in such cases. Or there is any reason I'm not supposed to do it this way in the first place?

Dataclasses in Python 3.7 will do exactly this. https://www.python.org/dev/peps/pep-0557/ — yeaske, Apr 20 '18 at 04:20

score 8 · Answer 1 · edited Oct 17 '20 at 09:10

8

For future reference for all others who encounter this question in the future (Python 3.7 or above): There is the dataclass decorator that does exactly this.

Example

from dataclasses import dataclass

@dataclass
class Person:
    name
    age
    address

# other methods...

edited Oct 17 '20 at 09:10

mathetes

11,766
7
25
32

answered Nov 18 '19 at 12:20

Adrian

755
9
17

score 7 · Answer 2 · edited Feb 12 '20 at 13:38

7

It's definitely possible, here's a somewhat naive implementation:

from functools import wraps

def lazy_init(init):
    import inspect
    arg_names = inspect.getargspec(init)[0]

    @wraps(init)
    def new_init(self, *args):
        for name, value in zip(arg_names[1:], args):
            setattr(self, name, value)
        init(self, *args)

    return new_init

class Person:
    @lazy_init
    def __init__(self, name, age):
        pass

p = Person("Derp", 13)
print p.name, p.age

Once you start having something besides attributes that map to properties, you're going to run into trouble though. You'll need at least some way to specify which args to initialize as properties... at which point it'll just become more hassle than it's worth.

edited Feb 12 '20 at 13:38

fsenart

5,661
2
35
54

answered Feb 19 '11 at 02:00

Matti Virkkunen

63,558
9
127
159

Thanks. I realize that if the `__init__` method is sophisticated it wouldn't be worth it, but the simple ones are so widespread that I think it would be nice to have something like that at hand. – André Lima Feb 19 '11 at 02:26
requires changes for keyword arguments – vijay shanker Oct 08 '18 at 12:19

score 3 · Answer 3 · answered Nov 24 '21 at 09:12

You can either use data classes as of Python 3.7 like this:

from dataclasses import dataclass

@dataclass
class MyClass:
    var_1: str
    var_2: float

Or you can make use of the store_attr() method from the fastcore lib like this:

from fastcore.utils import store_attr

class MyClass:
    def __init__(self, var_1, var_2):
        store_attr()

Both result in the equivalent init method:

def __init__(self, var_1, var_2):
    self.var_1 = var_1
    self.var_2 = var_2

The dataclass approach seems sufficient enough for most cases :-) — rv.kvetch, Nov 24 '21 at 14:48

score 1 · Accepted Answer · edited May 23 '17 at 12:02

1

http://code.activestate.com/recipes/551763-automatic-attribute-assignment/ is what you're looking for.

Also see What is the best way to do automatic attribute assignment in Python, and is it a good idea?

edited May 23 '17 at 12:02

Community

1
1

answered Feb 19 '11 at 02:07

li.davidm

11,736
4
29
31

12

Comments that are just a link to another resource are pretty bad form. – Miles Rout Sep 05 '16 at 10:45
dv'ed because the implementation is unnecessarily complex. Its almost 2022, and we have [dataclasses](https://docs.python.org/3/library/dataclasses.html) now! – rv.kvetch Nov 24 '21 at 14:49

score -1 · Answer 5 · 2015-05-25T04:23:30.570

initify.py created by me :) it does exactly what you'd expect.

class Animal:
   @init_args(exclude=["name"])
   def __init__(self, name):
       pass

or with default values:

class Animal:
   @init_args
   def __init__(self, name="Default name"):
       pass

or even excluding inheritance:

class Dog(Animal):
   @init_args(exclude=["name"])
   def __init__(self, species):
       pass

https://github.com/prankymat/initify.py

score -1 · Answer 6 · answered Feb 19 '11 at 02:31

Here it goes, in simplest form:

def lazy_init(*param_names):
  def ret(old_init):
    def __init__(self, *args, **kwargs):
      if len(args) > len(param_names):
        raise TypeError("Too many arguments")
      for k in kwargs:
        if k not in param_names:
          raise TypeError("Arg %r unexpected" % k)
      for par, arg in zip(param_names, args):
        setattr(self, par, arg)
      for par, arg in kwargs.items():
        setattr(self, par, arg)
      old_init(*args, **kwargs)
    return __init__
    #
  return ret


class Q(object):
  @lazy_init("a", "b")
  def __init__(self, *args, **kwargs):
    print "Original init"

>>> q = Q(1, 2)
Original init
>>> q.a, q.b
(1, 2)

Consider making a class decorator to cover __str__ too.

Python decorator for automatic binding __init__ arguments

6 Answers6

Example

Python decorator for automatic binding init arguments