Python学习：Python学习总结-资料大全 |

显示不全请点击全屏阅读

1. 1.     Python基础

1.1.     概述

Python是一个脚本解释器, 可以从命令行运行脚本, 也可以在脚本上双击, 象运行其他应用程序一样。它还是一个交互 shell, 可以执行任意的语句和表达式。

Python 的交互 shell 可以计算任意的 Python 表达式, 包括任何基本的数学表达式。交互 shell 可以执行任意的 Python 语句, 包括 print 语句。也可以给变量赋值, 并且变量值在 shell 打开时一直有效（一旦关毕交互 Sheel , 变量值将丢失）。

表格 1 编程语言数据类型的比较

 

1.2.     函数声明

def function_name([arguments]):

    ‘optional documentation string’

    function_suite

a．  arguments参数之间用逗号隔开。Python函数定义中不需要提定返回值的数据类型，也不需要指定是否有返回值。每个 Python 函数都返回一个值；如果函数执行过 return 语句, 它将返回指定的值, 否则将返回 None ( Python 的空值) 。Python 中没有子程序，只有函数, 所有的函数都有返回值,并且所有的函数都以 def 开始。

b．  文档化函数：函数声明后第一个没有赋值的字符串，也可使用三引号括起。使用函数的属性__doc__来调用这个字符串。

def buildConnectionString(params):

    “””Build a connection string from a dictionary of parameters.

 

    Returns string.“””

c．  print语句实用规则是print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout)，Python的print语句调用str()函数显示对象，交互式解释器则调用repr()函数来显示对象。

表格 2 对新Python程序员有用的内建函数

 

1.3.     Python常用习惯

a．  反斜杠（\）继续上一行，Python文件以模块形式组织。下划线（_）返回最后一个表达式的值。

b．  命令行选项：

-d 提供调试输出

-o生成优化字节码（pyo文件）

-s 不导入site模块以启动时查找Python路径

-v 冗余输出（导入语句详细追踪）

-m mod 将一个模块以脚本形式输出

-Q opt 除法选项

-c cmd 运行时以命令行字符串形式提交的Python脚本

file 从给定的文件运行Python脚本

c．  raw_input()内建函数：读取标准输入，并将读取到的数据赋值给指定的对象，键入EOF字符则引发EOFError。可以加在脚本最后一行，用来使程序执行时保持窗口开着。Python中函数input和raw_input可以看做是def input(prompt):return eval(raw_input(prompt)) 即调用eval函数来看输入是什么，实际上你甚至可以输入表达式，Python会计算表达式的值来返回。

d．  Python 函数没有明显的 begin 和 end, 没有花括号, 用于标函数的开始和结束。 唯一的分隔符是一个冒号 (:), 接着代码本身是缩进的。Python 使用硬回车来分割语句, 冒号和缩进来分割代码块。C++ 和 Java 使用分号来分割语句, 花括号来分割代码块。

e．  可使用help（函数名）来查询相应函数帮主信息。

 

1.4.     标识符

a．  任何时刻只有一个名字绑定，不支持重载标识符。内建（built-in）是__builtins__模块的成员，由解释器自动导入，可看作是任何一级的Pythong代码的全局变量。

b．  专用下划线标识符：_xxx不用‘form modules import *’导入，_xxx_系统定义的名字，_类中私有变量名。

c．  系统变量__name__决定运行是的模块是被导入还是直接执行：为模块名则导入，为‘__main__’则直接运行。

d．  “Pythonic”：以Python的方式去编写代码、组织、逻辑和对象行为。

表格 3 Python关键字

and	as	assert	break
class	continue	def	del
elif	else	except	exec
finally	for	from	global
if	import	in	is
lambda	not	or	pass
print	raise	return	try
while	with	yield	None

 

1.5.     变量声明

myParams = <表达式>

a．  命名规则：以字母或下划线开头，其他字符可以是数字、字母或下划线。大小写敏感。Python是动态类型语言，不需要预先声明变量类型，变量值和类型在赋值时被初始化。

b．  Python赋值语句不返回值，不支持类似x++或—x这样的单目双重运算符，允许符合赋值（*=）、多重赋值和“多元”赋值

c．  变量的赋值可以是一条被分成了多行的命令, 用反斜线 (“\”) 作为续行符，当一条命令用续行符 (“\”) 分割成多行时, 后续的行可以以任何方式缩近, 此时 Python 通常的严格的缩近规则无需遵守。

d．  Python 有局部变量和全局变量之分, 但没有明显的变量声明。变量通过首次赋值产生, 当超出作用范围时自动消亡。Python 不允许引用一个未被赋值的变量, 试图这样做会引发一个异常。

e．  Python的一种编程简写是一次使用序列来给多个变量赋值。Python 中，可以使用内置的 range 函数和多变量赋值的方法来快速进行赋值，与C++中的枚举相似。如：

(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)

 

1.6.     注释

a．  使用#符号标示注释；

b．  在模块、类或者函数起始添加一个字符串起文档作用；

c．  使用三引号标示注释。

 

1. 2.     数据类型

2.1.     基本数据类型

有符号整型、长整型（仅受限于用户计算机的虚拟内存总数，可由整型自动转换）、布尔值、浮点值、复数（a+bj或a+bJ）

△     引入decimal模块使用decimal类型（十进制浮点型）

？二进制表示中有一个无限循环：1.1 → 1.10000……1

a．  复数拥有real、imag、conjugete（）属性，coerce（）内建函数实现强制类型转换。

