Python核心编程（第2版） [Core PYTHON Programming] pdf epub mobi txt 电子书 下载 2025

简体网页||繁体网页

☆☆☆☆☆

[美] 丘恩（Chun W.J.） 著，宋吉广 译

图书标签:

• Python
• 编程
• 核心
• 第二版
• CorePython
• 计算机
• 技术
• 书籍
• 开发
• 教程

出版社： 人民邮电出版社

ISBN：9787115178503

版次：1

商品编码：10062788

品牌：异步图书

包装：平装

外文名称：Core PYTHON Programming

开本：16开

出版时间：2008-07-01

用纸：胶版纸

页数：654

字数：1317000

正文语种：中文

产品特色

编辑推荐

　　初学Python这是一本有关Python开发的指南
　　

　　涵盖近期发布的Pyttlon版本的核心功能特性，而不仅仅是语法
　　学习更多的高阶内容，如正则表达式、网络、多线程、图形用户界面、Web／CGl和Python扩展等
　　包括几个全新的章节，关于数据库、网络客户端、Java／Jytt30n和Microsoft Office等
　　展示数以百计的代码片段、交互实例和大量加强您的Python技能的实用练习
　　“对Wesley Chun《Python核心编程》第二版的漫长等待是值得的——它的深邃、它的全面，以及它实用的练习将会帮助读者学会并掌握杰出的Pythorl技能。”
　　——Alex Martelli，Python om a Nutshell一书作者和Python Cookbook一书编辑
　　“终于，一本杰出的融教材和参考书于一身的Python书籍诞生了。”
　　——Michael Baxter，Linux Journal
　　学习专业的Python风格、实践和好的编程习惯；
　　加强对Python对象、内存模型和Python面向对象特性的深入理解；
　　构建更有效的Web、CGI、互联网、网络和其他客户端／服务器架构应用程序及软件；
　　学习如何使用Python中的Tkinler和其他工具来开发自己的GUI应用程序及软件：
　　通过用C等语言编写扩展来提升Python应用程序的性能，或者通过使用多线程增强I／O相关的应用程序的能力；
　　学习Python中有关数据库的API，以及如何在Python中使用各种不同的数据库系统，包括MySQL、Postgres和SQLite。
　　本书提供：
　　对Python核心特性系统的专家级讲解；
　　开发复杂的应用程序和软件所需的强大深入的视角：
　　易用的图表，详细描述了Python模块、操作符、函数和方法：
　　大量的专业级实例代码，从小的代码片段到功能齐全的应用程序一应俱全。
　　
　　

内容简介

　　《Python核心编程(第2版)》是经典的Python指导书，在上一版的基础上进行了全面升级。全书分为两个部分：第1部分占据了大约三分之二的篇幅，阐释这门语言的“核心”内容，包括基本的概念和语句、语法和风格、Python对象、数字类型、序列类型、映射和集合类型、条件和循环、文件和输入/输出、错误和异常、函数和函数式编程、模块、面向对象编程、执行环境等内容：第2部分则提供了各种高级主题来展示可以使用Python做些什么，包括正则表达式、网络编程、网络客户端编程、多线程编程、图形用户界面编程、Web编程、数据库编程、扩展Python和一些其他材料。《Python核心编程(第2版)》适合Python初学者，以及已经入门但想继续学习和提高自身Python技巧的程序员。

目录

第1部分　Python核心
第1章　欢迎来到Python世界
1.1　什么是Python
1.2　起源
1.3　特点
1.3.1　高级
1.3.2　面向对象
1.3.3　可升级
1.3.4　可扩展
1.3.5　可移植性
1.3.6　易学
1.3.7　易读
1.3.8　易维护
1.3.9　健壮性
1.3.10　高效的快速原型开发工具
1.3.11　内存管理器
1.3.12　解释性和（字节）编译性
1.4　下载和安装Python
1.5　运行Python
1.5.1　命令行上的交互式解释器
1.5.2　从命令行启动脚本
1.5.3　集成开发环境
1.5.4　其他的集成开发环境和执行环境
1.6　Python文档
1.7　比较Python（Python与其他语言的比较）
1.8　其他实现
1.9　练习

第2章　快速入门
2.1　程序输出，print语句及"Hello World!"
2.2　程序输入和raw_input（）内建函数
2.3　注释
2.4　操作符
2.5　变量和赋值
2.6　数字
2.7　字符串
2.8　列表和元组
2.9　字典
2.10　代码块及缩进对齐
2.11　if语句
2.12　while循环
2.13　for循环和range（）内建函数
2.14　列表解析
2.15　文件和内建函数open（）、file（）
2.16　错误和异常
2.17　函数
2.17.1　如何定义函数
2.17.2　如何调用函数
2.17.3　默认参数
2.18　类
2.19　模块
2.19.1　如何导入模块
2.19.2　如何访问一个模块函数或访问一个模块变量
2.20　实用的函数
2.21　练习

第3章　Python基础
3.1　语句和语法
3.1.1　注释（#）
3.1.2　继续（）
3.1.3　多个语句构成代码组（：）
3.1.4　代码组由不同的缩进分隔
3.1.5　同一行书写多个语句（;）
3.1.6　模块
3.2　变量赋值
3.2.1　赋值操作符
3.2.2　增量赋值
3.2.3　多重赋值
3.2.4　"多元"赋值
3.3　标识符
3.3.1　合法的Python标识符
3.3.2　关键字
3.3.3　内建
3.3.4　专用下划线标识符
3.4　基本风格指南
3.4.1　模块结构和布局
3.4.2　在主程序中书写测试代码
3.5　内存管理
3.5.1　变量定义
3.5.2　动态类型
3.5.3　内存分配
3.5.4　引用计数
3.5.5　垃圾收集
3.6　第一个Python程序
3.7　相关模块和开发工具
3.8　练习

