What do you get with Print?

Instant access to your digital eBook copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Download this book in EPUB and PDF formats

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Learning Python Design Patterns - Second Edition

Chapter 1. Introduction to Design Patterns

In this chapter, we will go through the basics of object-oriented programming and discuss the object-oriented design principles in detail. This will get us prepared for the advanced topics covered later in the book. This chapter will also give a brief introduction to the concept of design patterns so that you will be able to appreciate the context and application of design patterns in software development. Here we also classify the design patterns under three main aspects—creational, structural, and Behavioral patterns. So, essentially, we will cover the following topics in this chapter:

Understanding object-oriented programming
Discussing object-oriented design principles
Understanding the concept of design patterns and their taxonomy and context
Discussing patterns for dynamic languages
Classifying patterns—creational pattern, structural pattern, and behavioral pattern

Understanding object-oriented programming

Before you start learning about design patterns, it's always good to cover the basics and go through object-oriented paradigms in Python. The object-oriented world presents the concept of objects that have attributes (data members) and procedures (member functions). These functions are responsible for manipulating the attributes. For instance, take an example of the Car object. The Car object will have attributes such as fuel level, isSedan, speed, and steering wheel and coordinates, and the methods would be accelerate() to increase the speed and takeLeft() to make the car turn left. Python has been an object-oriented language since it was first released. As they say, everything in Python is an object. Each class instance or variable has its own memory address or identity. Objects, which are instances of classes, interact among each other to serve the purpose of an application under development. Understanding the core concepts of object-oriented programming involves understanding the concepts of objects, classes, and methods.

Objects

The following points describe objects:

They represent entities in your application under development.
Entities interact among themselves to solve real-world problems.
For example, Person is an entity and Car is an entity. Person drives Car to move from one location to the other.

Classes

Classes help developers to represent real-world entities:

Classes define objects in attributes and behaviors. Attributes are data members and behaviors are manifested by the member functions
Classes consist of constructors that provide the initial state for these objects
Classes are like templates and hence can be easily reused

For example, class Person will have attributes name and age and member function gotoOffice() that defines his behavior for travelling to office for work.

Methods

The following points talk about what methods do in the object-oriented world:

They represent the behavior of the object
Methods work on attributes and also implement the desired functionality

A good example of a class and object created in Python v3.5 is given here:

class Person(object):
    def __init__(self, name, age):  #constructor
        self.name = name    #data members/ attributes
        self.age = age
    def get_person(self,):   # member function
         return "<Person (%s, %s)>" % (self.name, self.age)


p = Person("John", 32)    # p is an object of type Person
print("Type of Object:", type(p), "Memory Address:", id(p))

The output of the preceding code should look as follows:

Major aspects of object-oriented programming

Now that we have understood the basics of object-oriented programming, let's dive into the major aspects of OOP.

Encapsulation

The key features of encapsulation are as follows:

An object's behavior is kept hidden from the outside world or objects keep their state information private.
Clients can't change the object's internal state by directly acting on them; rather, clients request the object by sending messages. Based on the type of requests, objects may respond by changing their internal state using special member functions such as get and set.
In Python, the concept of encapsulation (data and method hiding) is not implicit, as it doesn't have keywords such as public, private, and protected (in languages such as C++ or Java) that are required to support encapsulation. Of course, accessibility can be made private by prefixing __ in the variable or function name.

Polymorphism

The major features of polymorphism are as follows:

Polymorphism can be of two types:
- An object provides different implementations of the method based on input parameters
- The same interface can be used by objects of different types
In Python, polymorphism is a feature built-in for the language. For example, the + operator can act on two integers to add them or can work with strings to concatenate them

In the following example, strings, tuples, or lists can all be accessed with an integer index. This shows how Python demonstrates polymorphism in built-in types:

a = "John"
b = (1,2,3)
c = [3,4,6,8,9]
print(a[1], b[0], c[2])

Inheritance

The following points help us understand the inheritance process better:

Inheritance indicates that one class derives (most of its) functionality from the parent class.
Inheritance is described as an option to reuse functionality defined in the base class and allow independent extensions of the original software implementation.
Inheritance creates hierarchy via the relationships among objects of different classes. Python, unlike Java, supports multiple inheritance (inheriting from multiple base classes).

In the following code example, class A is the base class and class B derives its features from class A. So, the methods of class A can be accessed by the object of class B:

class A:
    def a1(self):
        print("a1")

class B(A):
    def b(self):
        print("b")


b = B()
b.a1()

Abstraction

The key features of abstraction are as follows:

It provides you with a simple interface to the clients, where the clients can interact with class objects and call methods defined in the interface
It abstracts the complexity of internal classes with an interface so that the client need not be aware of internal implementations

In the following example, internal details of the Adder class are abstracted with the add() method:

class Adder:
    def __init__(self):
        self.sum = 0
    def add(self, value):
        self.sum += value

acc = Adder()
for i in range(99):
    acc.add(i)


print(acc.sum)

Composition

Composition refers to the following points:

It is a way to combine objects or classes into more complex data structures or software implementations
In composition, an object is used to call member functions in other modules thereby making base functionality available across modules without inheritance

