流畅的Python

流畅的Python

by Luciano Ramalho
Released May 2017
Publisher(s): Posts & Telecom Press
ISBN: None

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

本书由奋战在Python开发一线近20年的Luciano Ramalho执笔，Victor Stinner、Alex Martelli等Python大咖担纲技术审稿人，从语言设计层面剖析编程细节，兼顾Python 3和Python 2，告诉你Python中不亲自动手实践就无法理解的语言陷阱成因和解决之道，教你写出风格地道的Python代码。

内容特色

  • Python数据模型：理解为什么特殊方法是对象行为一致的关键。
  • 数据结构：充分利用内置类型，理解Unicode文本和字节二象性。
  • 把函数视作对象：把Python函数视作一等对象，并了解这一点对流行的设计模式的影响。
  • 面向对象习惯用法：通过构建类学习引用、可变性、接口、运算符重载和多重继承。
  • 控制流程：学习使用上下文管理器、生成器、协程，以及通过concurrent.futures和asyncio包实现的并发。
  • 元编程：理解特性、描述符、类装饰器和元类的工作原理。

Table of contents

  1. 封面
  2. 扉页
  3. 版权
  4. 版权声明
  5. O’Reilly Media, Inc.介绍
  6. 目录 (1/2)
  7. 目录 (2/2)
  8. 前言
    1. 目标读者
    2. 非目标读者
    3. 本书的结构
    4. 以实践为基础
    5. 硬件
    6. 杂谈：个人的一点看法
    7. Python术语表
    8. Python版本表
    9. 排版约定
    10. 使用代码示例
    11. Safari® Books Online
    12. 联系我们
    13. 致谢
    14. 电子书
  9. 第一部分 序幕
    1. 第1章 Python数据模型
      1. 1.1 一摞Python风格的纸牌
      2. 1.2 如何使用特殊方法
        1. 1.2.1 模拟数值类型
        2. 1.2.2 字符串表示形式
        3. 1.2.3 算术运算符
        4. 1.2.4 自定义的布尔值
      3. 1.3 特殊方法一览
      4. 1.4 为什么len不是普通方法
      5. 1.5 本章小结
      6. 1.6 延伸阅读
  10. 第二部分 数据结构
    1. 第2章 序列构成的数组
      1. 2.1 内置序列类型概览
      2. 2.2 列表推导和生成器表达式
        1. 2.2.1 列表推导和可读性
        2. 2.2.2 列表推导同filter和map的比较
        3. 2.2.3 笛卡儿积
        4. 2.2.4 生成器表达式
      3. 2.3 元组不仅仅是不可变的列表 (1/2)
      4. 2.3 元组不仅仅是不可变的列表 (2/2)
        1. 2.3.1 元组和记录
        2. 2.3.2 元组拆包
        3. 2.3.3 嵌套元组拆包
        4. 2.3.4 具名元组
        5. 2.3.5 作为不可变列表的元组
      5. 2.4 切片
        1. 2.4.1 为什么切片和区间会忽略最后一个元素
        2. 2.4.2 对对象进行切片
        3. 2.4.3 多维切片和省略
        4. 2.4.4 给切片赋值
      6. 2.5 对序列使用+和*
      7. 2.6 序列的增量赋值
      8. 2.7 list.sort方法和内置函数sorted
      9. 2.8 用bisect来管理已排序的序列
        1. 2.8.1 用bisect来搜索
        2. 2.8.2 用bisect.insort插入新元素
      10. 2.9 当列表不是首选时 (1/2)
      11. 2.9 当列表不是首选时 (2/2)
        1. 2.9.1 数组
        2. 2.9.2 内存视图
        3. 2.9.3 NumPy和SciPy
        4. 2.9.4 双向队列和其他形式的队列
      12. 2.10 本章小结
      13. 2.11 延伸阅读
    2. 第3章 字典和集合
      1. 3.1 泛映射类型
      2. 3.2 字典推导
      3. 3.3 常见的映射方法
        1. 用setdefault处理找不到的键
      4. 3.4 映射的弹性键查询
        1. 3.4.1 defaultdict：处理找不到的键的一个选择
        2. 3.4.2 特殊方法__missing__
      5. 3.5 字典的变种
      6. 3.6 子类化UserDict
      7. 3.7 不可变映射类型
      8. 3.8 集合论
        1. 3.8.1 集合字面量
        2. 3.8.2 集合推导
        3. 3.8.3 集合的操作
      9. 3.9 dict和set的背后 (1/2)
      10. 3.9 dict和set的背后 (2/2)
        1. 3.9.1 一个关于效率的实验
        2. 3.9.2 字典中的散列表
        3. 3.9.3 dict的实现及其导致的结果
        4. 3.9.4 set的实现以及导致的结果
      11. 3.10 本章小结
      12. 3.11 延伸阅读
    3. 第4章 文本和字节序列
      1. 4.1 字符问题
      2. 4.2 字节概要
      3. 4.3 基本的编解码器
      4. 4.4 了解编解码问题
        1. 4.4.1 处理UnicodeEncodeError
        2. 4.4.2 处理UnicodeDecodeError
        3. 4.4.3 使用预期之外的编码加载模块时抛出的SyntaxError
        4. 4.4.4 如何找出字节序列的编码
        5. 4.4.5 BOM：有用的鬼符
      5. 4.5 处理文本文件
      6. 4.6 为了正确比较而规范化Unicode字符串 (1/2)
      7. 4.6 为了正确比较而规范化Unicode字符串 (2/2)
        1. 4.6.1 大小写折叠
        2. 4.6.2 规范化文本匹配实用函数
        3. 4.6.3 极端“规范化”：去掉变音符号
      8. 4.7 Unicode文本排序
      9. 4.8 Unicode数据库
      10. 4.9 支持字符串和字节序列的双模式API
        1. 4.9.1 正则表达式中的字符串和字节序列
        2. 4.9.2 os函数中的字符串和字节序列
      11. 4.10 本章小结
      12. 4.11 延伸阅读
  11. 第三部分 把函数视作对象
    1. 第5章 一等函数
      1. 5.1 把函数视作对象
      2. 5.2 高阶函数
      3. 5.3 匿名函数
      4. 5.4 可调用对象
      5. 5.5 用户定义的可调用类型
      6. 5.6 函数内省
      7. 5.7 从定位参数到仅限关键字参数
      8. 5.8 获取关于参数的信息
      9. 5.9 函数注解
      10. 5.10 支持函数式编程的包
        1. 5.10.1 operator模块
        2. 5.10.2 使用functools.partial冻结参数
      11. 5.11 本章小结
      12. 5.12 延伸阅读
    2. 第6章 使用一等函数实现设计模式
      1. 6.1 案例分析：重构“策略”模式 (1/2)
      2. 6.1 案例分析：重构“策略”模式 (2/2)
        1. 6.1.1 经典的“策略”模式
        2. 6.1.2 使用函数实现“策略”模式
        3. 6.1.3 选择最佳策略：简单的方式
        4. 6.1.4 找出模块中的全部策略
      3. 6.2 “命令”模式
      4. 6.3 本章小结
      5. 6.4 延伸阅读
    3. 第7章 函数装饰器和闭包
      1. 7.1 装饰器基础知识
      2. 7.2 Python何时执行装饰器
      3. 7.3 使用装饰器改进“策略”模式
      4. 7.4 变量作用域规则
      5. 7.5 闭包
      6. 7.6 nonlocal声明
      7. 7.7 实现一个简单的装饰器
      8. 7.8 标准库中的装饰器
        1. 7.8.1 使用functools.lru_cache做备忘
        2. 7.8.2 单分派泛函数
      9. 7.9 叠放装饰器
      10. 7.10 参数化装饰器
        1. 7.10.1 一个参数化的注册装饰器
        2. 7.10.2 参数化clock装饰器
      11. 7.11 本章小结
      12. 7.12 延伸阅读
  12. 第四部分 面向对象惯用法
    1. 第8章 对象引用、可变性和垃圾回收
      1. 8.1 变量不是盒子
      2. 8.2 标识、相等性和别名
        1. 8.2.1 在==和is之间选择
        2. 8.2.2 元组的相对不可变性
      3. 8.3 默认做浅复制
      4. 8.4 函数的参数作为引用时
        1. 8.4.1 不要使用可变类型作为参数的默认值
        2. 8.4.2 防御可变参数
      5. 8.5 del和垃圾回收
      6. 8.6 弱引用
        1. 8.6.1 WeakValueDictionary简介
        2. 8.6.2 弱引用的局限
      7. 8.7 Python对不可变类型施加的把戏
      8. 8.8 本章小结
      9. 8.9 延伸阅读
    2. 第9章 符合Python风格的对象
      1. 9.1 对象表示形式
      2. 9.2 再谈向量类
      3. 9.3 备选构造方法
      4. 9.4 classmethod与staticmethod
      5. 9.5 格式化显示
      6. 9.6 可散列的Vector2d
      7. 9.7 Python的私有属性和“受保护的”属性
      8. 9.8 使用__slots__类属性节省空间
      9. 9.9 覆盖类属性
      10. 9.10 本章小结
      11. 9.11 延伸阅读
    3. 第10章 序列的修改、散列和切片
      1. 10.1 Vector类：用户定义的序列类型
      2. 10.2 Vector类第1版：与Vector2d类兼容
      3. 10.3 协议和鸭子类型
      4. 10.4 Vector类第2版：可切片的序列
        1. 10.4.1 切片原理
        2. 10.4.2 能处理切片的__getitem__方法
      5. 10.5 Vector类第3版：动态存取属性
      6. 10.6 Vector类第4版：散列和快速等值测试
      7. 10.7 Vector类第5版：格式化 (1/2)
      8. 10.7 Vector类第5版：格式化 (2/2)
      9. 10.8 本章小结
      10. 10.9 延伸阅读
    4. 第11章 接口：从协议到抽象基类
      1. 11.1 Python文化中的接口和协议
      2. 11.2 Python喜欢序列
      3. 11.3 使用猴子补丁在运行时实现协议
      4. 11.4 Alex Martelli的水禽
      5. 11.5 定义抽象基类的子类
      6. 11.6 标准库中的抽象基类
        1. 11.6.1 collections.abc模块中的抽象基类
        2. 11.6.2 抽象基类的数字塔
      7. 11.7 定义并使用一个抽象基类 (1/2)
      8. 11.7 定义并使用一个抽象基类 (2/2)
        1. 11.7.1 抽象基类句法详解
        2. 11.7.2 定义Tombola抽象基类的子类
        3. 11.7.3 Tombola的虚拟子类
      9. 11.8 Tombola子类的测试方法
      10. 11.9 Python使用register的方式
      11. 11.10 鹅的行为有可能像鸭子
      12. 11.11 本章小结
      13. 11.12 延伸阅读
    5. 第12章 继承的优缺点
      1. 12.1 子类化内置类型很麻烦
      2. 12.2 多重继承和方法解析顺序
      3. 12.3 多重继承的真实应用
      4. 12.4 处理多重继承
      5. 12.5 一个现代示例：Django通用视图中的混入
      6. 12.6 本章小结
      7. 12.7 延伸阅读
    6. 第13章 正确重载运算符
      1. 13.1 运算符重载基础
      2. 13.2 一元运算符
      3. 13.3 重载向量加法运算符+
      4. 13.4 重载标量乘法运算符*
      5. 13.5 众多比较运算符
      6. 13.6 增量赋值运算符
      7. 13.7 本章小结
      8. 13.8 延伸阅读
  13. 第五部分 控制流程
    1. 第14章 可迭代的对象、迭代器和生成器
      1. 14.1 Sentence类第1版：单词序列
      2. 14.2 可迭代的对象与迭代器的对比
      3. 14.3 Sentence类第2版：典型的迭代器
      4. 14.4 Sentence类第3版：生成器函数
      5. 14.5 Sentence类第4版：惰性实现
      6. 14.6 Sentence类第5版：生成器表达式
      7. 14.7 何时使用生成器表达式
      8. 14.8 另一个示例：等差数列生成器
      9. 14.9 标准库中的生成器函数 (1/2)
      10. 14.9 标准库中的生成器函数 (2/2)
      11. 14.10 Python 3.3中新出现的句法：yield from
      12. 14.11 可迭代的归约函数
      13. 14.12 深入分析iter函数
      14. 14.13 案例分析：在数据库转换工具中使用生成器
      15. 14.14 把生成器当成协程
      16. 14.15 本章小结
      17. 14.16 延伸阅读
    2. 第15章 上下文管理器和else块
      1. 15.1 先做这个，再做那个：if语句之外的else块
      2. 15.2 上下文管理器和with块
      3. 15.3 contextlib模块中的实用工具
      4. 15.4 使用@contextmanager
      5. 15.5 本章小结
      6. 15.6 延伸阅读
    3. 第16章 协程
      1. 16.1 生成器如何进化成协程
      2. 16.2 用作协程的生成器的基本行为
      3. 16.3 示例：使用协程计算移动平均值
      4. 16.4 预激协程的装饰器
      5. 16.5 终止协程和异常处理
      6. 16.6 让协程返回值
      7. 16.7 使用yield from
      8. 16.8 yield from的意义
      9. 16.9 使用案例：使用协程做离散事件仿真 (1/2)
      10. 16.9 使用案例：使用协程做离散事件仿真 (2/2)
        1. 16.9.1 离散事件仿真简介
        2. 16.9.2 出租车队运营仿真
      11. 16.10 本章小结
      12. 16.11 延伸阅读
    4. 第17章 使用future处理并发
      1. 17.1 示例：网络下载的三种风格
        1. 17.1.1 依序下载的脚本
        2. 17.1.2 使用concurrent.futures模块下载
        3. 17.1.3 future在哪里
      2. 17.2 阻塞型I/O和GIL
      3. 17.3 使用concurrent.futures模块启动进程
      4. 17.4 实验Executor.map方法
      5. 17.5 显示下载进度并处理错误 (1/2)
      6. 17.5 显示下载进度并处理错误 (2/2)
        1. 17.5.1 flags2系列示例处理错误的方式
        2. 17.5.2 使用futures.as_completed函数
        3. 17.5.3 线程和多进程的替代方案
      7. 17.6 本章小结
      8. 17.7 延伸阅读
    5. 第18章 使用asyncio包处理并发
      1. 18.1 线程与协程对比 (1/2)
      2. 18.1 线程与协程对比 (2/2)
        1. 18.1.1 asyncio.Future：故意不阻塞
        2. 18.1.2 从future、任务和协程中产出
      3. 18.2 使用asyncio和aiohttp包下载
      4. 18.3 避免阻塞型调用
      5. 18.4 改进asyncio下载脚本 (1/2)
      6. 18.4 改进asyncio下载脚本 (2/2)
        1. 18.4.1 使用asyncio.as_completed函数
        2. 18.4.2 使用Executor对象，防止阻塞事件循环
      7. 18.5 从回调到future和协程
      8. 18.6 使用asyncio包编写服务器 (1/2)
      9. 18.6 使用asyncio包编写服务器 (2/2)
        1. 18.6.1 使用asyncio包编写TCP服务器
        2. 18.6.2 使用aiohttp包编写Web服务器
        3. 18.6.3 更好地支持并发的智能客户端
      10. 18.7 本章小结
      11. 18.8 延伸阅读
  14. 第六部分 元编程
    1. 第19章 动态属性和特性
      1. 19.1 使用动态属性转换数据 (1/3)
      2. 19.1 使用动态属性转换数据 (2/3)
      3. 19.1 使用动态属性转换数据 (3/3)
        1. 19.1.1 使用动态属性访问JSON类数据
        2. 19.1.2 处理无效属性名
        3. 19.1.3 使用__new__方法以灵活的方式创建对象
        4. 19.1.4 使用shelve模块调整OSCON数据源的结构
        5. 19.1.5 使用特性获取链接的记录
      4. 19.2 使用特性验证属性
        1. 19.2.1 LineItem类第1版：表示订单中商品的类
        2. 19.2.2 LineItem类第2版：能验证值的特性
      5. 19.3 特性全解析
        1. 19.3.1 特性会覆盖实例属性
        2. 19.3.2 特性的文档
      6. 19.4 定义一个特性工厂函数
      7. 19.5 处理属性删除操作
      8. 19.6 处理属性的重要属性和函数
        1. 19.6.1 影响属性处理方式的特殊属性
        2. 19.6.2 处理属性的内置函数
        3. 19.6.3 处理属性的特殊方法
      9. 19.7 本章小结
      10. 19.8 延伸阅读
    2. 第20章 属性描述符
      1. 20.1 描述符示例：验证属性
        1. 20.1.1 LineItem类第3版：一个简单的描述符
        2. 20.1.2 LineItem类第4版：自动获取储存属性的名称
        3. 20.1.3 LineItem类第5版：一种新型描述符
      2. 20.2 覆盖型与非覆盖型描述符对比
        1. 20.2.1 覆盖型描述符
        2. 20.2.2 没有__get__方法的覆盖型描述符
        3. 20.2.3 非覆盖型描述符
        4. 20.2.4 在类中覆盖描述符
      3. 20.3 方法是描述符
      4. 20.4 描述符用法建议
      5. 20.5 描述符的文档字符串和覆盖删除操作
      6. 20.6 本章小结
      7. 20.7 延伸阅读
    3. 第21章 类元编程
      1. 21.1 类工厂函数
      2. 21.2 定制描述符的类装饰器
      3. 21.3 导入时和运行时比较
      4. 21.4 元类基础知识
      5. 21.5 定制描述符的元类
      6. 21.6 元类的特殊方法__prepare__
      7. 21.7 类作为对象
      8. 21.8 本章小结
      9. 21.9 延伸阅读
    4. 结语
    5. 附录A 辅助脚本
      1. A.1 第3章：in运算符的性能测试
      2. A.2 第3章：比较散列后的位模式
      3. A.3 第9章：有或没有__slots__时，RAM的用量
      4. A.4 第14章：转换数据库的isis2json.py脚本
      5. A.5 第16章：出租车队离散事件仿真
      6. A.6 第17章：加密示例
      7. A.7 第17章：flags2系列HTTP客户端示例
      8. A.8 第19章：处理OSCON日程表的脚本和测试
    6. Python术语表 (1/3)
    7. Python术语表 (2/3)
    8. Python术语表 (3/3)
  15. 作者简介
  16. 关于封面

