Python新手必读12652.pdf

《Python新手必读12652.pdf》由会员分享，可在线阅读，更多相关《Python新手必读12652.pdf（89页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、Python 新手必读（中国开源项目）Python 新手必读（中国开源项目）第一章 开始 为什么要选择 python?一个高层的总结 把 python 描述成一种面向对象的脚本语言可能是最合适的。它的设计混合了传统语言的软件工程的特点和脚本语言的易用性。它的主要特性有如下几个：1、它是面向对象的。它的类模式支持了诸如多态，操作符重载，多重继承等高级特性。2、它是自由的。它是开源的，像 Tcl 和 Perl 一样。3、它是可移植的。它是用 ANSI C 写成的。可以在今天所用的各种平台上编译、运行。4、它是功能强大的。python 丰富的工具集使它位于传统脚本语言（如 Tcl and perl）

2、和系统语言（如 C，C+,JAVA）之间。5、它是可混合的。python 程序可十分轻易地与其它语言写成的组件“粘合”在一起。如 python/c 集成 api,JPython。6、它是易于使用的。开发周期短，程序大小是其它语言的几分之一。7、它是简单易学的。实践中的 python 1、系统软件，python 对操作系统的内置接口，使它成为书写可移植程序，可维护的系统管理工具的理想工具。2、图形用户接口。它有一个叫 Tkinter 的 TK API 的标准的面向对象接口。3、组件集成。它可被 c/c+扩展和嵌入其它系统的能力。4、快速原型。5、Internet 脚本。6、数字编程。NumPy

3、数字扩展程序模块包含诸多数字编程工具。7、数据库编程。提供了与 sybase,oracle,odbc 等数据库接口。8、其它的图像处理，人工智能，分布式对象等。python 与类似工具的比较 1、比 Tcl 强大，可用于大型系统的开发。2、比 Perl 有更清晰的语法，更简单的设计，使它更可读，更容易理解。3、不要与 java 比较，python 只是一个脚本语言，而 java and c/c+是系统语言。如何运行 python 程序？1、交互式。交互命令行，在系统下打入 python，就进行交互命令模式，提示符是，按 Ctrl+D 退出。%python print hello,my frie

4、nd!;hello,my friend!2、运行模块文件。模块文件是包含 python 语句的简单文本文件。你可以用python xxx 来运行。用文本编辑器编写 example.py 的内容如下：import sys print sys.argv 接着就可以用以下命令运行。%python example.py 3、运行 unix 类型的脚本。就像 shell 脚本一样。#！/usr/local/bin/python print test.注释以#开头。存盘后，把它的属性改成可执行，就可以像 shell 脚本一样执行了。4、嵌入的代码和对象。在 c 程序中可调用 python 的运行时 API

5、。#include .py_Initialize();PyRun_SimpleString(x=brave+sir+robin);初览模块文件 以.py 为结尾的模块文件能导入或重载。例子：myfile.py 模块内容为 title=the example test 现在这个模块可能被其它程序导入，而且能访问 title 变量。方法一：import myfile print myfile.title 方法二：from myfile import title print title 初览名称空间检测 另一个技巧是用内置函数 dir()跟踪程序交互运行时的名字。python 设置细节 重要的环境变

6、量 path 系统 shell 查找路径，用来发现 python。PYTHONPATH Python 模块查找路径，用于导入。PYTHONSTARTUP Python 交互式启动文件路径。TCL_LIBRARY,TK_LIBRARY GUI 扩展变量(Tkinter)第二章 类型与操作符 Python 程序结构 它可分为模块，语句和对象三部份，关系如下：1、程序是由模块组成。2、模块中包含语句。3、语句生成并处理对象。为什么要使用内置类型？1、内置对象使简单程序写起来更容量。2、python 提供对象并支持扩展程序。3、内置对象是扩展程序的组件。4、内置对象总比定制的数据结构类型更加有效。内置