第4章　Python对象
4.1　Python 对象
4.2　标准类型
4.3　其他内建类型
4.3.1　类型对象和type类型对象
4.3.2　None--Python的Null对象
4.4　内部类型
4.4.1　代码对象
4.4.2　帧对象
4.4.3　跟踪记录对象
4.4.4　切片对象
4.4.5　省略对象
4.4.6　XRange 对象
4.5　标准类型操作符
4.5.1　对象值的比较
4.5.2　对象身份比较
4.5.3　布尔类型
4.6　标准类型内建函数
4.6.1　type（）
4.6.2　cmp（）
4.6.3　str（）和repr（）（及``操作符）
4.6.4　type（）和isinstance（）
4.6.5　Python类型操作符和内建函数总结
4.7　类型工厂函数
4.8　标准类型的分类
4.8.1　存储模型
4.8.2　更新模型
4.8.3　访问模型
4.9　不支持的类型
4.10　练习

第5章　数字
5.1　数字简介
5.1.1　如何创建数值对象并用其赋值（数字对象）
5.1.2　如何更新数字对象
5.1.3　如何删除数字对象
5.2　整型
5.2.1　布尔型
5.2.2　标准整型
5.2.3　长整型
5.2.4　整型和长整型的统一
5.3　双精度浮点型
5.4　复数
5.5　操作符
5.5.1　混合模式操作符
5.5.2　标准类型操作符
5.5.3　算术操作符
5.5.4　*位操作符（只适用于整型）
5.6　内建函数与工厂函数
5.6.1　标准类型函数
5.6.2　数字类型函数
5.6.3　仅用于整型的函数
5.7　其他数字类型
5.7.1　布尔"数"
5.7.2　十进制浮点型
5.8　相关模块
5.9　练习

第6章　序列：字符串、列表和元组
6.1　序列
6.1.1　标准类型操作符
6.1.2　序列类型操作符
6.1.3　内建函数（BIF）
6.2　字符串
6.3　字符串和操作符
6.3.1　标准类型操作符
6.3.2　序列操作符切片（[]和[：]）
6.4　只适用于字符串的操作符
6.4.1　格式化操作符（％）
6.4.2　字符串模板： 更简单的替代品
6.4.3　原始字符串操作符（r/R）
6.4.4　Unicode字符串操作符（u/U）
6.5　内建函数
6.5.1　标准类型函数
6.5.2　序列类型函数
6.5.3　字符串类型函数
6.6　字符串内建函数
6.7　字符串的独特特性
6.7.1　特殊字符串和控制字符
6.7.2　三引号
6.7.3　字符串不变性
6.8　Unicode
6.8.1　术语
6.8.2　什么是Unicode
6.8.3　怎样使用Unicode
6.8.4　Codec是什么
6.8.5　编码解码
6.8.6　把Unicode应用到实际应用中
6.8.7　从现实中得来的教训
6.8.8　Python的Unicode支持
6.9　相关模块
6.10　字符串关键点总结
6.11　列表
6.12　操作符
6.12.1　标准类型操作符
6.12.2　序列类型操作符
6.12.3　列表类型操作符和列表解析
6.13　内建函数
6.13.1　标准类型函数
6.13.2　序列类型函数
6.13.3　列表类型内建函数
6.14　列表类型的内建函数
6.15　列表的特殊特性
6.16　元组
6.17　元组操作符和内建函数
6.17.1　标准类型操作符、序列类型操作符和内建函数
6.17.2　元组类型操作符和内建函数、内建方法
6.18　元组的特殊特性
6.18.1　不可变性给元组带来了什么影响
6.18.2　元组也不是那么"不可变"
6.18.3　默认集合类型
6.18.4　单元素元组
6.18.5　字典的关键字
6.19　相关模块
6.20　*拷贝Python对象、浅拷贝和深拷贝
6.21　序列类型小结
6.22　练习

第7章　映像和集合类型
7.1　映射类型：字典
7.1.1　如何创建字典和给字典赋值
7.1.2　如何访问字典中的值
7.1.3　如何更新字典
7.1.4　如何删除字典元素和字典
7.2　映射类型操作符
7.2.1　标准类型操作符
7.2.2　映射类型操作符
7.3　映射类型的内建函数和工厂函数
7.3.1　标准类型函数[type（）、str（）和cmp（）]
7.3.2　映射类型相关的函数
7.4　映射类型内建方法
7.5　字典的键
7.5.1　不允许一个键对应多个值
7.5.2　键必须是可哈希的
7.6　集合类型
7.6.1　如何创建集合类型和给集合赋值
7.6.2　如何访问集合中的值
7.6.3　如何更新集合
7.6.4　如何删除集合中的成员和集合
7.7　集合类型操作符
7.7.1　标准类型操作符（所有的集合类型）
7.7.2　集合类型操作符（所有的集合类型）
7.7.3　集合类型操作符（仅适用于可变集合）
7.8　内建函数
7.8.1　标准类型函数
7.8.2　集合类型工厂函数
7.9　集合类型内建方法
7.9.1　方法（所有的集合方法）
7.9.2　方法（仅适用于可变集合）
7.9.3　操作符和内建方法比较
7.10　集合类型总结表
7.11　相关模块
7.12　练习

