Pub. Date:
Effective Python: 59 Specific Ways to Write Better Python / Edition 1

Effective Python: 59 Specific Ways to Write Better Python / Edition 1

by Brett Slatkin
Current price is , Original price is $39.99. You

Temporarily Out of Stock Online

Please check back later for updated availability.

Product Details

ISBN-13: 9780134034287
Publisher: Addison-Wesley
Publication date: 03/12/2015
Series: Effective Software Development Series
Pages: 256
Sales rank: 115,424
Product dimensions: 6.90(w) x 9.00(h) x 0.70(d)

About the Author

Brett Slatkin, senior staff software engineer at Google, is engineering lead and co-founder of Google Consumer Surveys. He previously worked on Google App Engine’s Python infrastructure, leveraged Python to manage Google’s enormous server fleet, and used Python to implement Google's system for PubSubHubbub, a protocol he co-created. Slatkin holds a B.S. in computer engineering from Columbia University in the City of New York. He lives in San Francisco.

Table of Contents

Preface xiii

Acknowledgments xvii

About the Author xix

Chapter 1: Pythonic Thinking 1

Item 1: Know Which Version of Python You’re Using 1

Item 2: Follow the PEP 8 Style Guide 2

Item 3: Know the Differences Between bytes, str, and unicode 5

Item 4: Write Helper Functions Instead of Complex Expressions 8

Item 5: Know How to Slice Sequences 10

Item 6: Avoid Using start, end, and stride in a Single Slice 13

Item 7: Use List Comprehensions Instead of map and filter 15

Item 8: Avoid More Than Two Expressions in List Comprehensions 16

Item 9: Consider Generator Expressions for Large Comprehensions 18

Item 10: Prefer enumerate Over range 20

Item 11: Use zip to Process Iterators in Parallel 21

Item 12: Avoid else Blocks After for and while Loops 23

Item 13: Take Advantage of Each Block in try/except/else/finally 26

Chapter 2: Functions 29

Item 14: Prefer Exceptions to Returning None 29

Item 15: Know How Closures Interact with Variable Scope 31

Item 16: Consider Generators Instead of Returning Lists 36

Item 17: Be Defensive When Iterating Over Arguments 38

Item 18: Reduce Visual Noise with Variable Positional Arguments 43

Item 19: Provide Optional Behavior with Keyword Arguments 45

Item 20: Use None and Docstrings to Specify Dynamic Default Arguments 48

Item 21: Enforce Clarity with Keyword-Only Arguments 51

Chapter 3: Classes and Inheritance 55

Item 22: Prefer Helper Classes Over Bookkeeping with Dictionaries and Tuples 55

Item 23: Accept Functions for Simple Interfaces Instead of Classes 61

Item 24: Use @classmethod Polymorphism to Construct Objects Generically 64

Item 25: Initialize Parent Classes with super 69

Item 26: Use Multiple Inheritance Only for Mix-in Utility Classes 73

Item 27: Prefer Public Attributes Over Private Ones 78

Item 28: Inherit from for Custom Container Types 83

Chapter 4: Metaclasses and Attributes 87

Item 29: Use Plain Attributes Instead of Get and Set Methods 87

Item 30: Consider @property Instead of Refactoring Attributes 91

Item 31: Use Descriptors for Reusable @property Methods 95

Item 32: Use __getattr__, __getattribute__, and __setattr__ for Lazy Attributes 100

Item 33: Validate Subclasses with Metaclasses 105

Item 34: Register Class Existence with Metaclasses 108

Item 35: Annotate Class Attributes with Metaclasses 112

Chapter 5: Concurrency and Parallelism 117

Item 36: Use subprocess to Manage Child Processes 118

Item 37: Use Threads for Blocking I/O, Avoid for Parallelism 122

Item 38: Use Lock to Prevent Data Races in Threads 126

Item 39: Use Queue to Coordinate Work Between Threads 129

Item 40: Consider Coroutines to Run Many Functions Concurrently 136

Item 41: Consider concurrent.futures for True Parallelism 145

Chapter 6: Built-in Modules 151

Item 42: Define Function Decorators with functools.wraps 151

Item 43: Consider contextlib and with Statements for Reusable try/finally Behavior 153

Item 44: Make pickle Reliable with copyreg 157

Item 45: Use datetime Instead of time for Local Clocks 162

Item 46: Use Built-in Algorithms and Data Structures 166

Item 47: Use decimal When Precision Is Paramount 171

Item 48: Know Where to Find Community-Built Modules 173

Chapter 7: Collaboration 175

Item 49: Write Docstrings for Every Function, Class, and Module 175

Item 50: Use Packages to Organize Modules and Provide Stable APIs 179

Item 51: Define a Root Exception to Insulate Callers from APIs 184

Item 52: Know How to Break Circular Dependencies 187

Item 53: Use Virtual Environments for Isolated and

Reproducible Dependencies 192

Chapter 8: Production 199

Item 54: Consider Module-Scoped Code to Configure Deployment Environments 199

Item 55: Use repr Strings for Debugging Output 202

Item 56: Test Everything with unittest 204

Item 57: Consider Interactive Debugging with pdb 208

Item 58: Profile Before Optimizing 209

Item 59: Use tracemalloc to Understand Memory Usage and Leaks 214

Index 217

Customer Reviews

Most Helpful Customer Reviews

See All Customer Reviews