In the following example, the object of class A is composited under class B:

class A(object):
    def a1(self):
        print("a1")

class B(object):
    def b(self):
        print("b")
        A().a1()


objectB = B()
objectB.b()

Object-oriented design principles

Now, let's talk about another set of concepts that are going to be crucial for us. These are nothing but the object-oriented design principles that will act as a toolbox for us while learning design patterns in detail.

The open/close principle

The open/close principle states that classes or objects and methods should be open for extension but closed for modifications.

What this means in simple language is, when you develop your software application, make sure that you write your classes or modules in a generic way so that whenever you feel the need to extend the behavior of the class or object, then you shouldn't have to change the class itself. Rather, a simple extension of the class should help you build the new behavior.

For example, the open/close principle is manifested in a case where a user has to create a class implementation by extending the abstract base class to implement the required behavior instead of changing the abstract class.

Advantages of this design principle are as follows:

Existing classes are not changed and hence the chances of regression are less
It also helps maintain backward compatibility for the previous code

The inversion of control principle

The inversion of control principle states that high-level modules shouldn't be dependent on low-level modules; they should both be dependent on abstractions. Details should depend on abstractions and not the other way round.

This principle suggests that any two modules shouldn't be dependent on each other in a tight way. In fact, the base module and dependent module should be decoupled with an abstraction layer in between.

This principle also suggests that the details of your class should represent the abstractions. In some cases, the philosophy gets inverted and implementation details itself decide the abstraction, which should be avoided.

Advantages of the inversion of control principle are as follows:

The tight coupling of modules is no more prevalent and hence no complexity/rigidity in the system
As there is a clear abstraction layer between dependent modules (provided by a hook or parameter), it's easy to deal with dependencies across modules in a better way

The interface segregation principle

As the interface segregation principle states, clients should not be forced to depend on interfaces they don't use.

This principle talks about software developers writing their interfaces well. For instance, it reminds the developers/architects to develop methods that relate to the functionality. If there is any method that is not related to the interface, the class dependent on the interface has to implement it unnecessarily.

For example, a Pizza interface shouldn't have a method called add_chicken(). The Veg Pizza class based on the Pizza interface shouldn't be forced to implement this method.

Advantages of this design principle are as follows:

It forces developers to write thin interfaces and have methods that are specific to the interface
It helps you not to populate interfaces by adding unintentional methods

The single responsibility principle

As the single responsibility principle states, a class should have only one reason to change.

This principle says that when we develop classes, it should cater to the given functionality well. If a class is taking care of two functionalities, it is better to split them. It refers to functionality as a reason to change. For example, a class can undergo changes because of the difference in behavior expected from it, but if a class is getting changed for two reasons (basically, changes in two functionalities), then the class should be definitely split.

Advantages of this design principle are as follows:

Whenever there is a change in one functionality, this particular class needs to change, and nothing else
Additionally, if a class has multiple functionalities, the dependent classes will have to undergo changes for multiple reasons, which gets avoided

The substitution principle

The substitution principle states that derived classes must be able to completely substitute the base classes.

This principle is pretty straightforward in the sense that it says when application developers write derived classes, they should extend the base classes. It also suggests that the derived class should be as close to the base class as possible so much so that the derived class itself should replace the base class without any code changes.

The concept of design patterns

Finally, now is the time that we start talking about design patterns! What are design patterns?

Design patterns were first introduced by GoF (Gang of Four), where they mentioned them as being solutions to given problems. If you would like to know more, GoF refers to the four authors of the book, Design Patterns: Elements of Reusable Object-Oriented Software. The book's authors are Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, with a foreword by Grady Booch. This book covers software engineering solutions to the commonly occurring problems in software design. There were 23 design patterns first identified, and the first implementation was done with respect to the Java program language. Design patterns are discoveries and not an invention in themselves.

The key features of design patterns are as follows:

They are language-neutral and can be implemented across multiple languages
They are dynamic, as new patterns get introduced every now and then
They are open for customization and hence useful for developers

Initially, when you hear about design patterns, you may feel the following:

It's a panacea to all the design problems that you've had so far
It's an extraordinary, specially clever way of solving a problem
Many experts in software development world agree to these solutions
There's something repeatable about the design, hence the word pattern

You too must have attempted to solve the problems that a design patterns intends to, but maybe your solution was incomplete, and the completeness that we're looking for is inherent or implicit in the design pattern. When we say completeness, it can refer to many factors such as the design, scalability, reuse, memory utilization, and others. Essentially, a design pattern is about learning from others' successes rather than your own failures!

Another interesting discussion that comes up on design patterns is—when do I use them? Is it in the analysis or design phase of Software Development Life Cycle (SDLC)?

Interestingly, design patterns are solutions to known issues. So they can be very much used in analysis or design, and as expected, in the development phase because of the direct relation in the application code.

Advantages of design patterns

The advantages of design patterns are as follows:

They are reusable across multiple projects
The architectural level of problems can be solved
They are time-tested and well-proven, which is the experience of developers and architects
They have reliability and dependence

