Python基本语法笔记

Python基本语法

@author 鲁伟林
刚开始学习python，以前是一个java/c++党。给出一份学习python时自己的笔记，方便自己回顾，也希望能给大家参考下。
学习python的网址是：http://www.runoob.com/python/python-object.html
gitHub地址: https://github.com/thinkingfioa/Notes/tree/master/python

Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。

---

Python语法的后缀名是以.py结尾，文件开头是:
#!/usr/bin/python 或 #!/usr/bin/env python
如果支持中文，请改成:
#!/usr/bin/python
# -*- coding: UTF-8 -*-

---

Python 基础语法

Python如何执行

• 1. 使用交互是界面执行。
• 2. 使用python test.py命令执行
• 3. 利用./test.py执行

Python 标识符

• 1. 以单下划线开头的属性，表示是类的私有属性(包括方法，变量)。如:_foo表示不能直接访问的类属性。
• 2. 以双下划线开头的 __foo 代表类的私有成员；
• 3. 以双下划线开头和结尾的 _ _ foo _ _ 代表Python 里特殊方法专用的标识，如 _ _ init _ _() 代表类的构造函数。

行和缩进

• 1. 学习Python与其他语言最大的区别：Python不使用{}来控制，而使用缩进来使用模块。
• 2. 要注意区别4个空格和Tab键。很容易导致执行出错。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

print "hello world";

if True:
    print("Answer:");
    print("true");
else:
    print("Answer:");
    # 没有严格缩进，在执行时会报错
  print("false");

Python引号

• 1. Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串。
• 2. 三引号(""")可以由多行组成，是编写多行文本的快捷语法，常用于文档字符串。

Python注释

• 1. python中单行注释采用 # 开头
• 2. python 中多行注释使用三个单引号(''')或三个双引号(""")

Python空行

• 函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

Print输出

• print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号。

//换行
print("hello");
//不换行
print("hello"),
print("world");

多个语句组成的代码组

• 1. 缩进相同的一组语句构成一个代码块，我们称之代码组。
• 2. 子句: 像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

if expression: 
   suite 
elif expression:
   suite  
else:
   suite 

---

Python变量类型

变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

Python变量赋值

• 1. 变量赋值不需要类型声明
• 2. 每个变量在使用前必须赋值，变量赋值以后该变量才会被创建

counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
print(count),
print(miles),
print(name);

多个变量赋值

a = b = c = 1;
a, b, c = 1,2, "thinking";

标准数据类型

• 1. Numbers(数字)
• 2. String(字符串)
• 3. List(列表)
• 4. Tuple(元组)
• 5. Dictionary(字典)

Python数字(Numbers)

