Mastering Object-Oriented Python

755 Pages·2019·12.728 MB·English

by  Steven F. Lott

Mastering Object-Oriented
Python
Second Edition
Build powerful applications with reusable code using
OOP design patterns and Python 3.7
Steven F. Lott
BIRMINGHAM - MUMBAI
Mastering Object-Oriented Python
Second Edition
Copyright © 2019 Packt Publishing
All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in
any form or by any means, without the prior written permission of the publisher, except in the case of brief
quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy of the information
presented. However, the information contained in this book is sold without warranty, either express or
implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any
damages caused or alleged to have been caused directly or indirectly by this book.
Packt Publishing has endeavored to provide trademark information about all of the companies and products
mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the
accuracy of this information.
Commissioning Editor: Richa Tripathi
Acquisition Editor: Chaitanya Nair
Content Development Editor: Zeeyan Pinheiro
Senior Editor: Afshaan Khan
Technical Editor: Ketan Kamble
Copy Editor: Safis Editing
Project Coordinator: Vaidehi Sawant
Proofreader: Safis Editing
Indexer: Manju Arasan
Production Designer: Jayalaxmi Raja
First published: April 2014
Second edition: June 2019
Production reference: 1130619
Published by Packt Publishing Ltd.
Livery Place
35 Livery Street
Birmingham
B3 2PB, UK.
ISBN 978-1-78953-136-7
www.packtpub.com
Packt.com
Subscribe to our online digital library for full access to over 7,000 books and videos,
as well as industry leading tools to help you plan your personal development and
advance your career. For more information, please visit our website.
Why subscribe?
Spend less time learning and more time coding with practical eBooks and
Videos from over 4,000 industry professionals
Improve your learning with Skill Plans built especially for you
Get a free eBook or video every month
Fully searchable for easy access to vital information
Copy and paste, print, and bookmark content
Did you know that Packt offers eBook versions of every book published, with PDF
and ePub files available? You can upgrade to the eBook version at www.packt.com and
as a print book customer, you are entitled to a discount on the eBook copy. Get in
touch with us at [email protected] for more details.
At www.packt.com, you can also read a collection of free technical articles, sign up for
a range of free newsletters, and receive exclusive discounts and offers on Packt books
and eBooks.
Contributors
About the author
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.
About the reviewers
Cody Jackson is a disabled military veteran, the founder of Socius Consulting – an IT
and business management consulting company in San Antonio – and a cofounder of
Top Men Technologies. He is currently employed at CACI International as the lead
ICS/SCADA modeling and simulations engineer. He has been involved in the tech
industry since 1994, when he joined the Navy as a nuclear chemist and Radcon
Technician. Prior to CACI, he worked at ECPI University as a computer information
systems adjunct professor. A self-taught Python programmer, he is the author of
Learning to Program Using Python and Secret Recipes of the Python Ninja. He holds an
Associate in Science degree, a Bachelor of Science degree, and a Master of Science
degree.
Hugo Solis is an assistant professor in the Physics Department at the University of
Costa Rica. His current research interests are computational cosmology, complexity,
cryptography, and the influence of hydrogen on material properties. He has vast
experience with languages, including C/C++ and Python for scientific programming.
He is a member of the Free Software Foundation and has contributed code to some
free software projects. He has also been a technical reviewer for Hands-On Qt for
Python Developers and Learning Object-Oriented Programming, and he is the author of
the Kivy Cookbook from Packt Publishing. Currently, he is in charge of the IFT, a Costa
Rican scientific nonprofit organization for the multidisciplinary practice of physics.
I'd like to thank Katty Sanchez, my beloved mother, for her support and vanguard
thoughts.
Packt is searching for authors like you
If you're interested in becoming an author for Packt, please visit
authors.packtpub.com and apply today. We have worked with thousands of
developers and tech professionals, just like you, to help them share their insight with
the global tech community. You can make a general application, apply for a specific
hot topic that we are recruiting an author for, or submit your own idea.
Table of Contents
Preface 1
Section 1: Tighter Integration Via Special
Methods
Chapter 1: Preliminaries, Tools, and Techniques 10
Technical requirements 11
About the Blackjack game 12
Playing the game 13
Blackjack player strategies 14
Object design for simulating Blackjack 14
The Python runtime and special methods 14
Interaction, scripting, and tools 15
Selecting an IDE 16
Consistency and style 17
Type hints and the mypy program 18
Performance – the timeit module 18
Testing – unittest and doctest 19
Documentation – sphinx and RST markup 21
Installing components 22
Summary 23
Chapter 2: The __init__() Method 24
Technical requirements 25
The implicit superclass – object 25
The base class object __init__() method 26
Implementing __init__() in a superclass 27
Creating enumerated constants 29
Leveraging __init__() via a factory function 31
Faulty factory design and the vague else clause 32
Simplicity and consistency using elif sequences 33
Simplicity using mapping and class objects 34
Two parallel mappings 35
Mapping to a tuple of values 36
The partial function solution 36
Fluent APIs for factories 37
Implementing __init__() in each subclass 38
Composite objects 40
Wrapping a collection class 41
Table of Contents
Extending a collection class 42
More requirements and another design 42
Complex composite objects 43
Complete composite object initialization 45
Stateless objects without __init__() 46
Some additional class definitions 47
Multi-strategy __init__() 50
More complex initialization alternatives 52
Initializing with static or class-level methods 54
Yet more __init__() techniques 55
Initialization with type validation 58
Initialization, encapsulation, and privacy 60
Summary 62
Chapter 3: Integrating Seamlessly - Basic Special Methods 63
Technical requirements 64
The __repr__() and __str__() methods 64
Simple __str__() and __repr__() 66
Collection __str__() and __repr__() 67
The __format__() method 68
Nested formatting specifications 71
Collections and delegating format specifications 71
The __hash__() method 72
Deciding what to hash 73
Inheriting definitions for immutable objects 75
Overriding definitions for immutable objects 78
Overriding definitions for mutable objects 80
Making a frozen hand from a mutable hand 82
The __bool__() method 84
The __bytes__() method 85
The comparison operator methods 88
Designing comparisons 90
Implementation of a comparison of objects of the same class 92
Implementation of a comparison of the objects of mixed classes 94
Hard totals, soft totals, and polymorphism 95
A mixed class comparison example 97
The __del__() method 100
The reference count and destruction 101
Circular references and garbage collection 102
Circular references and the weakref module 104
The __del__() and close() methods 106
The __new__() method and immutable objects 107
The __new__() method and metaclasses 109
Metaclass example – class-level logger 111
Summary 112
[ ii ]
Table of Contents
Chapter 4: Attribute Access, Properties, and Descriptors 114
Technical requirements 115
Basic attribute processing 115
Attributes and the __init__() method 117
Creating properties 118
Eagerly computed properties 121
The setter and deleter properties 123
Using special methods for attribute access 124
Limiting attribute names with __slots__ 126
Dynamic attributes with __getattr__() 127
Creating immutable objects as a NamedTuple subclass 128
Eagerly computed attributes, dataclasses, and __post_init__() 129
Incremental computation with __setattr__() 131
The __getattribute__() method 133
Creating descriptors 135
Using a non-data descriptor 138
Using a data descriptor 140
Using type hints for attributes and properties 143
Using the dataclasses module 145
Attribute Design Patterns 147
Properties versus attributes 148
Designing with descriptors 148
Summary 149
Chapter 5: The ABCs of Consistent Design 150
Technical requirements 150
Abstract base classes 151
Base classes and polymorphism 153
Callable 155
Containers and collections 155
Numbers 157
Some additional abstractions 158
The iterator abstraction 158
Contexts and context managers 159
The abc and typing modules 160
Using the __subclasshook__() method 162
Abstract classes using type hints 163
Summary, design considerations, and trade-offs 164
Looking forward 165
Chapter 6: Using Callables and Contexts 166
Technical requirements 167
Designing callables 167
Improving performance 169
Using memoization or caching 171
[ iii ]
Table of Contents
Using functools for memoization 172
Aiming for simplicity using a callable interface 173
Complexities and the callable interface 174
Managing contexts and the with statement 176
Using the decimal context 178
Other contexts 179
Defining the __enter__() and __exit__() methods 179
Handling exceptions 181
Context manager as a factory 182
Cleaning up in a context manager 183
Summary 185
Callable design considerations and trade-offs 185
Context manager design considerations and trade-offs 186
Looking forward 187
Chapter 7: Creating Containers and Collections 188
Technical requirements 189
ABCs of collections 189
Examples of special methods 191
Using the standard library extensions 191
The typing.NamedTuple class 193
The deque class 195
The ChainMap use case 197
The OrderedDict collection 198
The defaultdict subclass 199
The counter collection 201
Creating new kinds of collections 203
Narrowing a collection's type 204
Defining a new kind of sequence 205
A statistical list 206
Choosing eager versus lazy calculation 208
Working with __getitem__(), __setitem__(), __delitem__(), and slices 211
Implementing __getitem__(), __setitem__(), and __delitem__() 213
Wrapping a list and delegating 214
Creating iterators with __iter__() 217
Creating a new kind of mapping 218
Creating a new kind of set 220
Some design rationale 222
Defining the Tree class 223
Defining the TreeNode class 225
Demonstrating the binary tree bag 229
Design considerations and tradeoffs 230
Summary 231
Chapter 8: Creating Numbers 233
[ iv ]