7、对象预览 Number(数字)3.4，333，5+4j String(字符串)sleep,hello List(列表)1,34,this,33 Dictionary(字典)aaa:test,bbb:yyy Tuple(元组)(1,aa,4,cc)File(文件)text=open(a,r).read()数字 python 支持常见的数字类型，（整数，浮点数），常量和表达式。另外还提供更高级的数字类型支持。包括复数，无限精确整数，大量的数字工具库。正常整数（c 的长整型）1234，-11，0 长整数（无限大小）88888888L 浮点数（c 的双整型）2.33，3.14e-10，4E21i 复数

8、常量 3+4j,2.0+4.0j,3J 表达式操作符 x or y 逻辑或 lambda args:expression 匿名函数 x and y 逻辑与 not x 逻辑反,=,=,!=比较操作符 is,is not 身份测试 in,not in 序列成员关系测试 x|y 位或 x y 位异或 x&y 位与 xy 把 x 向左或向右移动 y 位 x+y,x-y 相加/合并，相减 x*y,x/y,x%y 乘/重复，除，余数/格式-x,+x,x 一元取反，一致，位取补 xi,xi:j,x.y,x(.)索引，分片，限定，函数调用(.),.,.,.元组，列表，字典，转化为字符串 混合操作符，表中越往

9、下的结合性越强 可用括号将表达式分组 在 混合类型的表达式上，python 先将操作对像转化为最复杂的操作类型，然后再运行同种类型的数字运算，如一个整数与一个浮点数相加，python 就会把 整数转化为浮点数，再把两个浮点数相加。python 的数字类型复杂程序如下：整数长整数浮点数x=1#0001 x x|2#位或：0011 3 x&1#位与：0001 注意：x 的值一直都是1，没有变化。python 提供了内置函数和内置模块用于数字处理。import math math.pi 3.14159265359 pow(2,4)#内置函数，不用导入。字符串 s1=空字符串 s2=spams 双引号

10、，单引号无需加反斜杠转义。block=.三引号块，字符串可跨过多行。s1+s2 合并 s2*3 重复 s2i 索引 s2i:j 分片 len(s2)长度 a%s parrot%dead 字符串格式 for x in s2 迭代 m in s2 成员关系 python 不允许你在+and*号表达式中混合数字和字符，如abc+9 会出错。索引和分片 因为字符串的定义是有序的字符集合，所以可以通过位置访问它们的内容。在 python，通过索引取得字符的位移。如同 C 一样，偏移以0开始，以比字符长度小1的值结尾。python 还可以通过负偏移从序列中取值。s=spam print s0,s1,s2,

11、s3#索引 s p a m print s1:3,s1:,s:-1#分片 pa pam spa 修改和格式化 在 python 中改变文本信息，只需用合并，分片这样的工具建立并赋值成一个新值即可。s=s+!spam!s=s:4+test spamtest this is%d%s word%(1,good)格式化字符串输出，类似于 C的 sprintf。重载了%操作符，原来的%操作符是取余。this is 1 good word 字符串格式代码%s 字符串%c 字符%d 十进制（整数）%i 整数%u 无符号整数%o 八进制整数%x 十六进制整数%X 十六进制整数大写%e 浮点数格式1%E 浮点数

12、格式2%f 浮点数格式3%g 浮点数格式4%G 浮点数格式5%文字%e%E%f%g%G%(1.1,2.2,3.3,4.4,5.5)1.100000e+000 2.200000E+000 3.300000 4.4 5.5 普通的字符串工具 python 提供 string 这个处理字符串的工具模块。它包括转换大小写，查找子串，将字符转化成数字等功能。import string s=test string.upper(s)TEST string.find(a,s)#返回索引的子串-1 string.atoi(1234)+1234#把字符转化为整数进行加减运算 2468 aa+99#用把整数转化为字

