Book Image

Mastering Object-Oriented Python - Second Edition

By : Steven F. Lott

Book Image

Mastering Object-Oriented Python - Second Edition

By: Steven F. Lott

Overview of this book

Object-oriented programming (OOP) is a relatively complex discipline to master, and it can be difficult to see how general principles apply to each language's unique features. With the help of the latest edition of Mastering Objected-Oriented Python, you'll be shown how to effectively implement OOP in Python, and even explore Python 3.x. Complete with practical examples, the book guides you through the advanced concepts of OOP in Python, and demonstrates how you can apply them to solve complex problems in OOP. You will learn how to create high-quality Python programs by exploring design alternatives and determining which design offers the best performance. Next, you'll work through special methods for handling simple object conversions and also learn about hashing and comparison of objects. As you cover later chapters, you'll discover how essential it is to locate the best algorithms and optimal data structures for developing robust solutions to programming problems with minimal computer processing. Finally, the book will assist you in leveraging various Python features by implementing object-oriented designs in your programs. By the end of this book, you will have learned a number of alternate approaches with different attributes to confidently solve programming problems in Python.

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

Section 1: Tighter Integration Via Special Methods

Section 1: Tighter Integration Via Special Methods

Preliminaries, Tools, and Techniques

Preliminaries, Tools, and Techniques

Technical requirements

About the Blackjack game

The Python runtime and special methods

Interaction, scripting, and tools

Selecting an IDE

Consistency and style

Type hints and the mypy program

Performance – the timeit module

Testing – unittest and doctest

Documentation – sphinx and RST markup

Installing components

The __init__() Method

The __init__() Method

Technical requirements

The implicit superclass – object

The base class object __init__() method

Implementing __init__() in a superclass

Creating enumerated constants

Leveraging __init__() via a factory function

Implementing __init__() in each subclass

Composite objects

Complex composite objects

Stateless objects without __init__()

Some additional class definitions

Multi-strategy __init__()

Yet more __init__() techniques

Integrating Seamlessly - Basic Special Methods

Integrating Seamlessly - Basic Special Methods

Technical requirements

The __repr__() and __str__() methods

The __format__() method

The __hash__() method

The __bool__() method

The __bytes__() method

The comparison operator methods

The __del__() method

The __new__() method and immutable objects

The __new__() method and metaclasses

Attribute Access, Properties, and Descriptors

Attribute Access, Properties, and Descriptors

Technical requirements

Basic attribute processing

Creating properties

Using special methods for attribute access

The __getattribute__() method

Creating descriptors

Using type hints for attributes and properties

Using the dataclasses module

Attribute Design Patterns

The ABCs of Consistent Design

The ABCs of Consistent Design

Technical requirements

Abstract base classes

Base classes and polymorphism

Containers and collections

Some additional abstractions

The abc and typing modules

Summary, design considerations, and trade-offs

Using Callables and Contexts

Using Callables and Contexts

Technical requirements

Designing callables

Improving performance

Using functools for memoization

Complexities and the callable interface

Managing contexts and the with statement

Defining the __enter__() and __exit__() methods

Context manager as a factory

Creating Containers and Collections

Creating Containers and Collections

Technical requirements

ABCs of collections

Examples of special methods

Using the standard library extensions

Creating new kinds of collections

Narrowing a collection's type

Defining a new kind of sequence

Creating a new kind of mapping

Creating a new kind of set

Design considerations and tradeoffs

Creating Numbers

Creating Numbers

Technical requirements

ABCs of numbers

The arithmetic operator's special methods

Creating a numeric class

Computing a numeric hash

Implementing other special methods

Optimization with the in-place operators

Decorators and Mixins - Cross-Cutting Aspects

Decorators and Mixins - Cross-Cutting Aspects

Technical requirements

Class and meaning

Using built-in decorators

Using standard library mixin classes

Writing a simple function decorator

Parameterizing a decorator

Creating a method function decorator

Creating a class decorator

Adding methods to a class

Using decorators for security

Section 2: Object Serialization and Persistence

Section 2: Object Serialization and Persistence

