Clean Python (eBook)

Table of Contents 4
About the Author 10
About the Technical Reviewer 11
Acknowledgments 12
Introduction 13
Chapter 1: Pythonic Thinking 14
Write Pythonic Code 15
Naming 15
Variables and Functions 15
Classes 18
Constants 18
Function and Method Arguments 18
Expressions and Statements in Your Code 19
Embrace the Pythonic Way to Write Code 22
Prefer join Instead of In-Place String Concatenation 23
Consider Using is and is not Whenever You Need to Compare with None 23
Prefer Using is not Instead of not … is 24
Consider Using a Function Instead of a Lambda When Binding to an Identifier 24
Be Consistent with the return Statement 25
Prefer Using ““.startswith() and ””.endswith() 26
Use the isinstance() Method Instead of type() for Comparison 27
Pythonic Way to Compare Boolean Values 27
Write Explicit Code for Context Manager 27
Use Linting Tools to Improve Python Code 29
Using Docstrings 31
Module-Level Docstrings 34
Make the Class Docstring Descriptive 36
Function Docstrings 37
Some Useful Docstring Tools 38
Write Pythonic Control Structures 39
Use List Comprehensions 39
Don’t Make Complex List Comprehension 41
Should You Use a Lambda? 43
When to Use Generators vs. List Comprehension 44
Why Not to Use else with Loops 45
Why range Is Better in Python 3 48
Raising Exceptions 50
Frequently Raised Exceptions 50
Leverage finally to Handle Exceptions 52
Create Your Own Exception Class 54
Handle Only Specific Exceptions 56
Watch Out for Third-Party Exceptions 58
Prefer to Have Minimum Code Under try 59
Summary 61
Chapter 2: Data Structures 62
Common Data Structures 62
Use Sets for Speed 63
Use namedtuple for Returning and Accessing Data 65
Access the Data 65
Return the Data 66
Understanding str, Unicode, and byte 68
Use Lists Carefully and Prefer Generators 70
Use zip to Process a List 73
Take Advantage of Python’s Built-in Functions 75
collections 75
csv 75
datetime and time 75
math 75
re 76
tempfile 76
itertools 76
functools 76
sys and os 76
subprocess 77
logging 77
json 77
pickle 77
__future__ 77
Take Advantage of Dictionary 78
When to Use a Dictionary vs. Other Data Structures 78
collections 79
Counter 79
deque 80
defaultdict 81
namedtuple 82
ordereddict 82
Ordered Dictionary vs. Default Dictionary vs. Normal Dictionary 83
switch Statement Using Dictionary 85
Ways to Merge Two Dictionaries 86
Pretty Printing a Dictionary 87
Summary 88
Chapter 3: Writing Better Functions and Classes 89
Functions 89
Create Small Functions 90
Return Generators 92
Raise Exceptions Instead of Returning None 94
Add Behavior Using the default and keyword Arguments 97
Do Not Return None Explicitly 98
Be Defensive While Writing a Function 101
Logging 101
Unit Test 103
Use a Lambda as a Single Expression 104
Classes 106
Right Size of Class? 106
Class Structure 107
Class Variables 109
__init__ 109
Special Python Methods 110
Class Methods 110
Static Methods 110
Instance Methods 110
Private Methods 111
Right Ways to Use @property 111
When to Use Static Methods? 114
Use Abstract Class Inheritance the Pythonic Way 116
Use @classmethod to Access Class State 118
Use the public Attribute Instead of private 119
Summary 121
Chapter 4: Working with Modules and Metaclasses 122
Modules and Metaclasses 122
How Modules Can Help to Organize Code 124
Take Advantage of the __init__ File 127
Import Functions and Classes from Modules in the Right Way 130
Use __all__ to Prevent Imports 132
When to Use Metaclasses 134
Use __new__ for Validating Subclasses 135
Why __slots__ Are Useful 138
Change Class Behavior Using Metaclasses 141
Learn About Python Descriptors 145
Summary 147
Chapter 5: Decorators and Context Managers 149
Decorators 150
What Are Decorators, and Why Are They Useful? 150
Understanding Decorators 151
Modify Behavior Using Decorators 154
Using Multiple Decorators 157
Decorators Accept Arguments 158
Consider Using a Library for Decorators 159
Class Decorators for Maintaining State and Validating Parameters 162
Context Manager 165
Context Managers and Their Usefulness 165
Understanding Context Managers 167
Using contextlib to Build a Context Manager 170
Some Practical Examples of Using a Context Manager 171
Accessing a Database 171
Writing Tests 172
Shared Resource 173
Remote Connection 174
Summary 175
Chapter 6: Generators and Iterators 176
Take Advantage of Iterators and Generators 176
Understanding Iterators 176
What Are Generators? 179
When to Use Iterators 180
Using itertools 183
combinations() 183
permuations() 183
product() 184
count() 184
groupby() 185
Why Generators Are Useful 185
List Comprehension vs. Iterators 186
Take Advantage of the yield Keyword 186
yield from 188
yield Is Faster Compared to a Data Structure 189
Summary 189
Chapter 7: Utilize New Python Features 190
Asynchronous Programming 191
Introducing async in Python 192
How It Works 196
Coroutine Function 197
Coroutine Object 197
asyncio.run() 197
await 197
Tasks 201
Awaitable Objects 203
Coroutines 203
Tasks 205
Futures 206
Timeouts 208
Async Generators 209
Async Comprehensions 210
Async Iterators 211
Third-Party Libraries to Consider for Async Code 214
Curio 214
Trio 216
Typing in Python 219
Types in Python 220
typing Module 221
Union 221
Any 222
Tuple 222
TypeVar and Generics 223
Optional 223
Do Data Types Slow Code? 224
How Typing Helps to Write Better Code 224
Typing Pitfalls 225
super() Method 226
Type Hinting 226
Better Path Handling Using pathlib 227
print() Is a Function Now 227
f-string 227
Keyword Only Arguments 228
Preserving the Order of a Dictionary 229
Iterable Unpacking 229
Summary 229
Chapter 8: Debugging and  Testing Python Code 230
Debugging 231
Debugging Tools 231
pdb 231
ipdb 232
pudb 233
breakpoint 236
Use the Logging Module Instead of print in Production Code 236
Classes and Functions in Logging 238
Use the metrics Library for Identifying Bottlenecks 243
How IPython Is Helpful 244
Testing 247
Why Testing Is Important 247
Pytest vs. UnitTest 248
Property Testing 253
How to Create a Report for Testing 254
Automate Unit Tests 255
Getting Your Code Ready for Production 256
Run Unit and Integration Tests in Python 256
Use Linting to Make Code Consistent 257
flake8 258
pylint 258
Use Code Coverage to Check for Tests 258
Use virtualenv for Your Project 259
Summary 260
Appendix: Some Awesome Python Tools 261
Sphinx 261
Coverage 263
pre-commit 264
Pyenv for virtualenv 265
Jupyter Lab 265
Pycharm/VSCode/Sublime 266
Flake8/Pylint 266
Index 268