如何优雅地将类的所有属性作为函数中的参数传递？

Question

I have a somewhat complex class Thing , and an associated mixin IterMixin (to make the class iterable)...and a funky method elsewhere in the codebase which receives an instance of my class as an argument.

In fact, I'm attempting to bundle up a bunch of parameters as single object to be passed to multiple external functions beyond the funky function below. A parameter object design pattern of sorts...

class IterMixin():
    def __iter__(self):
        for attr, value in self.__dict__.items():
            yield attr, value

class Thing(IterMixin):
    def __iter__(self, foo=None, bar=None, baz=999):

        if foo is None:
            self.foo = {}
        else:
            self.foo = foo

        if bar is None:
            self.foo = {}
        else:
            self.bar = bar

        self.baz = baz

    @property
    def foo(self):
        return self._foo

    @foo.setter
    def foo(self, data)
        self._foo = self.parser(data)

    @property
    def bar(self):
        return self._bar

    @bar.setter
    def bar(self, more_data)
        self._bar, self.baz = self.another_parser(more_data)

    def parser(self, data):
        ...do stuff...
        return foo

    def another_parser(self, more_data):
        ...do add'l stuff...
        return bar, baz

With regard to the funky function, in a completely different module, via the Thing class, I want to pass Thing 's attributes ( foo , bar , and baz ) to the funky function as one argument ...like so:

    thing_args = Thing()

    def funky(*thing_args):
        ...do stuff...
        ...expecting to manipulate keys from things_arg
        ...
        return whatever

PROBLEM:

If I do not make the setters for the attributes foo and bar private (for example, via self._foo )--ie, by way of an underscore--then I evoke infinite recursion during class initialization ...as the __init__ and setters for these attributes loop over and over and repeatedly call themselves. To avoid that, I used the @property decorator and "privatized" the foo and bar while setting them.

However, when I pass an instance of the Thing class, and unpack its attributes as args in the funky function via a splat or asterick, if I introspect the resultant keys for those attributes, I still get _foo and _bar . I can't seem to get rid of the underscores. (In other words, I get the "privatized" attribute names of Thing .)

The biz logic of funky needs the unpacked values to not have any underscores.

Why is this happening (the underscores upon unpacking)? How can I fix this? Is there a more elegant way to either initialize the foo and bar attributes without privatizing anything? Or perhaps a more Pythonic way to pass all the attributes in the Thing class to my funky function?

Answer 1

First, you've got a major problem that will prevent you from even seeing the problem you've asked for help with: Your Thing class defines an __iter__ method that doesn't super , and doesn't yield or return anything. Hopefully that part is just some typo and you know how to fix it to do whatever you actually wanted there.

No, onto the problem you're asking about:

class IterMixin():
    def __iter__(self):
        for attr, value in self.__dict__.items():
            yield attr, value

Try printing out the __dict__ of your instances. Or, better, instances of a minimal example like this:

class Thing:
    @property
    def foo(self):
        return self._foo
    @foo.setter
    def foo(self, data):
        self._foo = data

t = Thing()
t.foo = 2
print(t.__dict__)

The output is {'_foo': 2} .

You've tried to hide the attributes by giving them private names and putting them behind properties, but then you've gone around behind the properties' backs and looked directly into the __dict__ where the real attributes are.

And what else could be there? Your actual _foo has to be stored somewhere on each instance. That foo , on the other hand, isn't really a value, it's a getter/setter that uses that private attribute, so it isn't stored anywhere.

If you really want to use reflection to find all of the "public values" on an instance, you can do something like this:

for attr, value in inspect.getmembers(self):
    if not attr.startswith('_') and not callable(value):
        yield attr, value

However, I think it would be much better to not do this reflectively. Simpler and cleaner options include:

• Add a _fields = 'foo', 'bar', 'baz' and have the base class iterate _fields_ .
• Write a decorator that registers a property, and have the base class iterate that registry.
• Build something that lets you specify the attributes more declaratively and writes the boilerplate for you. See namedtuple , dataclass , and attrs for some inspiration.
• Just use attrs (or, if you're not the OP but someone reading this from the future who can rely on 3.7+, dataclass ) to do that work for you.
• Rethink your design. A class whose instances iterate name-value pairs of their public attributes is weird in the first place. A "parameter object" that acted like a mapping to be used for keyword-splatting could be useful; one that acted like a normal iterable could be useful; one that acts as an iterable of name-value pairs is useless for anything except for passing to a dict construct (at which point it's, again, simpler to be a mapping). Plus, a mixin is really not helping you with the hard part of doing it. Whatever you actually need to do, ask for help on how to do that, instead of how to make this code that shouldn't work work anyway.