book

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

Name: Effective Python: 125 Specific Ways to Write Better Python, 3rd Edition
Author: Brett Slatkin
ISBN: 9780138172398

by Brett Slatkin

November 2024

Intermediate to advanced

672 pages

21h 1m

English

Addison-Wesley Professional

Read now

Unlock full access

Includes

Sandbox

Cover Page
About This eBook
Halftitle Page
Title Page
Copyright Page
Dedication Page
Contents at a Glance
Contents
Preface
What This Book CoversConventions Used in This Book
Acknowledgments

About the Author
Chapter 1. Pythonic Thinking
Item 1: Know Which Version of Python You’re UsingItem 2: Follow the PEP 8 Style GuideItem 3: Never Expect Python to Detect Errors at Compile TimeItem 4: Write Helper Functions Instead of Complex ExpressionsItem 5: Prefer Multiple-Assignment Unpacking over IndexingItem 6: Always Surround Single-Element Tuples with ParenthesesItem 7: Consider Conditional Expressions for Simple Inline LogicItem 8: Prevent Repetition with Assignment ExpressionsItem 9: Consider match for Destructuring in Flow Control; Avoid When if Statements Are Sufficient
Chapter 2. Strings and Slicing
Item 10: Know the Differences Between bytes and strItem 11: Prefer Interpolated F-Strings over C-Style Format Strings and str.formatItem 12: Understand the Difference Between repr and str when Printing ObjectsItem 13: Prefer Explicit String Concatenation over Implicit, Especially in ListsItem 14: Know How to Slice SequencesItem 15: Avoid Striding and Slicing in a Single ExpressionItem 16: Prefer Catch-All Unpacking over Slicing
Chapter 3. Loops and Iterators
Item 17: Prefer enumerate over rangeItem 18: Use zip to Process Iterators in ParallelItem 19: Avoid else Blocks After for and while LoopsItem 20: Never Use for Loop Variables After the Loop EndsItem 21: Be Defensive when Iterating over ArgumentsItem 22: Never Modify Containers While Iterating over Them; Use Copies or Caches InsteadItem 23: Pass Iterators to any and all for Efficient Short-Circuiting LogicItem 24: Consider itertools for Working with Iterators and Generators
Chapter 4. Dictionaries
Item 25: Be Cautious when Relying on Dictionary Insertion OrderingItem 26: Prefer get over in and KeyError to Handle Missing Dictionary KeysItem 27: Prefer defaultdict over setdefault to Handle Missing Items in Internal StateItem 28: Know How to Construct Key-Dependent Default Values with __missing__Item 29: Compose Classes Instead of Deeply Nesting Dictionaries, Lists, and Tuples
Chapter 5. Functions
Item 30: Know That Function Arguments Can Be MutatedItem 31: Return Dedicated Result Objects Instead of Requiring Function Callers to Unpack More Than Three VariablesItem 32: Prefer Raising Exceptions to Returning NoneItem 33: Know How Closures Interact with Variable Scope and nonlocalItem 34: Reduce Visual Noise with Variable Positional ArgumentsItem 35: Provide Optional Behavior with Keyword ArgumentsItem 36: Use None and Docstrings to Specify Dynamic Default ArgumentsItem 37: Enforce Clarity with Keyword-Only and Positional-Only ArgumentsItem 38: Define Function Decorators with functools.wrapsItem 39: Prefer functools.partial over lambda Expressions for Glue Functions
Chapter 6. Comprehensions and Generators
Item 40: Use Comprehensions Instead of map and filterItem 41: Avoid More Than Two Control Subexpressions in ComprehensionsItem 42: Reduce Repetition in Comprehensions with Assignment ExpressionsItem 43: Consider Generators Instead of Returning ListsItem 44: Consider Generator Expressions for Large List ComprehensionsItem 45: Compose Multiple Generators with yield fromItem 46: Pass Iterators into Generators as Arguments Instead of Calling the send MethodItem 47: Manage Iterative State Transitions with a Class Instead of the Generator throw Method
Chapter 7. Classes and Interfaces
Item 48: Accept Functions Instead of Classes for Simple InterfacesItem 49: Prefer Object-Oriented Polymorphism over Functions with isinstance ChecksItem 50: Consider functools.singledispatch for Functional-Style Programming Instead of Object-Oriented PolymorphismItem 51: Prefer dataclasses for Defining Lightweight ClassesItem 52: Use @classmethod Polymorphism to Construct Objects GenericallyItem 53: Initialize Parent Classes with superItem 54: Consider Composing Functionality with Mix-in ClassesItem 55: Prefer Public Attributes over Private OnesItem 56: Prefer dataclasses for Creating Immutable ObjectsItem 57: Inherit from collections.abc Classes for Custom Container Types
Chapter 8. Metaclasses and Attributes
Item 58: Use Plain Attributes Instead of Setter and Getter MethodsItem 59: Consider @property Instead of Refactoring AttributesItem 60: Use Descriptors for Reusable @property MethodsItem 61: Use __getattr__, __getattribute__, and __setattr__ for Lazy AttributesItem 62: Validate Subclasses with __init_subclass__Item 63: Register Class Existence with __init_subclass__Item 64: Annotate Class Attributes with __set_name__Item 65: Consider Class Body Definition Order to Establish Relationships Between AttributesItem 66: Prefer Class Decorators over Metaclasses for Composable Class Extensions
Chapter 9. Concurrency and Parallelism
Item 67: Use subprocess to Manage Child ProcessesItem 68: Use Threads for Blocking I/O; Avoid for ParallelismItem 69: Use Lock to Prevent Data Races in ThreadsItem 70: Use Queue to Coordinate Work Between ThreadsItem 71: Know How to Recognize When Concurrency Is NecessaryItem 72: Avoid Creating New Thread Instances for On-Demand Fan-outItem 73: Understand How Using Queue for Concurrency Requires RefactoringItem 74: Consider ThreadPoolExecutor When Threads Are Necessary for ConcurrencyItem 75: Achieve Highly Concurrent I/O with CoroutinesItem 76: Know How to Port Threaded I/O to asyncioItem 77: Mix Threads and Coroutines to Ease the Transition to asyncioItem 78: Maximize Responsiveness of asyncio Event Loops with async-Friendly Worker ThreadsItem 79: Consider concurrent.futures for True Parallelism
Chapter 10. Robustness
Item 80: Take Advantage of Each Block in try/except/else/finallyItem 81: assert Internal Assumptions and raise Missed ExpectationsItem 82: Consider contextlib and with Statements for Reusable try/finally BehaviorItem 83: Always Make try Blocks as Short as PossibleItem 84: Beware of Exception Variables DisappearingItem 85: Beware of Catching the Exception ClassItem 86: Understand the Difference Between Exception and BaseExceptionItem 87: Use traceback for Enhanced Exception ReportingItem 88: Consider Explicitly Chaining Exceptions to Clarify TracebacksItem 89: Always Pass Resources into Generators and Have Callers Clean Them Up OutsideItem 90: Never Set __debug__ to FalseItem 91: Avoid exec and eval Unless You’re Building a Developer Tool
Chapter 11. Performance
Item 92: Profile Before OptimizingItem 93: Optimize Performance-Critical Code Using timeit MicrobenchmarksItem 94: Know When and How to Replace Python with Another Programming LanguageItem 95: Consider ctypes to Rapidly Integrate with Native LibrariesItem 96: Consider Extension Modules to Maximize Performance and ErgonomicsItem 97: Rely on Precompiled Bytecode and File System Caching to Improve Startup TimeItem 98: Lazy-Load Modules with Dynamic Imports to Reduce Startup TimeItem 99: Consider memoryview and bytearray for Zero-Copy Interactions with bytes
Chapter 12. Data Structures and Algorithms
Item 100: Sort by Complex Criteria Using the key ParameterItem 101: Know the Difference Between sort and sortedItem 102: Consider Searching Sorted Sequences with bisectItem 103: Prefer deque for Producer–Consumer QueuesItem 104: Know How to Use heapq for Priority QueuesItem 105: Use datetime Instead of time for Local ClocksItem 106: Use decimal when Precision Is ParamountItem 107: Make pickle Serialization Maintainable with copyreg
Chapter 13. Testing and Debugging
Item 108: Verify Related Behaviors in TestCase SubclassesItem 109: Prefer Integration Tests over Unit TestsItem 110: Isolate Tests from Each Other with setUp, tearDown, setUpModule, and tearDownModuleItem 111: Use Mocks to Test Code with Complex DependenciesItem 112: Encapsulate Dependencies to Facilitate Mocking and TestingItem 113: Use assertAlmostEqual to Control Precision in Floating Point TestsItem 114: Consider Interactive Debugging with pdbItem 115: Use tracemalloc to Understand Memory Usage and Leaks
Chapter 14. Collaboration
Item 116: Know Where to Find Community-Built ModulesItem 117: Use Virtual Environments for Isolated and Reproducible DependenciesItem 118: Write Docstrings for Every Function, Class, and ModuleItem 119: Use Packages to Organize Modules and Provide Stable APIsItem 120: Consider Module-Scoped Code to Configure Deployment EnvironmentsItem 121: Define a Root Exception to Insulate Callers from APIsItem 122: Know How to Break Circular DependenciesItem 123: Consider warnings to Refactor and Migrate UsageItem 124: Consider Static Analysis via typing to Obviate BugsItem 125: Prefer Open Source Projects for Bundling Python Programs over zipimport and zipapp
Index
Code Snippets

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

9 Concurrency and Parallelism

Concurrency enables a computer to do many different things seemingly at the same time. For example, on a computer with one CPU core, the operating system rapidly changes which program is running on the single processor. In doing so, it interleaves execution of the programs, providing the illusion that the programs are running simultaneously.

Parallelism, in contrast, involves actually doing many different things at the same time. Computers with multiple CPU cores can execute multiple programs simultaneously. Each CPU core runs the instructions of a separate program, allowing each program to make forward progress during the same instant.

Within a single program, concurrency is a tool that makes it easier for programmers ...

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.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

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

Publisher Resources

ISBN: 9780138172398

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

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

by Brett Slatkin

9

Concurrency and Parallelism

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.