第8章　条件和循环
8.1　if语句
8.1.1　多重条件表达式
8.1.2　单一语句的代码块
8.2　else语句
8.3　elif（即else-if）语句
8.4　条件表达式（即"三元操作符"）
8.5　while语句
8.5.1　一般语法
8.5.2　计数循环
8.5.3　无限循环
8.6　for语句
8.6.1　一般语法
8.6.2　用于序列类型
8.6.3　用于迭代器类型
8.6.4　range（）内建函数
8.6.5　xrange（） 内建函数
8.6.6　与序列相关的内建函数
8.7　break语句
8.8　continue语句
8.9　pass语句
8.10　再谈else语句
8.11　迭代器和iter（）函数
8.11.1　什么是迭代器
8.11.2　为什么要迭代器
8.11.3　如何迭代
8.11.4　使用迭代器
8.11.5　可变对象和迭代器
8.11.6　如何创建迭代器
8.12　列表解析
8.13　生成器表达式
8.14　相关模块
8.15　练习

第9章　文件和输入输出
9.1　文件对象
9.2　文件内建函数（open（）和file（））
9.2.1　工厂函数file（）
9.2.2　通用换行符支持（UNS）
9.3　文件内建方法
9.3.1　输入
9.3.2　输出
9.3.3　文件内移动
9.3.4　文件迭代
9.3.5　其他
9.3.6　文件方法杂项
9.4　文件内建属性
9.5　标准文件
9.6　命令行参数
9.7　文件系统
9.8　文件执行
9.9　永久存储模块
9.9.1　pickle和marshal模块
9.9.2　DBM风格的模块
9.9.3　shelve模块
9.10　相关模块
9.11　练习

第10章　错误和异常
10.1　什么是异常
10.1.1　错误
10.1.2　异常
10.2　Python 中的异常
10.3　检测和处理异常
10.3.1　try-except语句
10.3.2　包装内建函数
10.3.3　带有多个except的try语句
10.3.4　处理多个异常的except语句
10.3.5　捕获所有异常
10.3.6　"异常参数"
10.3.7　在应用使用我们封装的函数
10.3.8　else子句
10.3.9　finally子句
10.3.10　try-finally语句
10.3.11　try-except-else-finally：厨房一锅端
10.4　上下文管理
10.4.1　with语句
10.4.2　*上下文管理协议
10.5　*字符串作为异常
10.6　触发异常
10.7　断言
10.8　标准异常
10.9　*创建异常
10.10　（现在）为什么用异常
10.11　到底为什么要异常
10.12　异常和sys模块
10.13　相关模块
10.14　练习

第11章　函数和函数式编程
11.1　什么是函数？
11.1.1　函数vs过程
11.1.2　返回值与函数类型
11.2　调用函数
11.2.1　函数操作符
11.2.2　关键字参数
11.2.3　默认参数
11.2.4　参数组
11.3　创建函数
11.3.1　def语句
11.3.2　声明与定义比较
11.3.3　前向引用
11.3.4　函数属性
11.3.5　内部/内嵌函数
11.3.6　*函数（与方法）装饰器
11.4　传递函数
11.5　Formal Arguments
11.5.1　位置参数
11.5.2　默认参数
11.6　可变长度的参数
11.6.1　非关键字可变长参数（元组）
11.6.2　关键字变量参数（字典）
11.6.3　调用带有可变长参数对象函数
11.7　函数式编程
11.7.1　匿名函数与lambda
11.7.2　内建函数apply（）、filter（）、map（）、reduce（）
11.7.3　偏函数应用
11.8　变量作用域
11.8.1　全局变量与局部变量
11.8.2　globa语句
11.8.3　作用域的数字
11.8.4　闭包
11.8.5　作用域和lambda
11.8.6　变量作用域和名称空间
11.9　*递归
11.10　生成器
11.10.1　简单的生成器特性
11.10.2　加强的生成器特性
11.11　练习

第12章　模块
12.1　什么是模块
12.2　模块和文件
12.2.1　模块名称空间
12.2.2　搜索路径和路径搜索
12.3　名称空间
12.3.1　名称空间与变量作用域比较
12.3.2　名称查找、确定作用域、覆盖
12.3.3　无限制的名称空间
12.4　导入模块
12.4.1　import语句
12.4.2　from-import语句
12.4.3　多行导入
12.4.4　扩展的import语句（as）
12.5　模块导入的特性
12.5.1　载入时执行模块
12.5.2　导入（import）和加载（load）
12.5.3　导入到当前名称空间的名称
12.5.4　被导入到导入者作用域的名字
12.5.5　关于__future__
12.5.6　警告框架
12.5.7　从ZIP文件中导入模块
12.5.8　"新的"导入钩子
12.6　模块内建函数
12.6.1　__import__（）
12.6.2　globals（）和locals（）
12.6.3　reload（）
12.7　包
12.7.1　目录结构
12.7.2　使用from-import导入包
12.8　模块的其他特性
12.8.1　自动载入的模块
12.8.2　阻止属性导入
12.8.3　不区分大小的导入
12.8.4　源代码编码
12.8.5　导入循环
12.8.6　模块执行
12.9　相关模块
12.10　练习