Product information

  • Title: 流畅的Python
  • Author(s): Luciano Ramalho
  • Release date: May 2017
  • Publisher(s): Posts & Telecom Press
  • ISBN: None

You might also like

book

Python数据处理

by Jacqueline Kazil, Katharine Jarmul

用传统的电子表格来处理数据不仅效率低下，而且无法处理某些格式的数据，对于混乱或庞大的数据集更是束手无策。本书将教你如何利用语法简单、容易上手的Python轻松处理数据。作者通过循序渐进的练习，详细介绍如何有效地获取、清洗、分析与呈现数据，如何将数据处理过程自动化，如何安排文件编辑与清洗任务，如何处理更大的数据集，以及如何利用获取的数据来创作引人入胜的故事。学完本书，你的数据处理和分析能力将更上一层楼。 快速了解Python基本语法、数据类型和语言概念 概述数据的获取与存储方式 清洗数据并格式化，以消除数据集中的重复值与错误 学习何时对数据进行标准化，何时对数据清理进行测试并将其脚本化 使用Scrapy写网络爬虫 利用新的Python库和技术对数据集进行探索与分析 使用Python解决方案将整个数据处理过程自动化

book

Python网络爬虫权威指南（第2版）

by Ryan Mitchell

作为一种采集和理解网络上海量信息的方式，网页抓取技术变得越来越重要。而编写简单的自动化程序（网络爬虫），一次就可以自动抓取上百万个网页中的信息，实现高效的数据采集和处理，满足大量数据需求应用场景。 本书采用简洁强大的Python语言，全面介绍网页抓取技术，解答诸多常见问题，是掌握从数据爬取到数据清洗全流程的系统实践指南。书中内容分为两部分。第一部分深入讲解网页抓取的基础知识，重点介绍BeautifulSoup、Scrapy等Python库的应用。第二部分介绍网络爬虫编写相关的主题，以及各种数据抓取工具和应用程序，帮你深入互联网的每个角落，分析原始数据，获取数据背后的故事，轻松解决遇到的各类网页抓取问题。第2版全面更新，新增网络爬虫模型、Scrapy和并行网页抓取相关章节。 解析复杂的HTML页面 使用Scrapy框架开发爬虫 学习存储数据的方法 从文档中读取和提取数据 清洗格式糟糕的数据 自然语言处理 通过表单和登录窗口抓取数据 抓取JavaScript及利用API抓取数据 图像识别与文字处理 避免抓取陷阱和反爬虫策略 使用爬虫测试网站

