Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series) By Brett Slatkin

Effective

Download Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series)

Delivers on the title's promise in spades; it's specific, actionable, and insightful. The 90 items span all the aspects of the language, from functions and classes to testing and collaboration. It's great for learning or reminding yourself about the best approach to specific problems or parts of the language. It also imparts a fair amount of software engineering wisdom through its discussion of the pros and cons of the approaches discussed in each item, especially in later chapters.

The book's an excellent reference, and a big reason for that is the structure of each item. Brett motivates each problem, considers different approaches to solving it, from naive to overwrought; before presenting the best method. Each item is rounded out with a short bulleted list of Things to Remember. When I've needed a quick reminder I jump to the Things to Remember section, and when I've needed to re-learn a Python idiom or approach to development I can re-read the whole item. While the approach is uniform throughout and Brett's writing is very clear, some of the examples were a lot tougher to follow than others. That is to say, the assumed background for different items varies, which is not necessarily a bad thing given the scope and purpose of the book. Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series) I nicely packaged book with ways to improve your coding. My main concern is the time (and space) spent on examples of how not to do things and that some of the items in the book seems to be fillers as they are very basic compared to other examples. I would however recommend this as a dictionary-type book. Skim through the examples and re-iterate a section when you encounter a situation you recognize. Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series) I read the first edition of the book and I just finished the second edition. This is one of the best books on Python that I had. Every time I read it I always learn something. I also like the way it organized, 90 items, each one covers specific typic and in the end, it has a summary of the item. It's called Things to remember. New edition covers asyncio, static analysis, and walrus operator.
If I could I would give this book 10 stars. Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series) I picked this up after starting to work on a research project 40hrs/week in Python for the first time and wanting to improve my Python. I came to this book comfortable with Python data science basics, implementing methods in Numpy, and with some general data science and development background for R. The goal was to find the 'pit of success' workflows in Python that I use for research and exploratory modeling in R. This didn't quite happen, but I don't think that's quite the goal of the book.

Things that were super useful:

- In-depth explanations of Python's list idioms, and in particular zip() and * for variadic functions
- Explanations of function and class decorators
- General Python best practices recommendations
- Commentary on object-orientation and class design, especially as someone who mostly uses functional patterns

Things that were less useful to me:

- An extension discussion of threaded concurrency rather than true parallelism. The basic tool that I need for data science work is a truly parallel mapping operation, and this didn't really appear in the book in any detail.
- The metaclass chapter, largely because I didn't have enough background to understand the examples.

This book is analogous to Advanced R and has excellent examples, but assumes at least an intermediate level of Python background. I strongly recommend this book to R users (along not as an introduction to the language), as there are definitely design patterns in Python that it would be nice to see integrated in R.

Since my Python background is piecemeal, after reading this book I found myself wanting:

- An in-depth, opinionated guide on how to write doc-strings
- An in-depth, opinionated style-guide, or at least some more basic instructions on how to use a linter
- A brief overview of the OOP landscape in Python
- Discussions of logging and data/argument validation at a beginner level
- Some pointers to libraries like joblib for parallel maps, memoization and memory-mapping, which I've found essential in exploratory and research work.

At several points the book made me wish that I had taken an OS class or programming languages class to have a better understanding of system level stuff or how encapsulated (rather than generic-function) OOP works. This was largely from a personal curiosity point-of-view.

These are all critiques of content because I was personally hoping to learn something not quite in the book's scope; I found the writing itself and examples to be remarkably clear and will recommend and reference this book for years to come. Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series) Sehr ausnahmsweise möchte ich ein Buch bewerten das ich gar nicht ganz gelesen habe, weil es hier um ein Buch geht das vielleicht auch andere, so wie ich, vielleicht gar nicht von Deckel zu Deckel lesen. In 90 sehr präzisen, gut erklärten und knapp formulierten Tipps wird einem hier gesagt Mach diese eine Sache doch vielleicht lieber so und so. Das für mich bisher mit Abstand wichtigste Programmier-Buch, mein Code ist durch dieses Buch sicherlich besser geworden. Ratschläge die man nicht brauch kann man bedenkenlos überspringen ohne in anderen Ratschlägen dadurch etwas nicht zu verstehen, die Kapitel sind sinnvolle Einheiten, ich bin sehr zufrieden. Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series)

Updated and Expanded for Python 3
It’s easy to start developing programs 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.

This second edition of 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 the concise, scenario-driven style pioneered in Scott Meyers’ best-selling Effective C++, Brett Slatkin brings together 90 Python best practices, tips, and shortcuts, and explains them with realistic code examples so that you can embrace Python with confidence.

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 understand the best way to accomplish key tasks so you can write code that’s easier to understand, maintain, and improve. In addition to even more advice, this new edition substantially revises all items from the first edition to reflect how best practices have evolved.

Key features include
30 new actionable guidelines for all major areas of Python Detailed explanations and examples of statements, expressions, and built-in types Best practices for writing functions that clarify intention, promote reuse, and avoid bugs Better techniques and idioms for using comprehensions and generator functions Coverage of how to accurately express behaviors with classes and interfaces Guidance on how to avoid pitfalls with metaclasses and dynamic attributes More efficient and clear approaches to concurrency and parallelism Solutions for optimizing and hardening to maximize performance and quality Techniques and built-in modules that aid in debugging and testing Tools and best practices for collaborative development   Effective Python will prepare growing programmers to make a big impact using Python. Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series)

This was a really splendid Python book.

I enjoyed learning all the 90 improvements to syntax, refactoring code, and making executions more efficient.

I thought this was a very important coding book and would recommend it to fellow Python developers.

4.8/5 Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series) It's a nice book. It compiles a lot of good practices when writing Python code. I've found a lot of things I regularly do, and others that I will definitely start doing.

However the book gets a bit tedious at a certain point. In addition, the book avoids auxiliary pictures or schematics completely, and I feel a lot of concepts could have benefited greatly from a visual component. The text gets a bit too involved in these more complex topics. Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series) I saw Vicki Boykis' recommended this book on Twitter, and it didn't disappoint me. In fact, it is one of the best Python book out there for learning how to write effective Python for intermeidate+ practitioners. I especially appreciate the author's approach to the topics. The writing style was in itself effective - the author always try to solve a problem using plain Python, point out its limitations, and then gradually refactor the code as he introduce new concepts. I find a lot of the tips to be practical and have used quite a few myself during my work! This is definitely a great book for Python practitioners. Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series) Full review at: https://no-title.victordomingos.com/a...
---------------------------------------
This is a book that I definitely recommend to anyone who already has some basic or intermediate knowledge of Python. You can read it cover to cover, or just pick the specific topics that you’re interested in at a given time, and get back to it later when you need it. Even more experienced Python users may still benefit from some of the explanations in this book, like those on chapter 6 (“Metaclasses and Attributes”) or on chapter 7 (“Concurrency and Parallelism”).

In a world where the web is full of videos and tutorials on programming (which is great, but not always the most efficient way to learn), it is good to know that there are excellent quality books like this one being published, both on print and on digital formats, which can guide us throughout our journey towards a deeper knowledge of Python and its best programming practices. (...)
Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series) The second edition, like the first, is a must-read for professional Python developers. But I wouldn't take all of it that seriously. There are a number of weird, forced suggestions like how fervently he goes into use cases for the walrus operators, generators, and metaclasses specifically. The code ended up overcomplicated and not less brittle than it could have been. In general, just because there's syntax available doesn't mean you should use it for the sake of fellow maintainers (or yourself in the future). But it's good to know what exists. Effective Python: 90 Specific Ways to Write Better Python (Effective Software Development Series)