第13章　面向对象编程
13.1　引言
13.2　面向对象编程
13.2.1　面向对象设计与面向对象编程的关系
13.2.2　现实中的问题
13.2.3　*常用术语
13.3　类
13.3.1　创建类
13.3.2　声明与定义
13.4　类属性
13.4.1　类的数据属性
13.4.2　Methods
13.4.3　决定类的属性
13.4.4　特殊的类属性
13.5　实例
13.5.1　初始化：通过调用类对象来创建实例
13.5.2　__init__（）"构造器"方法
13.5.3　__new__（）"构造器"方法
13.5.4　__del__（）"解构器"方法
13.6　实例属性
13.6.1　"实例化"实例属性（或创建一个更好的构造器）
13.6.2　查看实例属性
13.6.3　特殊的实例属性
13.6.4　建类型属性
13.6.5　实例属性vs类属性
13.7　绑定和方法调用
13.7.1　调用绑定方法
13.7.2　调用非绑定方法
13.8　静态方法和类方法
13.8.1　staticmethod（）和classmethod（）内建函数
13.8.2　使用函数修饰符
13.9　组合
13.10　子类和派生
13.11　继承
13.11.1　__bases__类属性
13.11.2　通过继承覆盖方法
13.11.3　从标准类型派生
13.11.4　多重继承
13.12　类、实例和其他对象的内建函数
13.12.1　issubclass（）
13.12.2　isinstance（）
13.12.3　hasattr（）、getattr（）、setattr（）、delattr（）
13.12.4　dir（）
13.12.5　super（）
13.12.6　vars（）
13.13　用特殊方法定制类
13.13.1　简单定制（RoundFloat2）
13.13.2　数值定制（Time60）
13.13.3　迭代器（RandSeq和AnyIter）
13.13.4　*多类型定制（NumStr）
13.14　私有化
13.15　*授权
13.15.1　包装
13.15.2　实现授权
13.16　新式类的高级特性（Python 2.2+）
13.16.1　新式类的通用特性
13.16.2　__slots__类属性
13.16.3　__getattribute__（）特殊方法
13.16.4　描述符
13.16.5　元类和__metaclass__
13.17　相关模块和文档
13.18　练习

第14章　执行环境
14.1　可调用对象
14.1.1　函数
14.1.2　方法
14.1.3　类
14.1.4　类的实例
14.2　代码对象
14.3　可执行的对象声明和内建函数
14.3.1　callable（）
14.3.2　compile（）
14.3.3　eval（）
14.3.4　exec
14.3.5　input（）
14.3.6　使用Python在运行时生成和执行Python代码
14.4　执行其他（Python）程序
14.4.1　导入
14.4.2　execfile（）
14.4.3　将模块作为脚本执行
14.5　执行其他（非Python）程序
14.5.1　os.system（）
14.5.2　os.popen（）
14.5.3　os.fork（）、os.exec*（）、os.wait*（）
14.5.4　os.spawn*（）
14.5.5　subprocess 模块
14.5.6　相关函数
14.6　受限执行
14.7　结束执行
14.7.1　sys.exit（） and SystemExit
14.7.2　sys.exitfunc（）
14.7.3　os._exit（） 函数
14.7.4　os.kill（） Function
14.8　各种操作系统接口
14.9　相关模块
14.10　练习

第2部分　高级主题
第15章　正则表达式
15.1　引言/动机
15.2　正则表达式使用的特殊符号和字符
15.2.1　用管道符号（|）匹配多个正则表达式模式
15.2.2　匹配任意一个单个的字符（.）
15.2.3　从字符串的开头或结尾或单词边界开始匹配（^/$ / /B ）
15.2.4　创建字符类（[]）
15.2.5　指定范围（-）和否定（^）
15.2.6　使用闭包操作符（*，+，?，{}）实现多次出现/重复匹配
15.2.7　特殊字符表示、字符集
15.2.8　用圆括号（（））组建组
15.3　正则表达式和Python语言
15.3.1　re模块：核心函数和方法
15.3.2　使用compile（）编译正则表达式
15.3.3　匹配对象和group（）、groups（）方法
15.3.4　用match（）匹配字符串
15.3.5　search（）在一个字符串中查找一个模式（搜索与匹配的比较）
15.3.6　匹配多个字符串（|）
15.3.7　匹配任意单个字符（.）
15.3.8　创建字符集合（[]）
15.3.9　重复、特殊字符和子组
15.3.10　从字符串的开头或结尾匹配及在单词边界上的匹配
15.3.11　用findall（）找到每个出现的匹配部分
15.3.12　用sub（）（和subn（））进行搜索和替换
15.3.13　用split（）分割（分隔模式）
15.4　正则表达式示例
15.4.1　匹配一个字符串
15.4.2　搜索与匹配的比较，"贪婪"匹配
15.5　练习

第16章　网络编程
16.1　引言
16.1.1　什么是客户端/服务器架构
16.1.2　客户端/服务器网络编程
16.2　套接字：通信端点
16.2.1　什么是套接字
16.2.2　套接字地址：主机与端口
16.2.3　面向连接与无连接
16.3　Python中的网络编程
16.3.1　socket（）模块函数
16.3.2　套接字对象（内建）方法
16.3.3　创建一个TCP服务器
16.3.4　创建TCP客户端
16.3.5　运行我们的客户端与TCP服务器
16.3.6　创建一个UDP服务器
16.3.7　创建一个UDP客户端
16.3.8　执行UDP服务器和客户端
16.3.9　Socket模块属性
16.4　*SocketServer模块
16.4.1　创建一个SocketServerTCP服务器
16.4.2　创建SocketServerTCP客户端
16.4.3　执行TCP服务器和客户端
16.5　Twisted框架介绍
16.5.1　创建一个Twisted Reactor TCP服务器
16.5.2　创建一个Twisted Reactor TCP客户端
16.5.3　执行TCP服务器和客户端
16.6　相关模块
16.7　练习

第17章　网络客户端编程
17.1　什么是因特网客户端
17.2　文件传输
17.2.1　文件传输网际协议
17.2.2　文件传输协议（FTP）
17.2.3　Python和FTP
17.2.4　ftplib.FTP类方法
17.2.5　交互式FTP示例
17.2.6　客户端FTP程序举例
17.2.7　FTP的其他方面
17.3　网络新闻
17.3.1　Usenet与新闻组
17.3.2　网络新闻传输协议（NNTP）
17.3.3　Python和NNTP
17.3.4　nntplib.NNTP类方法
17.3.5　交互式NNTP举例
17.3.6　客户端程序NNTP举例
17.3.7　NNTP的其他方面
17.4　电子邮件
17.4.1　电子邮件系统组件和协议
17.4.2　发送电子邮件
17.4.3　Python和SMTP
17.4.4　smtplib.SMTP类方法
17.4.5　交互式SMTP示例
17.4.6　SMTP的其他方面
17.4.7　接收电子邮件
17.4.8　POP和IMAP
17.4.9　Python和POP3
17.4.10　交互式POP3举例
17.4.11　poplib.POP3类方法
17.4.12　客户端程序SMTP和POP3举例
17.5　相关模块
17.5.1　电子邮件
17.5.2　其他网络协议
17.6　练习

