book

Effective Python: 59 Specific Ways to Write Better Python

Name: Effective Python: 59 Specific Ways to Write Better Python
Author: Brett Slatkin
ISBN: 9780134034416

by Brett Slatkin

March 2015

Intermediate to advanced

256 pages

7h 12m

English

Addison-Wesley Professional

Read now

Unlock full access

About This eBook
Title Page
Copyright Page
Praise for Effective Python
Dedication Page
Contents
Preface
What This Book CoversConventions Used in This BookWhere to Get the Code and Errata
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, str, and unicodeItem 4: Write Helper Functions Instead of Complex ExpressionsItem 5: Know How to Slice SequencesItem 6: Avoid Using start, end, and stride in a Single SliceItem 7: Use List Comprehensions Instead of map and filterItem 8: Avoid More Than Two Expressions in List ComprehensionsItem 9: Consider Generator Expressions for Large ComprehensionsItem 10: Prefer enumerate Over rangeItem 11: Use zip to Process Iterators in ParallelItem 12: Avoid else Blocks After for and while LoopsItem 13: Take Advantage of Each Block in try/except/else/finally

2. Functions
Item 14: Prefer Exceptions to Returning NoneItem 15: Know How Closures Interact with Variable ScopeItem 16: Consider Generators Instead of Returning ListsItem 17: Be Defensive When Iterating Over ArgumentsItem 18: Reduce Visual Noise with Variable Positional ArgumentsItem 19: Provide Optional Behavior with Keyword ArgumentsItem 20: Use None and Docstrings to Specify Dynamic Default ArgumentsItem 21: Enforce Clarity with Keyword-Only Arguments
3. Classes and Inheritance
Item 22: Prefer Helper Classes Over Bookkeeping with Dictionaries and TuplesItem 23: Accept Functions for Simple Interfaces Instead of ClassesItem 24: Use @classmethod Polymorphism to Construct Objects GenericallyItem 25: Initialize Parent Classes with superItem 26: Use Multiple Inheritance Only for Mix-in Utility ClassesItem 27: Prefer Public Attributes Over Private OnesItem 28: Inherit from collections.abc for Custom Container Types
4. Metaclasses and Attributes
Item 29: Use Plain Attributes Instead of Get and Set MethodsItem 30: Consider @property Instead of Refactoring AttributesItem 31: Use Descriptors for Reusable @property MethodsItem 32: Use __getattr__, __getattribute__, and __setattr__ for Lazy AttributesItem 33: Validate Subclasses with MetaclassesItem 34: Register Class Existence with MetaclassesItem 35: Annotate Class Attributes with Metaclasses
5. Concurrency and Parallelism
Item 36: Use subprocess to Manage Child ProcessesItem 37: Use Threads for Blocking I/O, Avoid for ParallelismItem 38: Use Lock to Prevent Data Races in ThreadsItem 39: Use Queue to Coordinate Work Between ThreadsItem 40: Consider Coroutines to Run Many Functions ConcurrentlyItem 41: Consider concurrent.futures for True Parallelism
6. Built-in Modules
Item 42: Define Function Decorators with functools.wrapsItem 43: Consider contextlib and with Statements for Reusable try/finally BehaviorItem 44: Make pickle Reliable with copyregItem 45: Use datetime Instead of time for Local ClocksItem 46: Use Built-in Algorithms and Data StructuresItem 47: Use decimal When Precision Is ParamountItem 48: Know Where to Find Community-Built Modules
7. Collaboration
Item 49: Write Docstrings for Every Function, Class, and ModuleItem 50: Use Packages to Organize Modules and Provide Stable APIsItem 51: Define a Root Exception to Insulate Callers from APIsItem 52: Know How to Break Circular DependenciesItem 53: Use Virtual Environments for Isolated and Reproducible Dependencies
8. Production
Item 54: Consider Module-Scoped Code to Configure Deployment EnvironmentsItem 55: Use repr Strings for Debugging OutputItem 56: Test Everything with unittestItem 57: Consider Interactive Debugging with pdbItem 58: Profile Before OptimizingItem 59: Use tracemalloc to Understand Memory Usage and Leaks
Index
Code Snippets

Overview

It’s easy to start coding 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.

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 a concise, scenario-driven style, Brett Slatkin brings together 59 Python best practices, tips, and shortcuts, and explains them with realistic code examples.

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 learn the best way to accomplish key tasks, so you can write code that’s easier to understand, maintain, and improve.

Key features include

Actionable guidelines for all major areas of Python 3.x and 2.x development, with detailed explanations and examples

Best practices for writing functions that clarify intention, promote reuse, and avoid bugs

Coverage of how to accurately express behaviors with classes and objects

Guidance on how to avoid pitfalls with metaclasses and dynamic attributes

More efficient approaches to concurrency and parallelism

Better techniques and idioms for using Python’s built-in modules

Tools and best practices for collaborative development

Solutions for debugging, testing, and optimization in order to improve quality and performance

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: 9780134034416Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills