本书全面细致地介绍了Python的各个功能、逻辑和惯用模式,以便读者快速编写出专业、地道、实用的Python程序,从Python新手成长为高手。
本书共5个部分。第一部分“Python 环境”讲解 Python的哲学、开发环境、基本语法、项目结构和代码导入等内容,为读者编写规范的Python代码奠定坚实的基础。第二部分“基本结构”讲解Python的变量、数据类型、函数、类、对象、错误和异常等。第三部分“数据和流程”讲解操作数据和控制执行流程的许多独特方法,包括集合、迭代、生成器、推导式、文本输入/输出、上下文管理、二进制和序列化等。第四部分“高级概念”探索Python 的高级策略,如继承、混入、元类、抽象基类、自省、泛型、异步、并发、线程和并行等。第五部分“超越代码”讲解项目的打包、分发、调试、日志、测试和剖析等环节,并概述Python开发的方向。
本书适合想要学习编写专业Python程序的读者阅读,既可作为零基础入门 Python 的教材,也可作为程序员案头常备的Python工具书。本书尤其适合已掌握其他编程语言的开发者用来学习Python,可以帮助这些开发者不受其他编程语言的影响来学习地道的 Python编程方法。
本书并不是一本只简单罗列一些术语介绍的“傻瓜书”。本书的设计目标是让读者阅读完后会说:“起初这个主题似乎很难理解,但是经过书里的解释,这个主题对我来说变得非常简单了。”这实在是任何形式的教学的终极目标:即便是针对棘手主题的讨论,也要把概念讲解得非常清晰。
本书中的大量示例同样令人印象深刻。书中几乎涵盖想要编写实用的Python代码所需要的所有内容,包括变量、数据结构和循环等基础知识,以及并发和并行等高级内容。当我阅读本书时,每章都以其完备和丰富的细节给我留下了深刻印象。
本书中的示例设计精巧,引人入胜,对概念的解释清晰易懂。这确实是一本出类拔萃的好书。
——内奥米·塞德(Naomi Ceder),Python 软件基金会董事会主席

年份:2025
出版社:人民邮电出版社、异步图书
书籍汇总:
链接: https://pan.baidu.com/s/1FFw_24YdJIUfLGunRGT_7g?pwd=9at9
链接: https://pan.baidu.com/s/1wp1sxh_p5Cv9dI5OpBaSCg?pwd=2arp

在留言区参与互动发送(我想要一本赠书)
并点击转发朋友圈,邀好友助力点赞你的留言
我们将选点赞率最高的1名读者获得赠书1本
时间以公众号推文发出24小时为限
记得扫码加号主微信,以便联系邮寄地址哦
想要摆脱其他语言的思维定式,写出真正“Pythonic”的代码?
好消息来了!Python学习界的“扛把子”蟒蛇书系列再添力作——《Python编程从新手到高手》中文版正式发布!
▼点击下方,即可购书
这本书全面细致地介绍了Python的各个功能、逻辑和惯用模式,以便读者快速编写出专业、地道、实用的Python程序,从Python新手成长为高手。出色的内容引得Python软件基金会董事会主席作序推荐,美亚评分高达4.6(满分5分),接下来的很长时间你将被这本书刷屏,它将出现在各大畅销书榜单上,成为开发者案头新经典。


源自同名热门文章系列,
作者是实战经验丰富的开发者导师
本书作者贾森·C.麦克唐纳(Jason C. McDonald)是一位拥有十余年软件工程经验的实践者和讲师。他曾作为开发者或管理者在多家公司工作,经历过各种类型的项目,并多次在员工培训、技术会议和大学中进行软件开发、管理和职业发展等主题的演讲和教学。
他还是Ubuntu社区、开放源码倡议(OSI)和Python软件基金会(PSF)的成员,以及DEV社区的版主。这种深厚的工程背景与教学专长的结合,使他能精准把握学习者的痛点,也深谙开发者社群的挑战。

本书基于贾森发布在DEV社区的同名热门文章系列精心打磨而成。原文章系列在网络上一经发布,便吸引了大量编程爱好者的关注与追捧,其内容的优质性与实用性得到了市场的初步验证。如今,经过他的系统的整理与扩充,以书籍的形式呈现在广大读者面前。




本书的翻译工作则请来了PyChina创始人和PyCon China负责人,以确保把本书的知识内容和趣味性生动、准确地呈现给读者。