第18章　多线程编程
18.1　引言/动机
18.2　线程和进程
18.2.1　什么是进程
18.2.2　什么是线程
18.3　Python、线程和全局解释器锁
18.3.1　全局解释器锁（GIL）
18.3.2　退出线程
18.3.3　在Python中使用线程
18.3.4　没有线程支持的情况
18.3.5　Python的threading模块
18.4　thread模块
18.5　threading模块
18.5.1　Thread类
18.5.2　斐波那契、阶乘和累加和
18.5.3　threading模块中的其他函数
18.5.4　生产者-消费者问题和Queue模块
18.6　相关模块
18.7　练习

第19章　图形用户界面编程
19.1　简介
19.1.1　什么是Tcl、Tk和Tkinter
19.1.2　安装和使用Tkinter
19.1.3　客户端/服务器架构
19.2　Tkinter与Python编程
19.2.1　Tkinter模块：把Tk引入你的程序
19.2.2　GUI程序开发简介
19.2.3　顶层窗口：Tkinter.Tk（）
19.2.4　Tk组件
19.3　Tkinter举例
19.3.1　标签组件
19.3.2　按钮组件
19.3.3　标签和按钮组件
19.3.4　标签、按钮和进度条组件
19.3.5　偏函数应用举例
19.3.6　中级Tkinter范例
19.4　其他GUI简介
19.4.1　Tk Interface eXtensions （Tix）
19.4.2　Python MegaWidgets （PMW）
19.4.3　wxWidgets和wxPython
19.4.4　GTK+和PyGTK
19.5　相关模块和其他GUI
19.6　练习

第20章　Web编程
20.1　介绍
20.1.1　Web应用：客户端/服务器计算
20.1.2　因特网
20.2　使用Python进行Web应用：创建一个简单的Web客户端
20.2.1　统一资源定位符
20.2.2　urlparse模块
20.2.3　urllib模块
20.2.4　urllib2模块
20.3　高级Web客户端
20.4　CGI：帮助Web服务器处理客户端数据
20.4.1　CGI介绍
20.4.2　CGI应用程序
20.4.3　cgi模块
20.5　建立CGI应用程序
20.5.1　建立Web服务器
20.5.2　建立表单页
20.5.3　生成结果页
20.5.4　生成表单和结果页面
20.5.5　全面交互的Web站点
20.6　在CGI中使用Unicode编码
20.7　高级CGI
20.7.1　Mulitipart表单提交和文件的上传
20.7.2　多值字段
20.7.3　cookie
20.7.4　使用高级CGI
20.8　Web（HTTP）服务器
20.9　相关模块
20.10　练习

第21章　数据库编程
21.1　介绍
21.1.1　持久存储
21.1.2　基本的数据库操作和SQL语言
21.1.3　数据库和Python
21.2　Python数据库应用程序程序员接口（DB-API）
21.2.1　模块属性
21.2.2　连接对象
21.2.3　游标对象
21.2.4　类型对象和构造器
21.2.5　关系数据库
21.2.6　数据库和Python：接口程序
21.2.7　使用数据库接口程序举例
21.3　对象-关系管理器（ORM）
21.3.1　考虑对象，而不是SQL
21.3.2　Python和ORM
21.3.3　雇员数据库举例
21.3.4　总结
21.4　相关模块
21.5　练习

第22章　扩展Python
22.1　引言/动机
22.1.1　什么是扩展
22.1.2　为什么要扩展Python
22.2　创建Python扩展
22.2.1　创建您的应用程序代码
22.2.2　用样板来包装你的代码
22.2.3　编译
22.2.4　导入和测试
22.2.5　引用计数
22.2.6　线程和全局解释器锁（GIL）
22.3　相关话题
22.4　练习

第23章　其他话题
23.1　Web服务
23.2　用Win32的COM来操作微软Office
23.2.1　客户端COM编程
23.2.2 微软Excel
23.2.3　微软Word
23.2.4　微软PowerPoint
23.2.5　微软Outlook
23.2.6　中等规模的例子
23.3　用Jython写Python和Java的程序
23.3.1　什么是Jython
23.3.2　Swing GUI开发（Java或者Python!）
23.4　练习

精彩书摘

