CODEWITHSUNDEEP
python-3.xclassproperties
Steffen Schumacher
Steffen Schumacher

Reputation: 97

python property referring to property/attribute of member attribute?

I'm wondering if I have:

class A(object):
    def __init__(self):
        self.attribute = 1
        self._member = 2
    def _get_member(self):
        return self._member
    def _set_member(self, member):
        self._member = member
    member = property(_get_member, _set_member)

class B(object):
    def __init__(self):
        self._member = A()
    def _get_a_member(self):
        return self._member.member
    def _set_a_member(self, member):
        self._member.member = member
    member = property(_get_a_member, _set_a_member)

Can I somehow avoid to write get/setters for A.member, and simply refer to the attribute or property of the A object?

Where the get/setters do logic, its of course needed, but if I simply wan't to expose the member/attributes of a member attribute, then writing get/setters seems like overhead.

I think even if I could write the get/setters inline that would help?

Upvotes: 0

Views: 659

Answers (2)

farzad
farzad

Reputation: 8855

I find the question a bit unclear, however I try to explain some context.

Where the get/setters do logic, its of course needed, but if I simply wan't to expose the member/attributes of a member attribute

If there is no logic in getter/setters, then there is no need to define the attribute as a property, but the attribute can be used directly (in any context).

So

class A(object):
    def __init__(self):
        self.attribute = 1
        self.member = 2

class B(object):
    def __init__(self):
        self.member = A()

B().member.member  # returns 2
B().member.member = 10

In some languages, it's considered good practice to abstract instance properties with getter/setter methods, That's not necessarily the case in Python. Python properties are useful when you'd need more control over the attribute, for example:

  • when there is logic (validation, etc.)
  • to define a readonly attribute (so only providing a getter without a setter)

Update (after the comment)

properties are not necessarily a tool to "hide" some internal implementation. Hiding in Python is a bit different than say in Java, due to very dynamic nature of Python language. It's always possible to introspect and even change objects on the fly, you can add new attributes (even methods) to objects on runtime:

b = B()
b.foo = 4  # define a new attribute on runtime
b.foo  # returns 4

So Python developers rely more on conventions to hint their intentions of abstractions.

About the polymorphic members, I think it's most natural for Python classes to just share an interface, that's what's meant by Duck typing. So as long as your next implementation of A supports the same interface (provides the same methods for callers), it should not be any issue to change its implementation.

Upvotes: 2

Steffen Schumacher
Steffen Schumacher

Reputation: 97

So this is what I came up with - use a method to generate the properties, with the assumption that the obj has an attribute of _member:

def generate_cls_a_property(name):
    """Small helper method for generating a 'dumb' property for the A object"""
    def getter(obj):
        return getattr(obj._member, name)

    def setter(obj, new_value):
        setattr(obj._member, name, new_value)

    return property(getter, setter)

This allows me to add properties like so:

class B(object):
    def __init__(self):
        self._member = A()
    member = generate_cls_a_property('member')  # generates a dumb/pass-through property

I'll accept my own, unless someone tops it within a week.. :)

Upvotes: 0

Related Questions