高分佳作,口碑爆棚
英文原书由以出版高质量技术书籍闻名的No Starch Press(《Python编程:从入门到实践》同出版社)推出,这个封面一看就知道又是一本经典的“蟒蛇书”。
自问世以来,本书便在全球Python社区掀起一阵狂热追捧,美亚4.6高分。
Python软件基金会董事会主席内奥米·塞德(Naomi Ceder)在序言中盛赞:“这本书中的示例设计精巧,引人入胜,对概念的解释清晰易懂。这确实是一本出类拔萃的好书。”
多位专家也纷纷推荐,称其为“Python初学者的理想选择”、“很好的起点”,并肯定其中的“实用方法”。
"对于希望掌握Python编程语言基础的学习者而言,这是一份无价资源……《Dead Simple Python》是Python新手的理想选择,能帮助读者快速从零基础进阶到生产级编码水平。"
——本·卢特克维奇,科技资讯网(TechTarget)
"这绝对是每位Python程序员书架上[必备]的著作!"
——《Full Circle》杂志
"《Dead Simple Python》是追求高效、快速、愉悦掌握Python的必读宝典。杰森·C·麦克唐纳的专业造诣与简洁明晰的文风相得益彰,使本书成为程序员藏书库中不可或缺的珍品。无论您想构建首个Python应用,还是深入理解语言精妙之处,[本书]必将成为编程之旅中无可替代的良伴。"
——安全新手博客(The Security Noob)
"为那些计划深入研习Python且需从基础入门者提供了绝佳的起点。"
——李·泰什勒,《微控制器导报》(Microcontroller Tips)
"此书乃志在成为Python编程专家者的必读之作……我相信任何研习本书内容的人都将成长为能力出众、信心十足的Python开发者。实属非凡杰作。"
——桑德拉·亨利-斯托克,《网络世界》(NetworkWorld)
"节奏得当,阐述清晰……我下次开启Python项目时定会参考此书。"
——保罗·弗洛伊德,ACCU协会
"尤其欣赏其实践性引导——通过虚拟环境等工具开启开发之旅。这部近700页的厚实著作,绝对是您技术藏书中的珍贵典藏。"
——保罗·费里尔,多家杂志网站自由撰稿人
在众多入门书籍中,其优秀的教学效果赢得了广泛赞誉,成为许多初学者入门Python的可靠选择。




五大部分内容,
全方位覆盖Python编程知识体系
本书的目标是让读者在阅读完每一章后,无论主题初看多么复杂,都能由衷感叹:“原来如此简单!”最终达到像使用母语一般自然地使用Python进行思考。
为此,本书遵循由浅入深的原则,从每个主题最基础、最清晰的形式出发,确立核心概念,再层层递进,最终构建出Python的惯用模式。
全书分为五个逻辑严密的部分,构建了完整的学习体系:
第一部分“Python环境”(第1-4章)让读者首先掌握Python的基础知识,包括Python的哲学、开发环境、基本语法、项目结构和代码导入。这将为读者编写产品级代码奠定坚实的基础。
第二部分“基本结构”(第5-8章)探索Python的变量、数据类型、函数、类、对象、错误和异常等基本结构,并讲解如何充分利用它们。
第三部分“数据和流程”(第9-12章)介绍操作数据和控制执行流程的许多独特方法,包括集合、迭代、生成器、推导式、文本输入/输出、上下文管理、二进制和序列化等。
第四部分“高级概念”(第13-17章)揭示各种可以令读者编写出更强大的代码的高级策略,包含继承、混入、元类、抽象基类、自省、泛型、异步、并发、线程和并行等。这些正是以往多数课程和图书中略过的各种“可怕”主题。
第五部分“超越代码”(第18-21章)讲解实际项目的打包、分发、调试、日志、测试和剖析等内容,并介绍各种值得探索的Python应用方向。

注重细节,深度与广度兼具
本书中的大量示例同样令人印象深刻。书中几乎涵盖想要编写实用的Python代码所需要的所有内容,包括变量、数据结构和循环等基础知识,以及并发和并行等高级内容。


更可贵的是,本书的每一章都以完备的细节和深度内容,给读者留下深刻印象。
(1)突破认知盲区:比如11.9.2小节提及的斜线运算符(/),很多人只知道它能当成除法运算符使用,不知道还可以巧妙用于进行路径连接运算。书中时不时会补充基于作者经验而成的“陷阱警告”。


(2)填补知识空缺:作者凭借丰富的实战经验,将其他Python图书中常常忽略的内容进行了深入阐述。例如,针对跨平台路径处理这一常被忽略的痛点,书中不仅提供了详实的思路、工具和代码实践(11.9节),还分享了作者在实际项目中的心得体会。

(3)发掘优雅技巧:即使是拥有21年Python经验的资深开发者也从中发现令人惊叹的实用技巧,例如在with语句中优雅管理多个资源流及其退出清理操作,展现了源于海量实战的、对Python优雅特性的深刻理解和应用。