　　第1部分　Python核心
　　第1章　欢迎来到Python世界
　　开篇将介绍一些Python的背景知识，包括什么是Python、Python的起源和它的一些关键特性。一旦你来了兴致，我们就会向你介绍怎样获得Python，以及如何在你的系统上安装并运行它。本章最后的练习将会帮助你非常自如地使用Python，包括使用交互式解释器，以及创建并运行脚本程序。
　　1．1　什么是Python
　　Python是一门优雅而健壮的编程语言，它继承了传统编译语言的强大性和通用性，同时也借鉴了简单脚本和解释语言的易用性。它可以帮你完成工作，而且一段时问以后，你还能看明白自己写的这段代码。你会对自己如此快地学会它和它强大的功能感到十分的惊讶，更不用提你已经完成的工作了！只有你想不到，没有Python做不到。
　　1．2　起源
　　Guido van Rossum于1989年底始创了Python，那时，他还在荷兰的CWI（Centrum voor Wiskunde en Informatica，国家数学和计算机科学研究院）。1991年初，Python发布了第一个公开发行版。这一切究竟是如何开始的呢？像C、C++、Lisp、．Java和Perl一样，Python来自于某个研究项目，项目中的那些程序员利用手边现有的工具辛苦地工作着，他们设想并开发出了更好的解决办法。
　　那时van Rossum是一位研究人员，对解释型语言ABC有着丰富的设计‘经验，这个语言同样也是在CWI开发的。但是他不满足其有限的开发能力。已经使用并参与开发了像ABC这样的高级语言后，再退回到C语言显然是不可能的。他所期望的工具有一些是用于完成日常系统管理任务的，而且它还希望能够访问Amoeba分布式操作系统的系统调用。尽管vanRossum也曾想过为Amoeba开发专用语言，但足创造一种通用的程序设计语言显然更加明智，于是在1989年末，Python的种子被播下了。
　　1．3　特点
　　尽管Python已经流行了超过15年，但是一些人仍旧认为相对于通用软件开发产业而言，它还是个新丁。我们应当谨慎地使用“相对”这个词，因为“网络时代”的程序开发，几年看上去就像几十年。
　　当人们询问：“什么是Python？”的时候，很难用任何一个具象来描述它。人们更倾向于一口气不加思索地说出他们对Python的所有感觉，Python是一（请填写），这些特点究竟又是什么呢？为了让你能知其所以然，我们下面会对这些特点进行逐一地阐释。
　　1．3．1　高级
　　伴随着每一代编程语言的产生，我们会达到一个新的高度。汇编语言是献给那些挣扎在机器代码中的人的礼物，后来有了FORTRAN、c和Pascal语言，它们将计算提升到了崭新的高度，并且开创了软件开发行业。伴随着C语言诞生了更多的像c斗_卜、Java这样的现代编译语言。我们没有止步于此，于是有了强大的、可以进行系统调用的解释型脚本语言，例如Tcl、Perl和Python。
　　这些语言都有高级的数据结构，这样就减少了以前“框架”开发需要的时间。像Python中的列表（大小可变的数组）和字典（哈希表）就是内建于语言本身的。在核心语言中提供这些重要的构建单元，可以鼓励人们使用它们，缩短开发时间与代码量，产生出可读性更好的代码。
　　在C语言中，对于混杂数组（Python中的列表）和哈希表（Python中的字典）还没有相应的标准库，所以它们经常被重复实现，并被复制到每个新项目中去。这个过程混乱而且容易产生错误。

　　……

前言/序言

