Mastering Object Oriented Python电子书

Mastering Object-oriented Python

Table of Contents

Mastering Object-oriented Python

Credits

About the Author

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers and more

Why Subscribe?

Free Access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code for this book

Errata

Piracy

Questions

Some Preliminaries

About casino Blackjack

Playing the game

Blackjack player strategies

Object design for simulating Blackjack

Performance – the timeit module

Testing – unittest and doctest

Unit testing and technology spikes

Docstrings – RST markup and documentation tools

The IDE question

About special method names

Summary

1. Pythonic Classes via Special Methods

Pythonic Classes via Special Methods

1. The __init__() Method

The implicit superclass – object

The base class object __init__() method

Implementing __init__() in a superclass

Using __init__() to create manifest constants

Leveraging __init__() via a factory function

Faulty factory design and the vague else clause

Simplicity and consistency using elif sequences

Simplicity using mapping and class objects

Two parallel mappings

Mapping to a tuple of values

The partial function solution

Fluent APIs for factories

Implementing __init__() in each subclass

Simple composite objects

Wrapping a collection class

Extending a collection class

More requirements and another design

Complex composite objects

Complete composite object initialization

Stateless objects without __init__()

Some additional class definitions

Multi-strategy __init__()

More complex initialization alternatives

Initializing static methods

Yet more __init__() techniques

Initialization with type validation

Initialization, encapsulation, and privacy

Summary

2. Integrating Seamlessly with Python Basic Special Methods

The __repr__() and __str__() methods

Non collection __str__() and __repr__()

Collection __str__() and __repr__()

The __format__() method

Nested formatting specifications

Collections and delegating format specifications

The __hash__() method

Deciding what to hash

Inheriting definitions for immutable objects

Overriding definitions for immutable objects

Overriding definitions for mutable objects

Making a frozen hand from a mutable hand

The __bool__() method

The __bytes__() method

The comparison operator methods

Designing comparisons

Implementation of comparison for objects of the same class

Implementation of comparison for objects of mixed classes

Hard totals, soft totals, and polymorphism

A mixed class comparison example

The __del__() method

The reference count and destruction

Circular references and garbage collection

Circular references and the weakref module

The __del__() and close() methods

The __new__() method and immutable objects

The __new__() method and metaclasses

Metaclass example 1 – ordered attributes

Metaclass example 2 – self-reference

Summary

3. Attribute Access, Properties, and Descriptors

Basic attribute processing

Attributes and the __init__() method

Creating properties

Eagerly computed properties

Setter and deleter properties

Using special methods for attribute access

Creating immutable objects with __slots__

Creating immutable objects as a tuple subclass

Eagerly computed attributes

The __getattribute__() method

Creating descriptors

Using a nondata descriptor

Using a data descriptor

Summary, design considerations, and trade-offs

Properties versus attributes

Designing with descriptors

Looking forward

4. The ABCs of Consistent Design

Abstract base classes

Base classes and polymorphism

Callables

Containers and collections

Numbers

Some additional abstractions

The iterator abstraction

Contexts and context managers

The abc module

Summary, design considerations, and trade-offs

Looking forward

5. Using Callables and Contexts

Designing with ABC callables

Improving performance

Using memoization or caching

Using functools for memoization

Aiming for simplicity using the callable API

Complexities and the callable API

Managing contexts and the with statement

Using the decimal context

Other contexts

Defining the __enter__() and __exit__() methods

Handling exceptions

Context manager as a factory

Cleaning up in a context manager

Summary

Callable design considerations and trade-offs

Context manager design considerations and trade-offs

Looking forward

6. Creating Containers and Collections

ABCs of collections

Examples of special methods

Using the standard library extensions

The namedtuple() function

The deque class

The ChainMap use case

The OrderedDict collection

The defaultdict subclass

The counter collection

Creating new kinds of collections

Defining a new kind of sequence

A statistical list

Choosing eager versus lazy calculation

Working with __getitem__(), __setitem__(), __delitem__(), and slices

Implementing __getitem__(), __setitem__(), and __delitem__()

Wrapping a list and delegating

Creating iterators with __iter__()

Creating a new kind of mapping

Creating a new kind of set

Some design rationale

Defining the Tree class

Defining the TreeNode class

