《流畅Python》：清晰、简洁的编程艺术指南

需积分: 10 143 浏览量更新于2024-07-18 收藏 16.07MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

资源详情

资源推荐

1. Message to comp.lang.python, Dec. 23, 2002: “Acrimony in c.l.p.”

Preface

Here’s the plan: when someone uses a feature you don’t understand, simply shoot them.

This is easier than learning something new, and before too long the only living coders

will be writing in an easily understood, tiny subset of Python 0.9.6 <wink>

— Tim Peters

legendary core developer and author of The Zen of Python

“Python is an easy to learn, powerful programming language.” Those are the first words

of the official Python Tutorial. That is true, but there is a catch: because the language is

easy to learn and put to use, many practicing Python programmers leverage only a

fraction ot its powerful features.

An experienced programmer may start writing useful Python code in a matter of hours.

As the first productive hours become weeks and months, a lot of developers go on

writing Python code with a very strong accent carried from languages learned before.

Even if Python is your first language, often in academia and in introductory books it is

presented while carefully avoiding language-specific features.

As a teacher introducing Python to programmers experienced in other languages, I see

another problem that this book tries to address: we only miss stuff we know about.

Coming from another language, anyone may guess that Python supports regular ex‐

pressions, and look that up in the docs. But if you’ve never seen tuple unpacking or

descriptors before, you will probably not search for them, and may end up not using

those features just because they are specific to Python.

This book is not an A-Z exhaustive reference of Python. My emphasis is in the language

features that are either unique to Python or not found in many other popular languages.

This is also mostly a book about the core language and some of its libraries. I will rarely

talk about packages that are not in the standard library, even though the Python package

index now lists more than 53.000 libraries and many of them are incredibly useful.

XXXtodo

Who This Book Is For

This book was written for practicing Python programmers who want to become pro‐

ficient in Python 3. If you know Python 2 but are willing to migrate to Python 3.4 or

later, you should be fine. At this writing the majority of professional Python program‐

mers are using Python 2, so I took special care to highlight Python 3 features that may

be new to that audience.

However, Fluent Python is about making the most of Python 3.4, and I do not spell out

the fixes needed to make the code work in earlier versions. Most examples should run

in Python 2.7 with little or no changes, but in some cases backporting would require

significant rewriting.

Having said that, I believe this book may be useful even if you must stick with Python

2.7, because the core concepts are still the same. Python 3 is not a new language, and

most differences can be learned in an afternoon. What’s New In Python 3.0 is a good

starting point. Of course, there have been changes after Python 3.0 was released in 2009,

but none as important as those in 3.0.

If you are not sure whether you know enough Python to follow along, review the topics

of the official Python Tutorial. Topics covered in the tutorial will not be explained here,

except for some features that are new in Python 3.

Who This Book Is Not For

If you are just learning Python, this book is going to be hard to follow. Not only that, if

you read it too early in your Python journey, it may give you the impression that every

Python script should leverage special methods and metaprogramming tricks. Premature

abstraction is as bad as premature optimization.

How This Book is Organized

The core audience for this book should not have trouble jumping directly to any chapter

in this book. However, I did put some thought into their ordering.

I tried to emphasize using what is available before discussing how to build your own.

For example, Chapter 2 in Part II covers sequence types that are ready to use, including

some that don’t get a lot of attention, like collections.deque. Building user-defined

sequences is only addressed in Part IV, where we also see how to leverage the Abstract

Base Classes (ABC) from collections.abc. Creating your own ABCs is discussed even

later in Part IV, because I believe it’s important to be comfortable using an ABC before

writing your own.

xvi | Preface

This approach has a few advantages. First, knowing what is ready to use can save you

from reinventing the wheel. We use existing collection classes more often than we im‐

plement our own, and we can give more attention to the advanced usage of available

tools by deferring the discussion on how to create new ones. We are also more likely to

inherit from existing ABCs than to create a new ABC from scratch. And finally, I believe

it is easier to understand the abstractions after you’ve seen them in action.

The downside of this strategy are the forward references scattered throughout the

chapters. I hope these will be easier to tolerate now that you know why I chose this path.

The chapters are split in 6 parts. This is the idea behind each of them:

Part I: Prologue

A single chapter about the Python Data Model explaining how the special methods

(e.g. __repr__) are the key to the consistent behavior of objects of all types — in a

language that is admired for its consistency. Understanding various facets of the

data model is the subject of most of the rest of the book, but Chapter 1 provides a

high-level overview.

Part II: Data structures

The chapters in this part cover the use of collection types: sequences, mappings and

