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

Overview

Updated and Expanded for Python 3

It’s easy to start developing programs with Python, which is why the language is so popular. However, Python’s unique strengths, charms, and expressiveness can be hard to grasp, and there are hidden pitfalls that can easily trip you up.

This second edition of Effective Python will help you master a truly “Pythonic” approach to programming, harnessing Python’s full power to write exceptionally robust and well-performing code. Using the concise, scenario-driven style pioneered in Scott Meyers’ best-selling Effective C++, Brett Slatkin brings together 90 Python best practices, tips, and shortcuts, and explains them with realistic code examples so that you can embrace Python with confidence.

Drawing on years of experience building Python infrastructure at Google, Slatkin uncovers little-known quirks and idioms that powerfully impact code behavior and performance. You’ll understand the best way to accomplish key tasks so you can write code that’s easier to understand, maintain, and improve. In addition to even more advice, this new edition substantially revises all items from the first edition to reflect how best practices have evolved.

Key features include

30 new actionable guidelines for all major areas of Python
Detailed explanations and examples of statements, expressions, and built-in types
Best practices for writing functions that clarify intention, promote reuse, and avoid bugs
Better techniques and idioms for using comprehensions and generator functions
Coverage of how to accurately express behaviors with classes and interfaces
Guidance on how to avoid pitfalls with metaclasses and dynamic attributes
More efficient and clear approaches to concurrency and parallelism
Solutions for optimizing and hardening to maximize performance and quality
Techniques and built-in modules that aid in debugging and testing
Tools and best practices for collaborative development

Effective Python will prepare growing programmers to make a big impact using Python.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Start your free trial

Effective Python: 125 Specific Ways to Write Better Python, 3rd Edition

Publisher Resources

ISBN: 9780134854717

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

by Brett Slatkin

Overview

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

You might also like

Effective Python: 125 Specific Ways to Write Better Python, 3rd Edition

Python for Programmers

Head First Python, 2nd Edition

Learning Python, 6th Edition

Publisher Resources

Overview

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,and much more.

You might also like

Effective Python: 125 Specific Ways to Write Better Python, 3rd Edition

Python for Programmers

Head First Python, 2nd Edition

Learning Python, 6th Edition

Publisher Resources

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.