book

Effective Python: 90 Specific Ways to Write Better Python, 2nd Edition

by Brett Slatkin

November 2019

Intermediate to advanced

480 pages

13h 56m

English

Addison-Wesley Professional

Read now

Unlock full access

Item 1: Know Which Version of Python You’re UsingItem 2: Follow the PEP 8 Style GuideItem 3: Know the Differences Between bytes and strItem 4: Prefer Interpolated F-Strings Over C-style Format Strings and str.formatItem 5: Write Helper Functions Instead of Complex ExpressionsItem 6: Prefer Multiple Assignment Unpacking Over IndexingItem 7: Prefer enumerate Over rangeItem 8: Use zip to Process Iterators in ParallelItem 9: Avoid else Blocks After for and while LoopsItem 10: Prevent Repetition with Assignment Expressions
Item 11: Know How to Slice SequencesItem 12: Avoid Striding and Slicing in a Single ExpressionItem 13: Prefer Catch-All Unpacking Over SlicingItem 14: Sort by Complex Criteria Using the key ParameterItem 15: Be Cautious When Relying on dict Insertion OrderingItem 16: Prefer get Over in and KeyError to Handle Missing Dictionary KeysItem 17: Prefer defaultdict Over setdefault to Handle Missing Items in Internal StateItem 18: Know How to Construct Key-Dependent Default Values with __missing__
Item 19: Never Unpack More Than Three Variables When Functions Return Multiple ValuesItem 20: Prefer Raising Exceptions to Returning NoneItem 21: Know How Closures Interact with Variable ScopeItem 22: Reduce Visual Noise with Variable Positional ArgumentsItem 23: Provide Optional Behavior with Keyword ArgumentsItem 24: Use None and Docstrings to Specify Dynamic Default ArgumentsItem 25: Enforce Clarity with Keyword-Only and Positional-Only ArgumentsItem 26: Define Function Decorators with functools.wraps
Item 27: Use Comprehensions Instead of map and filterItem 28: Avoid More Than Two Control Subexpressions in ComprehensionsItem 29: Avoid Repeated Work in Comprehensions by Using Assignment ExpressionsItem 30: Consider Generators Instead of Returning ListsItem 31: Be Defensive When Iterating Over ArgumentsItem 32: Consider Generator Expressions for Large List ComprehensionsItem 33: Compose Multiple Generators with yield fromItem 34: Avoid Injecting Data into Generators with sendItem 35: Avoid Causing State Transitions in Generators with throwItem 36: Consider itertools for Working with Iterators and Generators
Item 37: Compose Classes Instead of Nesting Many Levels of Built-in TypesItem 38: Accept Functions Instead of Classes for Simple InterfacesItem 39: Use @classmethod Polymorphism to Construct Objects GenericallyItem 40: Initialize Parent Classes with superItem 41: Consider Composing Functionality with Mix-in ClassesItem 42: Prefer Public Attributes Over Private OnesItem 43: Inherit from collections.abc for Custom Container Types
Item 44: Use Plain Attributes Instead of Setter and Getter MethodsItem 45: Consider @property Instead of Refactoring AttributesItem 46: Use Descriptors for Reusable @property MethodsItem 47: Use __getattr__, __getattribute__, and __setattr__ for Lazy AttributesItem 48: Validate Subclasses with __init_subclass__Item 49: Register Class Existence with __init_subclass__Item 50: Annotate Class Attributes with __set_name__Item 51: Prefer Class Decorators Over Metaclasses for Composable Class Extensions
Item 52: Use subprocess to Manage Child ProcessesItem 53: Use Threads for Blocking I/O, Avoid for ParallelismItem 54: Use Lock to Prevent Data Races in ThreadsItem 55: Use Queue to Coordinate Work Between ThreadsItem 56: Know How to Recognize When Concurrency Is NecessaryItem 57: Avoid Creating New Thread Instances for On-demand Fan-outItem 58: Understand How Using Queue for Concurrency Requires RefactoringItem 59: Consider ThreadPoolExecutor When Threads Are Necessary for ConcurrencyItem 60: Achieve Highly Concurrent I/O with CoroutinesItem 61: Know How to Port Threaded I/O to asyncioItem 62: Mix Threads and Coroutines to Ease the Transition to asyncioItem 63: Avoid Blocking the asyncio Event Loop to Maximize ResponsivenessItem 64: Consider concurrent.futures for True Parallelism
Item 65: Take Advantage of Each Block in try/except/else/finallyItem 66: Consider contextlib and with Statements for Reusable try/finally BehaviorItem 67: Use datetime Instead of time for Local ClocksItem 68: Make pickle Reliable with copyregItem 69: Use decimal When Precision Is ParamountItem 70: Profile Before OptimizingItem 71: Prefer deque for Producer–Consumer QueuesItem 72: Consider Searching Sorted Sequences with bisectItem 73: Know How to Use heapq for Priority QueuesItem 74: Consider memoryview and bytearray for Zero-Copy Interactions with bytes
Item 75: Use repr Strings for Debugging OutputItem 76: Verify Related Behaviors in TestCase SubclassesItem 77: Isolate Tests from Each Other with setUp, tearDown, setUpModule, and tearDownModuleItem 78: Use Mocks to Test Code with Complex DependenciesItem 79: Encapsulate Dependencies to Facilitate Mocking and TestingItem 80: Consider Interactive Debugging with pdbItem 81: Use tracemalloc to Understand Memory Usage and Leaks
Item 82: Know Where to Find Community-Built ModulesItem 83: Use Virtual Environments for Isolated and Reproducible DependenciesItem 84: Write Docstrings for Every Function, Class, and ModuleItem 85: Use Packages to Organize Modules and Provide Stable APIsItem 86: Consider Module-Scoped Code to Configure Deployment EnvironmentsItem 87: Define a Root Exception to Insulate Callers from APIsItem 88: Know How to Break Circular DependenciesItem 89: Consider warnings to Refactor and Migrate UsageItem 90: Consider Static Analysis via typing to Obviate Bugs

Content preview from Effective Python: 90 Specific Ways to Write Better Python, 2nd Edition

3. Functions

The first organizational tool programmers use in Python is the function. As in other programming languages, functions enable you to break large programs into smaller, simpler pieces with names to represent their intent. They improve readability and make code more approachable. They allow for reuse and refactoring.

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. These extras can make a function’s purpose more obvious. They can eliminate noise and clarify the intention of callers. They can significantly reduce subtle bugs that are difficult to find.