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

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Mastering Object-oriented Python
  • Toc
  • feedback
Mastering Object-oriented Python

Mastering Object-oriented Python

By : Steven F. Lott
4.2 (13)
close
Mastering Object-oriented Python

Mastering Object-oriented Python

4.2 (13)
By: Steven F. Lott

Overview of this book

Table of Contents (26 chapters)
close
close
Mastering Object-oriented Python
Mastering Object-oriented Python
Credits
Credits
About the Author
About the Author
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Some Preliminaries
Some Preliminaries
Free Chapter
1
The __init__() Method
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
Implementing __init__() in each subclass
Simple composite objects
Complex composite objects
Stateless objects without __init__()
Some additional class definitions
Multi-strategy __init__()
Yet more __init__() techniques
Summary
2
Integrating Seamlessly with Python Basic Special Methods
Integrating Seamlessly with Python Basic Special Methods
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
Summary
3
Attribute Access, Properties, and Descriptors
Attribute Access, Properties, and Descriptors
Basic attribute processing
Creating properties
Using special methods for attribute access
The __getattribute__() method
Creating descriptors
Summary, design considerations, and trade-offs
4
The ABCs of Consistent Design
The ABCs of Consistent Design
Abstract base classes
Base classes and polymorphism
Callables
Containers and collections
Numbers
Some additional abstractions
The abc module
Summary, design considerations, and trade-offs
5
Using Callables and Contexts
Using Callables and Contexts
Designing with ABC callables
Improving performance
Using functools for memoization
Complexities and the callable API
Managing contexts and the with statement
Defining the __enter__() and __exit__() methods
Context manager as a factory
Summary
6
Creating Containers and Collections
Creating Containers and Collections
ABCs of collections
Examples of special methods
Using the standard library extensions
Creating new kinds of collections
Defining a new kind of sequence
Creating a new kind of mapping
Creating a new kind of set
Summary
7
Creating Numbers
Creating Numbers
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
Summary
8
Decorators and Mixins – Cross-cutting Aspects
Decorators and Mixins – Cross-cutting Aspects
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 method functions to a class
Using decorators for security
Summary
9
Serializing and Saving – JSON, YAML, Pickle, CSV, and XML
Serializing and Saving – JSON, YAML, Pickle, CSV, and XML
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
Summary
10
Storing and Retrieving Objects via Shelve
Storing and Retrieving Objects via Shelve
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
Summary
11
Storing and Retrieving Objects via SQLite
Storing and Retrieving Objects via SQLite
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 post objects given a tag string
Improving performance with indices
Summary
12
Transmitting and Sharing Objects
chevron up
Transmitting and Sharing Objects
Class, state, and representation
Using HTTP and REST to transmit objects
Implementing a REST server – WSGI and mod_wsgi
Using Callable classes for WSGI applications
Creating a secure REST service
Implementing REST with a web application framework
Using a message queue to transmit objects
Summary
13
Configuration Files and Persistence
Configuration Files and Persistence
Configuration file use cases
Representation, persistence, state, and usability
Storing the configuration in the INI files
Handling more literals via the eval() variants
Storing the configuration in PY files
Why is exec() a nonproblem?
Using ChainMap for defaults and overrides
Storing the configuration in JSON or YAML files
Storing the configuration in property files
Storing the configuration in XML files – PLIST and others
Summary
14
The Logging and Warning Modules
The Logging and Warning Modules
Creating a basic log
Configuration gotcha
Specializing logging for control, debug, audit, and security
Using the warnings module
Advanced logging – the last few messages and network destinations
Summary
15
Designing for Testability
Designing for Testability
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
Automated integration or performance testing
Summary
16
Coping With the Command Line
Coping With the Command Line
The OS interface and the command line
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
Summary
17
The Module and Package Design
The Module and Package Design
Designing a module
Whole module versus module items
Designing a package
Designing a main script and the __main__ module
Designing long-running applications
Organizing code into src, bin, and test
Installing Python modules
Summary
18
Quality and Documentation
Quality and Documentation
Writing docstrings for the help() function
Using pydoc for documentation
Better output via the 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
Summary
Index
Index

Using Callable classes for WSGI applications

We can implement WSGI applications as Callable objects instead of standalone functions. This allows us to have stateful processing in our WSGI server without the potential confusion of global variables. In our previous example, the get_spin() WSGI application relied on two global variables, american and european. The binding between the application and global can be mysterious.

The point of defining a class is to encapsulate the processing and data into a single package. We can use Callable objects to encapsulate our applications in a better manner. This can make the binding between stateful Wheel and WSGI applications clearer. Here is an extension to the Wheel class that makes it into a callable WSGI application:

from collections.abc import Callable
class Wheel2( Wheel, Callable ):
    def __call__(self, environ, start_response):
        winner= self.spin() # 3. Evaluate.
        status = '200 OK' # 4. Respond.
        headers = [('Content-type...

Unlock full access

Continue reading for free

A Packt free trial gives you instant online access to our library of over 7000 practical eBooks and videos, constantly updated with the latest in tech
Start a 7-day FREE trial
End of Section 5
Next Section
bookmark search playlist download
font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete