python

一.Python 是一种高层次的结合了解释性、编译性、交互性和面向对象的高级程序设计语言。

二.python文件类型

　1.源代码：文件名以 .py为扩展名, 文件第一行 #! /usr/bin/python

    2.字节代码:  python源文件编译后文件, 以 .pyc为扩展名,  编译方法: import py_compile    py_compile.py_compile("hello.py")

　3.优化代码:  python源文件经过优化后的文件, 执行速度会更快, 以 .pyo为扩展名,  优化方式: python -o -m py_compile hello.py 

三.变量

   1.python变量是计算器内存中一块区域, 变量可以存储规定范围内的值, 而值可以变化, 与java不同的是, python变化的数据类型不固定

   2.变量命名: 由字母,数字,下滑线组成, 不能以数字开头, 不能使用关键字

   3.查询变化在内存中地址: id (变量名)

四.运算符和表达式

   1.赋值运算符: 变量算术运算完成后赋值给自己,  +=, -=, *=, /=, %= 

　2.算术运算符: 加减乘除 + - * / , // 整除,  %取余数, ** 幂运算( n**m  n的m次方), 数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。

　3.关系运算符: >, <, =, !=, ==完全等于(3==3.0)

　4.逻辑运算符: 与 and, 或 or ,非 not

　5.表达式: 将不同数据(包括变量,函数)用运算符按一定规则连接起来的式子

　6.运算符计算优先级:

运算符说明	Python运算符	优先级
小括号	()	20
索引运算符	x[index] 或 x[index:index2[:index3]]	18、19
属性访问	x.attrbute	17
乘方	**	16
按位取反	~	15
符号运算符	+（正号）或 -（负号）	14
乘、除	*、/、//、%	13
加、减	+、-	12
位移	>>、<<	11
按位与	&	10
按位异或	^	9
按位或	|	8
比较运算符	==、!=、>、>=、<、<=	7
is 运算符	is、is not	6
in 运算符	in、not in	5
逻辑非	not	4
逻辑与	and	3
逻辑或	or	2

五.数据类型

　1.数字(number):