Taxonomy of design patterns

Not every piece of code or design can be termed as a design pattern. For example, a programming construct or data structure that solves one problem can't be termed as a pattern. Let's understand terms in a very simplistic way below:

Snippet: This is code in some language for a certain purpose, for example, DB connectivity in Python can be a code snippet
Design: A better solution to solve this particular problem
Standard: This is a way to solve some kind of problems, and can be very generic and applicable to a situation at hand
Pattern: This is a time-tested, efficient, and scalable solution that will resolve the entire class of known issues

Context – the applicability of design patterns

To use design patterns efficiently, application developers must be aware of the context where design patterns apply. We can classify the context into the following main categories:

Participants: They are classes that are used in design patterns. Classes play different roles to accomplish multiple goals in the pattern.
Non-functional requirements: Requirements such as memory optimization, usability, and performance fall under this category. These factors impact the complete software solution and are thus critical.
Trade-offs: Not all design patterns fit in application development as it is, and trade-offs are necessary. These are decisions that you take while using a design pattern in an application.
Results: Design patterns can have a negative impact on other parts of the code if the context is not appropriate. Developers should understand the consequences and use of design patterns.

Key benefits

Understand the structural, creational, and behavioral Python design patterns

Get to know the context and application of design patterns to solve real-world problems in software architecture, design, and application development

Get practical exposure through sample implementations in Python v3.5 for the design patterns featured

Description

With the increasing focus on optimized software architecture and design it is important that software architects think about optimizations in object creation, code structure, and interaction between objects at the architecture or design level. This makes sure that the cost of software maintenance is low and code can be easily reused or is adaptable to change. The key to this is reusability and low maintenance in design patterns. Building on the success of the previous edition, Learning Python Design Patterns, Second Edition will help you implement real-world scenarios with Python’s latest release, Python v3.5. We start by introducing design patterns from the Python perspective. As you progress through the book, you will learn about Singleton patterns, Factory patterns, and Façade patterns in detail. After this, we’ll look at how to control object access with proxy patterns. It also covers observer patterns, command patterns, and compound patterns. By the end of the book, you will have enhanced your professional abilities in software architecture, design, and development.

What you will learn

Enhance your skills to create better software architecture

Understand proven solutions to commonly occurring design issues

Explore the design principles that form the basis of software design, such as loose coupling, the Hollywood principle and the Open Close principle among others

Delve into the object-oriented programming concepts and find out how they are used in software applications

Develop an understanding of Creational Design Patterns and the different object creation methods that help you solve issues in software development

Use Structural Design Patterns and find out how objects and classes interact to build larger applications

Focus on the interaction between objects with the command and observer patterns

Improve the productivity and code base of your application using Python design patterns

What do you get with Print?

Instant access to your digital eBook copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Download this book in EPUB and PDF formats

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Frequently bought together

Learning Python Design Patterns - Second Edition

€32.99

€32.99

€32.99

Total € 98.97

Filter reviews by

All

Amazon verified reviews

maurice ling Mar 22, 2016

Disclaimer: I am a technical reviewer for this book.Through the entire period serving as technical reviewer for this book, I am impressed with the easy-to-follow style of writing. I had to review the book in chapters across a few months and there is no point in time where I need to wonder if I really understood what the author had to say. As such, I can safely say that this book is well-written and each chapter is contained (there is almost no need to flip back and forth the book to understand the material within any chapter on hand) - quite a remarkable feat for a book.Each chapter is focused on a specific design pattern. The why and how of each pattern is explained in a clear fashion. This makes it easy to read for anyone, both beginners and experienced Python programmers. The materials are even suitable for pre-bedtime leisure reading. Personally, I recommend this to the developers in my own company.

Amazon Verified review

Govind Karmakar Nov 11, 2018

A good blend of theory with code snippets. It gives a good start to the folks want to delve into the concepts of design patterns using python.

Sudhir Chawla May 02, 2016

With the growing popularity of Python as preferred programming language, the book serves the need to educate readers on the importance of design patterns in python. The author does a very good job by first delving into the basics of OOPs and then gradually introducing the subject of design patterns, all in python 3.5.However reference to python docs could have been included in the book while using some of the more esoteric functions in python. The UML Diagrams mentioned at the beginning of each pattern helps the reader to visualize the hierarchy of objects. The real world examples of all patterns certainly does drive the point home.In short, the book provides concise but well illustrated information about the design pattern and its implementation in python.

Christian Scheunert Oct 21, 2016

Short and conclusive pattern description with very nice examples. The layout is not the best (looks like a copy of a web page), however, the content is definitely worth it.

B Jul 29, 2017

The narrative style the book, at least up to where I've read so far, feels more like a brain dump from a friend to another than a carefully thought out and written book. The author clearly understands the concepts but struggles to explain them.However, my main gripe is with the code examples. They seem to go off at a tangent trying to do something clever (or asinine) instead of focusing on what they're meant to be illustrating.All in all I'm happy with this book, but at the price purchased.

Learning Python Design Patterns - Second Edition: , Second Edition

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Objects

Classes

Methods

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

About the authors

FAQs