b．  除法引入指令from __future__ import division使整型除法保留小数部分,//操作符执行“地板除”。浮点数取余表达式：x-(math.floor(x/y)*y)；复数取余表达式：x-(math.floor((x/y).real)*y)

c．  冥运算比其左侧操作数的一元操作符优先级高，比其右侧操作数的一元操作符的优先级低。？4xx-1报错

d．  Python支持标准位运算（仅适用于整型）：取反（~），按位与（&），或（|）和异或（^）、左移（<&lt;）、右移（>&gt;）

△     复数当成正数的2进制补码处理；

△     左移好右移N位等同于无溢出检查2的N次幂运算：2**N；

△     对长整形，位操作符使用一种未修改的2进制补码形式，使得符号位无限向左扩展。

数字类型相关模块：decimal（十进制浮点运算类Decimal）、array（高级数字数组）、math/cmath（标准C库数学运算函数，复数在cmath中）、operator（数字操作符的函数实现）、random（各种伪随机数生成器）

表格 4 数值工厂函数

表格 5 数值运算内建函数

表格 6 仅适用于整型的内建函数

 

 

2.2.     映射和集合类型

字典（Dictionary）：Python中唯一映射类型，作为可变的哈希表实现。

dictionaryName = {“key1“:”value1“, “key2“:”value2“……}

1. Dictionary定义了键和值之间一对一的关系,变量可以任意取名，Python在内部会记录下其数据类型。value可以为任意的数据类型，key的要求较为苛刻一些。
2. 重复赋值, 将简单覆盖原有的值。Dictionary 的 key 是大小写敏感的。可以通过key来引用value，不能通过value引用key。
3. 字典相关函数：type()、str()、cmp()；映射类型相关函数：dict()、len()、hash()。del dictionaryName[“key“]删除dictionary中独立元素；dictionaryName.clear（） 删除dictionary中所有元素。例7.1、7.2

表格 7 映射类型内建方法

1. d.      集合对象（Set）是一组无序排列的可哈希的值。集合类型操作符：in，not in，布尔操作符，联合（|）、交集（&）、差补（）、相对补集（-）、对称差分（^）（=、&=、-=、^=）

表格 8 集合类型的操作符、函数和方法

函数/方法名	等价操作符	说明
所有集合类型
len(s)		集合基数：集合s中元素个数
set([obj])		可变集合工厂函数：ojb必须是支持迭代的，由obj中的元素创建集合，否则创建一个空集合
frozenset([obj])		不可变集合工厂函数：执行方式好set()方法相同，但它返回的是不可变集合
	obj in s	成员测试
	obj not in s	非成员测试
	s == t	等价测试
	s != t	不等价测试
	s < t	（严格意义上）子集测试
s.issubset(t)	s <= t	子集测试
	s > t	（严格意义上）超集测试
s.issuperset(t)	s >= t	超集测试
s.union(t)	s | t	合并操作
s.intersec-tion(t)	s & t	交集操作
s.difference(t)	s – t	差分操作
s.symmetric_fifference(t)	s ^ t	对称差分操作
s.copy()		赋值操作：返回s的（浅复制）副本
仅适用于可变集合
s.update(t)	s |= t	（Union）修改操作：将t中的成员添加s
s.intersection_update(t)	s &= t	交集修改操作：s中仅包括s和t中共有的成员
s.difference_update(t)	s -= t	差修改操作：s中仅包括属于s但不属于t的成员
s.symmetric_difference_ update(t)	s ^= t	对称差分修改操作：s中包括仅属于s或仅属于t的成员
s.add(obj)		加操作：将obj添加到s
s.remove(obj)		删除操作
s.discard(obj)		丢弃操作：remove()的友好版本，如果s中存在ojb，从s中删除它
s.pop()		Pop操作：移除并返回s中的任意一个值
s.clear()		清除操作：移除s中的所有元素

 

2.3.     序列

序列类型操作符：成员关系操作符（in、not in）、连接操作符（+）、重复操作符（*）、切片操作符（[],[:],[::]）、切片索引的更多内容

序列类型函数(有返回值)：cmp(), len(), max(), min(), sorted(), reversed(), enumerate(), zip(), reduce(), sum(), list()和tuple()

表格 9 序列类型转换工厂函数

表格 10 序列类型可用的内建函数

 

2.3.1.   字符串（不可改变，比较操作中按照ASCII值的大小来比较）

a．  把重复操作z作为参数放在循环中进行是非常低效的；

b．  Python语法允许在源码中把几个字符串连在一起写，来构建新字符串，使用分号隔开，可加入注释；

c．  如果把一个普通字符串和一个Unicode字符串作连接处理，Python会在连接操作前先将普通字符串转换为Unicode字符串。

d．  字符串模板：原始字符串操作符（r/R）（原始字符串对每个字符都使用原意）；Unicode字符串操作符（u/U）。

e．  字符串类型函数（有返回值）：raw_input(), str(), unicode(), chr(), unichr(), ord()

f．  Python中允许使用三引号使一个字符串跨多行，并且可以包含换行符、制表符和其他特殊符号。

Unicode：P127

字符串内建函数：…………

表格 11 反斜杠开头的转义字符

表格 12 与字符串类型有关的模块

 

 

2.3.2.   列表（List）：（P145用列表模拟堆栈（stack.py）；P148用列表用作队列（queue.py））

listName = [“value1“, “value2“, “value3“, “value4“, ……]

