FilesExpand file tree

 master

/

factory_method.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

73 lines (54 loc) · 2.23 KB

 master

/

factory_method.py

Copy path

Top

File metadata and controls

• Code
• Blame

73 lines (54 loc) · 2.23 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

#!/usr/bin/env python

# -*- coding: utf-8 -*-

"""*What is this pattern about?

The Factory Method pattern can be used to create an interface for a

method, leaving the implementation to the class that gets

instantiated.

*What does this example do?

The code shows a way to localize words in two languages: English and

Greek. "getLocalizer" is the factory method that constructs a

localizer depending on the language chosen. The localizer object will

be an instance from a different class according to the language

localized. However, the main code does not have to worry about which

localizer will be instantiated, since the method "get" will be called

in the same way independently of the language.

*Where can the pattern be used practically?

The Factory Method can be seen in the popular web framework Django:

http://django.wikispaces.asu.edu/*NEW*+Django+Design+Patterns For

example, in a contact form of a web page, the subject and the message

fields are created using the same form factory (CharField()), even

though they have different implementations according to their

purposes.

*References:

http://ginstrom.com/scribbles/2007/10/08/design-patterns-python-style/

https://fkromer.github.io/python-pattern-references/design/#factory-method

https://sourcemaking.com/design_patterns/factory_method

*TL;DR80

Creates objects without having to specify the exact class.

"""

class GreekGetter(object):

"""A simple localizer a la gettext"""

def __init__(self):

self.trans = dict(dog="σκύλος", cat="γάτα")

def get(self, msgid):

"""We'll punt if we don't have a translation"""

return self.trans.get(msgid, str(msgid))

class EnglishGetter(object):

"""Simply echoes the msg ids"""

def get(self, msgid):

return str(msgid)

def get_localizer(language="English"):

"""The factory method"""

languages = dict(English=EnglishGetter, Greek=GreekGetter)

return languages[language]()

if __name__ == '__main__':

# Create our localizers

e, g = get_localizer(language="English"), get_localizer(language="Greek")

# Localize some text

for msgid in "dog parrot cat bear".split():

print(e.get(msgid), g.get(msgid))

### OUTPUT ###

# dog σκύλος

# parrot parrot

# cat γάτα

# bear bear