FilesExpand file tree

 master

/

lazy_evaluation.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

111 lines (82 loc) · 2.74 KB

 master

/

lazy_evaluation.py

Copy path

Top

File metadata and controls

• Code
• Blame

111 lines (82 loc) · 2.74 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

"""

Lazily-evaluated property pattern in Python.

https://en.wikipedia.org/wiki/Lazy_evaluation

*References:

bottle

https://github.com/bottlepy/bottle/blob/cafc15419cbb4a6cb748e6ecdccf92893bb25ce5/bottle.py#L270

django

https://github.com/django/django/blob/ffd18732f3ee9e6f0374aff9ccf350d85187fac2/django/utils/functional.py#L19

pip

https://github.com/pypa/pip/blob/cb75cca785629e15efb46c35903827b3eae13481/pip/utils/__init__.py#L821

pyramid

https://github.com/Pylons/pyramid/blob/7909e9503cdfc6f6e84d2c7ace1d3c03ca1d8b73/pyramid/decorator.py#L4

werkzeug

https://github.com/pallets/werkzeug/blob/5a2bf35441006d832ab1ed5a31963cbc366c99ac/werkzeug/utils.py#L35

*TL;DR

Delays the eval of an expr until its value is needed and avoids repeated evals.

"""

import functools

class lazy_property:

def __init__(self, function):

self.function = function

functools.update_wrapper(self, function)

def __get__(self, obj, type_):

if obj is None:

return self

val = self.function(obj)

obj.__dict__[self.function.__name__] = val

return val

def lazy_property2(fn):

"""

A lazy property decorator.

The function decorated is called the first time to retrieve the result and

then that calculated result is used the next time you access the value.

"""

attr = "_lazy__" + fn.__name__

@property

def _lazy_property(self):

if not hasattr(self, attr):

setattr(self, attr, fn(self))

return getattr(self, attr)

return _lazy_property

class Person:

def __init__(self, name, occupation):

self.name = name

self.occupation = occupation

self.call_count2 = 0

@lazy_property

def relatives(self):

# Get all relatives, let's assume that it costs much time.

relatives = "Many relatives."

return relatives

@lazy_property2

def parents(self):

self.call_count2 += 1

return "Father and mother"

def main():

"""

>>> Jhon = Person('Jhon', 'Coder')

>>> Jhon.name

'Jhon'

>>> Jhon.occupation

'Coder'

# Before we access `relatives`

>>> sorted(Jhon.__dict__.items())

[('call_count2', 0), ('name', 'Jhon'), ('occupation', 'Coder')]

>>> Jhon.relatives

'Many relatives.'

# After we've accessed `relatives`

>>> sorted(Jhon.__dict__.items())

[('call_count2', 0), ..., ('relatives', 'Many relatives.')]

>>> Jhon.parents

'Father and mother'

>>> sorted(Jhon.__dict__.items())

[('_lazy__parents', 'Father and mother'), ('call_count2', 1), ..., ('relatives', 'Many relatives.')]

>>> Jhon.parents

'Father and mother'

>>> Jhon.call_count2

1

"""

if __name__ == "__main__":

import doctest

doctest.testmod(optionflags=doctest.ELLIPSIS)