1. List 是一个用方括号包括起来的有序元素的集合，可以类比Java中的ArrayList，保存任意对象, 并且可以在增加新元素时动态扩展。可以使用负的索引，它从数据序列的最后一个-1向前数起。
2. 可以通过指定2个索引得到 list 的子集,叫做一个“slice”。返回值是一个新的list,它包含了list中按顺序从第一个slice索引开始, 直到不包括第二个slice索引的所有元素。
3. List支持+、+=、*运算符和布尔运算符。

 

列表类型函数（无返回值）：

listName.append(“value“)  向 list 的末尾追加单个元素,不论什么数据类型。

    listName.insert(<索引>, “value“)  将单个元素插入到 list 中。

    listName.extend([“value1“, “value2“……])  用来连接 list。

    listName.count(value) 返回value在listName中出现的次数

 

listName.sort(func=None,key=None,reverse=None) func和key表示以指定方式比较各个元素，reverse为True则以反序排列。默认归并排序，复杂度为O(lg(n!))

    listName.reverse() 原地翻转列表

 

    listName.index(“value“)  返回value在listName中首次出现的索引，若无引发异常。

    “value” in listName  测试value是否在 listname内,返回True或False。

 

    listName.remove(“value“)  删除value在listName中首次出现的值。

    listName.pop() 返回listName最后一个元素，并删除。

 

△     Python 在布尔环境 (如 if 语句) 中几乎接受所有东西：0 为 false，其它所有数值皆为 true。空串 (“”) 为 false；其它所有字符串皆为 true。空list([])为 false；其它所有list皆为true。空tuple(())为false；其它所有tuple皆为true。空dictionary ({})为 false；其它所有dictionary皆为true；non-empty、non-zero为false。

△     总结上面一条得出，下列对象的布尔值是False：None、False（布尔类型）、所有值为零的数、0（整数）、0.0（浮点型）、0L（长整型）、0.0+0j（复数）、””空字符串、[]空列表、()（空元组）、{}（空字典）

 

2.3.3.   元组（Tuple）

tupleName = (“value1“, “value2“, “value3“……)

1. Tuple 是用小括号包括起来的有序元素的集合，一旦创建就不能以任何方式改变。只有一个元素的元组需要在元组分隔符里加上一个逗号（，）。可“hash”的对象？
2. Tuple 比 list 操作速度快，可以定义为常量集，作为程序的运行中不断地遍历它。
3. 对不需要修改的数据进行“写保护”, 可使代码更安全，也可以使用turple，如同拥有隐含的assert语句, 说明数据是常量。Tuple可以作为Dictionary中Key的参数。
4. Tuple只有in方法，用于判断Tuple中是否存在某元素。
5. 如果必须要改变这些值, 则需要执行 tuple 到 list 的转换 (需要使用一个特殊的函数)，Tuple 可以转换成 list, 反之亦然。

△     拷贝Python对象：浅拷贝和深拷贝

默认拷贝类型（浅拷贝）： 

1.完全切片操作；2.利用工厂函数；3.使用copy模块的copy函数。

深拷贝：创建一个新的容器对象，包含原有对象元素（引用）全新拷贝的引用，使用copy.deepcopy（）函数。

表格 13 与序列类型相关的模块

 

2.4.     格式化字符串

“%s…%s” % (value1,value2)

1. Python 支持格式化字符串的输出，使用方法和C语言中的sprintf 函数一样，最基本的用法是：对于字符串使用%s 的字符串中，对于整数类型使用%d，十进制浮点数类型使用%f，+%.xf表示有正负号的小数点后x位的十进制浮点数，默认情况下是6位精度。
2. Python中，字符串连接只能在被连接的每一个都是字符串时起作用，试图将一个字符串同一个非字符串连接会引发一个异常。

表格 14  字符串格式化符号

表格 15 格式化操作符辅助指令

 

2.5.     映射list

[<关于value的表达式> for value in listName]

a．  可以通过对list中的每个元素应用一个函数, 从而将一个list映射为另一个list。

b．  对list的解析并不改变原始的 list。

 

dictionaryName.keys() 返回一个无序的所有键的 list。

dictionaryName.values() 返回一个所有值的list，以 keys 返回的 list 顺序输出dictionaryName.items() 返回一个形如 (key, value) 的 tuple 的 list。

 

2.6.     连接list与分割字符串

（*）.join(listName) 连接一个list中的元素为一个字符串，*表示各元素间连接的符号。

anystring.split(delimiter,num) 分隔一个字符串，其中delimiter为字符串分隔符，num为可选参数，表示分割的次数。不带参数的 split 按照空格进行分割。

 

1. 3.     Python过程语句

3.1.     if语句

if expression:

    if_suite

elif expression2:

    elif_suite

……

else:

    else_suite

条件表达式（“三元操作符”）：X if C else Y

避免“悬挂”else：P191

C语言中，else与最近的if搭配，属于内部的if，C编译器编译时会忽略额外的空白；而Python使用缩进使用强制使代码正确对齐，让程序员来决定else属于哪一个if。但是在大块的代码嵌入到类似的框架中时，会产生很多错误。

 

3.2.     while循环

while expression:

    suite_to_repeat

 

3.3.     for循环

for iter_var in iterable:

    suite_to_repeat

1. 迭代字符串是，迭代变量只会包含一个字符。迭代序列的三种方法：序列项、序列索引、使用项和索引。while和for语句中可以使用else语句。

break语句、continue语句、pass语句

1. 迭代器和iter()函数：返回一个迭代器

Python中可迭代的对象：列表、字典、文件。新的三个内建字典方法定义迭代：~.iterkeys(),~.itervalues(),~.iteritems()。一个实现了__iter__()和next()方法的类可作为迭代器。

 

