Type Here to Get Search Results !

Effective Python by Brett Slatkin in pdf


Download this PDF book: Effective Python: 59 Specific Ways to Write Better Python (Effective Software Development Series) 1st Edition by Brett Slatkin 

It's easy to start writing code with Python: that's why the language is so immensely popular. However, Python has unique strengths, charms, and expressivity that can be hard to grasp at first -- as well as hidden pitfalls that can easily trip you up if you aren't aware of them. 

Effective Python will help you harness the full power of Python to write exceptionally robust, efficient, maintainable, and well-performing code. Utilizing the concise, scenario-driven style pioneered in Scott Meyers's best-selling Effective C++, Brett Slatkin brings together 59 Python best practices, tips, shortcuts, and realistic code examples from expert programmers.

Through realistic examples, Slatkin uncovers little-known Python quirks, intricacies, and idioms that powerfully impact code behavior and performance. You'll learn how to choose the most efficient and effective way to accomplish key tasks when multiple options exist, and how to write code that's easier to understand, maintain, and improve.

Drawing on his deep understanding of Python's capabilities, Slatkin offers practical advice for each major area of development with both Python 3.x and Python 2.x. Coverage includes:





Built-in modules

Production techniques

And more

Each section contains specific, actionable guidelines organized into items, each with carefully worded advice supported by detailed technical arguments and illuminating examples. 

Using Effective Python, you can systematically improve all the Python code you write: not by blindly following rules or mimicking incomprehensible idioms, but by gaining a deep understanding of the technical reasons why they make sense.

About the Author

Brett Slatkin is a Senior Staff Software Engineer at Google. He is the engineering lead and co-founder of Google Consumer Surveys. He formerly worked on Google App Engine's Python infrastructure. He is the co-creator of the PubSubHubbub protocol. 

9 years ago he cut his teeth using Python to manage Google's enormous fleet of servers. Outside of his day job, he works on open source tools and writes about software, bicycles, and other topics on his personal website. He earned his B.S. in Computer Engineering from Columbia University in the City of New York. He lives in San Francisco.

About the Author

Brett Slatkin is a senior staff software engineer at Google. He is the engineering lead and co-founder of Google Consumer Surveys. He formerly worked on Google App Engine’s Python infrastructure. 

He is the co-creator of the PubSubHubbub protocol. Nine years ago he cut his teeth using Python to manage Google’s enormous fleet of servers.


Chapter 1: Pythonic Thinking

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

Item 2: Follow the PEP 8 Style Guide

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

Item 4: Write Helper Functions Instead of Complex Expressions

Item 5: Know How to Slice Sequences

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

Item 7: Use List Comprehensions Instead of map and filter

Item 8: Avoid More Than Two Expressions in List Comprehensions

Item 9: Consider Generator Expressions for Large Comprehensions

Item 10: Prefer enumerate Over range

Item 11: Use zip to Process Iterators in Parallel

Item 12: Avoid else Blocks After for and while Loops

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

Chapter 2: Functions

Item 14: Prefer Exceptions to Returning None

Item 15: Know How Closures Interact with Variable Scope

Item 16: Consider Generators Instead of Returning Lists

Item 17: Be Defensive When Iterating Over Arguments

Item 18: Reduce Visual Noise with Variable Positional Arguments

Item 19: Provide Optional Behavior with Keyword Arguments

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

Item 21: Enforce Clarity with Keyword-Only Arguments

Chapter 3: Classes and Inheritance

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

Item 23: Accept Functions for Simple Interfaces Instead of Classes

Item 24: Use @classmethod Polymorphism to Construct Objects Generically

Item 25: Initialize Parent Classes with super

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

Item 27: Prefer Public Attributes Over Private Ones

Item 28: Inherit from collections.abc for Custom Container Types

Chapter 4: Metaclasses and Attributes

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

Item 30: Consider @property Instead of Refactoring Attributes

Item 31: Use Descriptors for Reusable @property Methods

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


Item 33: Validate Subclasses with Metaclasses

Item 34: Register Class Existence with Metaclasses

Item 35: Annotate Class Attributes with Metaclasses

Chapter 5: Concurrency and Parallelism

Item 36: Use subprocess to Manage Child Processes

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

Item 38: Use Lock to Prevent Data Races in Threads

Item 39: Use Queue to Coordinate Work Between Threads

Item 40: Consider Coroutines to Run Many Functions Concurrently

Item 41: Consider concurrent.futures for True Parallelism

Chapter 6: Built-in Modules

Item 42: Define Function Decorators with functools.wraps

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


Item 44: Make pickle Reliable with copyreg

Item 45: Use datetime Instead of time for Local Clocks

Item 46: Use Built-in Algorithms and Data Structures

Item 47: Use decimal When Precision Is Paramount

Item 48: Know Where to Find Community-Built Modules

Chapter 7: Collaboration

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

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

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

Item 52: Know How to Break Circular Dependencies

Item 53: Use Virtual Environments for Isolated and Reproducible Dependencies

Chapter 8: Production

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

Item 55: Use repr Strings for Debugging Output

Item 56: Test Everything with unittest

Item 57: Consider Interactive Debugging with pdb

Item 58: Profile Before Optimizing

Item 59: Use tracemalloc to Understand Memory Usage and Leaks

About the book:

Publisher ‏ : ‎ Addison-Wesley Professional; 1st edition (February 26, 2015)

Language ‏ : ‎ English

Pages ‏ : ‎ 256 

File : PDF, 13MB


Free Download the Book: Effective Python: 59 Specific Ways to Write Better Python (Effective Software Development Series) 1st Edition by Brett Slatkin 

PS: Share the link with your friends

If the Download link is not working, kindly drop a comment below, so we'll update the download link for you.

Happy downloading!

Post a Comment

* Please Don't Spam Here. All the Comments are Reviewed by Admin.