学习笔记之Python 3 教程

Python 3 教程

http://www.runoob.com/python3/python3-tutorial.html

• Python的3.0版本，常被称为Python 3000，或简称Py3k。相对于Python的早期版本，这是一个较大的升级。为了不带入过多的累赘，Python 3.0在设计的时候没有考虑向下兼容。Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
• Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
• $ chmod +x test.py # 脚本文件添加可执行权限
• 在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。
• 以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入；
• 以双下划线开头的 __foo 代表类的私有成员；
• 以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。
• Python 可以同一行显示多条语句，方法是用分号 ; 分开。
• 学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
• Python语句中一般以新行作为为语句的结束符。但是我们可以使用斜杠（ \）将一行的语句分为多行显示。语句中包含 [], {} 或 () 括号就不需要使用多行连接符。
• Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字
• python中单行注释采用 # 开头。注释可以在语句或表达式行末。python 中多行注释使用三个单引号(''')或三个双引号(""")。
• print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：
• 缩进相同的一组语句构成一个代码块，我们称之代码组。像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。我们将首行及后面的代码组称为一个子句(clause)
• Python 中的变量赋值不需要类型声明。每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
• Python允许你同时为多个变量赋值。您也可以为多个对象指定多个变量。
• Python有五个标准的数据类型：Numbers（数字），String（字符串），List（列表），Tuple（元组），Dictionary（字典）
• 他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。当你指定一个值时，Number对象就会被创建。您可以通过使用del语句删除单个或多个对象的引用。
• Python支持四种不同的数字类型：int（有符号整型），long（长整型[也可以代表八进制和十六进制]），float（浮点型），complex（复数）
• python的字串列表有2种取值顺序：从左到右索引默认0开始的，最大范围是字符串长度少1；从右到左索引默认-1开始的，最大范围是字符串开头
• 如果你要实现从字符串中获取一段子字符串的话，可以使用变量 [头下标:尾下标]，就可以截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
• 当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。而取到的最大范围不包括上边界。
• 加号（+）是字符串连接运算符，星号（*）是重复操作。
• List（列表） 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。列表用 [ ] 标识，是 python 最通用的复合数据类型。
• 元组是另一个数据类型，类似于List（列表）。元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
• 字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
• 有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
• ** 幂 - 返回x的y次幂
• // 取整除 - 返回商的整数部分
• 注意：Python2.x 里，整数除整数，只能得出整数。如果要得到小数部分，把其中一个数改成浮点数即可。Python3.x里，则都得到小数部分。 
• **= 幂赋值运算符 c **= a 等效于 c = c ** a
• //= 取整除赋值运算符 c //= a 等效于 c = c // a
• and x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。E.g. (a and b) 返回 20。
• or x or y 布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 E.g. (a or b) 返回 10。
• in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
• not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
• 身份运算符用于比较两个对象的存储单元。注： id() 函数用于获取对象内存地址。
• is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
• is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
• is 与 == 区别：is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
• Python Number 数据类型用于存储数值。数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。
• 您也可以使用del语句删除一些 Number 对象引用。
• 您可以通过使用del语句删除单个或多个对象
• Python 支持三种不同的数值类型：整型(Int)，浮点型(floating point real values)，复数(complex numbers)
• Python3整型是没有限制大小的，可以当作Long类型使用，所以Python3没有Python2的Long类型。
• ceil 函数返回数字的上入整数。它不能直接访问，需要import math模块，通过静态对象调用该方法。
• floor函数返回数字的下舍整数。
• max函数返回给定参数的最大值，参数可以为序列。min函数则返回最小值。
• choice函数返回一个列表，元组或字符串的随机项。需要import random。
• randrange函数返回指定递增基数集合中的一个随机数，基数缺省值为1。
• random函数返回随机的一个实数，它在[0, 1)范围内。
• shuffle函数将序列的所有元素随机排序。
• uniform函数将随机生成下一个实数，它在[x, y)范围内。
• Python不支持单字符类型，单字符也在Python也是作为一个字符串使用。Python访问子字符串，可以使用方括号来截取字符串。
• 反斜杠（\）转义字符在行尾时，为续行符。
• 在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
• python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
• 三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。
• 引号前小写的"u"表示这里创建的是一个 Unicode 字符串。如果你想加入一个特殊字符，可以使用 Python 的 Unicode-Escape 编码。
• Python capitalize()将字符串的第一个字母变成大写,其他字母变小写。对于 8 位字节编码需要根据本地环境。
• Python center() 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。
• Python count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
• Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
• Python encode() 方法以 encoding 指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。
• Python endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
• Python expandtabs() 方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。
• Python find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
• Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序。
• Python index() 方法检测字符串中是否包含子字符串 str ，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
• Python isalnum() 方法检测字符串是否由字母和数字组成。
• Python isalpha() 方法检测字符串是否只由字母组成。
• Python isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。注意:定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。
• Python isdigit() 方法检测字符串是否只由数字组成。
• Python islower() 方法检测字符串是否由小写字母组成。
• Python isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对unicode对象。
• Python isspace() 方法检测字符串是否只由空格组成。
• Python istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
• Python isupper() 方法检测字符串中所有的字母是否都为大写。
• Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
• Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
• Python ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
• Python lower() 方法转换字符串中所有大写字符为小写。
• Python lstrip() 方法用于截掉字符串左边的空格或指定字符。
• maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。两个字符串的长度必须相同，为一一对应的关系。注：Python3.4已经没有string.maketrans()了，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans()
• Python max() 方法返回字符串中最大的字母。
• Python min() 方法返回字符串中最小的字母。
• partition() 方法用来根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
• Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
• Python rfind() 返回字符串最后一次出现的位置(从右向左查询)，如果没有匹配项则返回-1。
• Python rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。
• Python rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
• rpartition类似于 partition()函数,不过是从右边开始查找
• Python rstrip() 删除 string 字符串末尾的指定字符（默认为空格）.
• Python split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串
• Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
• Python startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
• Python strip() 方法用于移除字符串头尾指定的字符（默认为空格）。
• Python swapcase() 方法用于对字符串的大小写字母进行转换。
• Python title() 方法返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。
• Python translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。
• Python upper() 方法将字符串中的小写字母转为大写字母。
• Python zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
• Python isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。
• 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
• Python有6个序列的内置类型，但最常见的是列表和元组。
• 序列都可以进行的操作包括索引，切片，加，乘，检查成员。
• 此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
• Python 的元组与列表类似，不同之处在于元组的元素不能修改。
• 元组使用小括号，列表使用方括号。
• 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
• 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
• 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
• 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
• tuple(seq)函数将列表转换为元组。
• 字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
• 键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
• 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
• 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
• str(dict)函数输出字典，以可打印的字符串表示。
• type(variable)函数返回输入的变量类型，如果变量是字典就返回字典类型。
• 直接赋值：其实就是对象的引用（别名）。
• 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
• 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
• 复合赋值：右边的表达式会在赋值变动之前执行。右边表达式的执行顺序是从左往右的。
• 关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符
• 其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。
• 由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现
• 你也可以在同一行的位置上使用if条件判断语句
• 判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。
• 如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列；你也可以使用range指定区间的值；也可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长')；您可以结合range()和len()函数以遍历一个序列的索引；还可以使用range()函数来创建一个列表
• while … else 在循环条件为 false 时执行 else 语句块
• 另外一种执行循环的遍历方式是通过索引
• 在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
• Python pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。
• 迭代是Python最强大的功能之一，是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。迭代器有两个基本的方法：iter() 和 next()。字符串，列表或元组对象都可用于创建迭代器
• 在 Python 中，使用了 yield 的函数被称为生成器（generator）。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行 next()方法时从当前位置继续运行。
• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
• 在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
  • 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
  • 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