1. 列表解析（P206矩阵样例，磁盘文件样例）

[expr for iter_var in iterable]

[expr for iter_var in iterable if cond_expr]

1. 生成器表达式

特定的函数，允许返回一个值，然后“暂停”代码的执行，稍后恢复。并不真正创建数字列表，而是返回一个生成器，在每次计算出一个条目后，将它“产生”（yield）出来。使用了“延迟计算”（lazy evaluation），在使用内存上更有效。（P207例子）

1. range(start,end,step=1） 返回值为一个列表

简略形式：range(end)  start默认为0

          range(start,end)

xrange类似range()不在内存中创建列表完整拷贝，大范围列表是用在for循环中。

与序列相关的内建函数：sorted(),reversed(),enumerate(),zip()，P198例子

 

1. 4.     文件对象

4.1.     文件内建函数（open()和file()）

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

a．  open 方法可以接收三个参数：文件名，模式，和缓冲区参数。如果没有指定，文件以文本方式打开。（print open.__doc__ 会给出所有可能模式的很好的解释。）文件的打开主要有三种模式：”Append”（打开模式简写a）模式在写入数据时追加到文件尾，”write”（打开模式简写w）模式在写入数据时将覆盖文件的原有内容，”Read_Only”（打开模式简写r）模式仅用于读取文件内容。

b．  open 函数返回一个对象，对象mode属性返回文件打开模式，name属性返回打开的文件名。

c．  工厂函数file()同open()。

d．  文件对象的newlines属性会记录文件的行结束符。UNS（Universal NEWLINE Support通用换行符）

表格 16 文件对象的访问模式

 

4.2.     文件对象内建方法

4.2.1.   输入

read() 直接读取字节到字符串中

readline() 读取打开文件的一行，返回包含行结束符的字符串

readlines() 读取所有（剩下的）行，把它们作为一个字符串列表返回

△     保留行结束符：使用输入方法从文件读取行时，需要手动删除行结束符；使用输出方法时需要手动加入行结束符。

△     行分隔符和其他文件系统的差异：在POSIX系统上，行分隔符是换行符NEWLINE（\n）字符，旧的MacOS下是RETURN（\r），DOS和Wind32系统下结合使用了两者（\r\n）。路径分隔符（POSIX使用“/”；DOS和Windows使用“\”；旧版的MacOS使用“:”）用来分隔文件路径名、标记当前目录和父目录。

表格 17 跨平台开发的os模块

 

4.2.2.   输出

write() 把含有文本数据或二进制数据块的字符串写入文件中

 

4.2.3.   文件内移动

seek() 移动文件指针到不同位置，0从文件头，1从当前位置，2从文件尾

tell() 返回当前文件指针位置，从文件起始算起，单位为字节

文件迭代：for eachLine in f:

 

4.2.4.   其他

close() 关闭文件，结束访问

fileon() 返回打开文件的描述符，整形数据

flush() 直接把内部缓冲区中数据立刻写入文件

isatty() 布尔函数，文件是类atty设备时返回True

truncate() 将文件截取到当前文件指针位置，或者给定size以字节为单位

 

4.3.     标准文件sys模块中stdin，stdout，stderr

4.4.     sys模块通过sys.argv属性提供了对命令行参数的访问，命令行参数是调用某个程序是除程序名以外的其他参数。C语言中argv是从命令行上输入的各个参数组成的字符串数组，argc是输入的参数的个数。Python中：sys.argv是命令行参数的列表，len(sys.argv)是命令行参数的个数。相关模块getopt,optparse

4.5.     文件系统

表格 18 os模块的文件/目录访问函数

 

表格 19 os.path模块中的路径名访问函数

 

4.6.     永久存储模块

将比基本类型复杂的对象转换为一个二进制数据集合，marshall模块只能处理简单的Python对象，pickle可以处理递归对象，被不同地方多次引用的对象，以及用类自定义的类和实例。shelve模块

相关模块P229表9.7

文件相关模块如下表：

表格 20 文件相关模块

 

1. 5.     异常处理

异常是因为程序出现了错误而在正常控制流以外采取的行为。

5.1.     try-except-else-finally语句

try:

       try_suite

except Exception1：

       suite_for_Exception1

……

else:

       no_exceptions_detected_suite

finally:

       always_execute_suite

a．  Python 使用 try…except 来处理异常，使用 raise 来引发异常。 Java 和 C++ 使用 try…catch 来处理异常，使用 throw 来引发异常。

b．  使用不存在的字典关键字将引发 KeyError 异常，搜索列表中不存在的值将引发 ValueError异常，调用不存在的方法将引发 AttributeError 异常。引用不存在的变量 将引发 NameError 异常。未强制转换就混用数据类型 将引发 TypeError 异常。

c．  一旦异常被处理了，处理通常在 try…except 块之后的第一行继续进行。注意这一行将总是打印出来，无论异常是否发生。

 

5.2.     触发异常

raise语句：raise [SomeException [, args[, traceback]]]

1. 参数一，是触发异常的名字，必须是一个字符串、类或实例；若有其他参数，则须提供SomeException.Python所有标准异常。见附录…………
2. 参数二，单一字符串来指示错误原因，元组则组成是一个错误字符串，一个错误编号，还可能是一个错误的地址。
3. 参数三，当异常触发时新生成的一个用于异常-正常化（exception-normally）的跟踪记录对象）。

 

5.3.     断言

assert expression [, arguments]

 

5.4.     sys模块中exc_info()函数可以获取异常信息，返回一个三元组（3-tuple）的信息。

exc_type：异常类

exc_value：异常类的实例

ex_traceback：跟踪记录对象

 

1. 6.     函数和函数式编程

6.1.     Python函数详解

declaration /definition def foo():print ‘bar’

function object /reference foo

function cal /invocation foo()

△     P269参数组

a．  Python函数可以返回一个值或者对象，默认为元组，若加括号则为列表

b．  存储元组返回值的方式3种

c．  函数调用中的关键字参数、默认参数

d．  Python支持内部/内嵌函数，除在函数体内，任何地方都不能对其进行调用

e．  装饰器：引入日志；增加计时逻辑来检测性能；给函数加入事务能力P277例11.2

 

 

6.2.     可变长度参数

Formal Arguments形参集合（位置和默认）：

使用*和**来指定元组和字典的元素作为非关键字及关键字参数。

a．  非关键字可变长参组（元组）：位于最后，元组保存所有传递给函数的“额外”的参数，如果没有则为空。

b．  关键字变量参数(字典)：使用双星号（**）。

c．  调用带有可变长参数对象：定义对象，在函数调用中传递的对象加上*和**。

 

6.3.     测试函数（例如：）

def testit(func, *nkwargs,**kwargs)

       try:

              retval=func(*nkwargs,**kwargs)

              result=(True,ritual)

       except Exception,diag

              result=(False,str(diag))

       return result

 

6.4.     函数式编程

1. 匿名函数与lambda：lambda[args1[,args2,…argsN]]:ecpression使用lambda关键字创建匿名函数。用合适的表达式调用一个lambda生成一个可以像其它函数一样使用的函数对象。可被传递给其他函数，用额外的引用别名化，作为容器对象以及作为可调用对象被调用。
2. 内建函数apply(),filter(),map(),reduce():P288表11.2

a)       from random import randict as ri