sets, as well as the str versus bytes split — the reason for much joy for Python 3

users and much pain for Python 2 users who have not yet migrated their code bases.

The main goals are to recall what is already available and to explain some behavior

that is sometimes surprising, like the reordering of dict keys when we are not

looking, or the caveats of locale-dependent Unicode string sorting. To achieve these

goals, the coverage is sometimes high level and wide — when many variations of

sequences and mappings are presented — and sometimes deep, for example when

we dive into the hash tables underneath the dict and set types.

Part III: Functions as objects

Here we talk about functions as first-class objects in the language: what that means,

how it affects some popular design patterns, and how to implement function dec‐

orators by leveraging closures. Also covered here is the general concept of callables

in Python, function attributes, introspection, parameter annotations, and the new

nonlocal declaration in Python 3.

Part IV: Object Oriented Idioms

Now the focus is on building classes. In part II the class declaration appears in few

examples; part IV presents many classes. Like any OO language, Python has its

particular set of features that may or may not be present in the language where you

and I learned class-based programming. The chapters explain how references work,

what mutability really means, the lifecycle of instances, how to build your own

collections and ABCs, how to cope with multiple inheritance and how to implement

operator overloading — when that makes sense.

Preface | xvii

Part V: Control flow

Covered in this part are the language constructs and libraries that go beyond se‐

quential control flow with conditionals, loops and subroutines. We start with gen‐

erators, then visit context managers and coroutines, including the challenging but

powerful new yield from syntax. Part V closes with high level a introduction to

modern concurrency in Python with collections.futures — using threads and

processes under the covers with the help of futures — and doing event-oriented I/

O with asyncio — leveraging futures on top of coroutines and yield from.

Part VI: Metaprogramming

This part starts with a review of techniques for building classes with attributes

created dynamically to handle semi-structured data such as JSON datasets. Next

we cover the familiar properties mechanism, before diving into how object attribute

access works at a lower level in Python using descriptors. The relationship between

functions, methods and descriptors is explained. Throughout Part VI, the step by

step implementation of a field validation library uncovers subtle issues the lead to

the use of the advanced tools of the last chapter: class decorators and metaclasses.

Hands-on Approach

Often we’ll use the interactive Python console to explore the language and libraries. I

feel it is important to emphasize the power of this learning tool, particularly for those

readers who’ve had more experience with static, compiled languages that don’t provide

a REPL — read-eval-print-loop.

One of the standard Python testing packages, doctest, works by simulating console

sessions and verifying that the expressions evaluate to the responses shown. I used

doctest to check most of the code in this book, including the console listings. You don’t

need to use or even know about doctest to follow along: the key feature of doctests is

that they look like transcripts of interactive Python console sessions, so you can easily

try out the demonstrations yourself.

Sometimes I will explain what we want to accomplish by showing a doctest before the

code that makes it pass. Firmly establishing what is to be done before thinking about

how to do it helps focus our coding effort. Writing tests first is the basis of TDD (Test

Driven Development) and I’ve also found it helpful when teaching. If you are unfamiliar

with doctest, take a look at its documentation and this book’s source code repository.

You’ll find that you can verify the correctness of most of the code in the book by typing

python3 -m doctest example_script.py in the command shell of your OS.

xviii | Preface

剩余750页未读，继续阅读

dukedo235

粉丝: 0
资源: 4

《流畅Python》：清晰、简洁的编程艺术指南

Fluent Python(最新版 原版 高清 带书签)

fluent python.zip

fluent python

fluentPython

fluent_python_exercises:Fluent Python上的IDinsight DSEM阅读小组练习

fluent python 中英合集

fluent python pdf

fluent python 2nd pdf

fluent python英文版

一款纯VF控制的变频器方案方案说明:可做0.2KW7.5KW 220V，0.2KW75KW 380V，富士通MB90F462A

基于Java语言实现的软件工程Lab1-2021111888设计源码

基于Python的入门级人脸、视频、文字检测与识别项目设计源码

SANJIAO_JICHU gerber.zip

大创资源推荐学习《word文档》

CPA 会计 郑庆华 基础班 第24章 不丧失控制权处理部分子公司的处理.pdf

基于B站直播弹幕数据的实时数据可视化设计源码

基于Vue框架的个性化导航站前端设计源码

琼台师范学院在江西2020-2024各专业最低录取分数及位次表.pdf

最新资源

Fluent Python(最新版原版高清带书签)

CPA 会计郑庆华基础班第24章不丧失控制权处理部分子公司的处理.pdf