FilesExpand file tree

 master

/

flyweight.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

84 lines (66 loc) · 2.35 KB

 master

/

flyweight.py

Copy path

Top

File metadata and controls

• Code
• Blame

84 lines (66 loc) · 2.35 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

"""

*What is this pattern about?

This pattern aims to minimise the number of objects that are needed by

a program at run-time. A Flyweight is an object shared by multiple

contexts, and is indistinguishable from an object that is not shared.

The state of a Flyweight should not be affected by it's context, this

is known as its intrinsic state. The decoupling of the objects state

from the object's context, allows the Flyweight to be shared.

*What does this example do?

The example below sets-up an 'object pool' which stores initialised

objects. When a 'Card' is created it first checks to see if it already

exists instead of creating a new one. This aims to reduce the number of

objects initialised by the program.

*References:

http://codesnipers.com/?q=python-flyweights

https://python-patterns.guide/gang-of-four/flyweight/

*Examples in Python ecosystem:

https://docs.python.org/3/library/sys.html#sys.intern

*TL;DR

Minimizes memory usage by sharing data with other similar objects.

"""

import weakref

class Card:

"""The Flyweight"""

# Could be a simple dict.

# With WeakValueDictionary garbage collection can reclaim the object

# when there are no other references to it.

_pool = weakref.WeakValueDictionary()

def __new__(cls, value, suit):

# If the object exists in the pool - just return it

obj = cls._pool.get(value + suit)

# otherwise - create new one (and add it to the pool)

if obj is None:

obj = object.__new__(Card)

cls._pool[value + suit] = obj

# This row does the part we usually see in `__init__`

obj.value, obj.suit = value, suit

return obj

# If you uncomment `__init__` and comment-out `__new__` -

# Card becomes normal (non-flyweight).

# def __init__(self, value, suit):

# self.value, self.suit = value, suit

def __repr__(self):

return "<Card: {}{}>".format(self.value, self.suit)

def main():

"""

>>> c1 = Card('9', 'h')

>>> c2 = Card('9', 'h')

>>> c1, c2

(<Card: 9h>, <Card: 9h>)

>>> c1 == c2

True

>>> c1 is c2

True

>>> c1.new_attr = 'temp'

>>> c3 = Card('9', 'h')

>>> hasattr(c3, 'new_attr')

True

>>> Card._pool.clear()

>>> c4 = Card('9', 'h')

>>> hasattr(c4, 'new_attr')

False

"""

if __name__ == "__main__":

import doctest

doctest.testmod()