int: 整型 (python3中没有long

float: 浮点型

bool: 在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

complex复数:  4+3j

　2.字符串(string): 单引号和双引号相同, """  """ 三引号中可以为段落, Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始

• print(str) # 输出字符串
• print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
• print(str[0]) # 输出字符串第一个字符
• print(str[2:5]) # 输出从第三个开始到第五个的字符
• print(str[2:]) # 输出从第三个开始的后的所有字符
• print(str * 2) # 输出字符串两次
• print(str + '你好') # 连接字符串
• print('hello\nrunoob') # 使用反斜杠(\)+n转义特殊字符
• print(r'hello\nrunoob') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义(这里的 r 指 raw，即 raw string)

　3.元组(tuple): 元组与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开，元组中的元素类型也可以不相同。

• 元组中可以包含list
• tup1 = () # 空元组
• tup2 = (20,) # 一个元素，需要在元素后添加逗号

　4.列表(list):

• print (list) # 输出完整列表
• print (list[0]) # 输出列表第一个元素
• print (list[1:3]) # 从第二个开始输出到第三个元素
• print (list[2:]) # 输出从第三个元素开始的所有元素
• print (tinylist * 2) # 输出两次列表
• print (list + tinylist) # 连接列表
• List中的元素是可以改变的  a[0] = 9
• Python 列表截取可以接收第三个参数，参数作用是截取的步长  b[0,5,2] 表示从0到5, 步长为2,隔一个取一个

　5.集合(set): 集合是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

       创建格式：

• parame = {value01,value02,...}
• set(‘asghhffg’)

       set可以进行集合运算：

• a = set('abracadabra')
• b = set('alacazam')
• print(a)
• print(a - b) # a 和 b 的差集
• print(a | b) # a 和 b 的并集
• print(a & b) # a 和 b 的交集
• print(a ^ b) # a 和 b 中不同时存在的元素s.

       集合的基本操作

• 添加元素: s.add(x) , s.update(x) ---参数可以是列表，元组，字典等
• 移除元素:  s.remove( x ),  s.discard( x ) ---如果元素不存在，不会发生错误,  s.pop()---随机删除一个元素, 在交互模式是删除第一个
• 清空元素: s.clear()

　6.字典(dictionary):  字典是无序的对象集合。字典当中的元素是通过键来存取的，是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。键必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。

• dict = {}
• dict['one'] = "1 - 菜鸟教程"
• dict[2] = "2 - 菜鸟工具"
• tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
• print (dict['one']) # 输出键为 'one' 的值
• print (dict[2]) # 输出键为 2 的值
• print (tinydict) # 输出完整的字典
• print (tinydict.keys()) # 输出所有键
• print (tinydict.values()) # 输出所有值

 六.条件控制

　if 语句:

• 每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
• 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 在Python中没有switch – case语句。

七.循环语句

　1.while 循环:

while 判断条件：
    语句
在 while … else 在条件语句为 false 时执行 else 的语句块

　2.for循环

• for <variable> in <sequence>:
• 　　<statements>
• else:
• 　　<statements>

　　for 实例中使用了 break 语句，break 语句用于跳出当前循环体

　3.range()函数:  你需要遍历数字序列，可以使用内置range()函数

• for i in range(5): 0-4
• for i in range(5,9): 5-8
• for i in range(0, 10, 3): 设置步长 0,3,6,9
• for i in range(len(a)): 遍历序列的索引
• list(range(5)): 创建一个列表

    4.break: break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

　5.continue: continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

　6.pass: pass是空语句，是为了保持程序结构的完整性，pass 不做任何事情，一般用做占位语句。

八.迭代器和生成器

 　1.迭代器

• 把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
• 如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。
• 更多内容查阅：Python3 面向对象
• __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
• __next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。
• StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

　2.生成器

• 在 Python 中，使用了 yield 的函数被称为生成器（generator）。
• 跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
• 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
• 调用一个生成器函数，返回的是一个迭代器对象。

 九.函数

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
• 在 python 中，类型属于对象，变量是没有类型的

　1.调用函数时的参数:

• 必需参数: 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
• 关键字参数: 关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值
• 默认参数: 调用函数时，如果没有传递参数，则会使用默认参数。
• 不定长参数:  一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。加了两个星号 ** 的参数会以字典的形式导入。声明函数时，参数中星号 * 可以单独出现, 但星号 * 后的参数必须用关键字传入。

 　2.匿名函数:

　　python 使用 lambda 来创建匿名函数。所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

　　语法

　　lambda 函数的语法只包含一个语句，如下：

　　　　lambda [arg1 [,arg2,.....argn]]:expression

　3.return语句

　　return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

十.数据结构
　1.列表

方法	描述
list.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x)	删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i])	从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear()	移除列表中的所有项，等于del a[:]。
list.index(x)	返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x)	返回 x 在列表中出现的次数。
list.sort()	对列表中的元素进行排序。
list.reverse()	倒排列表中的元素。
list.copy()	返回列表的浅复制，等于a[:]。

　2.元组
　　元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。
　3.字典

• 在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来
• 在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到
• 同时遍历两个或更多的序列，可以使用 zip() 组合
• 要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数
• 要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值

十一.模块 

• 模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。
• 每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。
• 所以，模块的作者可以放心大胆的在模块内部使用这些全局变量，而不用担心把其他用户的全局变量搞混。
• 从另一个方面，当你确实知道你在做什么的话，你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。
• 模块是可以导入其他模块的。在一个模块（或者脚本，或者其他地方）的最前面使用 import 来导入一个模块，当然这只是一个惯例，而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。
• 还有一种导入的方法，可以使用 import 直接把模块内（函数，变量的）名称导入到当前操作模块。
• 每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。
• 内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

 十二.输入和输出

　1.Python两种输出值的方式: 表达式语句和 print() 函数。

　第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

　如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

　如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

• str()： 函数返回一个用户易读的表达形式。
• repr()： 产生一个解释器易读的表达形式。

　2.读和写文件

　 open() 将会返回一个 file 对象，基本语法格式如下:

　　open(filename, mode)

• filename：包含了你要访问的文件名称的字符串值。
• mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

　　不同模式打开文件的完全列表：

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

• f.read()

　　为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

　　size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

• f.readline()

　　f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

• f.readlines()

　　f.readlines() 将返回该文件中包含的所有行。

　　如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

• f.write()

　　f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。

• f.tell()

　　f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

• f.seek()

　　如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

　　from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如： 

• seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
• seek(x,1) ： 表示从当前位置往后移动x个字符
• seek(-x,2)：表示从文件的结尾往前移动x个字符

　　from_what 值为默认为0，即文件开头。

• f.close()

　　在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。

　　当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

• with

　　处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:

　　>>> with open('/tmp/foo.txt', 'r') as f:
　　...     read_data = f.read()
　　>>> f.closed
　　True

　3.pickle模块　　

　　python的pickle模块实现了基本的数据序列和反序列化。

　　通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

　　通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

　　基本接口：

　　pickle.dump(obj, file, [,protocol])

　　有了 pickle 这个对象, 就能对 file 以读取的形式打开:

　　x = pickle.load(file)

　4.file对象

序号	方法及描述
1	file.close() 关闭文件。关闭后文件不能再进行读写操作。
2	file.flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3	file.fileno() 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4	file.isatty() 如果文件连接到一个终端设备返回 True，否则返回 False。
5	file.next() Python 3 中的 File 对象不支持 next() 方法。 返回文件下一行。
6	file.read([size]) 从文件读取指定的字节数，如果未给定或为负则读取所有。
7	file.readline([size]) 读取整行，包括 "\n" 字符。
8	file.readlines([sizeint]) 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9	file.seek(offset[, whence]) 设置文件当前位置
10	file.tell() 返回文件当前位置。
11	file.truncate([size]) 从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。
12	file.write(str) 将字符串写入文件，返回的是写入的字符长度。
13	file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

 十三.OS文件/目录方法 

