python使用中文编码只需在开头加上 #coding=utf-8
在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。Python 中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入；
以双下划线开头的 foo 代表类的私有成员；以双下划线开头和结尾的 foo__ 代表 Python 里特殊方法专用的标识，如 init() 代表类的构造函数。
Python 可以同一行显示多条语句，方法是用分号 ; 分开
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建
多个变量赋值
Python允许你同时为多个变量赋值。例如：
a = b = c = 1
以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, "john"
以上实例，两个整型对象 1 和 2 分别分配给变量 a 和 b，字符串对象 “john” 分配给变量 c。
Python有五个标准的数据类型：
Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
Python支持四种不同的数字类型
int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）
Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
在 Python3.X 版本中 long 类型被移除，使用 int 替代。
元组用”()”标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
数据转换类型函数
python运算符
Python2.x里，整数除整数，只能得出整数如果要得到小数部分，把其中一个数改成浮点数即可。
python位运算符
按位运算符是把数字看作二进制来进行计算的。
| 运算符 | 描述 | |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | |
| \ | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 | |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 | |
| >> | 右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 |
Python成员运算符
| 运算符 | 描述 |
|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 |
| not | 如果在指定的序列中没有找到值返回 True，否则返回 False。 |
Python身份运算符
| 运算符 | 描述 |
|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 |
| is not | is not 是判断两个标识符是不是引用自不同对象 |
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符：
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 ‘AND’ |
| ^ 位运算符或 | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not and or | 逻辑运算符 |
and 和 or 的优先级低于>（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。
python中的break，continue，pass
break
Python break语句，就像在C语言中，打破了最小封闭for或while循环。
break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。
break语句用在while和for循环中。
continue
如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。
Python continue语句跳出本次循环，而break跳出整个循环。
continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
continue语句用在while和for循环中。
pass
Python pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句。
Python Number(数字)
Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中。
Python math 模块提供了许多对浮点数的数学运算函数。
Python cmath 模块包含了一些用于复数运算的函数。
python 字符串
字符串是python中最常见的数据类型。我们可以使用引号(‘或”)来创建字符串。
python访问字符串，可以使用方括号来截取字符串。
例：
var1 = 'Hello World!'
var2 = "Python Runoob"
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]
执行结果：
var1[0]: H
var2[1:5]: ytho
python 字符串更新
python中可以对已存在的字符串进行修改，并赋值给另一个变量。例：
# -*- coding: UTF-8 -*-
var1 = 'Hello World!'
print "更新字符串 :- ", var1[:6] + 'Runoob!'
执行结果：
更新字符串 :- Hello Runoob!
Python 字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
例：
print "My name is %s and weight is %d kg!" % ('Zara', 21)
输出结果：
My name is Zara and weight is 21 kg!
python三引号
python中三引号可以将复杂的字符串进行复制:
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。
一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
''')
Unicode 字符串
引号前小写的”u”表示这里创建的是一个 Unicode 字符串。如果你想加入一个特殊字符，可以使用 Python 的 Unicode-Escape 编码。
如下例所示：
>>>u'Hello\u0020World !'
u'Hello World !'
被替换的 \u0020 标识表示在给定位置插入编码值为 0x0020 的 Unicode 字符（空格符）。
python的字符串内建函数
略
Python 列表(List)
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引。
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符。
python列表脚本操作符
| python表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| [‘Hi!’] * 4 | [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print x, | 1 2 3 | 迭代 |
python列表函数
| 函数 | 描述 |
|---|---|
| cmp(list1, list2) | 比较两个列表的元素 |
| len(list) | 列表元素个数 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
| list(seq) | 将元组转换为列表 |
python列表函数
| 方法 | 描述 |
|---|---|
| list.append(obj) | 在列表末尾添加新的对象 |
| list.count(obj) | 统计某个元素在列表中出现的次数 |
| list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| list.insert(index, obj) | 将对象插入列表 |
| list.pop([index=-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| list.remove(obj) | 移除列表中某个值的第一个匹配项 |
| list.reverse() | 反向列表中元素 |
| list.sort(cmp=None, key=None, reverse=False) | 对原列表进行排序 |
Python 元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
元组中只包含一个元素时，需要在元素后面添加逗号。
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。
元组运算符
同列表
无关闭分隔符
任意无符号的对象，以逗号隔开，默认为元组。
元组内置函数
同列表
| 方法 | 描述 |
|---|---|
| tuple(seq) | 将列表转换为元组。 |
Python 字典(Dictionary)
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中。
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
字典内置函数
| 函数 | 描述 |
|---|---|
| cmp(dict1,dict2) | 比较两个字典元素 |
| len(dict) | 计算字典元素个数，即键的总数。 |
| str(dict) | 输出字典可打印的字符串表示。 |
| type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型。 |
字典内置方法
| 方法 | 描述 |
|---|---|
| dict.clear() | 删除字典内所有元素 |
| dict.copy() | 返回一个字典的浅复制 |
| dict.fromkeys(seq[, val]) | 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值 |
| dict.get(key, default=None) | 返回指定键的值，如果值不在字典中返回default值 |
| dict.has_key(key) | 如果键在字典dict里返回true，否则返回false |
| dict.items() | 以列表返回可遍历的(键, 值) 元组数组 |
| dict.keys() | 以列表返回一个字典所有的键 |
| dict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| dict.update(dict2) | 把字典dict2的键/值对更新到dict里 |
| dict.values() | 以列表返回字典中的所有值 |
| pop(key[,default]) | 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| popitem() | 随机返回并删除字典中的一对键和值。 |
python时间和日期
Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳。
时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。
格式化日期
最简单的获取可读的时间模式的函数是asctime():
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import time
localtime = time.asctime( time.localtime(time.time()) )
print "本地时间为 :", localtime
我们可以使用 time 模块的 strftime 方法来格式化日期，：
time.strftime(format[, t])
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import time
# 格式化成2016-03-20 11:45:39形式
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
# 格式化成Sat Mar 28 22:24:24 2016形式
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))
python中时间日期格式化符号：
- %y 两位数的年份表示（00-99）
- %Y 四位数的年份表示（000-9999）
- %m 月份（01-12）
- %d 月内中的一天（0-31）
- %H 24小时制小时数（0-23）
- %I 12小时制小时数（01-12）
- %M 分钟数（00=59）
- %S 秒（00-59）
- %a 本地简化星期名称
- %A 本地完整星期名称
- %b 本地简化的月份名称
- %B 本地完整的月份名称
- %c 本地相应的日期表示和时间表示
- %j 年内的一天（001-366）
- %p 本地A.M.或P.M.的等价符
- %U 一年中的星期数（00-53）星期天为星期的开始
- %w 星期（0-6），星期天为星期的开始
- %W 一年中的星期数（00-53）星期一为星期的开始
- %x 本地相应的日期表示
- %X 本地相应的时间表示
- %Z 当前时区的名称
- %% %号本身
获取某月日历
Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：
# -*- coding: UTF-8 -*-
import calendar
cal = calendar.month(2016, 1)
print "以下输出2016年1月份的日历:"
print cal
python函数
定义函数
规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
- 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
- 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
- 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
- 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响。
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
python 传不可变对象实例
# -*- coding: UTF-8 -*-
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print b # 结果是 2
实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。
传可变对象实例
# -*- coding: UTF-8 -*-
# 可写函数说明
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4]);
print "函数内取值: ", mylist
return
# 调用changeme函数
mylist = [10,20,30];
changeme( mylist );
print "函数外取值: ", mylist
实例中传入函数的和在末尾添加新内容的对象用的是同一个引用。
输出结果如下：
函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]
参数
调用函数时可使用的正式参数类型：
- 必备参数
- 关键字参数
- 默认参数
- 不定长参数
不定长参数
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
加了星号（*）的变量名会存放所有未命名的变量参数。
匿名函数
python 使用 lambda 来创建匿名函数。
- lambda只是一个表达式，函数体比def简单很多。
- lambda的主体是一个表达式，而不是代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
- 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda函数的语法只包含一个语句。
lambda [arg1 [,arg2,.....argn]]:expression
python模块
Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。
模块的引入
可以使用 import 语句来引入模块，语法如下：
import module1[, module2[,... moduleN]]
比如要引用模块 math，就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时，必须这样引用：
模块名.函数名
from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
from modname import name1[, name2[, ... nameN]]
例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：
from fib import fibonacci
这个声明不会把整个 fib 模块导入到当前的命名空间中，它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。
from…import* 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
from modname import *
这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
搜索路径
当你导入一个模块，Python 解析器对模块位置的搜索顺序是：
- 当前目录
- 如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3.如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
PYTHONPATH 变量
作为环境变量，PYTHONPATH 由装在一个列表里的许多目录组成。PYTHONPATH 的语法和 shell 变量 PATH 的一样。
在 Windows 系统，典型的 PYTHONPATH 如下：
set PYTHONPATH=c:\python27\lib;
在 UNIX 系统，典型的 PYTHONPATH 如下：
set PYTHONPATH=/usr/local/lib/python
命名空间和作用域
变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。
一个 Python 表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。
每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。
Python 会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。
因此，如果要给函数内的全局变量赋值，必须使用 global 语句。
global VarName 的表达式会告诉 Python， VarName 是一个全局变量，这样 Python 就不会在局部命名空间里寻找这个变量了。
globals() 和 locals() 函数
根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。
dir()函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块，变量和函数。
Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
读取键盘输入
raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）；
input([prompt]) 函数和 raw_input([prompt]) 函数基本类似，但是 input 可以接收一个Python表达式作为输入，并将运算结果返回。
open函数
你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。
语法：
file object = open(file_name [, access_mode][, buffering])
- file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
- access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
- buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
模式简图
File对象的属性
一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
| 属性 | 描述 |
|---|---|
| file.closed | 返回true如果文件已被关闭，否则返回false。 |
| file.mode | 返回被打开文件的访问模式。 |
| file.name | 返回文件的名称。 |
| file.softspace | 如果用print输出后，必须跟一个空格符，则返回false。否则返回true。 |
close()方法
File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
语法：
fileObject.close()
write()方法
write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符(‘\n’)：
语法：
fileObject.write(string)
read()方法
read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
语法：
fileObject.read([count])
被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。
通过write()写入后用read()函数会有错误
文件定位
tell()方法告诉你文件内的当前位置。通过read()函数后指针会指到读到的位置。
seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。
异常处理
捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
try….except…else的语法：
try:
<语句> #运行别的代码
except <名字>：
<语句> #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句> #如果引发了'name'异常，获得附加的数据
else:
<语句> #如果没有异常发生
以上方式try-except语句捕获所有发生的异常。但这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常。
try-finally 语句
try-finally 语句无论是否发生异常都将执行最后的代码。
触发异常
raise语句自己触发异常
raise语法格式如下：
raise [Exception [, args [, traceback]]]
语句中 Exception 是异常的类型（例如，NameError）参数标准异常中任一种，args 是自已提供的异常参数。
最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。
python内置函数
| 函数名 | 描述 | 参数 |
|---|---|---|
| abs() | abs()返回数字的绝对值 | 数值表达式 |
| divmod(a,b) | divmod()把除数和余数运算结果结合起来，返回一个商和余数的元组(a//b,a%b)。 | a,b为数字包括复数 |
| input([prompt]) | 希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。input() 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。 | prompt：提示信息 |
| open(name[, mode[, buffering]]) | open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。 | name : 一个包含了你要访问的文件名称的字符串值。mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。 |
| staticmethod(function) | staticmethod 返回函数的静态方法。 | 无 |
| all(iterable) | 如果iterable的所有元素不为0、’’、False或者iterable为空，all(iterable)返回True，否则返回False；注意：空元组、空列表返回值为True，这里要特别注意。 | iterable – 元组或列表。 |
| enumerate(sequence, [start=0]) | 返回 enumerate(枚举) 对象 | sequence – 一个序列、迭代器或其他支持迭代对象。start – 下标起始位置。 |
| int(x, base=10) | int() 函数用于将一个字符串或数字转换为整型。 | x – 字符串或数字。base – 进制数，默认十进制。 |
| ord(c) | 返回值是对应的十进制整数。 | c – 字符。 |
| str(object=’’) | 返回一个对象的string格式。 | object – 对象。 |
| any(iterable) | 如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。 | iterable – 元组或列表。 |
| eval(expression[, globals[, locals]]) | 返回表达式计算结果。 | expression – 表达式。globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。 |
| pow(x, y[, z]) | pow() 方法返回 xy（x的y次方） 的值。如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z。pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。 | x，y，z为数值表达式 |
| sum(iterable[, start]) | sum() 方法对系列进行求和计算。 | iterable – 可迭代对象，如：列表、元组、集合。 start – 指定相加的参数，如果没有设置这个值，默认为0。 |
| bin(x) | bin() 返回一个整数 int 或者长整数 long int 的二进制表示。返回值为字符串。 | x – int 或者 long int 数字 |
| iter(object[, sentinel]) | iter() 函数用来生成迭代器。返回值为迭代器对象。 | object – 支持迭代的集合对象。sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。 |
| filter(function, iterable) | filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。返回值为列表。 | function – 判断函数。iterable – 可迭代对象。 |
| len( s ) | 返回对象长度。 | s – 对象 |
| range(start, stop[, step]) | range() 函数可创建一个整数列表，一般用在 for 循环中。 | start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）。stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5。step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)。 |
| raw_input([prompt]) | raw_input() 用来获取控制台的输入。raw_input() 将所有输入作为字符串看待，返回字符串类型。 | prompt: 可选，字符串，可作为一个提示语。 |
| unichr(i) | 返回 unicode 的字符。 | i – 可以是10进制也可以是16进制的形式的数字。 |
| callable(object) | callable() 函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。可调用返回 True，否则返回 False。 | object – 对象 |
| str.format() | 字符格式化输出 | 略 |
| locals() | locals() 函数会以字典类型返回当前位置的全部局部变量。 | 无 |
| reduce(function, iterable[, initializer]) | reduce() 函数会对参数序列中元素进行累积。函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。 | function – 函数，有两个参数iterable – 可迭代对象initializer – 可选，初始参数 |
| chr(i) | chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。返回值是当前整数对应的ascii字符。 | i – 可以是10进制也可以是16进制的形式的数字。 |
| rozenset([iterable]) | frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。 | iterable – 可迭代的对象，比如列表、字典、元组等等。 |
| long(x, base=10) | long() 函数将数字或字符串转换为一个长整型数。 | x – 字符串或数字。base – 可选，进制数，默认十进制。 |
| reload(module) | reload() 用于重新载入之前载入的模块。返回模块对象。 | module – 模块对象 |
| getattr(object, name[, default]) | getattr() 函数用于返回一个对象属性值。 | object – 对象。name – 字符串，对象属性。default – 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。 |
| map(function, iterable, …) | map() 会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。 | function – 函数 iterable – 一个或多个序列 |
| repr(object) | 同str()函数 | 略 |
| xrange(start, stop[, step]) | xrange() 函数用法与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器。 | start: 计数从 start 开始。默认是从 0 开始。例如 xrange(5) 等价于 xrange(0， 5)。 stop: 计数到 stop 结束，但不包括 stop。例如：xrange(0， 5) 是 [0, 1, 2, 3, 4] 没有 5。 step：步长，默认为1。例如：xrange(0， 5) 等价于 xrange(0, 5, 1) |
| cmp( x, y ) | cmp(x,y) 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 | x,y– 数值表达式。 |
| max( x, y, z, …. ) | max() 方法返回给定参数的最大值，参数可以为序列 | x,y,z– 数值表达式 |
| list.reverse() | reverse() 函数用于反向列表中元素。该方法没有返回值，但是会对列表的元素进行反向排序。 | NA |
| zip([iterable, …]) | zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。 | iterabl – 一个或多个迭代器;请参考实例理解 |
| compile(source, filename, mode[, flags[, dont_inherit]]) | compile() 函数将一个字符串编译为字节代码。返回表达式执行结果。 | source – 字符串或者AST（Abstract Syntax Trees）对象。。filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。mode – 指定编译代码的种类。可以指定为 exec, eval, single。flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。flags和dont_inherit是用来控制编译源码时的标志 |
| hasattr(object, name) | hasattr() 函数用于判断对象是否包含对应的属性。如果对象有该属性返回 True，否则返回 False。 | object – 对象。name – 字符串，属性名。 |
| round( x [, n] ) | round() 方法返回浮点数x的四舍五入值。 | x ,n– 数值表达式。 |
| complex([real[, imag]]) | complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。 | real – int, long, float或字符串； imag – int, long, float； |
| hash(object) | ash() 用于获取取一个对象（字符串或者数值等）的哈希值。 | object – 对象； |
| min( x, y, z, …. ) | min() 方法返回给定参数的最小值，参数可以为序列。 | x,y,z – 数值表达式。 |
| class set([iterable]) | set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。返回新的集合对象。 | iterable – 可迭代对象对象； |
| delattr(object, name) | delattr 函数用于删除属性。 delattr(x, ‘foobar’) 相等于 del x.foobar。 | object – 对象。name – 必须是对象的属性。 |
| next(iterator[, default]) | next() 返回迭代器的下一个项目。 | iterator – 可迭代对象default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。 |
| setattr(object, name, value) | setattr() 函数对应函数 getattr()，用于设置属性值，该属性必须存在。 | object – 对象。name – 字符串，对象属性。value – 属性值。 |
| hex(x) | hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。返回16进制数，以字符串形式表示。 | x – 10进制整数 |
| class slice(start, stop[, step]) | slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。返回一个切片对象 | start – 起始位置stop – 结束位置step – 间距 |
| dir([object]) | dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。返回模块的属性列表。 | object – 对象、变量、类型。 |
| id([object]) | id() 函数用于获取对象的内存地址。返回对象的内存地址 | object – 对象。 |
| oct(x) | oct() 函数将一个整数转换成8进制字符串。返回8进制字符串。 | x – 整数。 |
| sorted(iterable[, cmp[, key[, reverse]]]) | sorted() 函数对所有可迭代的对象进行排序操作。返回重新排序的列表。 | iterable – 可迭代对象。 cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。 key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。 |
| exec obj | exec 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。exec 返回值永远为 None。 | obj – 要执行的表达式。 |
结语
终于看完啦基础，虽然有些东西还不算多懂。但也算看过一遍啦。多多努力。这些都是python2中的基础有些基础并没有看懂，而选择跳过。具体知识详解参考官方手册
本文借鉴菜鸟教程基础篇
