访问指向对象的类中的成员变量的方法的正确方法是什么？

Question

What's the correct way to define/access methods of a member variable in a class pointing to an object?

For example, I have a class Foo that has a method foo_method :

class Foo:
    def foo_method(self):
        return 'bar'

Now, in another class Bar , I'd like to store an object to this class (I do not want Bar to inherit Foo ).

What is the correct/recommended way to define class Bar ?

class Bar:
    def __init__(self):
        self.foo = Foo()

# OR

class Bar:
    def __init__(self):
        self.foo = Foo()

    def bar_method(self):
        return self.foo.bar()

The former will allow me to use:

x = Bar()
x.foo.foo_method()

But, with this I'm directly accessing methods of a member variable (strong coupling).

The benefits I see with this approach are:

• I don't have to wrap every new method that gets added to class Foo .
• Bar may contain more member variables pointing to other classes. Not wrapping them keeps Bar smaller and manageable in size.
• The auto-completion facility from IDE (PyCharm, etc.) or IPython helps inspect bar like a menu ( x.foo ) followed by a sub-menu ( x.foo.foo_method() , x.bar.foobar() , etc.) making it easier to develop code.
• Functional programming look-n-feel (not sure if this a pro or con)

The cons are strong coupling, not encapsulating internal details of foo , etc.

I wanted to check if this a recommended practice? And/or if there are any guidelines related to this (kind of implementing a composite pattern)?

Any inputs/pointers will be highly appreciated!

Answer 1

There are no real guidelines, but if you make a bar_method() that explicitly calls foo.bar() and does nothing in between it's the exact same coupling and less convenient.

Python's idioms include " We are all responsible users " and in that case, when encapsulation does not provide you any benefit, I personally wouldn't use proxy functions. Leaving it as is results in smaller code which is easier to maintain and is more accessible. Auto-completion as you mentioned is just an added bonus.