Python: Master the Art of Design Patterns电子书

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 code

Errata

Piracy

Questions

1. Module 1

1. Object-oriented Design

Introducing object-oriented

Objects and classes

Specifying attributes and behaviors

Data describes objects

Behaviors are actions

Hiding details and creating the public interface

Composition

Inheritance

Inheritance provides abstraction

Multiple inheritance

Case study

Exercises

Summary

2. Objects in Python

Creating Python classes

Adding attributes

Making it do something

Talking to yourself

More arguments

Initializing the object

Explaining yourself

Modules and packages

Organizing the modules

Absolute imports

Relative imports

Organizing module contents

Who can access my data?

Third-party libraries

Case study

Exercises

Summary

3. When Objects Are Alike

Basic inheritance

Extending built-ins

Overriding and super

Multiple inheritance

The diamond problem

Different sets of arguments

Polymorphism

Abstract base classes

Using an abstract base class

Creating an abstract base class

Demystifying the magic

Case study

Exercises

Summary

4. Expecting the Unexpected

Raising exceptions

Raising an exception

The effects of an exception

Handling exceptions

The exception hierarchy

Defining 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 detail

Decorators – another way to create properties

Deciding when to use properties

Manager objects

Removing duplicate code

In practice

Case study

Exercises

Summary

6. Python Data Structures

Empty objects

Tuples and named tuples

Named tuples

Dictionaries

Dictionary use cases

Using defaultdict

Counter

Lists

Sorting lists

Sets

Extending built-ins

Queues

FIFO queues

LIFO queues

Priority queues

Case study

Exercises

Summary

7. Python Object-oriented Shortcuts

Python built-in functions

The len() function

Reversed

Enumerate

File I/O

Placing it in context

An alternative to method overloading

Default arguments

Variable argument lists

Unpacking arguments

Functions are objects too

Using functions as attributes

Callable objects

Case study

Exercises

Summary

8. Strings and Serialization

Strings

String manipulation

String formatting

Escaping braces

Keyword arguments

Container lookups

Object lookups

Making it look right

Strings are Unicode

Converting bytes to text

Converting text to bytes

Mutable byte strings

Regular expressions

Matching patterns

Matching a selection of characters

Escaping characters

Matching multiple characters

Grouping patterns together

Getting information from regular expressions

Making repeated regular expressions efficient

Serializing objects

Customizing pickles

Serializing web objects

Case study

Exercises

Summary

9. The Iterator Pattern

Design patterns in brief

Iterators

The iterator protocol

Comprehensions

List comprehensions

Set and dictionary comprehensions

Generator expressions

Generators

Yield items from another iterable

Coroutines

Back to log parsing

Closing coroutines and throwing exceptions

The relationship between coroutines, generators, and functions

Case study

Exercises

Summary

10. Python Design Patterns I

The decorator pattern

A decorator example

Decorators in Python

The observer pattern

An observer example

The strategy pattern

A strategy example

Strategy in Python

The state pattern

A state example

State versus strategy

State 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 methods

Reducing boilerplate and cleaning up

Organizing and running tests

Ignoring broken tests

Testing with py.test

One way to do setup and cleanup

A completely different way to set up variables

Skipping tests with py.test

Imitating expensive objects

How much testing is enough?

Case study

Implementing it

Exercises

Summary

13. Concurrency

Threads

The many problems with threads

Shared memory

The global interpreter lock

Thread overhead

Multiprocessing

Multiprocessing pools

Queues

The problems with multiprocessing

Futures

AsyncIO

AsyncIO in action

Reading an AsyncIO future

AsyncIO for networking

Using executors to wrap blocking code

Streams

Executors

Case study

Exercises

Summary

2. Module 2

1. Introduction to Design Patterns

Understanding object-oriented programming

Objects

Classes

Methods

Major aspects of object-oriented programming

Encapsulation

Polymorphism

Inheritance

Abstraction

Composition

Object-oriented design principles

The open/close principle

The inversion of control principle

The interface segregation principle

The single responsibility principle

The substitution principle

The concept of design patterns

Advantages of design patterns

Taxonomy of design patterns

Context – the applicability of design patterns

Patterns for dynamic languages

Classifying patterns

Creational patterns:

Structural patterns

Behavioral patterns

Summary

2. The Singleton Design Pattern

Understanding the Singleton design pattern

Implementing 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 Method

Advantages 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çade

System

Client

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 proxy

A remote proxy

A protective proxy

A 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 model

The 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 pattern

Understanding the Template Method design pattern

A 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 application

View – the appearance

Controller – 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 pattern

Understanding the State design pattern

Understanding 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 code

Golden Hammer

Lava Flow

Copy-and-paste or cut-and-paste programming

Software architecture AntiPatterns

Reinventing the wheel

Vendor lock-in

Design by committee

Summary

3. Module 3

1. The Factory Pattern

Factory Method

A real-life example

A software example

Use cases

Implementation

Abstract Factory

A real-life example

A software example

Use cases

Implementation

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