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.

Related Content you might be interested in

Current Title:

Small book image
Mastering Object-Oriented Python - Second Edition
Steven F. Lott
Jun, 2019 | 770 pages
Small book image
Modern Python Cookbook.
Steven F Lott
Jul, 2020 | 822 pages
Small book image
Python Object-Oriented Programming
Steven F Lott | Dusty Phillips
Jul, 2021 | 714 pages
Small book image
Functional Python Programming
Steven F Lott
Apr, 2018 | 408 pages
Table of Contents (25 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Section 1: Tighter Integration Via Special Methods
Section 1: Tighter Integration Via Special Methods
2
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
Summary
3
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
Summary
4
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
Summary
5
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
Summary
6
The ABCs of Consistent Design
The ABCs of Consistent Design
Technical requirements
Abstract base classes
Base classes and polymorphism
Callable
Containers and collections
Numbers
Some additional abstractions
The abc and typing modules
Summary, design considerations, and trade-offs
7
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
Summary
8
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
Summary
9
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
Summary
10
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
Summary
11
Section 2: Object Serialization and Persistence
Section 2: Object Serialization and Persistence
12
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
Summary
13
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
Summary
14
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
Summary
15
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
Summary
16
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
Summary
17
Section 3: Object-Oriented Testing and Debugging
Section 3: Object-Oriented Testing and Debugging
18
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++
Summary
19
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
Summary
20
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
Summary
21
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
Summary
22
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
Summary
23
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
Summary
24
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Storing the configuration in INI files

The INI file format has historical origins from early Windows OS. The module to parse these files is configparser. For additional details on the INI file, you can refer to this Wikipedia article for numerous useful links: http://en.wikipedia.org/wiki/INI_file.

An INI file has sections and properties within each section. Our sample main program has three sections: the table configuration, player configuration, and overall simulation data gathering. For this simulation, we will use an INI file that is similar to the following example:

; Default casino rules 
[table] 
    dealer= Hit17 
    split= NoResplitAces 
    decks= 6 
    limit= 50 
    payout= (3,2) 
 
; Player with SomeStrategy 
; Need to compare with OtherStrategy 
[player] 
    play= SomeStrategy 
    betting= Flat 
    max_rounds= 100 
    init_stake= 50 
 
[simulator] 
    samples...
Previous Section
End of Section 5
Next Section