传授“Python之道”,融入社区智慧
本书的目标远不止于教授语法,更是致力于传授Python之道,即符合Python哲学和社区共识的编程方式。
书中敏锐地指出:有经验的开发者学习新语言时,最大的障碍往往不是学习新知识,而是摆脱原有语言思维的束缚。对于将Python作为第二甚至第三语言的程序员,这种“思维转换”尤为关键且具挑战性。
作者一直秉持一个观点:
“最好的学习Python的路径并不是从语言本身开始,而是从Python的哲学开始。要写出好的Python代码,必须先理解Python是什么。”
因而,本书的独特价值在于系统性地培养读者的“Pythonic”(具有Python特质精神的)思维与编码风格——引导读者遵循Python的核心哲学,摒弃非Python的编程习惯,从而不受其他编程语言的影响,写出简洁、优雅且高效的地道Python程序。
同时,书中还引用《Python之禅》(Zen of Python)这一官方哲学文档,并广泛借鉴其他优秀资源。这种尊重社区智慧的做法,不仅帮助读者理解“如何做”,更深刻领悟“为何这样做”,为新手融入Python社区提供了宝贵指引。


本书为谁而写?
本书适合想要学习编写专业Python程序的读者阅读,既可作为零基础入门Python的教材,也可作为程序员案头常备的Python工具书。
本书尤其适合已掌握其他编程语言的开发者用来学习Python,可以帮助这些开发者不受其他编程语言的影响来学习地道的Python编程方法,
阅读完本书,读者会掌握如何:
利用Python的动态类型写出整洁、适应性强的代码;
利用迭代技术构建和处理数据;
设计实用的类和函数;
利用多重继承和自省来编写直观易用的类;
通过异步、并发和并行提高代码的响应速度和性能;
构建可以进行生产级测试和分发的Python项目。
通过阅读《Python编程从新手到高手》,不同背景和需求的读者都能获得与其自身情况相匹配的知识和技能提升,开启Python编程的高效学习之旅,实现从新手到高手的华丽转变。