• 1. Python支持: int(有符号整型), long(长整型: 3291930L), float(浮点型), complex(复数: a+bj 或者 complex(a,b).
• 2. 可以使用del语句删除对象的引用. 如: del var1, var2;

Python字符串(String)

• 1. 如果想实现字符串截取，可以使用变量 [头下标:尾下标]。
• 2. 加号(+)是字符串连接运算符，星号(*)是重复操作

#!/usr/bin/python
# -*- coding: UTF-8 -*-

str = "Hello World!";

print(str); #输出: Hello World!
print(str[0]); # 输出: H
print(str[2:5]); # 输出: llo
print(str[2:]); # 输出: llo World!
print(str * 2); # 输出2遍: Hello World!Hello World!
print(str + " TEST"); # 输出: Hello World! TEST

Python 列表

• 1. 列表使用'[]'来标识
• 2. List(列表)是Python中使用最频繁的数据类型。
• 3. 列表的切割也可以用到变量 [头下标:尾下标]
• 4. 加号(+)是字符串连接运算符，星号(*)是重复操作
• 5. 列表允许更新，如 ：list[2] = 123;

#!/usr/bin/python
# -*- coding: UTF-8 -*-

list = [ "runoob", 786 , 2.23, "john", 70.2 ];
tinylist = [123, "john"];

print(list); #输出: ['runoob', 786, 2.23, 'john', 70.2]
print(list[0]); #输出: runoob
print(list[1:3]); #输出: [786, 2.23]
print(list[2:]); #输出: [2.23, 'john', 70.2]
print(tinylist *2 ); #输出: [123, 'john', 123, 'john']
print(list + tinylist); #输出: ['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

Python 元组

• 1. 元组用'()'标识
• 2. 元组是另一个数据类型，类似于List(列表)
• 3. 元组不允许二次赋值，相当于只读列表。如：tuple[2] = 1000非法访问

tuply = ("runoob", 786 , 2.23, "john", 70.2 );
tinytuply = (123, "john");

print(tuply); #输出: ['runoob', 786, 2.23, 'john', 70.2]
print(tuply[0]); #输出: runoob
print(tuply[1:3]); #输出: [786, 2.23]
print(tuply[2:]); #输出: [2.23, 'john', 70.2]
print(tinytuply *2 ); #输出: [123, 'john', 123, 'john']
print(tuply + tinytuply); #输出: ['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

Python字典

• 1. 字典用"{ }"标识。
• 2. 类似于其他语言的：Map

dict = {};
dict["one"] = "This is one";
dict[2] = "This is two";

tinydict = {"name": "john", "code":6734, "dept":"sales"};

print(dict["one"]); # 输出: This is one
print(dict[2]); # 输出: This is two
print(tinydict); # 输出: {'dept': 'sales', 'code': 6734, 'name': 'john'}
print(tinydict.keys()); # 输出: ['dept', 'code', 'name']
print(tinydict.values()); # 输出: ['sales', 6734, 'john']

Python数据类型转换

• int('12', 16),就是说：12是一个16进制的。输出为: 18.

函数	描述
int(x [,base])	将x转换为一个整数
long(x [,base] )	将x转换为一个长整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

---

Python 运算符

Python算术运算符

运算符	描述	举例
**	幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除	9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

Python逻辑运算符

运算符	描述	举例
and	x and y	布尔"与", 类似于: &&
or	x or y	布尔"或", 类似于:或
not	not x	布尔"非", 类似于: !

Python 成员运算符

运算符	描述
in	如果在指定的序列中找到值返回 True，否则返回 False
not in	如果在指定的序列中没有找到值返回 True，否则返回 False

a = 7;
b = 2;
list = [1,2,3,4,5];

if(a in list):
    print("a is in list");
else:
    print(" a is not list"); # 输出

if(b in list):
    print("b is in list"); # 输出
else:
    print("b is not list");

Python 身份运算符

• 1. is是传递地址
• 2. == 是比较值。

运算符	描述
is	is 是判断两个标识符是不是引用自一个对象
is not	is not 是判断两个标识符是不是引用自不同对象

//运用脚本运行，是同一个对象。
a = 7;
b = 7;

if(a is b):
    print("a is b"); # 输出
else:
    print(" a is not list"); 

b = 10;
if(a is b):
    print("a is b"); 
else:
    print("a is not b"); # 输出

---

Python条件语句

if 判断语句1:
    执行语句....;
elif 判断语句2:
    执行语句....;
else:
    执行语句3;

num = 9
if(num >= 0 and num <= 10):    # 判断值是否在0~10之间
    print 'hello'; # 输出结果: hello

---

Python 循环语句

Python的While语句

numbers = [12, 37, 5, 42, 8, 3];
even = [];
odd = [];
while(len(numbers) > 0):
    number = numbers.pop();
    if(number%2==0):
        even.append(number);
    else:
        odd.append(number);

Python的While-else语句

• 当while后的条件不满足时，执行:else语句

count = 0
while(count < 5):
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"

Python的for循环语句

for(letter in 'Python'):     # 第一个实例
   print '当前字母 :', letter
 
fruits = ['banana', 'apple',  'mango']
for(fruit in fruits):        # 第二个实例
   print '当前水果 :', fruit
 
print "Good bye!"

Python的for-else语句

• 当for后的条件不满足时，执行:else语句

---

Python的pass语句

• 1. pass是空语句，为了保证程序结构的完整性。
• 2. pass不做任何事，一般用作占位符

---

Python Number(数字)

• 1. Python支持: int(有符号整型), long(长整型: 3291930L), float(浮点型), complex(复数: a+bj 或者 complex(a,b).
• 2. 可以使用del语句删除对象的引用. 如: del var1, var2;

Python数据类型转换

• int('12', 16),就是说：12是一个16进制的。输出为: 18.

函数	描述
int(x [,base])	将x转换为一个整数
long(x [,base] )	将x转换为一个长整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

Python数学函数

函数	描述
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根

Python随机数函数

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，如random.choice(range(10))，从0到9中随机挑选一个整数
randrange	([start,] stop [,step])从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random()	随机生成下一个实数，它在[0,1)范围内
seed([x])	改变随机数生成器的种子seed
shuffle(list)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内

Python数学常量

常量	描述
pi	数学常量pi(圆周率)
e	数学常量e，e是自然数

---

Python字符串

Python字符串格式化

符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

Python三引号

• 三引号(""")可以将字符串变成多行，且字符串中可以包括一些特殊字符

---

Python列表

• 列表的数据项不需要具有相同的类型

删除列表元素

list = ["thinking", "fioa", 123, 456];
print list # 输出: ['thinking', 'fioa', 123, 456]
del list[2]
print list # 输出: ['thinking', 'fioa', 456]

Python列表截取

表达式	结果	描述
L[2]	'fioa'	读取列表中第三个元素
L[-2]	123	读取列表中倒数第二个元素
L[1:]	['fioa', 123, 456]	从第二个元素开始截取列表

list2 = ["thinking", "fioa", 123, 456]
print list2[2]  # 输出 123
print list2[-3]  # 输出 fioa
print list2[1:]  # 输出 ['fioa', 123, 456]

---

Python元组

• 1. 元组只有一个元素，需要在元素后面添加逗号。如：tup1 = (50,);
• 2. 元组不能修改，意味着元组不能删除，更新等更改型操作。

---

Python字典

删除字典元素

• 1. 能删除单一的元素，也能删除整个字典。还可以清空整个字典。
• 2. 键必须不可变，所以可以用数字，字符串或元组充当。但是列表不能作为key。

dict = {"Name": "thinking", "age":18, "lover":"ppp"}
print dict  #输出 {'age': 18, 'Name': 'thinking', 'lover': 'ppp'}
del dict["lover"]
print dict  #输出 {'age': 18, 'Name': 'thinking'}
dict.clear()
del dict

---

Python日期和时间

• 1. Python提供了time和calendar模块用于格式化时间和日期。
• 2. 时间间隔是以秒为单位的浮点数。

ticks = time.time()
print ticks  # 输出：1508668369.94

格式化日期

• 使用time模块的strftime方法来格式化日期

print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())  # 输出: 2017-10-22 18:36:56
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())  # 输出: Sun Oct 22 18:36:56

# 将格式化转换成时间戳
a = "Sun Oct 22 18:36:56 2017"
print time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y"))  # 输出: 1508668616.0

获取某月日历

cal = calendar.month(2017, 2)
'''输出：
   February 2017
Mo Tu We Th Fr Sa Su
       1  2  3  4  5
 6  7  8  9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28
'''
print cal

---

Python函数

定义一个函数

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

def functionname(parameters):
    """函数说明"""
    function_suite
    return [expression]
    

函数调用

def printme(str):
    """打印任何传入的字符串"""
    print str
    return


printme("thinking")  # 输出：thinking
printme("fioa")  # 输出：fioa

参数传递

在Python中，string，tuples和numbers是不可更改的对象，而list, dict等则是可修改的对象.

• 1. 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个int值的对象10，再让a指向它，5就被丢弃。
• 2. 可变类型：变量赋值 la=[1,2,3,4]后再赋值la[2]=5则是将list la的第三个元素更改了。

python函数的参数传递:

• 1. 不可变类型：类似于c++的值传递，如整数，字符串，元组。如fun(a)，传递的只是a的值。如果在函数内部修改了a的值，对传入的值没有任何影响.
• 2. 可变类型：类似C++的引用传递，如列表。如fun(la)传入，函数内部修改了la，对传入的值有影响。

python传不可变对象实例

def changeint(a):
    a = 10


b = 2
changeint(b)
print b  # 结果: 2

python传可变对象实例

def changelist(mylist):
    mylist.append("thinking")
    return
    

mylist = [1, 2, 3]
print mylist  # 输出：[1, 2, 3]
changelist(mylist)
print mylist  # 输出：[1, 2, 3, 'thinking']

总结:

• 1. 不可变类型(string, number, tuples)作为参数传值到函数中，如果在函数中修改，无效。
• 2. 可变类型(list, dict)作为参数传值到函数中，如果在函数中修改，有效。

函数参数

调用函数时可使用的参数类型

• 1. 必备参数
• 2. 关键字参数
• 3. 缺省参数
• 4. 不定长参数

必备参数

想调用函数，必须传入对应的参数

def printmustargument(str):
    """必备参数"""
    print str
    return


str = "ppp"
printmustargument(str)  # 输出:ppp

关键字参数

使用关键字参数，允许调用函数时参数的顺序可以不一致。

def printkeywordargument(name, age):
    """关键字函数"""
    print "Name: ", name
    print "Age:", age


printkeywordargument(name="ppp", age=35)  # 输出: Name: ppp   Age: 35

缺省参数

调用函数时，缺省参数没有传入，使用默认值

def printdefaultargument(name, age=20):
    """缺省参数"""
    print "Name: ", name
    print "Age:", age


printdefaultargument(name="thinking_fioa")  # 输出: Name: thinking_fioa   Age: 20

不定长参数

函数接受任意长度的参数

def printmoreargument(arg1, *vartuple):
    """不定长参数"""
    print arg1
    for var in vartuple:
        print var
    return


printmoreargument(10)  # 输出：10
printmoreargument(10, 20, 30)  # 输出: (10, 20, 30)

---

匿名函数

python使用lambda来创建匿名函数

• 1. lambda只是一个表达式，函数体比def简单很多
• 2. lambda函数拥有自己的命名空间，除了自有参数列表和全局命名空间里的参数外，其他都不能访问

语法

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

sum = lambda arg1, arg2: arg1 + arg2

print "sum is: ", sum(10, 20)  # 输出： 30

---

return语句

• return语句[表达式]，将计算结果返回

def sumtwonumber(arg1, arg2):
    return arg1+arg2


print sumtwonumber(100, 200)  # 输出: 300

---

变量作用域

• 1. 全局变量：定义在函数外的变量
• 2. 局部变量：定义在函数内的变量，只能在函数内部访问。
• 3. 全局变量想作用与函数内，需要加一个global

total = 1


def sumtwonumber(arg1, arg2):
    total = arg1 + arg2
    print "函数内total: ", total  # 输出: 函数内total: 300
    return total


sumtwonumber(100, 200)  # 输出: 300
print "全局变量: ", total  # 输出: 全局变量: 1

---

模块

• Python模块(Module)，是一个Python文件，以.py结尾

support.py是：
def print_func(var):
    print "Hello ", var
    return


test.py是
import support

support.print_func("thinking")  # 输出：Hello thinking

from ... import

• 语法: from support import print_func

搜索路径

当导入一个模块，Python解析器搜索模块的顺序:

• 1. 当前目录
• 2. 如果当前目录没有，搜索shell变量PYTHONPATH下的每个目录
• 3. 如果找不到，Python会查看默认路径。UNIX路径地址：/usr/local/lib/python

命名空间和作用域

当函数中想修改全局变量，需要使用关键字:global

 Money = 2000


def add_money():
    global Money
    Money = Money + 200


print Money  # 输出：2000
add_money()
print Money  # 输出：2200

dir()函数

dir()函数是一个排好序的字符串列表，内容是一个模块里定义过的名字

import support

print dir(support)  # 输出：['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'print_func']

globals() 和 locals() 函数

• 1. globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
• 2. 在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
• 3. 在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
• 4. 两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

reload()函数

当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。如果想从新执行模块里顶层部分的代码，需要使用reload()函数。

• reload(module_name)

python包

• 1. 包是一个分层次的文件目录结构，可以包含模块，子包和子包的子包等组成的Python的应用环境
• 2. 包其实就是文件夹，但是文件夹下，一定要有文件:__init__.py。文件__init__.py用于标识当前文件夹是一个包

定义包：package_runoob和文件：runoob1.py

def runoob1():
    print "I am runoob1"
    
在测试文件: test.py
import package_runoob.runoob1

package_runoob.runoob1.runoob1()  # 输出: I am runoob1

---

Python文件I/O

• 1. File对象方法：file对象提供了操作文件的一系列方法
• 2. Os对象方法：提供了处理文件及目录的一系列方法

读取键盘输入

Python提供了两个内置函数从标准输入读取一行文本，默认的标准输入是键盘

• 1. raw_input
• 2. input

raw_input

raw_input(提示文字)函数从标准输入读取一行，并返回一个字符串(去掉结尾的换行符)

str = raw_input("请输入: ")  # 输入: thinking
print "输入内容是：", str  # 输出: thinking

input

input函数和raw_input函数基本类似。但input可以接收一个Python表达式输入，并将运算结果返回

str2 = input("请输入: ")  # 输入: [x*5 for x in range(2,10,2)]
print "输入内容是：", str2  # 输出: [10, 20, 30, 40]

注： range函数用法解释: range(start, end, step)

打开和关闭文件

Open方法

Python函数内置一个open()函数

• 1. 语法: file object = open(filename, [, accesscode], [, buffering])
• 2. file_name变量是访问文件的名称字符串
• 3. access_code是决定打开文件的模式：只读，写入，追加等
• 4. buffering：如果buffering的值设为0，就不会有寄存。如果buffering的值设置为1，访问文件会寄存行

close方法

File对象的close()方法：刷新缓冲区里任何还没写的信息，并关闭该文件

write方法

• 1. write(）可将任何字符串写入打开的文件。主要注意的是：Python字符串可以是二进制数据，而不是仅仅是文字
• 2. write()方法不会在字符串的结尾加上换行符('\n')

read方法

• fileObject.read([count])。从已打开的文件中读取字节数，如果没有传，则读入整个文件尾

fileObject = open("test_io_file.txt", "rb+")
fileLine = fileObject.read()
print "context is : ", fileLine
fileObject.close()

文件定位

• 1. tell()方法返回文件内当前读取的位置。也就是说：下次读取的起点位置
• 2. seek(offset,[, from])方法改变当前文件的偏移量。
  • from = 0:从文件开头位置参考
  • from = 1:使用文件的当前位置
  • from = 2:从文件的末尾位置开始

重命名和删除文件

Python提供os模块，帮助执行文件处理操作的方法，比如：重命名和删除文件

• os.rename(currentfilename, newfilename)
• os.remove(file_name)

Python的目录管理

• 1. mdkir()方法：创建新的目录
• 2. chdir()方法：用chdir()方法来改变当前的目录
• 3. getcwd()方法：显示当前的工作目录
• 4. rmdir()方法：删除目录，目录名称以参数传递。注意：删除这个目录之前，所有内容必须已经被删除

---

Python异常处理

异常处理

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生

说明:

• 1. try/except语句理解和java的一样，除了else有点区别
• 2. 如果try子句执行没有发生异常，python就会执行else语句

使用except而不带任何异常类型

• try/except语句中，如果except不带任何异常，表示捕获所有的异常

try:
    正常的操作...
except:
    发生异常，执行这块代码...
else:
    如果没有异常执行这块代码

使用except而带多种异常类型

• 使用相同的except语句而处理多个异常信息

try:
    正常的操作...
except(Exception1[, Exception2[,...ExceptionN]]]):
   发生以上多个异常中的一个，执行这块代码...
else:
    如果没有异常执行这块代码

try-finally语句

• try-finally语句中，无论如何都会执行finally语句

try:
    正常的操作...
except(Exception1):
    发生异常，执行这块代码...
finally:
    无论如何都会执行这段代码

异常的参数

• 异常带上参数，帮助理解异常原因。在except后面加上Argument参数

def temp_convert(var):
    try:
        return int(var)
    except ValueError, Argument:
        print "reason: ", Argument


temp_convert("abc")  # 输出：reason:  invalid literal for int() with base 10: 'abc'

触发异常

• 1. 使用raise语句来触发异常
• 2. 语法：raise [Exception [,args] ]

def throw_excep(var):
    print "function start..."
    raise Exception("you win", var)


try:
    throw_excep("abcd")
except Exception:
    print "catch exception"
else:
    print "no problem."   # 输出: no problem

用户自定义异常

• 创建一个新的异常类，应该继承自Exception类

class Networkerror(Exception):
    def __init__(self, arg):
        self.args = arg

try:
    raise Networkerror("Bad hostname")
except Networkerror, argument:
    print argument.args  # 输出: ('B', 'a', 'd', ' ', 'h', 'o', 's', 't', 'n', 'a', 'm', 'e')