Book Image

Learning Python Design Patterns - Second Edition - Second Edition

By : Chetan Giridhar, Gennadiy Zlobin
Book Image

Learning Python Design Patterns - Second Edition - Second Edition

By: Chetan Giridhar, Gennadiy Zlobin

Overview of this book

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.

Related Content you might be interested in

Current Title:

Small book image
Learning Python Design Patterns - Second Edition - Second Edition
Chetan Giridhar | Gennadiy Zlobin
Feb, 2016 | 164 pages
No titles found
Table of Contents (19 chapters)
Learning Python Design Patterns Second Edition
Learning Python Design Patterns Second Edition
Credits
Credits
Foreword
Foreword
About the Author
About the Author
About the Reviewer
About the Reviewer
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
Introduction to Design Patterns
Introduction to Design Patterns
Understanding object-oriented programming
Major aspects of object-oriented programming
Object-oriented design principles
The concept of design patterns
Patterns for dynamic languages
Classifying patterns
Summary
2
The Singleton Design Pattern
The Singleton Design Pattern
Understanding the Singleton design pattern
Lazy instantiation in the Singleton pattern
Module-level Singletons
The Monostate Singleton pattern
Singletons and metaclasses
A real-world scenario – the Singleton pattern, part 1
A real-world scenario – the Singleton pattern, part 2
Drawbacks of the Singleton pattern
Summary
3
The Factory Pattern – Building Factories to Create Objects
The Factory Pattern – Building Factories to Create Objects
Understanding the Factory pattern
The Simple Factory pattern
The Factory Method pattern
The Abstract Factory pattern
The Factory method versus Abstract Factory method
Summary
4
The Façade Pattern – Being Adaptive with Façade
The Façade Pattern – Being Adaptive with Façade
Understanding Structural design patterns
Understanding the Façade design pattern
A UML class diagram
Implementing the Façade pattern in the real world
The principle of least knowledge
Frequently asked questions
Summary
5
The Proxy Pattern – Controlling Object Access
The Proxy Pattern – Controlling Object Access
Understanding the Proxy design pattern
A UML class diagram for the Proxy pattern
Understanding different types of Proxies
The Proxy pattern in the real world
Advantages of the Proxy pattern
Comparing the Façade and Proxy patterns
Frequently asked questions
Summary
6
The Observer Pattern – Keeping Objects in the Know
The Observer Pattern – Keeping Objects in the Know
Introducing Behavioral patterns
Understanding the Observer design pattern
The Observer pattern in the real world
The Observer pattern methods
Loose coupling and the Observer pattern
The Observer pattern – advantages and disadvantages
Frequently asked questions
Summary
7
The Command Pattern – Encapsulating Invocation
The Command Pattern – Encapsulating Invocation
Introducing the Command pattern
Understanding the Command design pattern
Implementing the Command pattern in the real world
Advantages and disadvantages of Command patterns
Frequently asked questions
Summary
8
The Template Method Pattern – Encapsulating Algorithm
The Template Method Pattern – Encapsulating Algorithm
Defining the Template Method pattern
The Template Method pattern in the real world
The Template Method pattern – hooks
The Hollywood principle and the Template Method
The advantages and disadvantages of the Template Method pattern
Frequently asked questions
Summary
9
Model-View-Controller – Compound Patterns
Model-View-Controller – Compound Patterns
An introduction to Compound patterns
The Model-View-Controller pattern
A UML class diagram for the MVC design pattern
The MVC pattern in the real world
Benefits of the MVC pattern
Frequently asked questions
Summary
10
The State Design Pattern
The State Design Pattern
Defining the State design pattern
A simple example of the State design pattern
Advantages/disadvantages of the State pattern
Summary
11
AntiPatterns
AntiPatterns
An introduction to AntiPatterns
Software development AntiPatterns
Software architecture AntiPatterns
Summary
Index
Index

Frequently asked questions

Q1. Should a low-level component be disallowed from calling a method in a higher-level component?

A: No, a low-level component would definitely call the higher-level component through inheritance. However, what the programmer needs to make sure is that there is no circular dependency where the low-level and high-level components are dependent on each other.

Q2. Isn't the strategy pattern similar to the Template pattern?

A: The strategy pattern and Template pattern both encapsulate algorithms. Template depends on inheritance while strategy uses composition. The Template Method pattern is a compile-time algorithm selection by sub-classing while the strategy pattern is a runtime selection.

Previous Section
End of Section 7
Next Section