book

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

Name: Effective Python: 90 Specific Ways to Write Better Python, 2nd Edition
Author: Brett Slatkin
ISBN: 9780134854717

by Brett Slatkin

November 2019

Intermediate to advanced

480 pages

13h 56m

English

Addison-Wesley Professional

Read now

Unlock full access

Cover Page
About This eBook
Half Title Page
Title Page
Copyright Page
Dedication Page
Contents at a Glance
Contents
Preface
Acknowledgments

About the Author
1. Pythonic Thinking
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
2. Lists and Dictionaries
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__
3. Functions
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
4. Comprehensions and Generators
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
5. Classes and Interfaces
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
6. Metaclasses and Attributes
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
7. Concurrency and Parallelism
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
8. Robustness and Performance
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
9. Testing and Debugging
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
10. Collaboration
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
Index
Code Snippets

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

About the Author

Brett Slatkin is a principal software engineer at Google. He is the technical co-founder of Google Surveys, the co-creator of the PubSubHubbub protocol, and he launched Google’s first cloud computing product (App Engine). Fourteen years ago, he cut his teeth using Python to manage Google’s enormous fleet of servers.

Outside of his day job, he likes to play piano and surf (both poorly). He also enjoys writing about programming-related topics on his personal website (https://onebigfluke.com). He earned his B.S. in computer engineering from Columbia University in the City of New York. He lives in San Francisco.

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: 125 Specific Ways to Write Better Python, 3rd Edition

Publisher Resources

ISBN: 9780134854717

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

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

by Brett Slatkin

About the Author

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.