Steven F. Lott has been programming since the 1970s, when computers were large, expensive, and rare. As a contract software developer and architect, he has worked on hundreds of projects, from very small to very large ones. He's been using Python to solve business problems for over 10 years. His other titles with Packt include Python Essentials, Mastering Object-Oriented Python, Functional Python Programming Second Edition, Python for Secret Agents, and Python for Secret Agents II. Steven is currently a technomad who lives in various places on the East Coast of the US. You can follow him on Twitter via the handle @s_lott.
- Title Page
- Copyright and Credits
- About Packt
- Contributors
- Preface
- Section 1: Tighter Integration Via Special Methods
- 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
- 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
- Integrating Seamlessly - Basic Special Methods
- Attribute Access, Properties, and Descriptors
- The ABCs of Consistent Design
- Using Callables and Contexts
- 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
- Creating Numbers
- Decorators and Mixins - Cross-Cutting Aspects
- Section 2: Object Serialization and Persistence
- 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
- 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
- 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
- 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
- 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
- Section 3: Object-Oriented Testing and Debugging
- Design Principles and Patterns
- The Logging and Warning Modules
- Designing for Testability
- 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
- Module and Package Design
- 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
- Other Books You May Enjoy
About the author
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.