دانلود کتاب کد پایتون بهتر

Python is a very well-designed programming language. In surprisingly many cases, the language manages to meet one of the aphorisms in Tim Peters’ The Zen of Python: “There should be one—and preferably only one—obvious way to do it.” If there is only one way to do it, it’s hard to make mistakes. Of course, that aphorism is an aspiration that is not uniformly met. Often there are many ways to perform a task in Python, many of them simply wrong, many inelegant, many leaning heavily on idioms of other programming languages rather than being Pythonic, and some of them not exactly wrong but still grossly inefficient. All the problems described in this book are ones that I’ve seen in real-life code, sometimes in the wild, sometimes caught during code review, and admittedly far too often in code I wrote myself before reflecting upon its flaws. About the Book The sections of this book each present some mistake, pitfall, or foible that developers can easily fall into, and are accompanied by descriptions of ways to avoid making them. At times those solutions simply involve a minor change in “spelling,” but in most cases they require a nuance of thought and design in your code. Many of the discussions do something else as well… I do not hope only to show you something you did not know, but in a great many cases I hope to show you something about which you did not know there was something to know. I believe that the most effective writing and teaching conveys to readers or students not only information, but also good ways of thinking about problems and reasoning about their particular solutions. The info boxes, footnotes, and silly digressions within this book all hope to allow you to think deeper about a particular domain, or a particular task, or a particular style of programming. There is no need to read this book from cover to cover (but I believe that readers who do so will benefit). Each chapter addresses a related cluster of concepts, but stands alone. Moreover, each section within a chapter is also self-contained. Each can be read independently of the others, and most readers will learn something interesting in each one. Some of the sections are more advanced than others, but even in those that seem introductory, I think you will find nuances you did not know. And even in those that seem advanced, I hope you will find the discussions accessible and enlightening. Notwithstanding that each section forms a sort of vignette, the chapters are generally organized in sequence of increasing sophistication, and the sections loosely build upon each other. Where it feels helpful, many discussions refer to other sections that might provide background, or foreshadow elaboration in later sections. In general, I am aiming at a reader who is an intermediate-level Python developer, or perhaps an advanced beginner. I assume you know the basics of the Python programming language; these discussions do not teach the most basic syntax and semantics that you would find in a first course or first book on Python. Mostly I simply assume you have an inquisitive mind and a wish to write code that is beautiful, efficient, and correct. This book is written with Python 3.12 in mind, which was released in October 2023. Code shown has been tested against 3.12 betas. The large majority of the code examples will work in Python 3.8, which is the earliest version that has not passed end-of-life as of mid-2023. In some cases, I note that code requires at least Python 3.10, which was released on October 4, 2021; or occasionally at least Python 3.11, released on October 24, 2022. The large majority of the mistakes discussed within this book were mistakes already in Python 3.8, although a few reflect improvements in later versions of Python. Documents titled “What’s new in Python M.m.μ”1 have been maintained since at least the Python 1.4 days (in 1996)