Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Book Overview & Buying Learning Python Design Patterns - Second Edition
  • Table Of Contents Toc
Learning Python Design Patterns - Second Edition

Learning Python Design Patterns - Second Edition - Second Edition

By : Giridhar, Zlobin
2.8 (13)
Buy this Book
close
close
Learning Python Design Patterns - Second Edition

Learning Python Design Patterns - Second Edition

2.8 (13)
By: Giridhar, Zlobin
Buy this Book

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.
Table of Contents (13 chapters)
close
close
close
Preface
Icon
Preface
Icon
What this book covers
Icon
What you need for this book
Icon
Who this book is for
Icon
Conventions
Icon
Reader feedback
Icon
Customer support
Lock Free Chapter
1
1. Introduction to Design Patterns
chevron up
Icon
1. Introduction to Design Patterns
Icon
Understanding object-oriented programming
Icon
Major aspects of object-oriented programming
Icon
Object-oriented design principles
Icon
The concept of design patterns
Icon
Patterns for dynamic languages
Icon
Classifying patterns
Icon
Summary
2
2. The Singleton Design Pattern
Icon
2. The Singleton Design Pattern
Icon
Understanding the Singleton design pattern
Icon
Lazy instantiation in the Singleton pattern
Icon
Module-level Singletons
Icon
The Monostate Singleton pattern
Icon
Singletons and metaclasses
Icon
A real-world scenario – the Singleton pattern, part 1
Icon
A real-world scenario – the Singleton pattern, part 2
Icon
Drawbacks of the Singleton pattern
Icon
Summary
3
3. The Factory Pattern – Building Factories to Create Objects
Icon
3. The Factory Pattern – Building Factories to Create Objects
Icon
Understanding the Factory pattern
Icon
The Simple Factory pattern
Icon
The Factory Method pattern
Icon
The Abstract Factory pattern
Icon
The Factory method versus Abstract Factory method
Icon
Summary
4
4. The Façade Pattern – Being Adaptive with Façade
Icon
4. The Façade Pattern – Being Adaptive with Façade
Icon
Understanding Structural design patterns
Icon
Understanding the Façade design pattern
Icon
A UML class diagram
Icon
Implementing the Façade pattern in the real world
Icon
The principle of least knowledge
Icon
Frequently asked questions
Icon
Summary
5
5. The Proxy Pattern – Controlling Object Access
Icon
5. The Proxy Pattern – Controlling Object Access
Icon
Understanding the Proxy design pattern
Icon
A UML class diagram for the Proxy pattern
Icon
Understanding different types of Proxies
Icon
The Proxy pattern in the real world
Icon
Advantages of the Proxy pattern
Icon
Comparing the Façade and Proxy patterns
Icon
Frequently asked questions
Icon
Summary
6
6. The Observer Pattern – Keeping Objects in the Know
Icon
6. The Observer Pattern – Keeping Objects in the Know
Icon
Introducing Behavioral patterns
Icon
Understanding the Observer design pattern
Icon
The Observer pattern in the real world
Icon
The Observer pattern methods
Icon
Loose coupling and the Observer pattern
Icon
The Observer pattern – advantages and disadvantages
Icon
Frequently asked questions
Icon
Summary
7
7. The Command Pattern – Encapsulating Invocation
Icon
7. The Command Pattern – Encapsulating Invocation
Icon
Introducing the Command pattern
Icon
Understanding the Command design pattern
Icon
Implementing the Command pattern in the real world
Icon
Advantages and disadvantages of Command patterns
Icon
Frequently asked questions
Icon
Summary
8
8. The Template Method Pattern – Encapsulating Algorithm
Icon
8. The Template Method Pattern – Encapsulating Algorithm
Icon
Defining the Template Method pattern
Icon
The Template Method pattern in the real world
Icon
The Template Method pattern – hooks
Icon
The Hollywood principle and the Template Method
Icon
The advantages and disadvantages of the Template Method pattern
Icon
Frequently asked questions
Icon
Summary
9
9. Model-View-Controller – Compound Patterns
Icon
9. Model-View-Controller – Compound Patterns
Icon
An introduction to Compound patterns
Icon
The Model-View-Controller pattern
Icon
A UML class diagram for the MVC design pattern
Icon
The MVC pattern in the real world
Icon
Benefits of the MVC pattern
Icon
Frequently asked questions
Icon
Summary
10
10. The State Design Pattern
Icon
10. The State Design Pattern
Icon
Defining the State design pattern
Icon
A simple example of the State design pattern
Icon
Advantages/disadvantages of the State pattern
Icon
Summary
11
11. AntiPatterns
Icon
11. AntiPatterns
Icon
An introduction to AntiPatterns
Icon
Software development AntiPatterns
Icon
Software architecture AntiPatterns
Icon
Summary
12
Index
Icon
Index

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:

Methods
Visually different images
CONTINUE READING
83
Tech Concepts
36
Programming languages
73
Tech Tools
Icon Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.
Icon Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.
Icon 50+ new titles added per month and exclusive early access to books as they are being written.
Learning Python Design Patterns - Second Edition
End of Section 1
Next Section
notes
bookmark Notes and Bookmarks search Search in title playlist Add to playlist font-size Font size

Change the font size

margin-width Margin width

Change margin width

day-mode Day/Sepia/Night Modes

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Confirmation

Modal Close icon
claim successful
Order Page Read Now

Buy this book with your credits?

Modal Close icon
Are you sure you want to buy this book with one of your credits?
Close
YES, BUY

Submit Your Feedback

Modal Close icon
Modal Close icon
Modal Close icon