book

Mastering Object-oriented Python

by Steven F. Lott

April 2014

Beginner to intermediate

634 pages

15h 22m

English

Packt Publishing

Read now

Unlock full access

Support files, eBooks, discount offers and moreWhy Subscribe?Free Access for Packt account holders
What this book covers

Customer supportDownloading the example code for this bookErrataPiracyQuestions
About casino BlackjackPlaying the gameBlackjack player strategiesObject design for simulating Blackjack
Unit testing and technology spikes
Pythonic Classes via Special Methods
The implicit superclass – object
Faulty factory design and the vague else clauseSimplicity and consistency using elif sequencesSimplicity using mapping and class objectsTwo parallel mappingsMapping to a tuple of valuesThe partial function solutionFluent APIs for factories
Wrapping a collection classExtending a collection classMore requirements and another design
Complete composite object initialization
More complex initialization alternativesInitializing static methods
Initialization with type validationInitialization, encapsulation, and privacy
The __repr__() and __str__() methodsNon collection __str__() and __repr__()Collection __str__() and __repr__()
Nested formatting specificationsCollections and delegating format specifications
Deciding what to hashInheriting definitions for immutable objectsOverriding definitions for immutable objectsOverriding definitions for mutable objectsMaking a frozen hand from a mutable hand
Designing comparisonsImplementation of comparison for objects of the same classImplementation of comparison for objects of mixed classesHard totals, soft totals, and polymorphismA mixed class comparison example
The reference count and destructionCircular references and garbage collectionCircular references and the weakref moduleThe __del__() and close() methods
Metaclass example 1 – ordered attributesMetaclass example 2 – self-reference
Basic attribute processingAttributes and the __init__() method
Eagerly computed propertiesSetter and deleter properties
Creating immutable objects with __slots__Creating immutable objects as a tuple subclassEagerly computed attributes
Using a nondata descriptorUsing a data descriptor
Properties versus attributesDesigning with descriptorsLooking forward
Abstract base classes
The iterator abstractionContexts and context managers
Looking forward
Designing with ABC callables
Using memoization or caching
Aiming for simplicity using the callable API
Using the decimal contextOther contexts
Handling exceptions
Cleaning up in a context manager
Callable design considerations and trade-offsContext manager design considerations and trade-offsLooking forward
ABCs of collections
The namedtuple() functionThe deque classThe ChainMap use caseThe OrderedDict collectionThe defaultdict subclassThe counter collection
A statistical listChoosing eager versus lazy calculationWorking with __getitem__(), __setitem__(), __delitem__(), and slicesImplementing __getitem__(), __setitem__(), and __delitem__()Wrapping a list and delegatingCreating iterators with __iter__()
Some design rationaleDefining the Tree classDefining the TreeNode classDemonstrating the binary tree set
Design considerations and Trade-offsLooking forward
ABCs of numbersDeciding which types to useThe method resolution and the reflected operator concept
Defining FixedPoint initializationDefining FixedPoint binary arithmetic operatorsDefining FixedPoint unary arithmetic operatorsImplementing FixedPoint reflected operatorsImplementing FixedPoint comparison operators
Designing more useful rounding
Design considerations and trade-offsLooking forward
Class and meaningConstructing the functionsConstructing the classSome class design principlesAspect-oriented programming
Using standard library decorators
Using the context manager mixin classTurning off a class feature
Creating separate loggers
Design considerations and trade-offsLooking forward
Persistence and Serialization
Understanding persistence, class, state, and representationCommon Python terminologies
Rendering a blog and posts
Supporting JSON in our classesCustomizing JSON encodingCustomizing JSON decodingThe security and the eval() issueRefactoring the encode functionStandardizing the date stringWriting JSON to a file
Formatting YAML data on a fileExtending the YAML representationSecurity and safe loading
Designing a class for reliable pickle processingSecurity and the global issue
Dumping simple sequences to CSVLoading simple sequences from CSVHandling containers and complex classesDumping and loading multiple row types in a CSV fileFiltering CSV rows with an iteratorDumping and loading joined rows in a CSV file
Dumping objects using string templatesDumping objects with xml.etree.ElementTreeLoading XML documents
Design considerations and trade-offsSchema evolutionLooking forward
Analyzing persistent object use casesThe ACID properties
Designing keys for our objectsGenerating surrogate keys for objectsDesigning a class with a simple keyDesigning classes for containers or collectionsReferring to objects via foreign keysDesigning CRUD operations for complex objects
Writing a demonstration script
Creating top-level indices
Schema evolution
Design considerations and trade-offsApplication software layersLooking forward
SQL databases, persistence, and objectsThe SQL data model – rows and tablesCRUD processing via SQL DML statementsQuerying rows with the SQL SELECT statementSQL transactions and the ACID propertiesDesigning primary and foreign database keys
Implementing class-like processing in pure SQL
Designing an access layer for SQLiteImplementing container relationships
Designing ORM-friendly classesBuilding the schema with the ORM layerManipulating objects with the ORM layer
Schema evolution
Design considerations and trade-offsMapping alternativesKeys and key designsApplication software layersLooking forward
Class, state, and representation
Implementing CRUD operations via RESTImplementing non-CRUD operationsThe REST protocol and ACIDChoosing a representation – JSON, XML, or YAML
Creating a simple REST application and serverImplementing a REST clientDemonstrating and unit testing the RESTful services
Designing RESTful object identifiersMultiple layers of REST servicesCreating the roulette serverCreating the roulette client
The WSGI Authentication application
Defining processesBuilding queues and supplying data
Design considerations and trade-offsSchema evolutionApplication software layersLooking forward
Configuration file use cases
Application configuration design patternsConfiguring via object constructionImplementing a configuration hierarchy
Configuration via class definitionsConfiguration via SimpleNamespaceUsing Python with exec() for the configuration
Using flattened JSON configurationsLoading a YAML configuration
Parsing a properties fileUsing a properties file
Customized XML configuration files
Design considerations and trade-offsCreating a shared configurationSchema evolutionLooking Forward
Testing, Debugging, Deploying, and Maintaining
Creating a basic logCreating a shared class-level loggerConfiguring the loggersStarting up and shutting down the logging systemNaming the loggersExtending the logger levelsDefining handlers for multiple destinationsManaging the propagation rules
Creating a debugging logCreating audit and security logs
Showing API changes with a warningShowing configuration problems with a warningShowing possible software problems with a warning
Building an automatic tail bufferSending logging messages to a remote processPreventing queue overrun
Design considerations and trade-offsLooking forward
Defining and isolating units for testingMinimizing the dependenciesCreating simple unit testsCreating a test suiteIncluding edge and corner casesMocking dependencies for testingUsing more mocks to test more behaviors
Combining doctest and unittestCreating a more complete test package
Using setup and teardown with OS resourcesUsing setup and teardown with databases
Design considerations and trade-offsLooking forward
The OS interface and the command lineArguments and options
A simple on/off optionAn option with an argumentPositional argumentsAll other arguments--version display and exit--help display and exit
Providing more configurable defaultsOverriding configuration file settings with environment variablesOverriding environment variables with the configuration filesMaking the configuration aware of the None values
Ensuring DRY for the configurationManaging nested configuration contexts
Designing command classesAdding the analysis command subclassAdding and packaging more features into an applicationDesigning a higher-level composite command
Design considerations and trade-offsLooking forward
Designing a moduleSome module design patternsModule versus classThe expected content of a module
Designing a module-package hybridDesigning a package with alternate implementations
Creating an executable script fileCreating a __main__ moduleProgramming in the large
Design considerations and trade-offsLooking forward
Writing docstrings for the help() function
Blocks of textThe RST inline markupRST directivesLearning RST
Writing API details in RST markupWriting class and method function docstringsWriting function docstrings
Using the Sphinx quickstartWriting the Sphinx documentationFilling in the 4+1 views for documentationWriting the implementation documentCreating the Sphinx cross-referencesRefactoring Sphinx files into directories
Use cases for literate programmingWorking with a literate programming tool
Design considerations and trade-offs

Content preview from Mastering Object-oriented Python

Summary

We looked at a number of considerations to design modules and packages. The parallels between a module and singleton class are deep. When we design a module, the essential questions of the encapsulation of the structure and processing are as relevant as they are for class design.

When we design a package, we need to be skeptical of the need for deeply nested structures. We'll need to use packages when there are variant implementations; we looked at a number of ways to handle this variability. We may also need to define a package to combine a number of modules into a single module-like package. We looked at how __init__.py can import from within the package.