Demonstrating the binary tree set

Summary

Design considerations and Trade-offs

Looking forward

7. Creating Numbers

ABCs of numbers

Deciding which types to use

The method resolution and the reflected operator concept

The arithmetic operator's special methods

Creating a numeric class

Defining FixedPoint initialization

Defining FixedPoint binary arithmetic operators

Defining FixedPoint unary arithmetic operators

Implementing FixedPoint reflected operators

Implementing FixedPoint comparison operators

Computing a numeric hash

Designing more useful rounding

Implementing other special methods

Optimization with the in-place operators

Summary

Design considerations and trade-offs

Looking forward

8. Decorators and Mixins – Cross-cutting Aspects

Class and meaning

Constructing the functions

Constructing the class

Some class design principles

Aspect-oriented programming

Using built-in decorators

Using standard library decorators

Using standard library mixin classes

Using the context manager mixin class

Turning off a class feature

Writing a simple function decorator

Creating separate loggers

Parameterizing a decorator

Creating a method function decorator

Creating a class decorator

Adding method functions to a class

Using decorators for security

Summary

Design considerations and trade-offs

Looking forward

2. Persistence and Serialization

Persistence and Serialization

9. Serializing and Saving – JSON, YAML, Pickle, CSV, and XML

Understanding persistence, class, state, and representation

Common Python terminologies

Filesystem and network considerations

Defining classes to support persistence

Rendering a blog and posts

Dumping and loading with JSON

Supporting JSON in our classes

Customizing JSON encoding

Customizing JSON decoding

The security and the eval() issue

Refactoring the encode function

Standardizing the date string

Writing JSON to a file

Dumping and loading with YAML

Formatting YAML data on a file

Extending the YAML representation

Security and safe loading

Dumping and loading with pickle

Designing a class for reliable pickle processing

Security and the global issue

Dumping and loading with CSV

Dumping simple sequences to CSV

Loading simple sequences from CSV

Handling containers and complex classes

Dumping and loading multiple row types in a CSV file

Filtering CSV rows with an iterator

Dumping and loading joined rows in a CSV file

Dumping and loading with XML

Dumping objects using string templates

Dumping objects with xml.etree.ElementTree

Loading XML documents

Summary

Design considerations and trade-offs

Schema evolution

Looking forward

10. Storing and Retrieving Objects via Shelve

Analyzing persistent object use cases

The ACID properties

Creating a shelf

Designing shelvable objects

Designing keys for our objects

Generating surrogate keys for objects

Designing a class with a simple key

Designing classes for containers or collections

Referring to objects via foreign keys

Designing CRUD operations for complex objects

Searching, scanning, and querying

Designing an access layer for shelve

Writing a demonstration script

Creating indexes to improve efficiency

Creating top-level indices

Adding yet more index maintenance

The writeback alternative to index updates

Schema evolution

Summary

Design considerations and trade-offs

Application software layers

Looking forward

11. Storing and Retrieving Objects via SQLite

SQL databases, persistence, and objects

The SQL data model – rows and tables

CRUD processing via SQL DML statements

Querying rows with the SQL SELECT statement

SQL transactions and the ACID properties

Designing primary and foreign database keys

Processing application data with SQL

Implementing class-like processing in pure SQL

Mapping Python objects to SQLite BLOB columns

Mapping Python objects to database rows manually

Designing an access layer for SQLite

Implementing container relationships

Improving performance with indices

Adding an ORM layer

Designing ORM-friendly classes

Building the schema with the ORM layer

Manipulating objects with the ORM layer

Querying post objects given a tag string

Improving performance with indices

Schema evolution

Summary

Design considerations and trade-offs

Mapping alternatives

Keys and key designs

Application software layers

Looking forward

12. Transmitting and Sharing Objects

Class, state, and representation

Using HTTP and REST to transmit objects

Implementing CRUD operations via REST

Implementing non-CRUD operations

The REST protocol and ACID

Choosing a representation – JSON, XML, or YAML

Implementing a REST server – WSGI and mod_wsgi

Creating a simple REST application and server

Implementing a REST client

Demonstrating and unit testing the RESTful services

Using Callable classes for WSGI applications

Designing RESTful object identifiers

Multiple layers of REST services

Creating the roulette server

Creating the roulette client

