Python核心编程第二版(中文).pdf 目录整理

python核心编程目录

Chapter1：欢迎来到python世界！-页码：7

1.1什么是python

1.2起源  ：罗萨姆1989底创建python

1.3特点

1.3.1高级

1.3.2面向对象

1.3.3可升级

1.3.4可扩展

1.3.5可移植性：python使用C写的。

1.3.6易学

1.3.7易读

1.3.8易维护

1.3.9健壮性

1.3.10高效的快速原型开发工具

1.3.11内存管理器 ：内存管理由python解释器负责，开发仅仅致力于开发计划中的应用程序。

1.3.12解释性和（字节）编译性：无需编译，当执行py文件，会生成.pyc或.pyo文件

1.4下载和安装python

1.5运行python

1.5.1命令行的交互式解释器

1.5.2从命令行启动脚本

1.5.3集成开发环境

1.5.4其他的集成开发环境和执行环境

1.6python文档

1.7比较python（python与其他语言的比较）

 

Chapter2：Python起步-页码：31

注：语句和表达式的区别

语句是使用关键词来组成命令，告诉解释器要做什么。

表达式没有关键词，可以使算术表达式，也可以是使用括号调用的函数。

2.1程序输出，print语句及“Hello World” ：print是关键字

Print ‘%s is number %d!’%(‘python’,1) #print与字符串格式运算符（%）结合使用。

2.2程序输入和raw_input()内建函数  ：raw_input()是内建函数

2.3注释#

2.4运算符 :算数运算符+ - * / // % ** 比较运算符，逻辑运算符

2.5变量和赋值

2.6数字：int，long，bool，float，complex（复数）

2.7字符串

2.8列表[]和元组()

2.9字典{}

2.10代码块及缩进对齐

2.11 if语句

2.12 while循环

2.13 for循环和range()内建函数：  enumerate()内建函数可循环索引和元素

2.14列表解析：可使用for循环将所有值放在一个列表里。

2.15文件和内建函数open()，file()

2.16错误和异常

2.17函数：python中的函数使用小括号()调用。

2.18类

2.19模块：文件名字，不包括.py

2.20实用的函数：dir，help，len，open，raw_input，str，type

 

Chapter3：Python基础-页码：59

3.1语句和语法

3.1.1注释（#）

3.1.2继续（\）

3.1.3多个语句构成代码组（:）

3.1.4代码组由不同的缩进分隔

3.1.5同一行书写多个语句（;）

3.1.6模块

3.2变量赋值：= 链式赋值，多元赋值

3.3标识符

3.3.1合法的python标识符：大小写敏感

3.3.2关键字：import keyword; print keyword.kwlist 关键字加对象=语句 直接使用

3.3.3内建：dir(__builtins__) 直接使用

3.3.4专用下划线标识符_xxx:私有的 __xxx__:系统定义的名字 __xxx:类中私有的变量名

3.4基本风格指南

3.4.1模块结构和布局

如果模块被导入，__name__的值为模块名字

如果模块是被直接执行，__name__的值为__main__

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相关模块和开发工具

 

Chapter4：Python对象-页码：86

4.1python对象：包括三个特性：身份id()，类型type()，值

4.1.1对象属性：用.标记法来访问属性，最常用的属性是函数和方法

4.2标准类型

4.3其他内建类型

4.3.1类型对象和type类型对象

4.3.2None，Python的Null对象：布尔值为False的对象列举。

4.4内部类型

4.4.1代码对象

4.4.2帧对象

4.4.3跟踪记录对象

4.4.4切片对象

4.4.5省略对象

4.4.6XRange对象

4.5标准类型运算符

4.5.1对象值的比较：< <= > >= != ==