13、符进行组合。aa99 字符串常量变量 a=aab print a aab a=aab print a aab a=aab print a aab a=test test test print a test test test 字符串的反斜线字符 newline 忽略（继续）反斜杠 单引号 双引号 a 响铃 b 退格 e 退出 000 空 n 新行（换行符）v 垂直制表符 t 水平制表符 r 回车 f 进纸符 0XX 八进制值 XX xXX 十六进制值 XX other 任何其它的字符 列表 列表可包含任何种类的对象：数字、字符串甚至其它列表。在 python 中的列表的主要属性有：1、任意对象

14、的有序集合。2、通过偏移存取。和字符串一样，可分片，合并等操作。3、可变长度，异构，任意嵌套。4、属于序列可变的类别。可在原位上改变，支持删除，索引赋值和方法等。5、对象引用的数组。类似于 C 的指针的数组。列表是 C 的数组，引有就像 C的指针（地址）。常用列表常量和操作 L1=一个空的列表 L2=0,1,2,3 四项：索引为0到3 L3=a,b,c 嵌套的子列表 L2i,L3i,j 索引 L2i:j 分片 len(L2)计算列表长度 L1+L2 合并 L2*3 重复 for x in L2 迭代 3 in L2 成员关系 L2.append(4)方法：增长 L2.sort()排序 L2.i

15、ndex(1)查找 L2.reverse()反转.del L2k 缩小 L2i:j=同上 L2i=1 索引赋值 L2i:j=1,2,3 分片赋值 range(4),xrange(0,4)生成整数的列表/元组 例子：len(1,2,3)3 1,2,3+4,5,6 1,2,3,4,5,6 1,2*4 1,2,1,2,1,2,1,2 for x in 1,2,3:print x 1 2 3 索引和分片 L=aa,bb,cc print L2#索引 cc print L1:2#分片 bb 原位改变列表 L=aa,aa,cc L1=bb#索引赋值 print L aa,bb,cc L=aa,bb,cc

16、L2:3=CC#分片赋值，删除+插入 print L aa,bb,CC L.append(please)#append 方法调用，其它方法类似。print L aa,bb,CC,please 注意：append 和 sort 在原位改变了关联的列表对象，但是不返回列表，它们返回一个叫 None 的值。对象本身同时改变，所以无需重新赋值。字典 字典是无序的集合，和列表相对，因为列表是有序的集合。字典中的项是通过键来存取的，而不是通过偏移。（perl 中的散列？）字典的主要属性如下：1、通过键而不是偏移量来存取。2、无序的任意对象集合。3、可变长度、异构、任意嵌套。4、属于可变映射类型。对象将键映

17、射到值。5、对象引用表（散列表）。本质上说字典是作为散列表实现的。常见的字典对象常量和操作 d1=空的字典 d2=aa:2,bb:4 两项的字典 d3=aa:bb:1,cc:2 嵌套 d2aa,d3aacc 通过键索引 d2.has_key(aa)方法：成员关系测试 d2.keys()键的列表 d2.values()值的列表.len(d2)长度（所存储的项的数目）d2key=new 添加/改变 del d2key 删除 提示：1、字典不是序列，所以不能像在字符串和列表中那样直接通过一个 for 进行迭代，需调用字典的 keys 方法，返回一个键值列表。2、序列操作，像合并，分片无法操作。3、赋