print [n for n in [ri(1,99) for I in range(9)]if n%2]

b)       map(lambda x,y:(x+y,x-y),[1,3,5],[2,4,6])

c)       reduce((lambda x,y:x+y),range(5))

函数式编程的内建函数如下表：

表格 21 函数式编程的内建函数

 

1. 偏函数应用：Currying能泛化成为偏函数引用（partial function application，PFA），这种函数将任意数量（顺序）的参数的函数转化为另一个带剩余参数的函数对象。

from functions import partial

basetwo = partial(int,base=2)

 

6.5.     变量的作用域

局部作用域内为了明确引用全局变量使用关键字global。

闭包

def counter(start_at=0):

       count=[start_at]

       def incr():

              count[0]+=1

              return count[0]

       return incr

 

6.6.     递归

6.7.     生成器

import generators form __future__

yield ~送回生成器[send()]，生成器退出[close()]

 

def counter(start_at=0):

       count=start_at

       while True:

              val=(yield count)

              if val is not None

                     count=val

              else count+=1

 

1. 7.     模块（自我包含并且有组织的代码片段）

7.1.     名称空间：名称（标识符）到对象的映射

a．  向名称空间添加名称操作过程涉及绑定标识符到指定对象的操作（引用计数加1）；

b．  Python解释器加载名称空间顺序：内建~，执行模块的全局~，（两个活动~）；执行期间调用函数将创建第三个名称空间（局部~），通过globals()和locals()内建函数判断属于哪个~；

c．  __builtins__模块包含__builtin__模块（包含内建函数，异常和其他属性）和内建名称空间中内建名字的集合；

d．  作用域：指出了从用户代码的哪些物理位置可以访问名称（标识符）；

e．  无限制的名称空间：可以在任何需要放置数据的地方获得一个名称空间。

完整授权名称（fully qualified）、路径搜索（查找某个文件的操作）、搜索路径（查找一组目录）；默认搜索路径：sys.path。

 

7.2.     导入模块（遵循作用域原则）

模块导入方法：①import语句；②form-import语句；③多行导入（行尾使用\符号）；④扩展的import语句（as）。

a．  模块导入几点注意：

a)       限制使from modual import *“污染当前名称空间。两种场合建议使用：1.目标模块属性多，反复键入模块名行不方便；2.交互解释器下，减少输入次数。

b)       sys.modual.keys()查看当前载入到解释器的模块组成字典的模块名；

c)       阻止属性导入：使用from modual import*时，可以给不想导入的属性名称前加下划线（_），但导入整个模块或显示地导入某个属性时不起作用；

d)       不区分大小写的导入（？PYTHONCASEOK环境变量）

e)       模块头部加入一个额外的编码表示说明可以让导入者使用指定的编码解析你的模块，例：

#!user/bin/envpython

#_*_coding:UTF-8-**

f)      导入循环?

g)       模块执行（命令行、shell、execfile()、模块导入、解释器的-m选项等）；相关模块：modulefinder, pkgutil, zipimport

b．  只从模块导入名字会成为局部名称空间的一部分，可能覆盖一个已经存在的具有相同名字的对象。使用import和完整标识符名称（名字属性标识）解决。

c．  from __future__ import new_future“导入”新特性，用户可以尝试新特性或特性变化，以便在特性固定下来的时候修改程序。

d．  警告框架：①应用程序（员）接口（Application programmer’s interface API）；②警告过滤器（警告会有一个默认的输出显示到sys.stderr。命令行也可控制警告过滤器，使用-w选项）

e．  从zip文件中导入模块：把zip文件当做目录处理，在文件中搜索模块。

 

7.3.     模块内建函数

a．  __import__(modual_name[,globals[,locals[,fromlist]]])可以使用自定义导入算法覆盖原函数