4.5.2对象身份的比较:is 或者 id(a)==id(b

4.5.3布尔类型的运算符：not，and，or

4.6标准类型内建函数

4.6.1 type()

4.6.2 cmp()

4.6.3 str()和repr()（及反引号运算符``）

4.6.4type()和isinstance()：isinstance(a,type(a))为True

4.6.5Python类型运算符和内建函数总结

4.7类型工厂函数：int，str，list，tyoe

4.8标准类型的分类

4.8.1存储模型

原子类型：数字，字符串

容量类型 列表，元组，字典

4.8.2更新模型

不可变类型：数字，字符串，元组:看似更新了，其实是新生成一个对象，可以用id查看。

可变：列表，字典

4.8.3访问模型

直接访问：数字

顺序访问：字符串，列表，元组

映射访问：字典

4.9不支持的类型

 

Chapter5：数字-页码：116

5.1数字类型

5.2整型

5.2.1布尔型：True False

5.2.2标准整数类型：int：长度与计算机的位数有关，有32位-2**31到2**31-1，也有64位

5.2.3长整型：无上限

5.2.3整型和长整型的统一

5.3双精度浮点数：8个字节

5.4复数

5.4.1复数的内建属性

5.5运算符

5.5.1混合模式运算符，优先级复数，浮点数，长整型，整型

5.5.2标准类型运算符

5.5.3算数运算符 /地板除：舍去小数部分，返回一个不大于结果的整数部分（注意负数）

若有：from __future__ import division：/代表浮点数除法，//代表地板除（整除）{浮点数相除，也是整除，最后结果加.0}

若无：from __future__ import division：当数字有浮点数，/代表浮点数除法，当数字都是整数，/代表地板除,//一直为地板除，若有浮点数，结果加.0

5.5.4*位运算符（只适用于整数）

5.6内建函数与工厂函数

5.6.1标准类型函数：cmp(),str(),type()

5.6.2数字类型函数：int(),long(),float(),complex(),bool()

功能函数

abs():返回参数的绝对值

coece():数据类型转换函数，返回一个包含类型转换完毕的两个数值元素的元组

divmod():内建函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组。

>>> divmod(5,3)

(1, 2)

>>> divmod(-5,3)

(-2, 1)

round():用于对浮点数进行四舍五入运算

>>> round(4.4)

4.0

>>> round(4.5)

5.0

>>> round(-4.4)

-4.0

>>> round(-4.5)

-5.0

pow():进行指数运算

5.6.3仅用户整数的函数

5.7其他数字类型

5.7.1布尔“数”

5.7.2十进制浮点数

5.8相关模块：decimal，array，math/cmath，operator，random

 

Chapter6：序列，字符串，列表和元组-页码：151

注：如果是标准类型的内建函数（dir（__builtins__）可查到），那么执行形式：内建函数（序列对象），如果是某序列的内建函数（dir(str)或dir(list)或dir(tuple)或dir(dict)或dir(file)等可以查到），那么执行形式：序列对象.内建函数。

6.1序列

6.1.1标准类型操作符

6.1.2序列类型操作符： in和not in，+，*，切片

6.1.3内建函数（BIFs）：list，str，tuple，enumerate，len，reversed，zip

6.2字符串：单引号和双引号都可以，转义字符在引号中起作用

6.3字符串和操作符

6.3.1标准类型操作符

6.3.2序列操作符：切片，成员操作符in，not in

6.4只适合于字符串的操作符

6.4.1格式化操作符（%）

6.4.2字符串模板：更简单的替代品

6.4.3原始字符串操作符（r/R）

6.4.4 Unicode字符串操作符（u/U）

6.5内建函数

6.5.1标准类型函数：cmp(),sorted()：排序总返回列表

6.5.2序列类型函数：len(),enumerate(),zip()

6.5.3字符串类型函数：raw_input(),str(),Unicode()

6.6字符串内建函数： join(列表), split(分隔符),引用 字符串对象.内建函数: dir(str)

>>> L=['a','b','c']

>>> s='_'.join(L) #join是将列表组合为字符串

>>> print s

a_b_c

>>> r=s.split('_') #split是将字符串分隔为列表

>>> print r

['a', 'b', 'c']

6.7字符串的独特特性

6.7.1特殊字符串和控制字符

6.7.2三引号：所见即所得

6.7.3字符串不变性

6.8 Unicode

6.8.1术语

6.8.2什么是Unicode？

6.8.4Codecs是什么？

6.8.5编码解码

6.8.6把Unicode应用到实际应用中

6.8.7从现实中得到的教训

6.8.8 Python的Unicode支持

6.9相关模块：string，re

6.10字符串关键点总结

6.11列表[]

6.12操作符

6.12.1标准类型操作符：比较操作符，俩列表的元素分别比较，直到一方胜出为止。

6.12.2序列类型操作符：切片，成员关系操作（in,not in）,连接操作符+，append(),*

6.12.3列表类型操作符和列表解析：用方括弧和for循环

6.13内建函数

6.13.1标准类型函数：cmp():同比较操作符

6.13.2序列类型函数：

len(),max(),min(),sorted(),reversed(),enumerate(),zip(),sum(),list(),tuple()

6.13.3列表类型内建函数：range()

range(1,4):1,2,3

range(4,1,-1):4,3,2

range(-4,-1)：-4,-3，-2

range（-1，-4，-1）：-1,-2，-3

6.14列表类型的内建函数：列表对象.内建函数：

dir(list):append(),insert(),pop(),remove()

注：字符串是不可变的：不可变对象的方法是不能改变它们的值的，所以它们必须返回一个新的对象。而列表是可变的，在使用可变对象的方法，这些操作会在原地执行操作，也就是说现有的列表内容会改变，但是没有返回值，不要傻傻的a=a.append()！

6.15列表的特殊特性

6.15.1用列表构建其他数据结构：堆栈：后进先出。队列：新进新出。

6.16元组()

6.17元组操作符和内建函数

6.17.1标准类型操作符，序列类型操作符和内建函数：与列表一致。

6.17.2元组类型操作符和内建函数，内建方法：暂无。

6.18元组的特殊特性

6.18.1不可变给元组带来了什么影响？

6.18.2元组也不是那么“不可变”：+更新成新对象。可以改变元组的列表元素的某个值。

6.18.3默认集合类型

6.18.4单元素元组：(‘xyz’,)

6.18.5字典的关键字

 

6.19相关模块：copy，re，operator

6.20拷贝Python对象浅拷贝和深拷贝

6.21序列类型小结

 

Chapter7：映射和集合类型-页码：250

7.1映射类型：字典{}可查看字典类型的属性dir(dict)

7.2映射类型操作符：不支持拼接+和重复*的操作

7.2.1标准类型操作符

7.2.2映射类型操作符[],in,not in

7.3映射类型的内建函数和工厂函数

7.3.1标准类型函数[type(),str()和cmp（）]

7.3.2映射类型相关的函数：dict(),len(),hash()

7.4映射类型的内建函数dir(dict):keys(),values(),items(),get(),copy()

7.5字典的键

7.5.1不允许一个键对应多个值

7.5.2键必须是可哈希的：不可变类型都是可哈希的。

7.6集合类型([])

7.7集合类型操作符

7.7.1标准类型操作符（所有的集合类型）

7.7.2集合类型操作符（所有的集合类型）

7.7.3集合类型操作符（仅适用于可变集合）

7.8内建函数

7.8.1标准类型函数：len()

7.8.2集合类型工厂函数：set(),frozenset()

7.9集合类型内建方法

7.9.1方法（所有的集合方法）

7.9.2方法（仅适用于可变集合）

7.9.3操作符和内建方法比较

7.10操作符，函数/方法

7.11相关模块：set

 

Chapter8：条件和循环-页码：285

8.1 if语句

8.1.1多重条件表达式：and,or,not

8.1.2单一语句的代码块

8.2 else语句

8.2.1避免“悬挂else”

8.3 elif语句

8.4条件表达式（即“三元操作符”）

X if C else Y   #C是条件表达式；X是C为True时的结果；Y是C为False时的结果

8.5while语句

8.5.1一般语法

8.5.2计数循环

8.5.3无限循环

8.6 for语句：可用在列表解析和生成器表达式中。

8.6.1一般语法：序列或迭代器

8.6.2用于序列类型：字符串，列表，元组

通过序列项迭代 for x in 对象  print x

通过序列索引迭代for x in range（len（对象）） print对象[x]

通过项和索引迭代 for x,y in enumerate(对象)  print x，y

8.6.3用于迭代器类型

8.6.4 range()内建函数：range()的完整语法

8.6.5 xrange()内建函数

8.6.6与序列相关的内建函数

sorted()和zip()返回一个序列（列表）

reversed()和enumerate()返回迭代器（类似序列）

8.7 break语句：结束当前循环然后跳转到下条语句

8.8 continue语句：终止当前循环，并忽略剩余的语句，然后回到循环顶端，进行下一次迭代。

在while和for循环里，while循环是条件性的，而for循环是迭代的。

8.9 pass语句：不做任何事。开发和调试时，可先把结构定下来。

Pass在任何需要的语句块里都可以使用（如if，for，while，elif，else，class，def，try，except，finally）

8.10 再谈else语句

if else，while else，for else：只要循环正常结束（不是通过break），else子句就会被执行。

8.11迭代器和iter()函数

8.11.1什么是迭代器？

8.11.2为什么要迭代器？

8.11.3如何迭代？ next(),reversed(),enumerate(),any(),all()

8.11.4使用迭代器：序列（iter）和字典（iterkeys，itervalues，iteritems），文件

8.11.5可变对象和迭代器

8.11.6如何创建迭代器：iter(对象)

8.12列表解析：expr for iter_var in iterable [if cond_expr]，最后产生列表。可替换map（）和lambda及filter（）和lambda

8.13生成器表达式

8.14 R相关模块

 

Chapter9：文件和输入输出-页码：317

9.1文件对象

9.2文件内建函数[open()和file()]

File_object=open(file_name,access_mode=’r’,buffering=-1)

9.2.1工厂函数file()

9.2.2通用换行符支持（UNS）

9.3文件内建方法：dir(file)

9.3.1输入：read(),readline(),   readlines():将列表变为文件，无行结束符

9.3.2输出：write(),   writelines()：将文件变为列表，不会删除行结束符

9.3.3文件内移动：seek()

9.3.4文件迭代：for eachline in f:

9.3.5其他：close()

9.3.6文件方法杂项：os模块，文件内建函数整理说明。

9.3.6文件内建属性（数据属性）

9.5标准文件：sys模块

9.6命令行参数：sys.argv属性

9.7文件系统 os模块及os.path模块中路径名访问函数整理

9.8文件执行

9.9永久存储模块

9.9.1 pickle和marshal模块

9.9.2 DBM风格的模块

9.9.3 shelve模块

9.10相关模块

 

Chapter10：错误和异常-页码：345

10.1什么是异常

10.1.1错误

10.1.2异常

10.2 Python中的异常：各个Error说明：NameError，ZeroDivisionError，SyntaxError，IOError，IndexError，KeyError，AttributeError

10.3检测和处理异常

10.3.1 try-except语句：如果发生异常，try子句的剩余语句会被忽略，控制流立即跳转到对应的处理器。没有发生异常，控制流就会忽略except语句继续执行。

10.3.2封装内建函数

10.3.3带有多个except的try语句

10.3.4处理多个异常的except语句

10.3.5捕获所有异常：try： except Exception，e：

BaseException:(KeyboardInterrupt,SystemExit,Exception,所有内建异常)

10.3.6异常参数e

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触发异常

之前的异常都是解释器引发的，而程序员在编写API时也可以程序触发异常。

10.6.1 raise语句：raise Exception(‘[%s]错误信息提示’[%变量])

raise语句放在try块中，if条件满足则raise（抛出异常），通过except捕捉Exception异常。

10.7断言

10.7.1断言语句：assert expression[,’错误信息提示’]

Assert语句放在try块中，通过except捕捉AssertionError异常。

如果断言成功，则不采取任何措施。

如果断言失败，则触发AssertionError（断言错误）的异常。AssertionError异常和其他异常一样可以用try-except语句块捕捉，如果没有捕捉，他将终止程序运行并提示traceback。

10.8标准异常：Python内建异常整理，异常是类。

根异常BaseException的子类:KeyboardInterrupt,SystemExit,Exception

Exception的子类：其他所有内建异常

10.9*创建异常

10.10为什么用异常（现在）？

10.11到底为什么要异常？

10.12异常和sys模块

10.13相关模块

 

Chapter11：函数和函数式编程-页码：388

11.1什么是函数？

11.1.1函数VS过程：过程时没有返回值的函数（隐式返回默认值None）

11.1.2返回值与函数类型

11.2调用函数

11.2.1函数操作符

11.2.2关键字参数

11.2.3默认参数

11.2.4参数组-例子

通过一个把元组（非关键字参数）或字典（关键字参数）作为参数组传递给函数，可以将所有参数放进一个元组或字典中。如：

func（*tuple_grp_nonkw_args,**dict_grp_kw_args）

11.3创建函数

11.3.1 def语句

11.3.2声明与定义比较

11.3.3前向引用

11.3.4函数属性

11.3.5内部/内嵌函数

11.3.6 *函数（与方法）装饰器

11.4传递函数：

1.def foo(): foo（函数对象的引用）和foo()（函数对象的调用）

2.foo作为函数的入参：foo1（foo）

11.5形式参数

11.5.1位置参数

11.5.2默认参数

11.6可变长度的参数

11.6.1非关键字可变长参数（元组）

11.6.2关键字变量参数（Dictionary）

11.6.3调用带有可变长参数对象函数

11.7函数式编程

11.7.1匿名函数与lambda

11.7.2内建函数apply(),filter(),map(),reduce()

filter(func,seq)过滤，选出为真的序列(入参什么类型，结果就是什么类型)

map(func,seq)映射，将调用函数的结果返回来，列表类型。

reduce(func,seq),func为二元函数，只接受两个参数，返回单一的，然后再与序列下一个元素来获取又一个值，知道迭代整个seq，最终，返回一个值。

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.7.3-11.10.2未仔细看，练习题未做。

 

Chapter12：模块-页码：450

12.1什么是模块

12.2模块和文件

12.2.1模块名称空间：通过句点属性标志指定了各自的命名空间

12.2.2搜索路径和路径搜索PYTHONPATH和sys.path

12.3名称空间：名称到对象的映射。

三个命名空间：局部命名空间，全局命名空间，内建命名空间

12.3.1名称空间与变量作用域比较

12.3.2名称查找，确定作用域，覆盖：优先局部，再全局，再内建。

12.3.3无限制的名称空间

12.4导入模块

12.4.1语句：import：顺序：Python标准库模块，Python第三方模块，应用程序自定义模块

解释器执行到这条语句，则会在搜索路径中找到了指定的模块，就会加载它。

12.4.2 from import语句：导入指定模块的是模块属性from a[.b.c] import d

12.4.3多行导入：\

12.4.4扩展的import语句（as）:from a import b as c

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文件导入模块（zip文件包括.py,.pyc,.pyo文件）

12.5.8”新的”导入钩子

12.6模块内建函数

12.6.1__import__()

12.6.2 globals()和locals()

12.6.3 reload()

12.7包：使用标准的import和from-import语句导入包中的模块

12.7.1目录结构：每个包都有__init__.py文件

12.7.2使用from –import导入包

12.7.3绝对导入：名字通过Python路径（sys.path或PYTHONPATH）来访问

12.7.4相对导入：句点导入

12.8模块的其他特性

12.8.1自动载入的模块：__builtin__会被自动导入

12.8.2阻止属性导入：属性名称前加_

12.8.3不区分大小的导入？

12.8.4源代码编码

12.8.5导入循环？

12.8.6模块执行

12.9相关模块

 

Chapter13：面向对象编程OOP-页码：473

13.1介绍：

13.1.1类和类实例

类是对象的定义，而实例是“真正的实物”，它存放了类中所定义的对象的具体信息。

class 类名(继承的父类，如object)：object是“所有类之母”

13.1.2方法：类的功能通俗名称就是方法：def 方法名（self）

方法定义在类的定义中，但只能被实例所调用。所以用self，代表实例对象本身。

定义类（和方法）2.创建实例 3.用实例调用方法

13.1.3创建一个类（类定义）

__init__()方法：初始化一些值或初始化一些操作（如登录数据库），类的实例化会隐式调用__init__()方法，实例化的入参完全和__init__()方法接收的入参一致（除了self）

13.1.4创建子类

13.1.5命名类，属性，方法 命名规范

类名：通常由大写字母打头：AbcDef

属性（变量或常量）：名词：小写：abc

方法：使用谓词（动词加对象）：小写_小写：abc_def

13.2面向对象编程

13.2.1面向对象设计OOD与面向对象编程OOP的关系

13.2.2现实世界中的问题

13.2.3*常用术语

13.3类

13.3.1创建类

13.3.2声明与定义：无区别，同时进行

13.4类属性：属于一个对象的数据和函数元素，通过句点标识符访问。在调用类的方法前，需要创建一个实例。

13.4.1类的数据属性

数据属性仅仅是所定义的类的变量。不依赖任何类实例。

13.4.2方法

方法仅应用在类类型的对象（实例）

13.4.3决定类的属性

通过dir（类名）或类名.__dict__可查看类的属性

13.4.4特殊的类属性:__name__,__doc__,__bases__,__dict__,__module__,__class__

13.5实例

13.5.2 __init__()“构造器”方法

调用类时，传进的任何参数都交给了__init__(),__init__()是解释器为你创建一个实例后调用的第一个方法。另，__init__()不允许放回任何对象（应当为None）

13.5.3 __new__() “构造器”方法

13.5.4 __del__() “解构器”方法

13.6实例属性

实例仅拥有数据属性（方法严格来说是类属性）

13.6.1“实例化”实例属性（或创建一个更好的构造器）

13.6.2查看实例属性：通过dir和__dict__查看

13.6.3特殊的实例属性：__class__和__dict__

13.6.4内建类型属性

13.6.5实例属性vs类属性

13.7从这里开始校对—绑定和方法调用

方法是类属性。方法只有在其所属的类拥有实例时才能被调用，方法才绑定到实例中。方法的第一个参数都是变量self。

13.7.1调用绑定方法

13.7.2调用非绑定方法：派生一个子类，覆盖父类的方法。

13.8静态方法和类方法：未看

13.8.1 staticmethod()和classmethod内建函数

13.8.2使用函数修饰符

13.9组合：将不同的类混合到其他类中

13.10子类和派生：相同的类但有一些不同的功能

13.10.1创建子类

13.11继承：描述了基类的属性如何遗传给派生类。一个子类可以继承它的基类的任何属性（除了__doc__）。

13.11.1__bases__类属性

13.11.2通过继承覆盖（Overriding）方法：如果方法名相同，优先用子类自己的方法。

13.11.3从标准类型派生：未看

13.11.4多重继承：未看

13.12类，实例和其他对象的内建函数

13.12.1 issubclass():是否是子类issubclass(sub,sup)

13.12.2 isinstance()：是否是实例isinstance(obj1，obj2)

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.13.2__slots__类属性

13.16.3特殊方法__getattribute__()

13.16.4描述符

13.16.5 Metaclasses(元类)和__metaclass__

13.17相关模块和文档

 

Chapter14：执行环境-页码：582  以后再看

14.1可调用对象：函数，方法，类，以及类的实例

14.1.1函数：内建函数BIFs，用户定义函数UDF

14.1.2方法：内建方法BIM，用户定义的方法UDM

14.1.3类

14.1.4类的实例：__call__

14.2代码对象

14.3可执行的对象声明和内建函数

14.3.1 callable()

14.3.2 compile()

14.3.3 eval()

14.3.4 exec

14.3可执行对象语句和内建函数

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() Function os._exit()函数

14.7.4 os.kill() Function

14.8各种操作系统接口

14.9相关模块

 

Chapter15：正则表达式-页码：621

15.1介绍/动机

15.1.1您的第一个正则表达式

15.2正则表达式使用的特殊符号和字符：整理表

15.2.1用管道符号（|）匹配多个正则表达式模式

15.2.2匹配任意一个单个的字符（.）

15.2.4从字符串的开头或结尾或单词边界开始匹配（^ / $ / \b / \B）

15.2.5创建字符类（[]）:任何一个字符

15.2.5.1[]中指定范围（-）和否定（^）

15.2.6使用必报操作符（*，+，？，{}）实现多次出现/重复匹配

15.2.7特殊字符表示字符集

15.2.8用圆括号（（））组建组：为多个字符添加重复操作符

15.3正则表达式和python语言

15.3.1 re模块：核心函数和方法：compile，match，search，findall，finditer，split，sub，group，groups  :函数的pattern指的是正则表达式

15.3.2使用compile()编译正则表达式

compile(pattern,flags=0)

15.3.3匹配对象和group(),groups()方法

15.3.4用match()匹配字符串：

match(pattern,string,flags=0)

从头开始匹配：返回regex对象。通过group提取匹配后的字符。

15.3.5 search()在一个字符串中查找一个模式（搜索与匹配的比较）：

search(pattern,string,flags=0)

从任意位置匹配：返回regex对象。通过group提取匹配后的字符。

15.3.6匹配多个字符串（|）

15.3.7匹配任意单个字符（.）:除了\n

15.3.8创建字符集合([])

15.3.9重复，特殊字符和子组:group(),groups()整理

15.3.10从字符串的开头或结尾匹配及在单词边界上的匹配

15.3.11用findall()找到每个出现的匹配部分：返回列表或空列表

findall(pattern,string)

15.3.12用sub[和subn()]进行搜索和替换：返回替换后的字符串

sub(pattern,string,max=0)

15.3.13用split()分割（分隔模式）：返回列表

re的split是根据正则表达式分隔字符串。字符串的split()是通过固定字符分隔。

split(pattern,string,max=0)

python原始字符串（raw strings）的用法

15.4正则表达式示例

15.4.1匹配一个字符串

15.4.2搜索与匹配的比较，“贪婪”匹配

 

Chapter16：网络编程-页码：655

16.介绍

16.1.1什么是客户/服务器架构

16.1.2客户/服务器网络编程

16.2套接字：通讯断点

16.2.1什么是套接字？ 通信接口？

套接字家族：基于文件型的AF_UNIX和基于网络型的AF_INET

16.2.2套接字地址：主机与端口

16.2.3面向连接SOCK_STREAM与无连接SOCK_DGRAM

16.3 Python中的网络编程

16.3.1 socket()模块函数

16.3.2套接字对象（内建）方法

 

Chapter17：网络客户端编程-页码：685

Chapter18：多线程编程-页码：721

Chapter19：图形用户界面编程-页码：748

Chapter20：Web编程-页码：781 

Chapter21：数据库编程-页码：841

Chapter22：拓展Python-页码：880

Chapter23：其他话题-页码：901

 

转载于:https://www.cnblogs.com/yufeihlf/p/5709832.html