Python：洞悉万象，掌控未来 在快速演进的数字浪潮中，拥有一门强大的编程语言，如同拥有驾驭技术、洞察数据、创新未来的利器。Python，以其优雅的语法、丰富的库和广泛的应用领域，已成为全球开发者、数据科学家、人工智能研究者以及无数技术爱好者的首选。本书，旨在为读者揭示Python的深层魅力，带领大家从入门到精通，掌握这门语言的核心理念与实战技巧，从而在各自的领域中游刃有余，甚至开辟全新的可能。 为何选择Python？ Python的普及并非偶然。其设计哲学强调代码的可读性和简洁性，使得开发者能够用更少的代码实现更多的功能。这不仅降低了学习门槛，也提高了开发效率，让更多人能够专注于解决实际问题，而非被复杂的语法所困扰。从Web开发、自动化脚本、数据分析，到机器学习、人工智能、科学计算，Python的身影无处不在。它拥有一个庞大而活跃的社区，源源不断地贡献着高质量的第三方库和工具，为任何编程需求提供了坚实的支持。学习Python，就是开启了一扇通往无限技术可能的大门。 本书定位与目标读者 本书并非简单地罗列Python的语法规则，而是深入探究其核心设计思想和工作机制。我们旨在帮助读者建立起对Python语言的深刻理解，使其不仅能“会写”Python代码，更能“写好”Python代码。 初学者： 对于从未接触过编程，或者对其他语言感到迷茫的读者，本书将提供一个循序渐进的学习路径。从基础数据类型、控制流，到函数、模块，再到面向对象编程，我们将以清晰易懂的方式讲解每一个概念，并辅以大量贴近实际的示例，帮助您快速建立编程思维。 有一定编程基础的开发者： 如果您已经掌握了一门或多门其他编程语言，并希望快速高效地学习Python，本书将帮助您理解Python的独特性，例如其动态类型、垃圾回收机制、生成器、装饰器等，并引导您掌握Pythonic的编程风格，编写出更具可读性和效率的代码。 希望深入理解Python工作原理的读者： 对于那些不满足于表面操作，渴望了解Python底层实现、内存管理、对象模型等深层机制的读者，本书也将提供深入的剖析，让您对Python有更全面的认知。 期望应用Python解决实际问题的专业人士： 无论是需要自动化重复性任务的IT从业者，还是需要进行复杂数据分析的科学家，亦或是热衷于探索人工智能的工程师，本书都将为您提供必要的知识储备和实践指导，让您能将Python的力量应用于您的工作中。 本书内容概览：从基础到精通 本书将围绕Python的核心概念，展开详尽的讲解： 第一部分：Python语言基础与核心概念 1. Python初探： Python的安装与环境配置：让您轻松搭建属于自己的Python开发环境。 第一个Python程序：理解代码的执行流程，感受编程的乐趣。 Python的哲学与风格：深入理解Python的设计理念，掌握编写“Pythonic”代码的艺术。 变量、数据类型与运算符：认识Python中最基础的构建块，理解数字、字符串、布尔值等。 内置函数与标准库：探索Python自带的强大工具，高效地完成常见任务。 2. 控制流程与数据结构： 条件语句（if, elif, else）：学习如何根据不同情况做出决策，编写具有逻辑的代码。 循环语句（for, while）：掌握重复执行代码的方法，实现自动化和迭代。 列表（List）：学习如何存储和操作有序的数据集合，Python中最常用的数据结构之一。 元组（Tuple）：理解不可变序列的特性，以及其在某些场景下的优势。 字典（Dictionary）：掌握键值对存储方式，高效地查找和管理数据。 集合（Set）：了解无序且不重复元素的集合，以及其在数学运算和去重方面的应用。 3. 函数：代码的复用与组织： 函数的定义与调用：学习如何创建可重用的代码块，提高开发效率。 参数传递：理解位置参数、关键字参数、默认参数和可变参数，灵活地传递信息。 返回值：掌握函数如何返回结果，以及多返回值的使用。 作用域与命名空间：深入理解变量的可访问性，避免命名冲突。 递归：探索一种强大的问题解决技巧，通过函数自调用解决复杂问题。 4. 模块与包：代码的组织与分享： 模块的创建与导入：学习如何将代码组织成独立的模块，提高代码的可维护性。 包的使用：掌握如何组织和管理多个模块，构建大型项目。 标准库的探索：深入了解Python丰富的标准库，例如os, sys, math, datetime等，并学会如何利用它们。 第二部分：面向对象编程与进阶特性 5. 面向对象编程（OOP）基础： 类与对象：理解面向对象的概念，掌握如何创建类和实例化对象。 属性与方法：学习如何定义类的成员，以及如何操作对象。 封装：理解将数据和行为绑定在一起的重要性，提高代码的稳定性和安全性。 继承：学习如何创建类之间的层次结构，实现代码的复用和扩展。 多态：掌握如何通过统一的接口处理不同类型的对象，提高代码的灵活性。 6. Python的对象模型： 特殊方法（Magic Methods/Dunder Methods）：深入理解Python的对象协议，例如`__init__`, `__str__`, `__len__`等，让您的对象行为更加符合Python的习惯。 属性访问控制：学习如何通过getter和setter方法，或者property装饰器，精细地控制对象的属性访问。 类变量与实例变量：区分不同作用域的变量，理解它们在对象生命周期中的区别。 类方法与静态方法：掌握不同类型的方法，理解它们在类设计中的作用。 7. 异常处理与错误管理： try-except-finally：学习如何优雅地处理程序运行时可能发生的错误，防止程序崩溃。 自定义异常：掌握如何创建自己的异常类型，使错误处理更具针对性。 异常传播：理解异常如何在函数调用栈中传递，以及如何捕获和处理。 8. 文件I/O操作： 文件读写：学习如何打开、读取、写入和关闭文件，处理各种类型的数据。 文本文件与二进制文件：区分不同类型的文件，掌握相应的读写模式。 with语句：学习使用上下文管理器，确保文件被正确关闭。 9. 迭代器与生成器： 迭代器协议：深入理解Python的迭代机制，掌握如何创建自己的迭代器。 生成器函数与表达式：学习如何使用yield关键字，以更高效的方式创建迭代器，尤其适合处理大型数据集。 生成器表达式的惰性求值：理解生成器在内存使用上的优势。 10. 装饰器： 装饰器的原理：深入理解函数作为一等公民的特性，掌握如何使用装饰器为函数添加额外功能。 应用场景：学习使用装饰器进行日志记录、访问控制、性能测量等。 第三部分：Python进阶应用与实战 11. 正则表达式：强大的文本匹配工具： 正则表达式基础语法：学习各种元字符、量词、分组，掌握精确的文本匹配。 Python的re模块：学会如何在Python中使用正则表达式进行搜索、替换、分割等操作。 12. 并发与并行： 线程（Threading）：理解线程在并发执行中的作用，以及GIL（全局解释器锁）的限制。 进程（Multiprocessing）：学习如何利用多进程绕过GIL，实现真正的并行计算。 异步编程（Asyncio）：探索Python的异步I/O模型，实现高效的网络I/O操作。 13. 网络编程基础： Socket编程：理解网络通信的基本原理，学习如何使用Python进行TCP/UDP通信。 HTTP协议：了解HTTP的基本请求和响应，为Web开发打下基础。 14. 数据库交互： SQLite：学习如何使用Python内置的sqlite3模块，进行轻量级数据库操作。 SQLAlchemy（可选）：为需要与更强大的数据库（如MySQL, PostgreSQL）交互的读者提供初步的指导。 15. 测试与调试： 单元测试（unittest/pytest）：学习如何编写测试用例，确保代码的正确性和稳定性。 调试技巧：掌握Python的调试器，高效地定位和解决代码中的bug。 学习路径与实践建议 本书的设计旨在提供一个完整且深入的学习体验。我们建议您： 动手实践： 阅读理论知识的同时，务必动手敲代码、运行示例，并尝试修改它们。编程是一门实践的艺术，只有通过不断的练习，才能真正掌握。 理解原理： 对于每一个概念，尽量去理解其背后的原理，而不仅仅是记住语法。这有助于您在遇到新问题时，能够灵活地运用所学知识。 解决问题： 尝试用Python解决您日常生活或工作中遇到的实际问题，哪怕是很小的任务，也能极大地提升您的学习动力和成就感。 查阅文档： 养成查阅Python官方文档和其他权威资源的习惯。官方文档是学习Python最可靠的来源。 参与社区： 加入Python相关的在线社区，与其他学习者和开发者交流，分享经验，解决问题。 结语 Python的魅力远不止于此。本书将为您打开通往Python世界的大门，但真正的探索才刚刚开始。掌握了Python的核心，您将能够自信地驾驭各种技术挑战，用代码创造无限可能。愿本书成为您在Python学习道路上的得力助手，助您洞悉万象，掌控未来。