• python 函数的参数传递：python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。以下是调用函数时可使用的正式参数类型：必需参数／关键字参数／默认参数／不定长参
  • 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
  • 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
• 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
• 使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
• 你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。加了星号（*）的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。
• python 使用 lambda 来创建匿名函数。所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
  • lambda 只是一个表达式，函数体比 def 简单很多。
  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
• Python的作用域一共有4种，分别是：以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问
  • L （Local） 局部作用域
  • E （Enclosing） 闭包函数外的函数中
  • G （Global） 全局作用域
  • B （Built-in） 内建作用域
• 当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
• 如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了
• Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。 
• 列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
• 列表的数据项不需要具有相同的类型
• 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
• 你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项
• 可以使用 del 语句来删除列表的的元素
• 列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
• 使用嵌套列表即在列表里创建其它列表
• list() 方法用于将元组转换为列表。注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
• extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
• clear() 函数用于清空列表，类似于 del a[:]。
• copy() 函数返回列表的浅复制，类似于 a[:]。
• list.insert(i, x)在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
• list.index(x)返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
• list.count(x) 返回 x 在列表中出现的次数。
• list.copy() 返回列表的浅复制，等于a[:]。
• 列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。
• 也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。
• 列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。 
• 每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
• 使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。
• 元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）
• 集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典。
• 序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。
• 一对大括号创建一个空的字典：{}。
• 构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对。此外，字典推导可以用来创建任意键和值的表达式词典。如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便。
• 在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来。
• 在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到。
• 同时遍历两个或更多的序列，可以使用 zip() 组合。
• 要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数。
• 要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值。
• Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。
• 想使用 Python 源文件，只需在另一个源文件里执行 import 语句。当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端。一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
• Python的搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量。sys.path 输出是一个列表，其中第一项是空串''，代表当前目录（若是从一个脚本中打印出来的话，可以更清楚地看出是哪个目录），亦即我们执行python解释器的目录（对于脚本的话就是运行的脚本所在的目录）。因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。了解了搜索路径的概念，就可以在脚本中修改sys.path来引入一些不在搜索路径中的模块。
• 在 python 用 import 或者 from...import 来导入相应的模块。
• 将整个模块(somemodule)导入，格式为： import somemodule
• 从某个模块中导入某个函数,格式为： from somemodule import somefunction
• 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
• 将某个模块中的全部函数导入，格式为： from somemodule import *
• 模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。所以，模块的作者可以放心大胆的在模块内部使用这些全局变量，而不用担心把其他用户的全局变量搞花。
• 一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。
• 内置的函数 dir() 可以找到模块内定义的所有名称。如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称。
• 包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。
• 在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。最简单的情况，放一个空的 :file:__init__.py就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面介绍的） __all__变量赋值。 
• 用户可以每次只导入一个包里面的特定模块
• 注意当使用from package import item这种形式的时候，对应的item既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。import语法会首先把item当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，恭喜，一个:exc:ImportError 异常被抛出了。反之，如果使用形如import item.subitem.subsubitem这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。
• 如果我们使用 from sound.effects import *，Python 会进入文件系统，找到这个包里面所有的子模块，一个一个的把它们都导入进来。但是很不幸，这个方法在 Windows平台上工作的就不是非常好，因为Windows是一个大小写不区分的系统。在这类平台上，没有人敢担保一个叫做 ECHO.py 的文件导入为模块 echo 还是 Echo 甚至 ECHO。
• 为了解决这个问题，只能烦劳包作者提供一个精确的包的索引了。导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。作为包的作者，可别忘了在更新包之后保证 __all__ 也更新了啊。
• Python两种输出值的方式: 表达式语句和 print() 函数。第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。
• str()：函数返回一个用户易读的表达形式。repr()：产生一个解释器易读的表达形式。
• 字符串对象的 rjust() 方法, 可以将字符串靠右, 并在左边填充空格。还有类似的方法, 如 ljust() 和 center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。另一个方法 zfill(), 它会在数字的左边填充 0。
• str.format() 的基本使用如下：% 操作符也可以实现字符串格式化。它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串。因为 str.format() 比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format()。Python提供了 input() 置函数从标准输入读入一行文本，默认的标准输入是键盘。input 可以接收一个Python表达式作为输入，并将运算结果返回。
  • 括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。在括号中的数字用于指向传入对象在 format() 中的位置。
  • 如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。位置及关键字参数可以任意的结合。
  • '!a' (使用 ascii()), '!s' (使用 str()) 和 '!r' (使用 repr()) 可以用于在格式化某个值之前对其进行转化。
  • 可选项 ':' 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。在 ':' 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。
  • 如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。最简单的就是传入一个字典, 然后使用方括号 '[]' 来访问键值，也可以通过在 table 变量前使用 '**' 来实现相同的功能。
