свойства и наследование python

Я просто предпочитаю повторять property() так же, как вы будете повторять декоратор @classmethod при переопределении метода класса.

Хотя это кажется очень подробным, по крайней мере, для стандартов Python, вы можете заметить:

1) для свойств только для чтения property можно использовать как декоратор:

class Foo(object):
    @property
    def age(self):
        return 11

class Bar(Foo):
    @property
    def age(self):
        return 44

2) в Python 2.6 в property появилась пара методов setter и deleter, которые могут использовать для применения к общим свойствам ярлык, уже доступный для свойств только для чтения:

class C(object):
    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

Я не согласен с тем, что выбранный ответ является идеальным способом переопределения методов свойств. Если вы ожидаете, что геттеры и сеттеры будут переопределены, вы можете использовать лямбду для предоставления доступа к себе с чем-то вроде lambda self: self.<property func>.

Это работает (по крайней мере) для версий Python с 2.4 по 3.6.

Если кто-нибудь знает способ сделать это, используя свойство как декоратор, а не как прямой вызов свойства (), я хотел бы это услышать!

Пример:

class Foo(object):
    def _get_meow(self):
        return self._meow + ' from a Foo'
    def _set_meow(self, value):
        self._meow = value
    meow = property(fget=lambda self: self._get_meow(),
                    fset=lambda self, value: self._set_meow(value))

Таким образом, переопределение может быть легко выполнено:

class Bar(Foo):
    def _get_meow(self):
        return super(Bar, self)._get_meow() + ', altered by a Bar'

так что:

>>> foo = Foo()
>>> bar = Bar()
>>> foo.meow, bar.meow = "meow", "meow"
>>> foo.meow
"meow from a Foo"
>>> bar.meow
"meow from a Foo, altered by a Bar"

Я обнаружил это на сайте играть.

Другой способ сделать это без необходимости создавать какие-либо дополнительные классы. Я добавил метод set, чтобы показать, что вы делаете, если вы переопределяете только один из двух:

class Foo(object):
    def _get_age(self):
        return 11

    def _set_age(self, age):
        self._age = age

    age = property(_get_age, _set_age)


class Bar(Foo):
    def _get_age(self):
        return 44

    age = property(_get_age, Foo._set_age)

Это довольно надуманный пример, но вы должны уловить идею.

Да, это способ сделать это; объявление свойства выполняется во время выполнения определения родительского класса, что означает, что он может «видеть» только версии методов, которые существуют в родительском классе. Поэтому, когда вы переопределяете один или несколько из этих методов в дочернем классе, вам необходимо повторно объявить свойство, используя версию метода (методов) дочернего класса.

Возможный обходной путь может выглядеть так:

class Foo:
    def __init__(self, age):
        self.age = age

    @property
    def age(self):
        print('Foo: getting age')
        return self._age

    @age.setter
    def age(self, value):
        print('Foo: setting age')
        self._age = value


class Bar(Foo):
    def __init__(self, age):
        self.age = age

    @property
    def age(self):
        return super().age

    @age.setter
    def age(self, value):
        super(Bar, Bar).age.__set__(self, value)

if __name__ == '__main__':
    f = Foo(11)
    print(f.age)
    b = Bar(44)
    print(b.age)

Он печатает

Foo: setting age
Foo: getting age
11
Foo: setting age
Foo: getting age
44

Идея взята из «Поваренной книги Python» Дэвида Бизли и Брайана К. Джонса. Использование Python 3.5.3 в Debian GNU/Linux 9.11 (растяжка)

Я согласен с вашим решением, которое кажется методом шаблона на лету. Эта статья посвящена вашей проблеме и предлагает именно ваше решение.

Что-то вроде этого будет работать

class HackedProperty(object):
    def __init__(self, f):
        self.f = f
    def __get__(self, inst, owner):    
        return getattr(inst, self.f.__name__)()

class Foo(object):
    def _get_age(self):
        return 11
    age = HackedProperty(_get_age)

class Bar(Foo):
    def _get_age(self):
        return 44

print Bar().age
print Foo().age

То же, что и @mr-b, но с декоратором.

class Foo(object):
    def _get_meow(self):
        return self._meow + ' from a Foo'
    def _set_meow(self, value):
        self._meow = value
    @property
    def meow(self):
        return self._get_meow()
    @meow.setter
    def meow(self, value):
        self._set_meow(value)

Таким образом, переопределение может быть легко выполнено:

class Bar(Foo):
    def _get_meow(self):
        return super(Bar, self)._get_meow() + ', altered by a Bar'

Я столкнулся с проблемами при установке свойства в родительском классе из дочернего класса. Следующий обходной путь расширяет свойство родителя, но делает это путем прямого вызова метода _set_age родителя. Морщинистый всегда должен быть правильным. Хотя это немного javathonic.

import threading


class Foo(object):
    def __init__(self):
        self._age = 0

    def _get_age(self):
        return self._age

    def _set_age(self, age):
        self._age = age

    age = property(_get_age, _set_age)


class ThreadsafeFoo(Foo):

    def __init__(self):
        super(ThreadsafeFoo, self).__init__()
        self.__lock = threading.Lock()
        self.wrinkled = False

    def _get_age(self):
        with self.__lock:
             return super(ThreadsafeFoo, self).age

    def _set_age(self, value):
        with self.__lock:
            self.wrinkled = True if value > 40 else False
            super(ThreadsafeFoo, self)._set_age(value)

    age = property(_get_age, _set_age)

Я думаю, что ответ из Владимир Золотых почти оптимален.
Насколько я понимаю, несколько лучшим вариантом может быть вызов конструктора суперкласса.
В результате получается следующий код :

class Foo:
    def __init__(self, age):
        self.age = age

    @property
    def age(self):
        print("Foo: getting age")
        return self._age

    @age.setter
    def age(self, value):
        print("Foo: setting age")
        self._age = value


class Bar(Foo):
    def __init__(self, age):
        super().__init__(age)


if __name__ == "__main__":
    a = Foo(11)
    print(a.age)
    b = Bar(44)
    print(b.age)

С этим решением нет необходимости переопределять свойство для подкласса. Просто скажите подклассу, что он должен вести себя как суперкласс, используя конструктор.

Верхние строки приводят к следующему выводу

Foo: setting age
Foo: getting age
11
Foo: setting age
Foo: getting age
44

с питоном3.

class Foo:
    # Template method
    @property
    def age(self):
        return self.dothis()
    # Hook method of TM is accessor method of property at here
    def dothis(self):
        return 11
class Bar(Foo):
    def dothis(self):
        return 44

То же, что и у Низама Мохамеда, просто упомянем руководство по стилю 2.13. .4 с использованием как метода шаблона, так и свойства