b．  globals()和locals()返回调用者全局和局部名称空间的字典，全局名称空间下两函数返回值相同。

c．  reload(modual)重新导入一个已经导入的模块（全部且成功导入）

 

7.4.     包

有层次的文件目录结构，定义了一个由模块和子包组成的Python应用程序执行环境。和模块相同，也使用句点属性标识来访问他们的元素，使用标准的import和from –import语句导入包中模块。

P321引入包的作用

 

1. 8.     Python面向对象

8.1.     Python对象概述

a．  Python使用对象模型来存储数据，构造任何类型的值都是一个对象，所有Python对象都有以下三个特性：身份（id()查看，被认为是该对象的内存地址）、类型（type()查看）和值。所有Python类型的根和所有Python标准累的 默认元组（metaclass）即type。对象的身份比较：obj1 is (not) obj2或id(obj1) == id(obj2)。Python仅缓存简单整型。

b．  Python内部对象

a)       代码：编译过的Python源代码片段，compile()执行exec命令或eval()内建函数，用户自定义函数核心。

b)       帧：标识Python的执行栈帧，包含Python解释器运行时需要知道的所有信息。

c)       跟踪记录：异常发生时，一包含针对异常的栈跟踪信息的跟踪记录对象被创建。

d)       切片对象：

e)       省略对象：用于扩展切片语法中起记号作用，表示省略号。

f)       XRange对象：

c．  工厂函数：即类对象，当调用时，实际是创建了一个类实例。

 

8.2.     类属性

a．  Python不支持纯虚函数或者抽象方法，这些都是强制在子类中定义方法。作为替代方法，可以简单地在基类方法中引发NotImplementedErrer异常，获得类似效果。

查看类属性：①使用dir()内建函数；②访问类的字典属性__dict__（所有类都具备的特殊属性之一）。__doc__是类的文档字符串，不被派生类继承。

表格 22 特殊类属性

 

b．  命名类属性和方法：①类名以大写字母开头，数据属性听起来应当是数据值的名字，方法名应当指出对应对象或值的行为；②数据值使用名词作为名字，方法使用谓词（动词加对象）。

 

8.3.     类实例

a．  __init__()构造器方法

b．  __new__()构造器方法 （见13.11.3）

c． __del__()解构器方法，直到该实例对象所有引用都被清除掉后才会执行（P343 DEL方法使用总结）

△     跟踪实例：使用静态成员记录实例个数，显式加入一些代码进入类定义或__init__()和__del__()中

 

8.4.     实例属性（能够中“运行时”创建实例属性）

a．  构造器中首先设置实例属性；默认参数提供人都市里安装；__init__()应当返回None；内建实例属性使用dir()查看，不存在__dict__属性；给一个与类属性同名的实例属性赋值，会有效地“隐藏”类属性，若类属性可变则无法删除修改后实例属性，修改类属性使用类名而不是实例名。

b．  使用dir()查看所有实例属性（同样可用于查看类属性）；

c．  特殊实例属性：I.__class__实例化I都类，I.__dict__I都属性；

d．  可修改类和实例中__dict__属性，但要重载__setattr__方法。

 

8.5.     绑定与方法调用（）

调用绑定方法：self参数不需要明确地传入；

调用非绑定方法：必须传递self参数。

 

8.6.     静态方法和类方法

a．  使用staticmethos()和classmethos()内建函数进行转换；

b．  使用函数修饰符(@staticmethos和@classmethos)。

 

8.7.     继承

a．  使用类与其他数据类型及逻辑执行流混合使用都方法：组合、子类和派生类；

class SubClassName(ParentClass1 [, ParentClass2,…])

               ‘class_suite’

b．  文档字符串对类、函数/方法、模块来说都是唯一的，特殊属性__doc__不会从基类中继承过来；__base__类属性，对任何（子）类，是一个包含其他父类（parent）的集合的元组，没有父类的类的属性值为空；

c．  使用super()内建函数显式地调用父类方法；重写__init__不会自动调用基类的__init__； super(子类名,self).__init__() <=> 基类名.__init__(self)

d．  从标准类型派生：

不可变类型class RoundFloat(float):

             def __new__(cls,val):

                 return super(RoundFloat,cls).__new__(cls,round(val,2)

可变类型  class SortedKeyDict(dict):

             def keys(self):

                 return Sorted(super(SortedKeyDict,self).keys())

1. 多重继承（要点：1.找到合适都属性；2.重写方法时，如何调用对应父类方法，“以发挥它们的作用”，同时在子类中处理好自己的义务。）

a)       方法解释顺序（MRO）：经典类使用深度优先，从左至右的查找顺序；新式类使用广度优先，首先查找同胞兄弟。

（新式类属性__mro__显示查找都顺序）

b)       棱形效应引起MRO问题

 

8.8.     类、实例和其他对象都内建函数

表格 23 类、实例和其他对象都内建函数

 

8.9.     用特殊方法定制类

示例：例13.2 P371 roundFloat2.py、P374 例13.3 time60.py、例13.4 randSeq.py

a．  迭代器

a)       RandSeq（RANDom SEQuence的缩写）（无损地读取一个序列，不会越界，永远不会引发StopIteration异常）；

b)       AnyIter（ANY number of items ITERator）（同时给出一个安全标示符（safe）来创建这个对象，为真则在遍历完这个迭代器前，返回所获取的任意条目；若为假，则在用户请求过多条目时，引发异常。示例P376 例13.5 anyIter.py

b．  多类型定制（NumStr）示例P378 例13.6 numstr.py