18、值给新的索引将添加项。4、键没有必要总是字符串。元组(tuple)元组由简单的对象组构成。不能原位改变。写在一串圆括号中，与列表类似。1、任意对象的有序集合。2、通过偏移量存取。3、属于不可变序列类型。4、固定长度，异常，任意嵌套。可包含列表，字典其它元组。5、对象引用的数组。常见的元组常量和操作()空元组 t1=(0,)只有一项的元组，不是一个表达式。不要漏了逗号。t2=(0,1,2,3)四项的元组 t2=0,1,2,3 四项的元组，同上一行。t3=(aa,(bb,cc)嵌套的元组 t1i,t3ij 索引 t1i:j 分片 len(t1)计算长度 t1+t2 合并 t3*3 重复 for x

19、 in t1 迭代 3 in t2 成员关系 有了列表，为什么还要用元组？元组的不可变性可以提供某些整体性，你能肯定在一个程序中一个元组不会被另一个引用改变。一个来自实践的原则：列表可以用于想变动的有序集合，元组则处理其它事情。文件 文件对象方法和 C 标准库的函数是一一对应的。常见的文件操作 output=open(/temp/test,w)生成输出文件（写方式）input=open(data,r)生成输入文件（读方式）s=input.read()把整个文件读到一个字符串中 s=input.ead(N)读 N 个字节 s=input.readline()读下一行（越过行结束标志）L=inpu

20、t.readlines()读取整个文件到一个行字符串的列表中 output.write(S)把字符串 S 写入文件 output.writelnes(L)将列表 L 中所有的行字符串写到文件中 output.close()手工关闭 任何情况下，Python 程序中的文本采取字符串的形式，读取一个文件将返回字符串形式的文本，并且文本作为字符串传递给 write 方法。调用 close 方法将终止对处部文件的连接。实际的文件操作 file=open(test,w)#打开文件用以输入，如果文件不存则生成。file.write(hello world)#把hello world写入文件 file.cl

21、ose()#关闭文件句柄 read=open(test,r)#打开文件用以输出 read.readline()#读一行 hello world read.readline()#空字符串：到文件结尾 共有的对象属性 对象分类 数字 数字的 不可变 列表 序列的 可变 字符串 序列的 不可变 字典 映射的 可变 元组 序列的 不可变 文件 扩展程序 -共性 1、列表，字典和元组可以包含任何种类的对象。2、列表，字典和元组可以任意嵌套。3、列表，字典可以动态扩大和缩小。比较相等性和真值=测试值是否相等 is 测试对象的一致性 L1=1,2,33 L2=1,2,33 L1=L2 True L1 is

22、L2 False 真值表 aaa true false false false 1 true 0.0 false None false#None 是 python 中一个特列对象，总被认为是假的。python 的比较方法 1、数字通过关系值比较。2、字符串按字典顺序，字符到字符的比较 (abc L=1,2,3 M=1,L,3 print M 1,1,2,3,3 L1=0#也改变了 M，共享引用。print M 1,1,0,3,3 解决办法，通过拷贝避免共享对象。L=1,2,3 M=1,L:,3#嵌入的 L 拷贝 print M 1,1,2,3,3 L1=0#只改变 L，M 不改变。print

23、M 1,1,2,3,3 print L 1,0,3 同层深度的重复加 L=1,2,3 X=L*4 print X 1,2,3,1,2,3,1,2,3,1,2,3 Y=L*4 print Y 1,2,3,1,2,3,1,2,3,1,2,3 L1=0#改变 Y 但不改变 X print X 1,2,3,1,2,3,1,2,3,1,2,3 print Y 1,0,3,1,0,3,1,0,3,1,0,3 解决方法同上 L=1,2,3 Y=L:*4 print Y 1,2,3,1,2,3,1,2,3,1,2,3 L1=0 print L 1,0,3 print Y 1,2,3,1,2,3,1,2,3,1

24、,2,3 循环数据结构不能打印 L=1 L.append(L)#追加引用到同一个对象中，在1.5.1之前这是个循环，需按 ctl-c 中断。print L 1,.解决方法，不要这样做。这是一种无意义的操作。不可变类型在原位不可以被改变 T=(1,2,3)print T(1,2,3)T2=4 Traceback(most recent call last):File,line 1,in-toplevel-T2=4 TypeError:object doesnt support item assignment T=T:2+(4,)#用分片，合并等操作生成一个新的对象。print T(1,2,4)第

25、三章 基本语句 程序由模块组成，模块包含语句，语句生成并处理对象。赋值 1、赋值生成对象引用，而不是对象的拷贝，因此，与数据存储结构相比，python的变量更像 C 中的指针。2、名字在第一次赋值时即已生成，不用事先声明。3、名字在引用前必须赋值。4、隐式赋值：import,from,def,class,for 函数参数等。赋值语句形式 a=test 基本形式 a,b=1,2 元组赋值 a,b=test,goods 列表赋值 a=b=test 多目标赋值 a,b=b,a 交换值 变量名规则 1、与 C 类似，以下划线或字母开头，随之可以是任意位的字母，数字或下划线。2、大小写敏感。3、保留字限

26、制。表达式 aa(bb,cc)函数调用 aa.read(bb)方法调用 aa 交互式打印 aa bb and bb!=cc 复合表达式 aa bb cc 范围测试 if 条件测试 一般格式为：if:elif：else:在 python 中没有 switch and case 语句，多路分支可被一系列 if/elif，或是通过检索字典，查找列表代替，字典和列表可在运行时生成，比逻辑上的硬性编码更有弹性。choice=aa print aa:12.33,bb:343.3,cc:44choice#一个基于字典的switch语句 12.33 python 的语法规则 1、语句一条接一条执行，一直到你说

27、不为止。2、块和语句边界自动控测。用首行缩进形式将语句分组。3、复合语句=首行，“：”，缩进语句。4、空格和注释被忽略。5、语句太长可跨行写。真值测试 1、真代表着任意非空的数或非空的对象。2、假代表不真，数0，空的对象或 None。3、比较或判断相等返回1或0（真或假）。4、and 和 or 布尔操作返回一个真或假的操作数对象。while 循环 一般格式：while：else:例子：while 1:print type ctrl-c to stop me#1为真，所以无限循环地打印。遍历字符串：x=test while x:#只要 x 不为空就执行 print x,x=x1:#从 x 中取出

28、第一个字符。test est st t 循环计数 a=0;b=10 while a b:print a a=a+1 0 1 2 3 4 5 6 7 8 9 break,continue,pass,else 循环 break 和 continue 和 C 类似。break 跳出最近的包围它的循环 continue 跳到最近的循环的开头 pass 什么都不做，只是一个空的占位空语句。else 运行并且只有在循环正常退出的情况下运行。没有碰到 break。包含 break and continue 的循环语句。while：if:break#跳出循环，忽略 else。if:continue#转到循环开

29、头。else:#如果没有遇上 break for 循环 for in:#该目标赋以对象的项#重复循环体：使用目标 else:#如果没有遇上 break 当 python 运行 for 时，它将序列对象中的项一个接一个赋值给目标，并且为每一个执行一次循环体。for 也支持一个可选的 else 块，和在 while 中完全一样，如果循环没有遇到 break，它就会执行，也就是说序列中所有的项都被访问了。for in:if:break#跳出循环，忽略 else。if:continue#转到循环开头。else:#如果没有遇上 break range 和计数循环 range 函数可能成一个连接的整数列表

30、，它可以在 for 中作为索引使用。带一个参数时，range 生成一个从0开始到参数值（不包含参数）的列表。range(10)0,1,2,3,4,5,6,7,8,9 带两个参数时，range 生成以第一个参数为下边界，第二个参数上边界的列表。range(10,20)10,11,12,13,14,15,16,17,18,19 带三个参数时，range 生成以第一个参数为下边界，第二个参数上边界，第三个参数为步长的列表。range(10,20,2)10,12,14,16,18 利用循环扫描文件内容 file=open(test,r)while 1:line=file.readline()#取得下一

31、行 if not line:break#在文件结束时跳出循环 在这里处理行 也可用 for 实现同样功能 file=open(test,r)for line in file.readlines():#读入一个行列表 在这里处理行 最简单的遍历一个序列的方法是用一个简单的 for 循环,python 为你处理了大多数的细节。x=myfile for a in x:print a m y f i l e 在内部，for 始初化一个索引，检测序列是否结束，索引序列以取得当前的项。在每一个迭代上增加索引。如果你真想知道索引的逻辑复杂性，你可以用一个 while 循环做一个。这个形式和 C 中的 for

32、 相似。x=myfile i=0 while i x=myfile i=0 for i in range(len(x):print xi m y f i l e python 代码编写中的常见问题 1、不要忘了冒号。2、一定要从第一列开始写顶层。3、交互提示符下的空白行代表结束语句。4、缩进一致性，不能混合使用制表符和空格。5、在 python 中不要写 c/c+代码。没有必要在 if 的条件和 while 的头加上括号。6、不要总想得到结果。list.append(),list.sort()不返回值，无需赋值就可以调用它，不要写成 sort=list.sort()7、适当地使用 call a

33、nd import。第四章 函数 函数两个主要作用是：1、代码重用 2、过程的分解 函数的基础 1、def 生成一个函数对象并赋给它一个名字 2、return 给调用者返回一个结果对象。3、global 声明模块级被赋值的变量。4、参数通过赋值传递（对象引用）。5、参数，返回类型和变量不用声明。def (arg1,arg2,.,argN):return 没有 return 的函数自动返回一个 None。def time(x,y):return x*y time(2,3)6 time(test,3)#函数是无类型的 testtesttest 函数中的作用域规则 通常函数定义一个局部作用域，模块定

34、义一个全局作用域。关系如下：1、模块是一个全局作用域 2、对函数的每个调用是一个新的局部作用域。3、赋值的名字是局部的，除非声明是全局。4、所有其它名字都是全局的或内置的。名字解析 LGB 规则 1、大多数名字引用在三个作用域中查找：先局部(Local)，次之全局(Global)，再次之内置(Build-in)。2、名字赋值默认情况下生成、改变局部的名字。3、global声明把赋值的名字映射到一个包含它的模块的作用域中。global 语句 它就象一个声明，告诉 python，一个函数计划改变全局名字-包围它的模块的作用域内的名字。参数传递 1、参数通过局部名字传递。2、在一个函数中对参数名赋值

35、不影响调用者。3、在一个函数中改变一个可变的对象参数可能影响调用者。def changer(x,y):x=2#只改变局部的名字值 y0=test#在该位置改变共享的对象,y 传递一个可变对象，对在函数中对 y0的赋值的结果影响了函数返回后 L 的值。x=1 L=1,2 changer(x,L)#x 没变，L 改变了 x,L(1,test,2)python 通过赋值传递参数的方式，与 C+中的参数引用不同，但与 C 的类似：1、不可变参数作用类似于 C 中的“传值”模式。2、可变参数作用类似于 C 的“传指针”模式。特列参数匹配模式 位置 从左到右 关键字 通过参数名匹配 可变参数 捕捉未匹配位

36、置或关键字参数 func(value)正常参数：通过位置匹配 func(name=value)关键字参数，通过名字匹配 def func(name)正常参数：匹配任何位置和名字 def func(name=value)默认的参数值，如果没有在调用中传递的话。def func(*name)匹配剩下的位置变量（在一个元组中）def func(*name)匹配剩下的关键字变量（在一个字典中）规则：1、在调用中，关键字参数必须出现在所有非关键字参数后。2、在一个函数首部，*name 必须在普通参数和默认后，*name 必须在最后。python 内部在赋值前采取下列步骤匹配参数：1、通过位置赋值非关键字

37、参数。2、通过匹配名字赋值关键字参数。3、赋值额外的非关键字参数给“*name”元组。4、赋值额外的关键字参数给“*name”字典。5、在首部给无赋值的参数赋以默认值。其它内容 lambda 表达式 除了 def 语句，python 还提供了一个可以生成函数对象的表达式。因为它与LIST 语言中的一个工具类似，所以叫 lambda，lambda 是一个表达式，而不是一个语句；它的结构体是一个单一的表达式，不是一个语句块。格式如下：lambda 参数1，参数2.参数 N：使用参数的表达式。如用 def 写一个函数：def func(x,y):return x+y func(1,2)3 可以用 l

38、ambda 写成：f=lambda x,y:x+y f(1,2)3 可以在一个列表常量中嵌入 lamdba 表达式，建立一个函数列表：L=lambda x:x*2,lambda x:x*3,lambda x:x*4 for f in L:print f(2)#打印4，8，16 print L0(30)#打印9 内置的 apply 函数 有的程序需要调用任意的函数，而无须事先知道它们的名字或参数。内置函数可以做到这一点：apply(func,(1,2,3)apply 函数简单的调用传递的参数，用函数所需的参数匹配传递的参数。它的一个优点是，它无须知道在一个函数中有多少个参数被调用。内置函数 ma

39、p 程序通常可以做的一件事是：对列表中的每一个成员进行一个操作并收集结果。例如：更新一个列表中的所有数据，可以用一个 for 循环轻松实现：counts=1,2,3,4 updated=for x in counts:updated.append(x+10)updated 11,12,13,14 由于这个操用很常见，所以 python 提供了一个内置工具 map 函数来完成这个任务，map 函数对在一个常列对象中的每一项都调用了一个传递的函数，并返回一个包含所有调用结果的列表。def inc(x):return x+10 map(inc,counts)11,12,13,14 python 的过

40、程 在 python 中 return 是可选的，所以不带 return 的函数就与其它语言中的过程等效。函数设计概念 1、输入用参数，输出用 return 语句。2、只在绝对必要时才用全局变量。全局变量通常是对函数通信的一种很不好的工具。3、不要改变参数除非调用者期望这样做。函数是对象：非直接调用 因为函数在运行时是对象，可以写程序来处理它们。函数对象可以被赋值，传递给其它函数，在数据结构中存储等。def echo(test):print test echo(aa)aa x=echo#用 x 引用函数对象 x(hello)#给函数赋值 hello 函数的常见问题 局部名字静态检测 默认情况下

41、，python 把函数中赋值的名字归类为局部的。局域作用域探测是在 python 编译代码时检测的，而不是通过它们在运行时的赋值。x=1 def selector():print x#x 在一个全局作用域被发现 selector()#x 被解析为外部的 x。99 如果在引用后对 x 赋值，为发生什么？def selector():print x#x 还没存在 x=2 selector()#提示出错，得一个未定义的名字错误。Traceback(most recent call last):File,line 1,in-toplevel-selector()File,line 2,in selec

42、tor print x UnboundLocalError:local variable x referenced before assignment 解决办法 如果想打印全局变量 x，应该在一个 global 语句中声明它。嵌套的函数不是嵌套的作用域，不要指望作用域在 python 中嵌套。第五章 模块 这一章介绍 python 的模块-最高级的程序组织单位。import 允许客户按整体取得一个模块 from 允许客户从一个模块中取得某些特定的名字 reload 提供了一种无需停止 python 就可以重载模块代码的方法 为什么要使用模块 1、代码重用。2、系统名字空间的划分。是组织系统组件

43、的工具。3、实现服务或数据的共享。只要一个模块，就可以被多个客户导入。模块基础 生成模块的形式：python 文件，C 扩展程序，很多 python 的内置工具事实上都是导入的 C 扩展模块。使用模块：import,from,reload()模块查找路径：PYTHONPATH 定义 模块文件以.py 后缀结尾，文件名不要与保留字重名。用法 import 模块名 from 模块名 import xxx from 模块名 import*模块文件就是名字空间 1、模块语句在第一次导入时执行 2、顶层赋值生成模块的属性，在导入过程中，在文件顶层赋值名字的语句（=，def）生成模块对象的属性，赋值的名字

44、在模块的名字空间存储 3、模块的名字空间：可用_dict_,or dir()访问。4、模块文件是单一作用域的（局部的就是全局的）。名字限定 简单变量 x 代表在当前作用域中查找名字。限定 x.y 代表在 x 对象中查找 y 属性。限定路径 x.y.z 代表在对象 x 中查找名字 y，再在对象 x.y 中查找 z。一般性 限定可以对所有拥有属性的对象工作：模块，类，C 类型等。导入模式 导入只发生一次。模块在第一次 import 或 from 的时候载入运行，默认情况下，每个过程 python 只执行一次。可用以初始化变量。import 或 from 都是赋值 1、import 把整个模块对象赋

45、值给一个名字。2、from 把一个或多个名字赋值给另一个模块中的同名字对象。重载模块 使用 reload()函数强迫一个已经载入的模块代码重新载入。模块编译模式 与 java 相同，python 程序被编译为一种称之为字节码的中间形式。它在一个虚拟机的东西上运行。python 在模块第一次导入时自动把它们编译成字节 码，而且，它保存在一个文件中，以.pyc 为后缀。如果.py 源文件更改，python会智能化地在导入时重新编译。编译过和.pyc 文件是一种可以不用 源代码发放系统的方法。由于 python 的字节码是可移植的，你通常可以在多平台上执行.pyc 文件。也可以把 python 程序

46、变为 C 语言的可执行形式，用标准的freeze 工具打包字节码就可生成一个 C 程序。_name_ 和_main_ 1、如果文件作为程序运行，在启动时，_name_设定为字符串_main_。2、如果文件是被导入的，_name_被设为用户已知的模块名。结果，模块可以检测自已的_name_，决定是运行还是被导入。第六章 类 类是 python 面向对象编程的主要工具，它是可选的。为什么要使用类 继承(inheritance)，一次编程，多次重复作用。合成(composition)，协调各部份工作。三个关键特征：1、多个实例，类是一个产生一个或多个实例的模板，每次调用一个类，就产生一个具有不同名字

47、空间的对象，每个由类产生的对象可以访问类的属性，但有各自不同的存放数据的名字空间。2、通过继承来定制。通过覆盖（override）它们的属性来扩展。通过继承可以定义名字空间的层次。3、操作符重载。通过提供特列的协议方法，对内置类型适用的操作符也适用于类定义的对象，例如可以对用户自定义的对象使用分片，合并，索引等操作。类的基础知识 1、class 语句创建一个类对象并赋给它一个名字。2、class 语句内部的赋值生成类的属性。3、象调用函数一样调用类就生成一个新实例对象。4、每个实例对象都继承了类的属性，并有自已的名字空间。5、方法中对 self 的赋值就生成了实例的属性。在类的方法中，第一个参

48、数，按贯例称为 self 引用的是要处理的实例对象，对 self 的属性的赋值，创建或改变的是实例中的数据，而不是类的数据。一个例子：class firstclass:#定义一个类对象 def setdata(self,value):#定义类方法 self.data=value#self 就是实例 def display(self):print self.data#self.data:每个实例的数据 x=firstclass()#生成实例 x.setdata(class test)#调用方法，self 是 x。x 是没有自已的 setdata，它会沿链接到类里找。这就是继承的运行机制。x.di

49、splay()#调用方法。class test 通过继承来定制类 与模块不同，类可以产生新部件（子类，subclass）而不必影响已存在的部分，这使我们可以创建一个类层次，较低的类通过覆盖属性而获得特定的行为，这通常被称为框架（framework）。这个机制背后的恩想是：1、超类列在类首部的括号里，如 class secondclass(firstclass)。2、类从超类继承属性。3、实例从所有相关类中继承，包括超类。4、通过子类改变逻辑，而不是直接改变超类。在子类中覆盖超类里的名字，子类就覆盖了继承的行为。一个例子：class secondclass(firstclass):#继承了 se

50、tdata def display(self):#改变了 display print current value=%s%self.data z=secondclass()z.setdata(11)z.display()#新的 display 语句 current value=11 类可以重载 python 的操作符 操 作符重载使我们的对象与内置的一样。_X_的名字的方法是特殊的挂钩（hook），python 通过这种特殊的命名来拦截操作符，以实现重载。python在计算操作符时会自动调用这样的方法，例如：如果对象继承了_add_方法，当它出现在+表达式中时会调用这个方法。通过重载，用户定义