Creating a secure REST service

The WSGI Authentication application

Implementing REST with a web application framework

Using a message queue to transmit objects

Defining processes

Building queues and supplying data

Summary

Design considerations and trade-offs

Schema evolution

Application software layers

Looking forward

13. Configuration Files and Persistence

Configuration file use cases

Representation, persistence, state, and usability

Application configuration design patterns

Configuring via object construction

Implementing a configuration hierarchy

Storing the configuration in the INI files

Handling more literals via the eval() variants

Storing the configuration in PY files

Configuration via class definitions

Configuration via SimpleNamespace

Using Python with exec() for the configuration

Why is exec() a nonproblem?

Using ChainMap for defaults and overrides

Storing the configuration in JSON or YAML files

Using flattened JSON configurations

Loading a YAML configuration

Storing the configuration in property files

Parsing a properties file

Using a properties file

Storing the configuration in XML files – PLIST and others

Customized XML configuration files

Summary

Design considerations and trade-offs

Creating a shared configuration

Schema evolution

Looking Forward

3. Testing, Debugging, Deploying, and Maintaining

Testing, Debugging, Deploying, and Maintaining

14. The Logging and Warning Modules

Creating a basic log

Creating a shared class-level logger

Configuring the loggers

Starting up and shutting down the logging system

Naming the loggers

Extending the logger levels

Defining handlers for multiple destinations

Managing the propagation rules

Configuration gotcha

Specializing logging for control, debug, audit, and security

Creating a debugging log

Creating audit and security logs

Using the warnings module

Showing API changes with a warning

Showing configuration problems with a warning

Showing possible software problems with a warning

Advanced logging – the last few messages and network destinations

Building an automatic tail buffer

Sending logging messages to a remote process

Preventing queue overrun

Summary

Design considerations and trade-offs

Looking forward

15. Designing for Testability

Defining and isolating units for testing

Minimizing the dependencies

Creating simple unit tests

Creating a test suite

Including edge and corner cases

Mocking dependencies for testing

Using more mocks to test more behaviors

Using doctest to define test cases

Combining doctest and unittest

Creating a more complete test package

Using setup and teardown

Using setup and teardown with OS resources

Using setup and teardown with databases

The TestCase class hierarchy

Using externally defined expected results

Automated integration or performance testing

Summary

Design considerations and trade-offs

Looking forward

16. Coping With the Command Line

The OS interface and the command line

Arguments and options

Parsing the command line with argparse

A simple on/off option

An option with an argument

Positional arguments

All other arguments

--version display and exit

--help display and exit

Integrating command-line options and environment variables

Providing more configurable defaults

Overriding configuration file settings with environment variables

Overriding environment variables with the configuration files

Making the configuration aware of the None values

Customizing the help output

Creating a top-level main() function

Ensuring DRY for the configuration

Managing nested configuration contexts

Programming In The Large

Designing command classes

Adding the analysis command subclass

Adding and packaging more features into an application

Designing a higher-level composite command

Additional composite command design patterns

Integrating with other applications

Summary

Design considerations and trade-offs

Looking forward

17. The Module and Package Design

Designing a module

Some module design patterns

Module versus class

The expected content of a module

Whole module versus module items

Designing a package

Designing a module-package hybrid

Designing a package with alternate implementations

Designing a main script and the __main__ module

Creating an executable script file

Creating a __main__ module

Programming in the large

Designing long-running applications

Organizing code into src, bin, and test

Installing Python modules

Summary

Design considerations and trade-offs

Looking forward

18. Quality and Documentation

Writing docstrings for the help() function

Using pydoc for documentation

Better output via the RST markup

Blocks of text

The RST inline markup

RST directives

Learning RST

Writing effective docstrings

Writing file-level docstrings, including modules and packages

Writing API details in RST markup

Writing class and method function docstrings

Writing function docstrings

More sophisticated markup techniques

Using Sphinx to produce the documentation

Using the Sphinx quickstart

Writing the Sphinx documentation

Filling in the 4+1 views for documentation

Writing the implementation document

Creating the Sphinx cross-references

Refactoring Sphinx files into directories

Writing the documentation

Literate programming

Use cases for literate programming

Working with a literate programming tool

Summary

Design considerations and trade-offs

Index