表格 24 定制类的特殊方法

特殊方法	描述
基本定制型
C.__init__(self[,arg1,…])	构造器（带一些可选参数）
C.__new__(self[,arg1,…])	构造器；通常用在设置不变数据类型的子类
C.__del__(self)	解构器
C.__str__(self)	可打印的字符输出；内建str()及print语句
C.__repr__(self)	运行时的字符串输出；内建repr()和‘’操作符
C.unicode__(self)	Unicode字符串输出；内建unicode()
C.__call__(self,args)	表示可调用的实例
C.__nonzero__(self)	为object定义False值；内建bool()
C.__len__(self)	“长度”；内建len()
对象（值）比较
C.__cmp__(self,obj)	对象比较；内建cmp()
C.__lt__(self,obj) and C.__le__(self,obj)	小于/小于或等于；对应<及&lt;=操作符
C.__gt__(self,obj) and C.__ge__(self,obj)	大于/大于或等于；
C.__eq__(self,obj) and C.__ne__(self,obj)	等于/不等于；
属性
C.__getattr__(self,attr)	获取属性；内建getattr()，仅当属性没有找到时调用
C.__setattr__(self,attr,val)	设置属性
C.__delattr__(self,attr)	删除属性
C.__getattribute__(self,attr)	获取属性；内建getattr()；总是被调用
C.__get__(self,attr)	（描述符）获取属性
C.__set__(self,attr)	（描述符）设置属性
C.__delete__(self,attr)	（描述符）删除属性
定制类/模拟类型
数值类型：二进制操作符
C.__*add__(self,obj)	加；+操作符
C.__*sub__(self,obj)	减；-操作符
C.__*mul__(self,obj)	乘；*操作符
C.__*div__(self,obj)	除；/操作符
C.__*truediv__(self,obj)	True除；/操作符
C.__*floordiv__(self,obj)	False除；//操作符
C.__*mod__（self,obj）	取模/取余；%操作符
C.__*divmod__(self,obj)	除和取模；内建divmod()
C.__*pow__(self,obj[,mod])	乘幂；内建pow()；**操作符
C.__*lshift__(self,obj)	左移位；&lt;&lt;操作符
定制类/模拟类型
数值类型：二进制操作符
C.__*rshift__(self,obj)	右移；>&gt;操作符
C.__*and__(self,obj)	按位与；&操作符
C.__*or__(self,obj)	按位或；|操作符
C.__*xor__(self,obj)	按位与或；^操作符
数值类型：一元操作符
C.__neg__(self)	一元负
C.__pos__(self)	一元正
C.__abs__(self)	绝对值；内建abs()
C.__invert__(self)	按位求反；~操作符
数值类型：数值转换
C.__complex__(self,com)	转为complex（复数）；内建complex()
C.__int__(self)	转为int；内建int()
C.__long__(self)	转为long；内建long()
C.__float__(self)	转为float；内建float()
数值类型：基本表示法（String）
C.__oct__(self)	八进制表示；内建oct()
C.__hex__(self)	十六进制表示；内建hex()
数值类型：数值压缩
C.__coerce__(self,num)	压缩成同样的数值类型；内建coerce()
C.__index__(self)	必要时压缩可选的数值类型为整型
序列类型
C.__len__(self)	序列中项的数目
C.__getitem__(self,ind)	得到单个序列元素
C.__setitem__(self,ind,val)	设置单个序列元素
C.__delitem__(self,ind)	删除单个序列元素
C.__getslice__(self,ind1,ind2)	得到序列片段
C.__setslice__(self,i1,i2,val)	设置序列片段
C.__delslice__(self,ind1,ind2)	删除序列片段
C.__contains__(self,val)	测试序列成员；内建in关键字
C.__*add__(self,obj)	串连；+操作符
C.__*mul__(self,obj)	重复；*操作符
C.__iter__(self)	创建迭代类；内建iter()
映射类型
C.__len__(self)	mapping中的项的数目
C.__hash__(self)	散列（hash）函数值
C.__getitem__(self,key)	得到给定键（key）的值
C.__setitem__(self,key,val)	设置给定键（key）的值
C.__delitem__(self,key)	删除给定键（key）的值
C.__missing__(self,key)	给定键如果不存在字典中则提供一个默认值

 

8.10.  私有化

1. Python的默认属性都是“公开的”；
2. 双下划线（__）：私有性的初步形成（）
3. 单下划线（_）：简单的模块级私有化只需要中属性名前使用一个单下划线字符，防止模块的属性用”from mymodule import *”加载，这种严格是基于作用域，也适用于函数。

 

8.11.  授权（P386 例13.7 twrapme.py）

 

 

 

8.12.  新式类的高级属性

1. Python中工厂函数：init(),long(),float(),complex(),str(),unicode(),list() tuple(),type()；（新加入）basestring(),dict(),bool(),set(),frozenset() object(),classmethod(),staticmethod(),super(),property(),file()
2. __slots__类属性：可替代属性__dict__，是一个类变量，由一序列对象组成，由所有合法标识符构成的实例属性的集合来表示，可以是元组、列表或可迭代对象或简单的字符串，试图创建非__slots__中名字的实例属性将导致AttributeError异常。
3. __getattribute__()特殊方法？P394 例13.9 descr.py
4. 描述符

a)       __get__(),__set__()和__delete__()特殊方法；

b)       优先级别：类属性-&gt;数据描述符-&gt;实例属性-&gt;非数据描述符；

c)       属性和property()内建函数   –&gt; 默认为__getattr__()？

