book

Python: Master the Art of Design Patterns

Name: Python: Master the Art of Design Patterns
ISBN: 9781787125186

by Dusty Phillips, Chetan Giridhar, Sakis Kasampalis

September 2016

Intermediate to advanced

775 pages

18h 22m

English

Packt Publishing

Read now

Unlock full access

Python: Master the Art of Design Patterns
Table of Contents
Python: Master the Art of Design Patterns
Python: Master the Art of Design Patterns
Credits
Preface
What this learning path covers
What you need for this learning path
Who this learning path is for
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions

1. Module 1
1. Object-oriented Design
Introducing object-oriented
Objects and classes
Specifying attributes and behaviors
Data describes objectsBehaviors are actions
Hiding details and creating the public interface
Composition
Inheritance
Inheritance provides abstractionMultiple inheritance
Case study
Exercises
Summary
2. Objects in Python
Creating Python classesAdding attributesMaking it do somethingTalking to yourselfMore argumentsInitializing the objectExplaining yourself
Modules and packages
Organizing the modulesAbsolute importsRelative imports
Organizing module contents
Who can access my data?
Third-party libraries
Case study
Exercises
Summary
3. When Objects Are Alike
Basic inheritanceExtending built-insOverriding and super
Multiple inheritance
The diamond problemDifferent sets of arguments
Polymorphism
Abstract base classes
Using an abstract base classCreating an abstract base classDemystifying the magic
Case study
Exercises
Summary
4. Expecting the Unexpected
Raising exceptionsRaising an exceptionThe effects of an exceptionHandling exceptionsThe exception hierarchyDefining our own exceptions
Case study
Exercises
Summary
5. When to Use Object-oriented Programming
Treat objects as objects
Adding behavior to class data with properties
Properties in detailDecorators – another way to create propertiesDeciding when to use properties
Manager objects
Removing duplicate codeIn practice
Case study
Exercises
Summary
6. Python Data Structures
Empty objects
Tuples and named tuples
Named tuples
Dictionaries
Dictionary use casesUsing defaultdictCounter
Lists
Sorting lists
Sets
Extending built-ins
Queues
FIFO queuesLIFO queuesPriority queues
Case study
Exercises
Summary
7. Python Object-oriented Shortcuts
Python built-in functionsThe len() functionReversedEnumerateFile I/OPlacing it in context
An alternative to method overloading
Default argumentsVariable argument listsUnpacking arguments
Functions are objects too
Using functions as attributesCallable objects
Case study
Exercises
Summary
8. Strings and Serialization
StringsString manipulationString formattingEscaping bracesKeyword argumentsContainer lookupsObject lookupsMaking it look rightStrings are UnicodeConverting bytes to textConverting text to bytesMutable byte strings
Regular expressions
Matching patternsMatching a selection of charactersEscaping charactersMatching multiple charactersGrouping patterns togetherGetting information from regular expressionsMaking repeated regular expressions efficient
Serializing objects
Customizing picklesSerializing web objects
Case study
Exercises
Summary
9. The Iterator Pattern
Design patterns in brief
Iterators
The iterator protocol
Comprehensions
List comprehensionsSet and dictionary comprehensionsGenerator expressions
Generators
Yield items from another iterable
Coroutines
Back to log parsingClosing coroutines and throwing exceptionsThe relationship between coroutines, generators, and functions
Case study
Exercises
Summary
10. Python Design Patterns I
The decorator patternA decorator exampleDecorators in Python
The observer pattern
An observer example
The strategy pattern
A strategy exampleStrategy in Python
The state pattern
A state exampleState versus strategyState transition as coroutines
The singleton pattern
Singleton implementation
The template pattern
A template example
Exercises
Summary
11. Python Design Patterns II
The adapter pattern
The facade pattern
The flyweight pattern
The command pattern
The abstract factory pattern
The composite pattern
Exercises
Summary
12. Testing Object-oriented Programs
Why test?Test-driven development
Unit testing
Assertion methodsReducing boilerplate and cleaning upOrganizing and running testsIgnoring broken tests
Testing with py.test
One way to do setup and cleanupA completely different way to set up variablesSkipping tests with py.test
Imitating expensive objects
How much testing is enough?
Case study
Implementing it
Exercises
Summary
13. Concurrency
ThreadsThe many problems with threadsShared memoryThe global interpreter lockThread overhead
Multiprocessing
Multiprocessing poolsQueuesThe problems with multiprocessing
Futures
AsyncIO
AsyncIO in actionReading an AsyncIO futureAsyncIO for networkingUsing executors to wrap blocking codeStreamsExecutors
Case study
Exercises
Summary
2. Module 2
1. Introduction to Design Patterns
Understanding object-oriented programmingObjectsClassesMethods
Major aspects of object-oriented programming
EncapsulationPolymorphismInheritanceAbstractionComposition
Object-oriented design principles
The open/close principleThe inversion of control principleThe interface segregation principleThe single responsibility principleThe substitution principle
The concept of design patterns
Advantages of design patternsTaxonomy of design patternsContext – the applicability of design patterns
Patterns for dynamic languages
Classifying patterns
Creational patterns:Structural patternsBehavioral patterns
Summary
2. The Singleton Design Pattern
Understanding the Singleton design patternImplementing a classical Singleton in Python
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
Understanding the Factory pattern
The Simple Factory pattern
The Factory Method pattern
Implementing the Factory MethodAdvantages of the Factory method pattern
The Abstract Factory pattern
Implementing the Abstract Factory pattern
The Factory method versus Abstract Factory method
Summary
4. The Façade Pattern – Being Adaptive with Façade
Understanding Structural design patterns
Understanding the Façade design pattern
A UML class diagram
FaçadeSystemClient
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
Understanding the Proxy design pattern
A UML class diagram for the Proxy pattern
Understanding different types of Proxies
A virtual proxyA remote proxyA protective proxyA smart proxy
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
Introducing Behavioral patterns
Understanding the Observer design pattern
A UML class diagram for the Observer pattern
The Observer pattern in the real world
The Observer pattern methods
The pull modelThe push model
Loose coupling and the Observer pattern
The Observer pattern – advantages and disadvantages
Frequently asked questions
Summary
7. The Command Pattern – Encapsulating Invocation
Introducing the Command pattern
Understanding the Command design pattern
A UML class diagram for the Command pattern
Implementing the Command pattern in the real world
Design considerations
Advantages and disadvantages of Command patterns
Frequently asked questions
Summary
8. The Template Method Pattern – Encapsulating Algorithm
Defining the Template Method patternUnderstanding the Template Method design patternA UML class diagram for 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
An introduction to Compound patterns
The Model-View-Controller pattern
Model – knowledge of the applicationView – the appearanceController – the glue
A UML class diagram for the MVC design pattern
The MVC pattern in the real world
Modules
Benefits of the MVC pattern
Frequently asked questions
Summary
10. The State Design Pattern
Defining the State design patternUnderstanding the State design patternUnderstanding the State design pattern with a UML diagram
A simple example of the State design pattern
The State design pattern with v3.5 implementation
Advantages/disadvantages of the State pattern
Summary
11. AntiPatterns
An introduction to AntiPatterns
Software development AntiPatterns
Spaghetti codeGolden HammerLava FlowCopy-and-paste or cut-and-paste programming
Software architecture AntiPatterns
Reinventing the wheelVendor lock-inDesign by committee
Summary
3. Module 3
1. The Factory Pattern
Factory MethodA real-life exampleA software exampleUse casesImplementation
Abstract Factory
A real-life exampleA software exampleUse casesImplementation
Summary
2. The Builder Pattern
A real-life example
A software example
Use cases
Implementation
Summary
3. The Prototype Pattern
A real-life example
A software example
Use cases
Implementation
Summary
4. The Adapter Pattern
A real-life example
A software example
Use cases
Implementation
Summary
5. The Decorator Pattern
A real-life example
A software example
Use cases
Implementation
Summary
6. The Facade Pattern
A real-life example
A software example
Use cases
Implementation
Summary
7. The Flyweight Pattern
A real-life example
A software example
Use cases
Implementation
Summary
8. The Model-View-Controller Pattern
A real-life example
A software example
Use cases
Implementation
Summary
9. The Proxy Pattern
A real-life example
A software example
Use cases
Implementation
Summary
10. The Chain of Responsibility Pattern
A real-life example
A software example
Use cases
Implementation
Summary
11. The Command Pattern
A real-life example
A software example
Use cases
Implementation
Summary
12. The Interpreter Pattern
A real-life example
A software example
Use cases
Implementation
Summary
13. The Observer Pattern
A real-life example
A software example
Use cases
Implementation
Summary
14. The State Pattern
A real-life example
A software example
Use cases
Implementation
Summary
15. The Strategy Pattern
A real-life example
A software example
Use cases
Implementation
Summary
16. The Template Pattern
A real-life example
A software example
Use cases
Implementation
Summary
A. Bibliography
Index

Content preview from Python: Master the Art of Design Patterns

An alternative to method overloading

One prominent feature of many object-oriented programming languages is a tool called method overloading. Method overloading simply refers to having multiple methods with the same name that accept different sets of arguments. In statically typed languages, this is useful if we want to have a method that accepts either an integer or a string, for example. In non-object-oriented languages, we might need two functions, called add_s and add_i, to accommodate such situations. In statically typed object-oriented languages, we'd need two methods, both called add, one that accepts strings, and one that accepts integers.

In Python, we only need one method, which accepts any type of object. It may have to do some testing ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781787125186Purchase Link

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills