Category: python Design Patterns

Python Design Patterns – Prototype ”; Previous Next Prototype design pattern helps to hide the complexity of the instances created by the class. The concept of the existing object will differ with that of the new object, which is created from scratch. The newly copied object may have some changes in the properties if required. This approach saves time and resources that go in for the development of a product. How to implement a prototype pattern? Let us now see how to implement a prototype pattern. import copy class Prototype: _type = None _value = None def clone(self): pass def getType(self): return self._type def getValue(self): return self._value class Type1(Prototype): def __init__(self, number): self._type = “Type1” self._value = number def clone(self): return copy.copy(self) class Type2(Prototype): “”” Concrete prototype. “”” def __init__(self, number): self._type = “Type2” self._value = number def clone(self): return copy.copy(self) class ObjectFactory: “”” Manages prototypes. Static factory, that encapsulates prototype initialization and then allows instatiation of the classes from these prototypes. “”” __type1Value1 = None __type1Value2 = None __type2Value1 = None __type2Value2 = None @staticmethod def initialize(): ObjectFactory.__type1Value1 = Type1(1) ObjectFactory.__type1Value2 = Type1(2) ObjectFactory.__type2Value1 = Type2(1) ObjectFactory.__type2Value2 = Type2(2) @staticmethod def getType1Value1(): return ObjectFactory.__type1Value1.clone() @staticmethod def getType1Value2(): return ObjectFactory.__type1Value2.clone() @staticmethod def getType2Value1(): return ObjectFactory.__type2Value1.clone() @staticmethod def getType2Value2(): return ObjectFactory.__type2Value2.clone() def main(): ObjectFactory.initialize() instance = ObjectFactory.getType1Value1() print “%s: %s” % (instance.getType(), instance.getValue()) instance = ObjectFactory.getType1Value2() print “%s: %s” % (instance.getType(), instance.getValue()) instance = ObjectFactory.getType2Value1() print “%s: %s” % (instance.getType(), instance.getValue()) instance = ObjectFactory.getType2Value2() print “%s: %s” % (instance.getType(), instance.getValue()) if __name__ == “__main__”: main() Output The above program will generate the following output − The output helps in creating new objects with the existing ones and it is clearly visible in the output mentioned above. Print Page Previous Next Advertisements ”;

Python Design Patterns – Command ”; Previous Next Command Pattern adds a level of abstraction between actions and includes an object, which invokes these actions. In this design pattern, client creates a command object that includes a list of commands to be executed. The command object created implements a specific interface. Following is the basic architecture of the command pattern − How to implement the command pattern? We will now see how to implement the design pattern. def demo(a,b,c): print ”a:”,a print ”b:”,b print ”c:”,c class Command: def __init__(self, cmd, *args): self._cmd=cmd self._args=args def __call__(self, *args): return apply(self._cmd, self._args+args) cmd = Command(dir,__builtins__) print cmd() cmd = Command(demo,1,2) cmd(3) Output The above program generates the following output − Explanation The output implements all the commands and keywords listed in Python language. It prints the necessary values of the variables. Print Page Previous Next Advertisements ”;

Python Design Patterns – Adapter ”; Previous Next Adapter pattern works as a bridge between two incompatible interfaces. This type of design pattern comes under structural pattern as this pattern combines the capability of two independent interfaces. This pattern involves a single class, which is responsible to join functionalities of independent or incompatible interfaces. A real life example could be the case of a card reader, which acts as an adapter between memory card and a laptop. You plug in the memory card into the card reader and the card reader into the laptop so that memory card can be read via the laptop. The adapter design pattern helps to work classes together. It converts the interface of a class into another interface based on requirement. The pattern includes a speciation a polymorphism which names one name and multiple forms. Say for a shape class which can use as per the requirements gathered. There are two types of adapter pattern − Object Adapter Pattern This design pattern relies on object implementation. Hence, it is called the Object Adapter Pattern. Class Adapter Pattern This is an alternative way to implement the adapter design pattern. The pattern can be implemented using multiple inheritances. How to implement the adapter pattern? Let us now see how to implement the adapter pattern. class EuropeanSocketInterface: def voltage(self): pass def live(self): pass def neutral(self): pass def earth(self): pass # Adaptee class Socket(EuropeanSocketInterface): def voltage(self): return 230 def live(self): return 1 def neutral(self): return -1 def earth(self): return 0 # Target interface class USASocketInterface: def voltage(self): pass def live(self): pass def neutral(self): pass # The Adapter class Adapter(USASocketInterface): __socket = None def __init__(self, socket): self.__socket = socket def voltage(self): return 110 def live(self): return self.__socket.live() def neutral(self): return self.__socket.neutral() # Client class ElectricKettle: __power = None def __init__(self, power): self.__power = power def boil(self): if self.__power.voltage() > 110: print “Kettle on fire!” else: if self.__power.live() == 1 and self.__power.neutral() == -1: print “Coffee time!” else: print “No power.” def main(): # Plug in socket = Socket() adapter = Adapter(socket) kettle = ElectricKettle(adapter) # Make coffee kettle.boil() return 0 if __name__ == “__main__”: main() Output The above program generates the following output − Explanation The code includes adapter interface with various parameters and attributes. It includes Adaptee along with Target interface that implements all the attributes and displays the output as visible. Print Page Previous Next Advertisements ”;

Python Design Patterns – Gist ”; Previous Next Python is an open source scripting language, which is high-level, interpreted, interactive and object-oriented. It is designed to be highly readable. The syntax of Python language is easy to understand and uses English keywords frequently. Features of Python Language In this section, we will learn about the different features of Python language. Interpreted Python is processed at runtime using the interpreter. There is no need to compile program before execution. It is similar to PERL and PHP. Object-Oriented Python follows object-oriented style and design patterns. It includes class definition with various features like encapsulation, polymorphism and many more. Portable Python code written in Windows operating system and can be used in Mac operating system. The code can be reused and portable as per the requirements. Easy to code Python syntax is easy to understand and code. Any developer can understand the syntax of Python within few hours. Python can be described as “programmer-friendly” Extensible If needed, a user can write some of Python code in C language as well. It is also possible to put python code in source code in different languages like C++. This makes Python an extensible language. Important Points Consider the following important points related to Python programming language − It includes functional and structured programming methods as well as object-oriented programming methods. It can be used as scripting language or as a programming language. It includes automatic garbage collection. It includes high-level dynamic data types and supports various dynamic type checking. Python includes a feature of integration with C, C++ and languages like Java. How to download python language in your system? To download Python language in your system, follow this link − https://www.python.org/downloads/ It includes packages for various operating systems like Windows, MacOS and Linux distributions. The Important Tools in Python In this section, we will learn in brief about a few important tools in Python. Python Strings The basic declaration of strings is as follows − str = ”Hello World!” Python Lists The lists of python can be declared as compound data types separated by commas and enclosed within square brackets ([]). list = [ ”abcd”, 786 , 2.23, ”john”, 70.2 ] tinylist = [123, ”john”] Python Tuples A tuple is dynamic data type of Python, which consists of number of values separated by commas. Tuples are enclosed with parentheses. tinytuple = (123, ”john”) Python Dictionary Python dictionary is a type of hash table. A dictionary key can be almost any data type of Python. The data types are usually numbers or strings. tinydict = {”name”: ”omkar”,”code”:6734, ”dept”: ”sales”} What constitutes a design pattern in Python? Python helps in constituting a design pattern using the following parameters − Pattern Name Intent Aliases Motivation Problem Solution Structure Participants Constraints Sample Code Print Page Previous Next Advertisements ”;