book

基于Python的智能文本分析

by Benjamin Bengfort, Rebecca Bilbro, Tony Ojeda

从新闻、讲话，到社交媒体上非正式的聊天，自然语言是最丰富、且尚未充分利用的数据源之一。不但数据源源不断，在使用环境中还在不断调整、变化;还包含了很多传统数据源未能传达的信息。 打开自然语言宝藏的钥匙，就是基于文本分析的创造性应用。这本 实战指南介绍了从数据科学家角度如何建立语言感知产品并有效应 用机器学习。 您将学到如何用Python实现健壮、可重复和可扩展的文本分析，包括上下文特征和语言特征工程、向量化、分类、主题建模、实体解析、图分析和可视化操作。在本书的最后，您将获得解决众多复杂现实问题的实用方法。 预处理并将文本向量化成高维特征表示。 执行文档分类和主题建模。 通过可视化诊断指导模型选择过程。 提取关键短语、命名实体和图结构，实现文本数据推断。 建立对话框架，实现聊天机器人和语言驱动交互。 用Spark扩展处理能力，用神经网络实现对更复杂模型的支持。

book

Python语言及其应用（第2版）

by Bill Lubanovic

本书通俗易懂，阅读起来饶有乐趣，十分适合想快速获得Python应用经验的新手。第2版带你从基础知识出发，逐步迈向更复杂、更多样化的主题，帮助你全面构建Python知识体系。书中将教程与代码示例相结合，清晰解释了Python 3的各种常用概念。每章配有练习和参考答案，帮助你学以致用。 你将通过本书打下坚实的Python基础，并牢固掌握测试、调试、代码重用等开发技巧。第2版加入了新的代码示例和练习，还向你展示了如何使用丰富的Python包在商业分析、数据库和机器学习等领域开发应用。 学习简单的数据类型、基础的数学运算和文本操作 将数据整理技术与内建数据结构结合使用 探索函数等Python代码结构 使用模块和包来编写大型Python程序 深入理解对象、类和其他面向对象特性 学习关系数据库和NoSQL等数据存储技术 构建Web客户端、服务器、API和服务 管理程序、进程和线程等系统任务 理解并发和网络编程的基础知识