• open() 将会返回一个 file 对象，基本语法格式如下：open(filename, mode)。为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。size 是一个可选的数字类型的参数。当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
  • filename：filename 变量是一个包含了你要访问的文件名称的字符串值。
  • mode：mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
• f.readlines() 将返回该文件中包含的所有行。如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。另一种方式是迭代一个文件对象然后读取每行。
• f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。如果要写入一些不是字符串的东西, 那么将需要先进行转换。
• f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。
• 如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。from_what 值为默认为0，即文件开头。from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。
  • seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
  • seek(x,1) ： 表示从当前位置往后移动x个字符
  • seek(-x,2)：表示从文件的结尾往前移动x个字符
• python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
• 基本接口：
  • pickle.dump(obj, file, [,protocol])
• 有了 pickle 这个对象, 就能对 file 以读取的形式打开:file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：file.close() / file.flush() / file.fileno() / file.isatty() / file.next() / file.read([size]) / file.readline([size]) / file.readlines([sizeint]) / file.seek(offset[, whence]) / file.tell() / file.truncate([size]) / file.write(str) / file.writelines(sequence)
  • x = pickle.load(file)
• os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：
  • os.access(path, mode) 检验权限模式
  • os.chdir(path) 改变当前工作目录
  • os.chflags(path, flags) 设置路径的标记为数字标记。
  • os.chmod(path, mode) 更改权限
  • os.chown(path, uid, gid) 更改文件所有者
  • os.chroot(path) 改变当前进程的根目录
  • os.close(fd) 关闭文件描述符 fd
  • os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
  • os.dup(fd) 复制文件描述符 fd
  • os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2
  • os.fchdir(fd) 通过文件描述符改变当前工作目录
  • os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
  • os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
  • os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
  • os.fdopen(fd[, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
  • os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
  • os.fstat(fd) 返回文件描述符fd的状态，像stat()。
  • os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，像 statvfs()
  • os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。
  • os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
  • os.getcwd() 返回当前工作目录
  • os.getcwdu() 返回一个当前工作目录的Unicode对象
  • os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
  • os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接
  • os.lchmod(path, mode) 修改连接文件权限
  • os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。
  • os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src
  • os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。
  • os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
  • os.lstat(path) 像stat(),但是没有软链接
  • os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
  • os.makedev(major, minor) 以major和minor设备号组成一个原始设备号
  • os.makedirs(path[, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
  • os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
  • os.mkdir(path[, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
  • os.mkfifo(path[, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制)
  • os.mknod(filename[, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
  • os.open(file, flags[, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的
  • os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
  • os.pathconf(path, name) 返回相关文件的系统配置信息。
  • os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
  • os.popen(command[, mode[, bufsize]]) 从一个 command 打开一个管道
  • os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
  • os.readlink(path) 返回软链接所指向的文件
  • os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
  • os.removedirs(path) 递归删除目录。
  • os.rename(src, dst) 重命名文件或目录，从 src 到 dst
  • os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。
  • os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
  • os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
  • os.stat_float_times([newvalue]) 决定stat_result是否以float对象显示时间戳
  • os.statvfs(path) 获取指定路径的文件系统统计信息
  • os.symlink(src, dst) 创建一个软链接
  • os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
  • os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
  • os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
  • os.unlink(path) 删除文件路径
  • os.utime(path, times) 返回指定的path文件的访问和修改的时间。
  • os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。
  • os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
• Python有两种错误很容易辨认：语法错误和异常。Python 的语法错误或者称之为解析错。即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。大多数的异常都不会被程序处理，都以错误信息的形式展现在这里。
• 一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组。最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。
• try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。异常处理并不仅仅处理那些直接发生在try子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。
• Python 使用 raise 语句抛出一个指定的异常。raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。
• 你可以通过创建一个新的exception类来拥有自己的异常。异常应该继承自 Exception 类，或者直接继承，或者间接继承。当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类。大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。
• try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。不管 try 子句里面有没有发生异常，finally 子句都会执行。如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。
• 一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法。