Python 2.7: Is it good practice to set all args/kwargs attribute with setattr?

Question

In this answer it is shown how to automatically set as attribute the kwargs/args passed to a class __init__

For example, one could do:

class Employee(object):
    def __init__(self, *initial_data, **kwargs):
        # EDIT
        self._allowed_attrs = ['name', 'surname', 'salary', 'address', 'phone', 'mail']

        for dictionary in initial_data:
            for key in dictionary:   
                if key in self._allowed_attrs:  # EDIT
                    setattr(self, key, dictionary[key])
        for key in kwargs:
            if key in self._allowed_attrs:  # EDIT
                setattr(self, key, kwargs[key])

In my case I already know in advance the arguments I am going to pass, so I am considering this solution only to have a less repetitive and shorter code.

Is this considered good practice? Which are the pro/cons of this solutions against manually initialise each attribute? Is there any other preferable approach?

EDIT: As the first comments/answers (rightly) focus on sanitizing arguments or listing arguments, I think this can be solved quite easily in this framework.

Answer 1

Question: ... less repetitive and shorter code

Your example code needs, 9 Lines and 28 Keywords.

class Employee(object):
    def __init__(self, name, surname, salary, address, phone, mail):
        self.name = name
        self.surname = surename
        self.salary = salary
        self.address = address
        self.phone = phone
        self.mail = mail

This default one needs, 6 Lines and 19 Keywords. Summary, your example needs more not "shorter code". I can't see any "repetitive ... code" in the default one, all assignments are done once.

Compared these two lines, doing the same. Control which args can passed:

self._allowed_attrs = ['name', 'surname', 'salary', 'address', 'phone', 'mail']  

with

def __init__(self, name, surname, salary, address, phone, mail):

The second one need less effort and do it all in one.
No if key in self._allowed_attrs: necessary, as python does it for you.

---

In a real project, I would use something like this

class Employee(object):
    def __init__(self, person, salary=None):
        self.id = unique_id()
        self.person = person
        self.salary = salary

All person related data are to be summarized in object person.

---

Conclusion:
For your given example class Employee i would never use (*args, **kwargs).
(*args, **kwargs) arguments are only usefull if one can't predict which args are passed.

Answer 2

It makes it impossible to figure out what kind of arguments the class expects.

If someone (or you in a few months' time) wants to create an Employee in their code, they look at the arguments of the constructor to see what they should pass (maybe by hand, or maybe an IDE automatically shows them). Your code achieves little except hiding this.

Answer 3

Prior discussion: Python decorator to automatically define __init__ variables, Python: Is it a good idea to dynamically create variables?

Pros:

• Reduces code duplication

Cons:

• Less readable
• Makes it harder to locate member references (thus may also upset static analyzers like pylint)
• The amount of boilerplate code needed to handle all scenarios (e.g. a positional argument passed as a keyword one; check that all required arguments are present) makes code reduction nonexistent and duplicates stock subroutine invocation code
• Requiring a lot of arguments in a constructor that are to be simply set as members is an anti-pattern in and of itself

Answer 4

It is perfectly ok to use the language introspection capabilities to reduce teh ammoutn of repetion and typing you have to do.

Of course, it is better if you are taking care to handle the attributes correctly, and even sanitize contents - so the best thing is to have either a decorator for the __init__ method, or the equivalent of it in the base-class __init__ that will do everything that is wanted: check if the passed parameters are ok for the specific class, and then use setattr to set their values within the instance.

I think the less magic way is to have a convention in your class hierarchy to declare the wanted parameters as class attributes. In that way, you could use those class attributes to document the expected parameters and their type, and keep the __init__ signature as *args, **kwargs and have your base-class init handle them all.

SQLAlchemy Base models do that - you specify the class attributes as special "instrumented attributes" and they are automatically assigned when called in __init__.

A simpler way would be:

_sentinel = object()

class Base(object):
    def __init__(self, *args, **kwargs):
        for attr_name, class_attr in self.__class__.__dict__.items():
            if isinstance(class_attr, type) and kwargs.get(attr_name, _sentinel) != _sentinel:
                attr_value = kwargs[attr_name]
                if not isinstance(attr_value, class_attr):
                    raise TypeError("Parameter {} is expected to be of type {}".format(attr_name, class_attr))
                setattr(self, attr_name, attr_value)


class Person(Base):
    name = str
    age = int
    phonenumber = Phone
    ...

This would require all parameters to the class to be passed as named parameters - but all of them would automatically be assigned to instance attributes, it would work, be documentable and safe. If you want to get even better, just define some fancy descriptor class to be your class attr value.