1. 元类和__metaclass__（元类[MetaClasses]赋予你如何创建类的控制权，传统类的元素是types.ClassType）P402 例13.10 meta.py

表格 25 与类相关的模块

 

1. 9.     执行环境

9.1.     可调用对象（Python有4种可调用对象：函数、方法、类和一些类的实例）

9.1.1.   函数

a．  内建函数（BIF）：用C/C++写的，编译后放入Python解释器，作为第一（内建）名称空间的一部分加载进系统。这些函数中__bulitin__模块中，作为__builtins__模块导入到解释器中。

表格 26 内建函数属性

b．  用户定义的函数（UDF）：定义在模块最高级，作为全局名称空间都一部分装载到系统中。

表格 27 用户自定义函数属性

c．  lambda表达式（名为“<lambda>”的函数）

9.1.2.   方法

a．  内建方法（BIM）

如下是内建方法的属性：

表格 28 内建方法的属性

 

b．  用户定义的方法（UDM）：包含在类定义中，只有标准函数都包装，仅有定义它们都类可以使用。

表格 29 用户自定义方法的属性

 

9.1.3.   类：“调用”类的结果便是创建了实例

9.1.4.   类的实例：Python给类提供了名为__call__的特殊方法，允许程序员创建可调用对象（实例），默认情况没有实现该方法，即大多数实例都是不可调用的。

 

9.2.     代码对象（每个可调用物的核心都是代码对象，可以作为函数或者方法调用的一部分来执行，也可用exec语句或内建函数eval()来执行。整体上，一个Python模块的代码对象是构成该模块全部代码。

 

9.3.     可执行对象声明和内建函数

P421 例14.1 loopmake.py、P425 例14.2 funcAttrs.py

表格 30 可执行的对象声明和内建函数

 

9.4.     执行其他（Python）程序

a．  导入（在定义模块的执行语句前加入语句if __name– = ‘__main__’；

b．  execfile() =&gt; execfile(filename,globals=blobals(),locals=locals())；

c．  将模块作为脚本执行（可以使用命令行从工作目录中调用脚本$ myScript.py # or $ python myScript.py）

 

9.5.     执行其他（非Python）程序

表格 31 为外部程序执行提供的os模块（△代表Unix下，■代表Windows下）

1. a.    os.system()
2. b.    os.popen()
3. c.    os.fork()、os.exec()、os.wait()
4. d.    os.spawn()
5. e.    subprocess模块

表格 32 各种文件执行函数

 

9.6.     受限执行

在Python历史的某个时期，存在着使用了rexec和bastion模块的限制执行的概念。第一个模块允许沙盒（sandbox）中的执行代码修改内建对象。第二个模块用来过滤属性和包装你的类。但由于一个显著的缺点和弥补安全漏洞的困难，这些模块便被废弃了。

 

9.7.     结束执行

干净的执行表示当所有模块最高级的语句执行完毕后的退出，当遇到某种致命的错误或不满足继续执行的条件的时候，Python会提前退出。可以通过异常和异常处理，或者建造一个“清扫器”方法，把代码的主要部分放在if语句中，在没有错误的情况下执行，因而可以让错误的情况“正常地”终结。

1. sys.exit() and SystemExit

当调用sys.exit()时，会引发systemExit()异常。除非对异常进行监控，异常通常不会被捕捉到或处理的，解释器会用给定的状态参数退出，默认为0，exit()的任何整型参数都会以退出状态返回给调用者。sys.exit()经常用在命令调用的中途发现错误之后。

1. sys.exitfunc()

sys.exitfunc()默认是不可用的，可以修改它以提供额外的功能。在调用exit()退出解释器之前用到这个函数，如果sys.exitfunc已经被先前定义的exit函数覆盖了，则把这段代码作为exit()函数的一部分执行。通常exit函数用于执行某些类型的关闭活动，比如关闭文件和网络连接，最好用于完成维护任务，比如释放先前保留的系统资源。

1. os._exit()函数

os模块中的_exit()函数不是在一般应用中使用（平台相关，只是用特定的平台，比如基于Unix的平台，以及Win32平台）。语法是os._exit(status)，不执行任何清理便立即退出Python，状态参数是必需的。

1. os.kill() Function

os模块的kill()函数模拟传统的unix函数来发送信号给进程。kill()参数是进程标识数（PID）和想要发送的进程的信号。发送的典型信号为SIGINT、SIGQUIT、或更彻底地，SIGKIL来使进程终结。

 

9.8.     各种操作系统接口

表格 33 各种OS模块属性（△也适用于win32）

表格 34 相关模块

模块	描述
atexit	注册当Python解释器退出时的执行句柄
popen2	提供额外的在os.popen之上的功能：提供通过标准文件和其他进程交互的能力；对于Python2.4及以上版本，使用subpross()
commands	提供额外的在os.system之上的功能：把所有的程序输出保存在返回的字符串中（与输出到屏幕相反）；对于2.4及以上版本，使用subpross
getopt	在这样的应用程序中的处理选项和命令行参数
site	处理site-specific模块或包
platform	底层平台和架构的属性
subprocess	管理（计划替代旧的函数和模块，比如os.system()、os.spawn()、os.popen()、popen2.*和command.*）

 原文：http://www.lupaworld.com/home-space-do-blog-uid-294076-id-121557.html

Tags：

python资料,

如果您喜欢我的博客，欢迎点击图片定订阅到邮箱 也可以点击链接【订阅到鲜果】

如果我的想法或工具帮助到了你，也可微信扫下方二维码打赏本人一杯咖啡