Automatically-generated Python constructor

Question

I have countless Python classes from various projects from SQLAlchemy (and a couple from Pygame as well), and I recently noticed a pattern in many of them: their constructors always went something like this:

class Foo(Base):
    def __init__(self, first, last, email, mi=""):
        self.first = first
        self.last = last
        self.email = email
        self.mi = mi

... whereby the only thing the constructor did was to transfer a set of positional arguments into an exactly identically named set of data members, performing no calculation or other function calls whatsoever.

It seems to me that this repetition is unnecessary and prone to human error upon change.

This leads me to the question here: is it possible to automatically generate such an __init__(self, ...) function, preferably without mucking around with CPython bytecode or using templates/macros to alter the source file itself?

Muriate

Answer 1

For python >= 3.7, the proper way of handling this is through dataclasses:

This module provides a decorator and functions for automatically adding generated special methods such as __init__() and __repr__() to user-defined classes. It was originally described in PEP 557.

Sforza

Seems like the proper way to do it if you're on >=3.7 – Diffractive

Answer 2

You can probably do this with Metaclasses. Here's an example of a metaclass which overrides __init__(): Python Class Decorator

You will need to somehow specify the field/argument names, of course - or used named arguments, if you prefer. Here's one way to do that:

# This is the mataclass-defined __init__
def auto_init(self, *args, **kwargs):
    for arg_val, arg_name in zip(args, self.init_args):
        setattr(self, arg_name, arg_val)

    # This would allow the user to explicitly specify field values with named arguments
    self.__dict__.update(kwargs)

class MetaBase(type):
    def __new__(cls, name, bases, attrs):
        attrs['__init__'] = auto_init
        return super(MetaBase, cls).__new__(cls, name, bases, attrs)

class Base(object):
    __metaclass__ = MetaBase

# No need to define __init__
class Foo(Base):
    init_args = ['first', 'last', 'email', 'mi']

Stylobate

What is the purpose of class Base? Why not just define the metaclass on Foo, and define the init_args class variable? This would make it a bit clearer what init_args is there for. – Traceable

@Paul: Base is there so you can define as many classes as you want deriving from it, and you won't have to redefine __metaclass__ for each and any one of them. OP wanted to save typing, not the maximum possible clarity. – Stylobate

Answer 3

You can do something like this:

class Foo(Base):
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)

One problem with doing this is there is no guarantee that all instances will have the same members. Another problem is now all constructors must be called with keyword arguments.

Bartholomeo

Answer 4

Check out namedtuple:

>>> from collections import namedtuple
>>> Foo = namedtuple("Foo", "first last email mi")
>>> f = Foo("Alfred", "Neumann", "[email protected]", "E")
>>> f
Foo(first='Alfred', last='Neumann', email='aen@madmagazinecom', mi='E')

Traceable

What the original code has that yours doesn't, though, is a default value of None for the mi field. – Coursing