What This Book Covers
Each chapter in Effective Python contains a broad but related set of items. You should jump between items and follow your interest. Each item contains concise and specific guidance explaining how you can write Python programs more effectively. Items include advice on what to do, what to avoid, how to strike the right balance, and why this is the best choice.
The items in this book are for Python 3 and Python 2 programmers alike. Programmers using alternative runtimes like Jython, IronPython, or PyPy should also find the majority of items to be applicable.
Chapter 1: Pythonic Thinking
The Python community has come to use the adjective Pythonic to describe code that follows a particular style. The idioms of Python have emerged over time through experience using the language and working with others. This chapter covers the best way to do the most common things in Python.
- Know Which Version of Python You’re Using
- Follow the PEP 8 Style Guide
- Know the Differences Between
bytes, str, and unicode
- Write Helper Functions Instead of Complex Expressions
- Know How to Slice Sequences
- Avoid Using
start, end, and stride in a Single Slice
- Use List Comprehensions Instead of
map and filter
- Avoid More Than Two Expressions in List Comprehensions
- Consider Generator Expressions for Large Comprehensions
- Prefer
enumerate Over range
- Use
zip to Process Iterators in Parallel
- Avoid
else Blocks After for and while Loops
- Take Advantage of Each Block in
try/except/else/finally
Chapter 2: Functions
Functions in Python have a variety of extra features that make a programmer’s life easier. Some are similar to capabilities in other programming languages, but many are unique to Python. This chapter covers how to use functions to clarify intention, promote reuse, and reduce bugs.
- Prefer Exceptions to Returning
None
- Know How Closures Interact with Variable Scope
- Consider Generators Instead of Returning Lists
- Be Defensive When Iterating Over Arguments
- Reduce Visual Noise with Variable Positional Arguments
- Provide Optional Behavior with Keyword Arguments
- Use
None and Docstrings to Specify Dynamic Default Arguments
- Enforce Clarity with Keyword-Only Arguments
Chapter 3: Classes and Inheritance
Python is an object-oriented language. Getting things done in Python often requires writing new classes and defining how they interact through their interfaces and hierarchies. This chapter covers how to use classes and inheritance to express your intended behaviors with objects.
- Prefer Helper Classes Over Bookkeeping with Dictionaries and Tuples
- Accept Functions for Simple Interfaces Instead of Classes
- Use
@classmethod Polymorphism to Construct Objects Generically
- Initialize Parent Classes with
super
- Use Multiple Inheritance Only for Mix-in Utility Classes
- Prefer Public Attributes Over Private Ones
- Inherit from
collections.abc for Custom Container Types
Chapter 4: Metaclasses and Attributes
Metaclasses and dynamic attributes are powerful Python features. However, they also enable you to implement extremely bizarre and unexpected behaviors. This chapter covers the common idioms for using these mechanisms to ensure that you follow the rule of least surprise.
- Use Plain Attributes Instead of Get and Set Methods
- Consider
@property Instead of Refactoring Attributes
- Use Descriptors for Reusable
@property Methods
- Use
__getattr__, __getattribute__, and __setattr__ for Lazy Attributes
- Validate Subclasses with Metaclasses
- Register Class Existence with Metaclasses
- Annotate Class Attributes with Metaclasses
Chapter 5: Concurrency and Parallelism
Python makes it easy to write concurrent programs that do many different things seemingly at the same time. Python can also be used to do parallel work through system calls, subprocesses, and C-extensions. This chapter covers how to best utilize Python in these subtly different situations.
- Use
subprocess to Manage Child Processes
- Use Threads for Blocking I/O, Avoid for Parallelism
- Use
Lock to Prevent Data Races in Threads
- Use
Queue to Coordinate Work Between Threads
- Consider Coroutines to Run Many Functions Concurrently
- Consider
concurrent.futures for True Parallelism
Chapter 6: Built-in Modules
Python is installed with many of the important modules that you’ll need to write programs. These standard packages are so closely intertwined with idiomatic Python that they may as well be part of the language specification. This chapter covers the essential built-in modules.
- Define Function Decorators with
functools.wraps
- Consider
contextlib and with Statements for Reusable try/finally Behavior
- Make
pickle Reliable with copyreg
- Use
datetime Instead of time for Local Clocks
- Use Built-in Algorithms and Data Structures
- Use
decimal When Precision is Paramount
- Know Where to Find Community-Built Modules
Chapter 7: Collaboration
Collaborating on Python programs requires you to be deliberate about how you write your code. Even if you’re working alone, you’ll want to understand how to use modules written by others. This chapter covers the standard tools and best practices that enable people to work together on Python programs.
- Write Docstrings for Every Function, Class, and Module
- Use Packages to Organize Modules and Provide Stable APIs
- Define a Root
Exception to Insulate Callers from APIs
- Know How to Break Circular Dependencies
- Use Virtual Environments for Isolated and Reproducible Dependencies
Chapter 8: Production
Python has facilities for adapting to multiple deployment environments. It also has built-in modules that aid in hardening your programs and making them bulletproof. This chapter covers how to use Python to debug, optimize, and test your programs to maximize quality and performance at runtime.
- Consider Module-Scoped Code to Configure Deployment Environments
- Use
repr Strings for Debugging Output
- Test Everything with
unittest
- Consider Interactive Debugging with
pdb
- Profile Before Optimizing
- Use
tracemalloc to Understand Memory Usage and Leaks