序号	方法及描述
1	os.access(path, mode) 检验权限模式
2	os.chdir(path) 改变当前工作目录
3	os.chflags(path, flags) 设置路径的标记为数字标记。
4	os.chmod(path, mode) 更改权限
5	os.chown(path, uid, gid) 更改文件所有者
6	os.chroot(path) 改变当前进程的根目录
7	os.close(fd) 关闭文件描述符 fd
8	os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
9	os.dup(fd) 复制文件描述符 fd
10	os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2
11	os.fchdir(fd) 通过文件描述符改变当前工作目录
12	os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
13	os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
14	os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
15	os.fdopen(fd[, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
16	os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17	os.fstat(fd) 返回文件描述符fd的状态，像stat()。
18	os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。
19	os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。
20	os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
21	os.getcwd() 返回当前工作目录
22	os.getcwdu() 返回一个当前工作目录的Unicode对象
23	os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
24	os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接
25	os.lchmod(path, mode) 修改连接文件权限
26	os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。
27	os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src
28	os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。
29	os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
30	os.lstat(path) 像stat(),但是没有软链接
31	os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
32	os.makedev(major, minor) 以major和minor设备号组成一个原始设备号
33	os.makedirs(path[, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
34	os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
35	os.mkdir(path[, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
36	os.mkfifo(path[, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制)
37	os.mknod(filename[, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
38	os.open(file, flags[, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的
39	os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
40	os.pathconf(path, name) 返回相关文件的系统配置信息。
41	os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
42	os.popen(command[, mode[, bufsize]]) 从一个 command 打开一个管道
43	os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
44	os.readlink(path) 返回软链接所指向的文件
45	os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
46	os.removedirs(path) 递归删除目录。
47	os.rename(src, dst) 重命名文件或目录，从 src 到 dst
48	os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。
49	os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
50	os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
51	os.stat_float_times([newvalue]) 决定stat_result是否以float对象显示时间戳
52	os.statvfs(path) 获取指定路径的文件系统统计信息
53	os.symlink(src, dst) 创建一个软链接
54	os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
55	os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
56	os.tempnam([dir[, prefix]]) Python3 中已删除。返回唯一的路径名用于创建临时文件。
57	os.tmpfile() Python3 中已删除。返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
58	os.tmpnam() Python3 中已删除。为创建一个临时文件返回一个唯一的路径
59	os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
60	os.unlink(path) 删除文件路径
61	os.utime(path, times) 返回指定的path文件的访问和修改的时间。
62	os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。
63	os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
64	os.path 模块 获取文件的属性信息。

十四.错误和异常

　1.try语句按照如下方式工作；

• 首先，执行try子句（在关键字try和关键字except之间的语句）
• 如果没有异常发生，忽略except子句，try子句执行后结束。
• 如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
• 如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。

　2.Python 使用 raise 语句抛出一个指定的异常。

　3.可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承

　4.try 语句还有另外一个可选的子句finally，它定义了无论在任何情况下都会执行的清理行为。

　5.关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法

　6.Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。  语法:assert expression 或者 assert expression [, arguments]

 十五,面向对象

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

 

类属性与方法

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

类的专有方法：

• __init__ : 构造函数，在生成对象时调用
• __del__ : 析构函数，释放对象时使用
• __repr__ : 打印，转换
• __setitem__ : 按照索引赋值
• __getitem__: 按照索引获取值
• __len__: 获得长度
• __cmp__: 比较运算
• __call__: 函数调用
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __truediv__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

十六.命名空间和作用域

　1.一般有三种命名空间：

• 内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
• 全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
• 局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）
• 命名空间查找顺序为：局部的命名空间去 -> 全局命名空间 -> 内置命名空间。

　2.Python的作用域一共有4种，分别是：

• L（Local）：最内层，包含局部变量，比如一个函数/方法内部。
• E（Enclosing）：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数（或类） A 里面又包含了一个函数 B ，那么对于 B 中的名称来说 A 中的作用域就为 nonlocal。
• G（Global）：当前脚本的最外层，比如当前模块的全局变量。
• B（Built-in）： 包含了内建的变量/关键字等，最后被搜索

　　规则顺序： L –> E –> G –>gt; B。在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

　3.当内部作用域想修改全局变量时，要用到global关键字。如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字

十七.python3标准库

　1.操作系统接口

>>> import os
>>> os.getcwd()      # 返回当前的工作目录
'C:\\Python34'
>>> os.chdir('/server/accesslogs')   # 修改当前的工作目录
>>> os.system('mkdir today')   # 执行系统命令 mkdir 

>>> dir(os)
<returns a list of all module functions>
>>> help(os)
<returns an extensive manual page created from the module's docstrings>
针对日常的文件和目录管理任务，:mod:shutil 模块提供了一个易于使用的高级接口:

>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
>>> shutil.move('/build/executables', 'installdir')

　2.文件通配符: glob模块提供了一个函数用于从目录通配符搜索中生成文件列表

>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

　3.命令行参数: 通用工具脚本经常调用命令行参数。这些命令行参数以链表形式存储于 sys 模块的 argv 变量。

　4.字符串正则匹配: re模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案:

　5.数学: math模块为浮点运算提供了对底层C函数库的访问

　6.访问 互联网: 有几个模块用于访问互联网以及处理网络通信协议。其中最简单的两个是用于处理从 urls 接收的数据的 urllib.request 以及用于发送电子邮件的 smtplib

　7.日期和时间: datetime模块为日期和时间处理同时提供了简单和复杂的方法。支持日期和时间算法的同时，实现的重点放在更有效的处理和格式化输出。该模块还支持时区处理

　8.数据压缩: 以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。

　9.性能度量:有些用户对了解解决同一问题的不同方法之间的性能差异很感兴趣。Python 提供了一个度量工具，为这些问题提供了直接答案。

　　例如，使用元组封装和拆封来交换元素看起来要比使用传统的方法要诱人的多,timeit 证明了现代的方法更快一些。

>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791

　　相对于 timeit 的细粒度，:mod:profile 和 pstats 模块提供了针对更大代码块的时间度量工具。

　10.测试模块:

　　doctest模块提供了一个工具，扫描模块并根据程序中内嵌的文档字符串执行测试。

　　测试构造如同简单的将它的输出结果剪切并粘贴到文档字符串中。

　　通过用户提供的例子，它强化了文档，允许 doctest 模块确认代码的结果是否与文档一致:

def average(values):
    """Computes the arithmetic mean of a list of numbers.

    >>> print(average([20, 30, 70]))
    40.0
    """
    return sum(values) / len(values)

import doctest
doctest.testmod()   # 自动验证嵌入测试

　　unittest模块不像 doctest模块那么容易使用，不过它可以在一个独立的文件里提供一个更全面的测试集:

import unittest

class TestStatisticalFunctions(unittest.TestCase):

    def test_average(self):
        self.assertEqual(average([20, 30, 70]), 40.0)
        self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
        self.assertRaises(ZeroDivisionError, average, [])
        self.assertRaises(TypeError, average, 20, 30, 70)

unittest.main() # Calling from the command line invokes all tests