【目录】
第 一部分 Python环境
第 1章 Python的哲学 ... 2
1.1 到底什么是Python ... 2
1.2 破除误解:Python不是什么 ... 2
1.2.1 误解1:Python仅仅是一种脚本语言 ... 3
1.2.2 误解2:Python很慢 ... 3
1.2.3 误解3:Python不能被编译 ... 3
1.2.4 误解4:Python在后台编译 ... 4
1.2.5 误解5:Python不适合大型项目 ... 4
1.3 Python 2 vs Python 3 ... 4
1.4 定义“Pythonic”代码 ... 5
1.5 Python之禅 ... 5
1.6 文档、PEP和你 ... 6
1.7 社区中谁说了算? ... 7
1.8 Python社区 ... 7
1.9 对“明显的方式”的追求 ... 8
1.10 本章小结 ... 9
第 2章 Python开发环境 ... 10
2.1 安装Python ... 10
2.1.1 在Windows系统中安装Python ... 10
2.1.2 在macOS系统中安装Python ... 11
2.1.3 在Linux系统中安装Python ... 11
2.1.4 通过源代码构建Python ... 11
2.2 认识Python解释器 ... 13
2.2.1 交互式会话 ... 13
2.2.2 运行Python文件 ... 14
2.3 包和虚拟环境 ... 14
2.3.1 创建一个虚拟环境 ... 15
2.3.2 激活虚拟环境 ... 15
2.3.3 退出虚拟环境 ... 16
2.4 pip介绍 ... 16
2.4.1 系统范围的包 ... 16
2.4.2 安装包 ... 16
2.4.3 requirements.txt ... 17
2.4.4 更新包 ... 17
2.4.5 卸载包 ... 17
2.4.6 搜索包 ... 18
2.4.7 一个关于pip的警告 ... 18
2.5 虚拟环境和Git ... 18
2.5.1 shebang ... 19
2.5.2 文件编码 ... 20
2.6 一些额外的关于虚拟环境的小贴士 ... 21
2.6.1 在不激活虚拟环境的情况下使用虚拟环境 ... 21
2.6.2 一些替代品 ... 21
2.7 认识PEP 8 ... 22
2.7.1 行宽限制的历史债务 ... 22
2.7.2 制表符还是空格 ... 23
2.8 代码质量控制:静态分析工具 ... 23
2.8.1 Pylint ... 23
2.8.2 Flake8 ... 25
2.8.3 Mypy ... 26
2.9 代码风格守护者:自动格式化工具 ... 26
2.9.1 autopep8 ... 27
2.9.2 Black ... 27
2.10 测试框架 ... 27
2.11 代码编辑器一览 ... 27
2.11.1 IDLE ... 28
2.11.2 Emacs和Vim ... 28
2.11.3 PyCharm ... 28
2.11.4 Visual Studio Code ... 28
2.11.5 Sublime Text ... 29
2.11.6 Spyder ... 29
2.11.7 Eclipse配合PyDev/LiClipse ... 29
2.11.8 Eric Python IDE ... 29
2.12 本章小结 ... 30
第3章 语法速成课程 ... 31
3.1 “Hello, world!”程序 ... 31
3.2 语句和表达式 ... 31
3.3 空格的重要性 ... 32
3.4 空语句 ... 33
3.5 注释以及文档字符串 ... 33
3.6 声明变量 ... 34
3.7 数学操作 ... 35
3.7.1 初识数字类型 ... 35
3.7.2 运算符 ... 36
3.7.3 math模块 ... 37
3.8 逻辑 ... 38
3.8.1 条件语句 ... 38
3.8.2 比较运算符 ... 39
3.8.3 Boolean、None和身份运算符 ... 39
3.8.4 真实性 ... 40
3.8.5 逻辑运算符 ... 41
3.8.6 海象运算符 ... 41
3.8.7 省略符 ... 42
3.9 字符串 ... 42
3.9.1 字符串字面量 ... 42
3.9.2 原始字符串 ... 44
3.9.3 格式化字符串 ... 44
3.9.4 模板字符串 ... 48
3.9.5 字符串转换 ... 49
3.9.6 字符串拼接的注意事项 ... 49
3.10 函数 ... 50
3.11 类和对象 ... 50
3.12 异常处理 ... 51
3.13 元组和列表 ... 52
3.14 循环 ... 53
3.14.1 while循环 ... 53
3.14.2 循环控制 ... 53
3.14.3 for循环 ... 54
3.15 结构模式匹配 ... 54
3.15.1 文本模式和通配符 ... 54
3.15.2 or模式 ... 55
3.15.3 捕获模式 ... 55
3.15.4 门卫语句 ... 56
3.15.5 更多关于模式匹配的信息 ... 57
3.16 本章小结 ... 57
第4章 项目结构和代码导入 ... 58
4.1 设置代码仓库 ... 58
4.2 模块和包 ... 58
4.2.1 PEP 8和命名 ... 59
4.2.2 项目的目录结构 ... 59
4.3 import是如何工作的 ... 60
4.4 导入操作的注意事项 ... 61
4.4.1 从模块中导入函数 ... 62
4.4.2 覆盖问题 ... 62
4.4.3 包嵌套问题 ... 63
4.4.4 谨防导入所有 ... 64
4.5 在项目中使用import ... 65
4.5.1 绝对导入 ... 65
4.5.2 相对导入 ... 66
4.5.3 从同一个包中导入 ... 66
4.6 入口点 ... 67
4.6.1 模块入口点 ... 67
4.6.2 包入口点 ... 68
4.6.3 控制包的导入 ... 69
4.6.4 程序入口点 ... 70
4.7 Python模块搜索路径 ... 71
4.8 导入模块时底层发生了什么? ... 71
4.9 本章小结 ... 73
第二部分 基本结构
第5章 变量和数据类型 ... 76
5.1 Python中的变量:名称和值 ... 76
5.2 赋值 ... 76
5.3 数据类型 ... 78
5.3.1 type()函数 ... 79
5.3.2 鸭子类型 ... 79
5.4 作用域和垃圾回收 ... 80
5.4.1 局部作用域以及引用计数垃圾回收器 ... 80
5.4.2 解释器关闭 ... 81
5.4.3 全局作用域 ... 81
5.4.4 全局作用域的注意事项 ... 83
5.4.5 nonlocal关键字 ... 83
5.4.6 作用域解析 ... 84
5.4.7 关于类的一些特殊情况 ... 84
5.4.8 分代垃圾回收器 ... 85
5.5 不可变的真相 ... 85
5.6 赋值传递 ... 86
5.7 集合和引用 ... 87
5.7.1 浅拷贝 ... 89
5.7.2 深拷贝 ... 91
5.8 隐式类型转换和显式类型转换 ... 92
5.9 关于匈牙利命名法的注意事项 ... 93
5.10 术语回顾 ... 94
5.11 本章小结 ... 95
第6章 函数和匿名函数 ... 96
6.1 Python函数基础 ... 98
6.2 递归 ... 99
6.3 默认参数值 ... 100
6.4 关键字参数 ... 102
6.5 重载函数 ... 104
6.6 可变参数 ... 104
6.7 仅关键字参数 ... 106
6.7.1 仅位置参数 ... 106
6.7.2 参数类型:都在这儿了! ... 107
6.8 嵌套函数 ... 107
6.9 闭包 ... 108
6.9.1 带闭包的递归 ... 109
6.9.2 有状态闭包 ... 110
6.10 lambda表达式 ... 111
6.10.1 为什么lambda表达式很有用? ... 111
6.10.2 将lambda表达式作为排序键 ... 113
6.11 装饰器 ... 114
6.12 类型提示及函数注解 ... 116
6.12.1 鸭子类型和类型提示 ... 118
6.12.2 应该使用类型提示吗? ... 118
6.13 本章小结 ... 119
第7章 类和对象 ... 120
7.1 声明一个类 ... 121
7.1.1 初始化器 ... 121
7.1.2 构造器 ... 122
7.1.3 终结器 ... 123
7.2 属性 ... 124
7.2.1 实例属性 ... 124
7.2.2 类属性 ... 124
7.3 范围命名约定 ... 125
7.3.1 非公共属性 ... 125
7.3.2 公共属性 ... 125
7.3.3 名称修饰 ... 125
7.3.4 公共属性、非公共属性,还是名称修饰? ... 126
7.4 方法 ... 127
7.4.1 实例方法 ... 127
7.4.2 类方法 ... 127
7.4.3 静态方法 ... 128
7.5 特性 ... 128
7.5.1 设置场景 ... 129
7.5.2 定义一个特性 ... 130
7.5.3 使用装饰器创建特性 ... 132
7.5.4 什么时候不使用特性? ... 133
7.6 特殊方法 ... 134
7.6.1 场景设置 ... 134
7.6.2 转换方法 ... 135
7.6.3 比较方法 ... 138
7.6.4 二元运算符支持 ... 139
7.6.5 一元运算符支持 ... 140
7.6.6 让类可调用 ... 141
7.6.7 更多特殊方法 ... 141
7.7 类装饰器 ... 142
7.8 对象的结构模式匹配 ... 143
7.9 函数式编程和面向对象编程 ... 145
7.10 什么时候使用类? ... 146
7.10.1 类不是模块 ... 146
7.10.2 单一职责 ... 146
7.10.3 共享状态 ... 146
7.10.4 对象是否适合你? ... 146
7.11 本章小结 ... 147
第8章 错误和异常 ... 148
8.1 Python中的异常 ... 148
8.2 阅读异常信息 ... 150
8.3 捕获异常:LBYL和EAFP ... 151
8.4 多异常处理 ... 152
8.5 当心“尿布反模式” ... 153
8.6 抛出异常 ... 155
8.7 使用异常 ... 157
8.7.1 异常和日志 ... 158
8.7.2 冒泡 ... 161
8.7.3 异常链 ... 162
8.8 else和finally ... 164
8.8.1 else:如果所有功能正常运行 ... 164
8.8.2 finally:在所有语句之后 ... 165
8.9 创建异常 ... 168
8.10 异常一览 ... 169
8.11 本章小结 ... 170
第三部分 数据和流程
第9章 集合与迭代 ... 172
9.1 循环 ... 172
9.1.1 while循环 ... 172
9.1.2 for循环 ... 174
9.2 集合 ... 174
9.2.1 元组 ... 174
9.2.2 具名元组 ... 175
9.2.3 列表 ... 175
9.2.4 双端队列 ... 177
9.2.5 可变集合 ... 178
9.2.6 不可变集合 ... 179
9.2.7 字典 ... 179
9.2.8 检查还是例外? ... 180
9.2.9 字典变体 ... 181
9.3 集合的解包 ... 182
9.3.1 星号表达式 ... 183
9.3.2 字典的解包 ... 184
9.4 集合的结构模式匹配 ... 185
9.5 以索引或键访问元素 ... 186
9.6 切片符 ... 187
9.6.1 开始和停止 ... 188
9.6.2 负索引 ... 188
9.6.3 步长 ... 189
9.6.4 切片复制 ... 190
9.6.5 切片对象 ... 190
9.6.6 对自定义对象切片 ... 191
9.6.7 使用islice() ... 191
9.7 in运算符 ... 191
9.8 检验集合的长度 ... 192
9.9 迭代 ... 193
9.9.1 可迭代对象和迭代器 ... 193
9.9.2 手动使用迭代器 ... 194
9.9.3 用for循环进行迭代 ... 196
9.9.4 在循环中对集合进行排序 ... 197
9.9.5 枚举循环 ... 198
9.9.6 循环中的突变 ... 198
9.9.7 嵌套循环和替代方案 ... 200
9.10 迭代工具 ... 202
9.10.1 基础内建工具 ... 202
9.10.2 filter ... 202
9.10.3 map ... 203
9.10.4 zip ... 204
9.10.5 itertools ... 205
9.11 自定义可迭代类 ... 205
9.12 本章小结 ... 209
第 10章 生成器和推导式 ... 210
10.1 惰性求值和贪婪迭代 ... 210
10.2 无限迭代器 ... 211
10.3 生成器 ... 211
10.3.1 生成器vs迭代器类 ... 213
10.3.2 生成器关闭 ... 215
10.3.3 行为关闭 ... 216
10.3.4 异常抛出 ... 217
10.4 yield from ... 219
10.5 生成器表达式 ... 220
10.5.1 生成器对象都是惰性的 ... 222
10.5.2 生成器表达式具有复合循环 ... 222
10.5.3 生成器表达式中的条件 ... 223
10.5.4 嵌套生成器表达式 ... 226
10.6 列表推导式 ... 226
10.7 集合推导式 ... 227
10.8 字典推导式 ... 228
10.9 生成器表达式的隐患 ... 228
10.9.1 它们很快就会变得不可读 ... 228
10.9.2 它们无法替代循环 ... 229
10.9.3 它们很难调试 ... 230
10.9.4 何时用生成器表达式 ... 230
10.10 简单协程 ... 231
10.10.1 从协程返回值 ... 233
10.10.2 行为序列 ... 233
10.11 异步又如何? ... 234
10.12 本章小结 ... 234
第 11章 文本输入/输出和上下文管理 ... 235
11.1 标准输入和输出 ... 235
11.1.1 重温print() ... 235
11.1.2 重温input() ... 239
11.2 流 ... 240
11.3 上下文管理器基础 ... 241
11.4 文件模式 ... 242
11.5 读取文件 ... 243
11.5.1 read()方法 ... 243
11.5.2 readline()方法 ... 244
11.5.3 readlines()方法 ... 244
11.5.4 迭代读取 ... 245
11.6 流位置 ... 245
11.7 写入文件 ... 246
11.7.1 write()方法 ... 247
11.7.2 writelines()方法 ... 248
11.7.3 用print()写文件 ... 249
11.7.4 行分隔符 ... 250
11.8 上下文管理器的细节 ... 250
11.8.1 上下文管理器如何工作? ... 250
11.8.2 使用多个上下文管理器 ... 251
11.8.3 实现上下文管理协议 ... 252
11.8.4 __enter__()方法 ... 253
11.8.5 __exit__()方法 ... 254
11.8.6 使用自定义类 ... 254
11.9 路径 ... 256
11.9.1 路径对象 ... 257
11.9.2 路径组成 ... 258
11.9.3 创建路径 ... 261
11.9.4 相对路径 ... 262
11.9.5 相对包路径 ... 263
11.9.6 路径操作 ... 265
11.9.7 异地文件写入 ... 266
11.9.8 os模块 ... 267
11.10 文件格式 ... 268
11.10.1 JSON ... 268
11.10.2 其他格式 ... 271
11.11 本章小结 ... 273
第 12章 二进制和序列化 ... 274
12.1 二进制表示和位运算 ... 274
12.1.1 数字系统 ... 274
12.1.2 Python整数和二进制 ... 278
12.1.3 位运算 ... 279
12.2 字节字面量 ... 281
12.3 类字节对象 ... 282
12.3.1 创建字节对象 ... 282
12.3.2 使用int.to_bytes() ... 284
12.3.3 序列操作 ... 285
12.3.4 将字节对象转换为整数 ... 285
12.4 struct模块 ... 286
12.4.1 struct格式字符串和打包 ... 286
12.4.2 用struct解包 ... 289
12.4.3 struct对象 ... 290
12.5 类字节对象的位运算 ... 291
12.5.1 通过整数进行位运算 ... 291
12.5.2 通过迭代进行位运算 ... 292
12.6 memoryview ... 294
12.7 读写二进制文件 ... 295
12.7.1 数据组织 ... 296
12.7.2 文件写入 ... 299
12.7.3 从二进制文件读取 ... 300
12.7.4 从二进制流中查找 ... 302
12.7.5 BufferedRWPair ... 303
12.8 序列化技术 ... 303
12.8.1 禁忌工具:pickle、marshal和shelve ... 304
12.8.2 序列化格式 ... 305
12.9 本章小结 ... 307
第四部分 高级概念
第 13章 继承和混入 ... 310
13.1 何时使用继承? ... 312
13.2 Python的基础继承 ... 313
13.3 多继承 ... 315
13.3.1 方法解析顺序 ... 315
13.3.2 确保方法解析顺序一致 ... 318
13.3.3 显式地指定解析顺序 ... 321
13.3.4 解析多继承中的基类 ... 321
13.4 混入 ... 324
13.5 本章小结 ... 326
第 14章 元类和抽象基类 ... 327
14.1 元类 ... 327
14.1.1 用类型创建类 ... 327
14.1.2 自定义元类 ... 329
14.2 用鸭子类型进行类型推导 ... 330
14.2.1 EAFP:捕获异常 ... 330
14.2.2 LBYL:检查属性 ... 331
14.3 抽象基类 ... 332
14.3.1 内置抽象基类 ... 333
14.3.2 从抽象基类派生 ... 333
14.3.3 实现自定义抽象基类 ... 336
14.4 虚拟子类 ... 338
14.4.1 设置示例 ... 339
14.4.2 使用虚拟子类 ... 341
14.5 本章小结 ... 343
第 15章 自省和泛型 ... 344
15.1 特殊属性 ... 344
15.2 内部对象属性访问:__dict__特殊属性 ... 344
15.2.1 列出属性 ... 346
15.2.2 获取属性 ... 347
15.2.3 检查属性 ... 348
15.2.4 设置属性 ... 349
15.2.5 删除属性 ... 350
15.3 函数属性 ... 351
15.3.1 函数属性的错误使用方式 ... 351
15.3.2 可变性和函数属性 ... 353
15.4 描述符 ... 353
15.4.1 描述符协议 ... 354
15.4.2 编写描述符类(有点问题的方式) ... 354
15.4.3 使用描述符 ... 355
15.4.4 以正确方式编写描述符类 ... 356
15.4.5 在同一个类中使用多个描述符 ... 358
15.5 slots ... 360
15.5.1 将属性名绑定到值 ... 361
15.5.2 通过slots使用任意属性 ... 361
15.5.3 slots和继承 ... 362
15.6 不可变类 ... 362
15.7 单分派泛型函数 ... 365
15.7.1 用类型提示注册单分派泛型函数 ... 365
15.7.2 用显式类型注册单分派泛型函数 ... 366
15.7.3 用register()方法注册单分派泛型函数 ... 367
15.8 使用元素类 ... 367
15.9 任意执行 ... 368
15.10 本章小结 ... 370
第 16章 异步和并发 ... 371
16.1 Python中的异步 ... 372
16.2 示例场景:Collatz游戏同步版本 ... 374
16.3 异步 ... 376
16.3.1 原生协程 ... 376
16.3.2 任务 ... 378
16.3.3 事件循环 ... 379
16.3.4 令其(实际上)异步 ... 380
16.4 调度和异步执行流程 ... 381
16.5 异步迭代 ... 383
16.6 异步上下文管理器 ... 385
16.7 异步生成器 ... 385
16.8 其他异步概念 ... 386
16.9 本章小结 ... 386
第 17章 线程和并行 ... 387
17.1 线程 ... 387
17.1.1 并发vs并行 ... 387
17.1.2 基本线程 ... 388
17.1.3 超时 ... 390
17.1.4 守护线程 ... 391
17.1.5 futures和执行器 ... 391
17.1.6 futures的超时 ... 393
17.2 条件竞争 ... 395
17.2.1 条件竞争示例 ... 397
17.2.2 用ThreadPoolExecutor创建多线程 ... 398
17.3 锁 ... 399
17.4 死锁、活锁和饥锁 ... 400
17.5 用队列传递消息 ... 401
17.6 多工作线程的future ... 402
17.7 多进程实现并行 ... 404
17.7.1 序列化数据 ... 404
17.7.2 加速注意事项和ProcessPoolExecutor ... 405
17.8 生产者/消费者问题 ... 407
17.8.1 导入模块 ... 407
17.8.2 监视队列 ... 408
17.8.3 子进程清理 ... 408
17.8.4 消费者 ... 409
17.8.5 检查空队列 ... 410
17.8.6 生产者 ... 410
17.8.7 启动进程 ... 411
17.8.8 性能结果 ... 411
17.8.9 多进程日志 ... 412
17.9 本章小结 ... 412
第五部分 超越代码
第 18章 打包和分发 ... 416
18.1 规划打包 ... 416
18.1.1 货物崇拜式编程的危险 ... 417
18.1.2 关于打包的观点 ... 417
18.1.3 确定打包目标 ... 417
18.2 项目结构:src或src-less ... 419
18.3 用setuptools打包和分发 ... 419
18.3.1 项目文件和结构 ... 420
18.3.2 元数据归属 ... 420
18.3.3 README.md和LICENSE文档 ... 420
18.3.4 setup.cfg文件 ... 421
18.3.5 setup.py文件 ... 426
18.3.6 MANIFEST.in文件 ... 427
18.3.7 requirements.txt文件 ... 428
18.3.8 pyproject.toml文件 ... 429
18.3.9 测试配置的设置 ... 430
18.4 构建你的包 ... 430
18.5 发布到pip ... 431
18.5.1 上传到TestPyPI ... 431
18.5.2 安装你上传的包 ... 432
18.5.3 上传到PyPI ... 433
18.6 其他打包工具 ... 433
18.6.1 Poetry ... 433
18.6.2 Flit ... 433
18.7 分发给最终用户 ... 433
18.7.1 PEX ... 434
18.7.2 冻结器 ... 434
18.7.3 镜像和容器 ... 435
18.7.4 原生Linux包注意事项 ... 437
18.8 文档 ... 438
18.9 本章小结 ... 439
第 19章 调试和日志 ... 440
19.1 警告 ... 440
19.1.1 警告的类型 ... 441
19.1.2 过滤警告 ... 442
19.1.3 将警告转换为异常 ... 443
19.2 日志记录 ... 444
19.2.1 Logger对象 ... 444
19.2.2 Handler对象 ... 445
19.2.3 日志记录级别 ... 447
19.2.4 控制日志级别 ... 448
19.2.5 运行示例程序 ... 449
19.2.6 过滤器、格式化程序和配置文件 ... 450
19.3 断言语句 ... 450
19.3.1 正确使用断言 ... 450
19.3.2 错误使用断言 ... 452
19.3.3 实战中的断言 ... 453
19.4 inspect模块 ... 454
19.5 使用pdb ... 454
19.5.1 调试案例 ... 454
19.5.2 启动调试器 ... 455
19.5.3 调试器shell指令 ... 456
19.5.4 单步穿行代码 ... 456
19.5.5 设置断点并单步执行函数 ... 457
19.5.6 遍历执行栈 ... 458
19.5.7 探查源代码 ... 459
19.5.8 检验解决方案 ... 460
19.5.9 事后调试 ... 461
19.6 使用faulthandler ... 462
19.7 用Bandit评估程序安全性 ... 463
19.8 向Python开发团队汇报问题 ... 465
19.9 本章小结 ... 466
第 20章 测试和剖析 ... 467
20.1 什么是TDD? ... 467
20.2 测试框架 ... 467
20.3 示例项目 ... 468
20.4 测试和项目结构 ... 469
20.5 基础测试 ... 470
20.5.1 启动示例 ... 470
20.5.2 单元测试 ... 471
20.5.3 用pytest执行测试 ... 472
20.5.4 测试异常 ... 473
20.6 测试夹具 ... 474
20.6.1 继续之前的示例:使用API ... 476
20.6.2 在测试模块间共享数据 ... 477
20.7 不稳定测试和有条件忽略测试 ... 478
20.8 高级夹具:模拟和参数化 ... 479
20.8.1 继续之前的示例:表达拼写错误 ... 479
20.8.2 参数化 ... 481
20.8.3 间接参数化夹具 ... 482
20.8.4 动态替换模拟输入 ... 483
20.8.5 标记 ... 484
20.8.6 从标准流中捕获 ... 486
20.8.7 GUI测试 ... 488
20.8.8 继续之前的示例:将API连接到Typo ... 488
20.8.9 自动夹具 ... 489
20.8.10 混合参数化 ... 490
20.8.11 模糊测试 ... 491
20.8.12 完成示例 ... 491
20.9 代码覆盖率 ... 492
20.10 用tox进行自动化测试 ... 494
20.11 基准测试和性能分析 ... 496
20.11.1 用timeit进行基准测试 ... 496
20.11.2 用cProfile或profile进行性能分析 ... 497
20.11.3 tracemalloc ... 500
20.12 本章小结 ... 501
第 21章 前路迢迢 ... 502
21.1 关于未来 ... 502
21.2 你想出发去哪儿? ... 503
21.2.1 Python应用程序开发 ... 503
21.2.2 Python游戏开发 ... 504
21.2.3 Python Web开发 ... 504
21.2.4 客户端Python ... 505
21.2.5 Python数据科学 ... 505
21.2.6 Python机器学习 ... 506
21.2.7 安全 ... 507
21.2.8 Python嵌入式开发 ... 508
21.2.9 脚本 ... 508
21.3 Python特色 ... 508
21.4 开发Python本身 ... 509
21.4.1 开发Python包和工具 ... 509
21.4.2 开发Python扩展 ... 510
21.4.3 为Python做各种贡献 ... 511
21.5 和Python共同成长 ... 512
21.5.1 提出问题 ... 512
21.5.2 回答问题 ... 513
21.5.3 用户组 ... 513
21.5.4 PyLadies ... 514
21.5.5 参加各种会议 ... 514
21.5.6 加入Python软件基金会 ... 514
21.6 在这条路上一直走下去 ... 515
附录A 特殊方法和属性 ... 516
附录B pdb指令 ... 522
附录C Guido van Rossum的国王节演讲 ... 525
译者后记 ... 529

在留言区参与互动发送(我想要一本赠书)
并点击转发朋友圈,邀好友助力点赞你的留言
我们将选点赞率最高的1名读者获得赠书1本
时间以公众号推文发出24小时为限
记得扫码加号主微信,以便联系邮寄地址哦
欢迎自购或向图书馆荐购

微信群
内容中包含的图片若涉及版权问题,请及时与我们联系删除
评论
沙发等你来抢