Computed static property in python

Question

Is it possible to have a static property on a class that would be computed as a one off. The idea would be to be able to do it like so:

class Foo:
    static_prop = Foo.one_off_static_method()

    @staticmethod
    def one_off_static_method():
        return 'bar'

I thought of using __new__ as well.

Class Foo:
    def __new__(cls):
         cls.static_prop = ... do everything here

Not sure the implications of that though.

Do you want this lazily evaluated (and is it actually something sufficiently expensive and sufficiently likely to never be used that lazy evaluation makes sense)? — user2357112, Sep 14 '16 at 20:15
Do you want it computed at first-use or at class definition time? — wim, Sep 14 '16 at 20:17
This is what I use: http://stackoverflow.com/a/6849299/107660 — Duncan, Sep 14 '16 at 20:30
@user2357112 It is expensive, a file gets opened read and a data structure is created. — mkohram, Sep 14 '16 at 20:41

wim · Accepted Answer · 2022-06-29T14:43:03.670

6

If you want it computed at class definition time, see chepner's answer - although I would recommend just to use a module level function instead.

If you want it lazily evaluated, per instance, then you might be interested in functools.cached_property.

>>> from random import random
>>> from functools import cached_property
>>> class Foo(object):
...     @cached_property
...     def one_off_thing(self):
...         print("computing...")
...         return random()
...     
>>> foo = Foo()
>>> foo.one_off_thing
computing...
0.5804382038855782
>>> foo.one_off_thing
0.5804382038855782

Note: stdlib functools.cached_property requires Python 3.8+, for Python < 3.8 you can pip install cached_property.

edited Jun 29 '22 at 14:43

answered Sep 14 '16 at 20:30

wim

338,267
99
616
750

This would be computed once per instance though right? – mkohram Sep 14 '16 at 20:53
Yes, once per instance. – wim Sep 14 '16 at 21:00

Bharel · Answer 2 · 2016-09-14T20:56:55.167

3

Here you go, I made a small descriptor for you :-)

Upon accessing the attribute, it will be computed and cached.

class CachedStaticProperty:
    """Works like @property and @staticmethod combined"""

    def __init__(self, func):
        self.func = func

    def __get__(self, inst, owner):
        result = self.func()
        setattr(owner, self.func.__name__, result)
        return result

The way it works is rather simple:

Upon using the decorator syntax, I save the function internally.
Upon access, I call the function and set the value as the class value with the same name as the original function.

That's all there is to it. Simple and efficient.

edited Sep 14 '16 at 20:56

answered Sep 14 '16 at 20:39

Bharel

23,672
5
40
80

@mkohram Whoops, here you go :-) It's even smaller :P – Bharel Sep 14 '16 at 20:52
@mkohram Added a small explanation. – Bharel Sep 14 '16 at 20:57

score 1 · Answer 3 · answered Sep 14 '16 at 20:16

Until the class is actually created, one_off_static_method is just a regular function. It needs to be defined before you attempt to call it, since you want to call it while the class statement is being executed. Once you are done with it, you can simply delete it.

class Foo:
    def _one_off_static_method():
        return 'bar'

    static_prop = _one_off_static_method()
    del _one_off_static_method

score 1 · Answer 4 · answered Jul 31 '19 at 19:04

Starting in Python 3.8 there will be a cached_property decorator included in the Python builtin/core functools library.

https://docs.python.org/dev/library/functools.html?highlight=s#functools.cached_property

Other questions on this website have similar answers. Some highlights are that one can do

@property
@functools.lru_cache(1)

(both Python builtins) for a similar effect. And that some web server libraries like Flask or Werkzeug already include their own implementations of cached_property decorators.

There are of course other ways (as mentioned in the other answers to this question and the answers to other questions) that one can create their own custom cached property decorators.

python: are property fields being cached automatically?
Is there a decorator to simply cache function return values?

Computed static property in python

4 Answers4