评分☆☆☆☆☆

拿到《Python核心编程（第2版）》这本书，我首先被它厚实的体量所吸引，这预示着它内容的丰富程度。然而，我真正开始阅读后，才发现其价值远超我最初的想象。这本书对于Python的每一个重要概念都进行了深入的剖析，并且提供了大量的代码示例来佐证。我之前在学习某个特定模块时，常常会遇到很多似懂非懂的地方，而这本书就像一本百科全书，能够为我提供详尽的解释和背景知识。我特别佩服作者在组织内容上的条理性和逻辑性，让我能够清晰地把握Python的知识脉络。例如，在讲解装饰器时，作者循序渐进地展示了它的演变过程，从简单的函数嵌套到真正的装饰器语法，整个过程都显得非常自然和易于理解。我感觉这本书不仅仅是教我如何使用Python，更是让我理解Python的“哲学”。

评分☆☆☆☆☆

我之所以会选择《Python核心编程（第2版）》，是因为我之前接触过一些Python的书籍，但总感觉它们要么过于基础，要么过于晦涩。我希望找到一本能够在我现有基础上，带我进一步深入的。这本书恰好填补了我的需求。我最看重的是它对Python生态系统的全面覆盖，从基础的语法特性，到文件 I/O、网络编程、数据库交互，再到更高级的并发和多线程，这本书几乎面面俱到。作者的讲解风格非常务实，他不会回避那些复杂的细节，而是用清晰的语言和恰当的例子，帮助读者理解。我尤其喜欢书中对错误处理和调试技巧的讲解，这对于日常开发来说简直是福音。通过这本书，我学会了如何更有效地定位和解决问题，这无疑大大提升了我的开发效率。

评分☆☆☆☆☆

说实话，我购买《Python核心编程（第2版）》这本书，很大程度上是抱着一种“死马当活马医”的心态。我是一名有一定Python基础的开发者，但总感觉自己在某些方面不够扎实，特别是在理解Python的底层机制和一些高级用法时，总是云里雾里。这本书的出现，就像一盏明灯，照亮了我前行的道路。我特别欣赏作者在处理复杂话题时所展现出的清晰思路和详实讲解。比如，在讲解生成器和迭代器的时候，我之前一直对它们的使用场景和内部原理感到模糊，而这本书通过大量生动的例子和细致的解释，让我彻底理解了它们是如何工作的，以及如何利用它们来优化代码性能和简化程序逻辑。更让我惊喜的是，书中还涉及了一些Python的内部实现细节，这对于我这样想要深入理解Python的人来说，简直是太宝贵了。我感觉自己不仅仅是在学习Python的语法，更是在学习Python的“思维方式”，这对于我今后的编程生涯有着深远的影响。

评分☆☆☆☆☆

刚拿到这本《Python核心编程（第2版）》的时候，说实话，我有点犹豫。毕竟市面上Python的书籍琳琅满目，从入门到精通的都有，再多一本似乎也掀不起什么大浪。但是，我还是被书名里的“核心”二字吸引了，我总觉得，一本真正优秀的书，应该能把我从“会用”提升到“精通”，能够让我真正理解Python的设计哲学，而不是仅仅停留在语法层面。读了几天之后，我的感觉就像是挖到宝藏一样。这本书不仅仅是在罗列Python的各种特性，它更像是在为我构建一个坚实的Python知识体系。作者在讲解每一个概念的时候，都非常注重逻辑的严谨性和知识的连贯性，让我能够循序渐进地理解Python的方方面面。特别是关于面向对象编程的部分，作者的讲解非常深入浅出，让我一下子就明白了类、对象、继承、多态这些概念在Python中是如何优雅实现的。我之前看过的很多书，对这部分都只是点到为止，而这本书则给了我醍醐灌顶的感觉。感觉作者就像一位经验丰富的老船长，带领我在这浩瀚的Python海洋中稳健航行，指引我避开那些浅滩暗礁，直达知识的彼岸。

评分☆☆☆☆☆

我拿到《Python核心编程（第2版）》这本书已经有一段时间了，这段时间里，我几乎是爱不释手。作为一个对编程充满好奇心的学生，我一直渴望找到一本能够真正让我“玩转”Python的书。这本书完全满足了我的期待。它没有那些枯燥乏味的理论堆砌，而是通过大量贴近实际应用的例子，让我一步步感受到Python的强大和灵活。我尤其喜欢书中关于数据结构和算法的讲解，作者用非常易于理解的方式，将抽象的概念具象化，让我能够轻松掌握各种数据结构的优缺点以及适用场景。而且，这本书的排版也很舒服，代码示例清晰易读，让我能够很快地将书中的知识应用到我的学习和实践中。我现在觉得，我不再仅仅是输入代码，而是真正理解了代码背后的逻辑，这让我对编程的信心大大提升。

评分☆☆☆☆☆

好评，书还没看，不错呀，好评

评分☆☆☆☆☆

挺好的，书比较厚，够学一段时间了。

评分☆☆☆☆☆

很好的书，质量也很好，发货速度快，送货速度快，在京东买东西就是顺心

评分☆☆☆☆☆

书侧面全是黑手印

评分☆☆☆☆☆

不错，讲的很详细，新手自学，有经验的复习都可以

评分☆☆☆☆☆

很不满意！！！！京东利民华明提货点态度太差！！！还要加收*钱！！

评分☆☆☆☆☆

我的人都是我的人都是我的人都是我的

评分☆☆☆☆☆

正在看,还不错哦111111111111111111

评分☆☆☆☆☆

好好好好好好好好好好好好好