Serializing and Saving - JSON, YAML, Pickle, CSV, and XML

Serializing and Saving - JSON, YAML, Pickle, CSV, and XML

Technical requirements

Understanding persistence, class, state, and representation

Filesystem and network considerations

Defining classes to support persistence

Dumping and loading with JSON

Dumping and loading with YAML

Dumping and loading with pickle

Dumping and loading with CSV

Dumping and loading with XML

Storing and Retrieving Objects via Shelve

Storing and Retrieving Objects via Shelve

Technical requirements

Analyzing persistent object use cases

Creating a shelf

Designing shelvable objects

Searching, scanning, and querying

Designing an access layer for shelve

Creating indexes to improve efficiency

Adding yet more index maintenance

The writeback alternative to index updates

Storing and Retrieving Objects via SQLite

Storing and Retrieving Objects via SQLite

Technical requirements

SQL databases, persistence, and objects

Processing application data with SQL

Mapping Python objects to SQLite BLOB columns

Mapping Python objects to database rows manually

Improving performance with indices

Adding an ORM layer

Querying posts that are given a tag

Defining indices in the ORM layer

Transmitting and Sharing Objects

Transmitting and Sharing Objects

Technical requirements

Class, state, and representation

Using HTTP and REST to transmit objects

Using Flask to build a RESTful web service

Handling stateful REST services

Creating a secure REST service

Implementing REST with a web application framework

Using a message queue to transmit objects

Configuration Files and Persistence

Configuration Files and Persistence

Technical requirements

Configuration file use cases

Representation, persistence, state, and usability

Storing the configuration in INI files

Handling more literals via the eval() variants

Storing the configuration in PY files

Why exec() is a non-problem

Using ChainMap for defaults and overrides

Storing the configuration in JSON or YAML files

Storing the configuration in properties files

Using XML files – PLIST and others

Section 3: Object-Oriented Testing and Debugging

Section 3: Object-Oriented Testing and Debugging

Design Principles and Patterns

Design Principles and Patterns

Technical requirements

The SOLID design principles

A SOLID principle design test

Building features through inheritance and composition

Parallels between Python and libstdc++

The Logging and Warning Modules

The Logging and Warning Modules

Technical requirements

Creating a basic log

Configuration Gotcha

Specialized logging for control, debugging, audit, and security

Using the warnings module

Advanced logging – the last few messages and network destinations

Designing for Testability

Designing for Testability

Technical requirements

Defining and isolating units for testing

Using doctest to define test cases

Using setup and teardown

The TestCase class hierarchy

Using externally defined expected results

Using pytest and fixtures

Automated integration or performance testing

Coping with the Command Line

Coping with the Command Line

Technical requirements

The OS interface and the command line

Using the pathlib module

Parsing the command line with argparse

Integrating command-line options and environment variables

Customizing the help output

Creating a top-level main() function

Programming in the large

Additional composite Command design patterns

Integrating with other applications

Module and Package Design

Module and Package Design

Technical requirements

Designing a module

Whole modules versus module items

Designing a package

Designing a main script and the __main__ module

Designing long-running applications

Organizing code into src, scripts, tests, and docs

Installing Python modules

Quality and Documentation

Quality and Documentation

Technical requirements

Writing docstrings for the help() function

Using pydoc for documentation

Better output via RST markup

Writing effective docstrings

Writing file-level docstrings, including modules and packages

More sophisticated markup techniques

Using Sphinx to produce the documentation

Writing the documentation

Literate programming

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Handling more literals via the eval() variants

A configuration file may have values of types that don't have simple string representations. For example, a collection might be provided as a tuple or a list literal; a mapping might be provided as a dict literal. We have several choices to handle these more complex values.

The choices resolve the issue of how much Python syntax the conversion is able to tolerate. For some types (int, float, bool, complex, decimal.Decimal, and fractions.Fraction), we can safely convert the string to a literal value because the __init__() object for these types can handle string values.

For other types, however, we can't simply do the string conversion. We have several choices on how to proceed:

Forbid these data types and rely on the configuration file syntax plus processing rules to assemble complex Python values from very simple parts...