python基本语法

变量赋值

$\hspace{1cm}$ Python的变量不必显式地声明保留的存储器空间。当分配一个值给一个变量的声明将自动发生。等号(=)来赋值给变量。
python可以多重赋值。如给a、b和c都赋值为5,

a=b=c=5

标准的数据类型

$\hspace{1cm}$ 存储在内存中的数据可以是多种类型的。例如，一个人的年龄被存储为一个数字值和他的地址被存储为字母数字字符。Python用于对每个人的操作的各种标准类型定义在存储方法。
$\hspace{1cm}$ Python有五个标准的数据类型：数字、字符串、列表、元组和字典。

Python数字

也可以使用del语句删去有关一些对象。 del语句的语法是：

del var1[,var2[,var3[....,varN]]]]

Python支持四种不同的数值类型：

• int (有符号整数): 通常被称为只是整数或整数，是正或负整数，不带小数点。
• long (长整数 ): 或长，是无限大的整数，这样写整数，后面跟着一个大写或小写的L。
• float (浮点实数值) : 或浮点数，表示实数，并写入一个小数点分隔的整数部分和小数部分。浮点数也可以是科学记数法，用e或E表示的功率10 (2.5e2 = 2.5 x 102 = 250).
• complex (复数) : 形式如 a + bJ，其中a和b是浮点和J（或j）表示-1的平方根（这是一个虚数）。 a是数的实部，b是虚部。Python编程不使用复杂的数字。

例如，这是一些数字例子

int	long	float	complex
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786 0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32.3+e18	.876j
-0490	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

数量类型转换：
Python中含有混合类型计算表达式内部将数字转换为普通类型。但有时，需要从一种类型的显式强制数到另一个类型，以满足操作符或函数参数的要求。

• 类型int（X）将x转换为一个普通的整数。
• 类型long(x)将x转换为一个长整数。
• 类型float(x)转换x为一个浮点数。
• 类型complex(x)转换x为复数与实部x和虚部为零。
• 类型complex(x, y) 将x和y转换成一个复数与实数部分x和虚部y。 x和y是数值表达式

数学函数：
Python包括以下执行数学计算的函数。

函数	返回（描述）
abs(x)	x的绝对值：x和零之间的（正极）的距离。
ceil(x)	x的上限：最小整数不小于x
cmp(x, y)	-1 if x < y, 0 if x == y, 或1 if x > y
exp(x)	x的指数: ex
fabs(x)	x的绝对值
floor(x)	x的地板：最大的整数不大于x
log(x)	x的自然对数，对于x> 0时
log10(x)	以10为底的对数，X>0。
max(x1, x2,…)	它最大的参数：值最接近正无穷大
min(x1, x2,…)	它的最小参数：值最接近负无穷大
modf(x)	x的两个项元组的整数和小数部分。这两个元素具有相同的x符号。整数部分返回一个浮点数。
pow(x, y)	x**y 的值
round(x [,n])	x在小数点四舍五入到n位数字。 Python远离零点决定：round(0.5) 是1.0 而round(0.5) 为-1.0。
sqrt(x)	x的平方根（x>0）

随机数函数：
用于游戏，模拟，测试，安全性和保密性的应用的随机数。Python包括常用以下函数。

函数	描述
choice(seq)	从列表，元组或字符串随机项。
randrange ([start,] stop [,step])	从范围随机选择的元素（启动，停止，步骤）
random()	随机浮点数r，使得0是小于或等于r，r小于1
seed([x])	设置生成随机数使用整数开始值。调用任何其他随机模块函数之前调用这个函数。返回None。
shuffle(lst)	随机化代替列表中的项。返回None。
uniform(x, y)	随机浮点数r，使得x小于或等于r，r小于y

三角函数：
Python包括以下执行三角函数计算功能。

函数	描述
acos(x)	返回x的反余弦值，以弧度形式表示
asin(x)	返回x的反正弦，以弧度形式表示
atan(x)	返回x的反正切值，以弧度表示形式
atan2(y, x)	返回反正切atan(y / x)，以弧度形式表示
cos(x)	返回x 弧度的余弦
hypot(x, y)	返回欧几里德范数，sqrt(x*x + y*y)
sin(x)	返回x的弧度的正弦值
tan(x)	返回x的弧度的正切
degrees(x)	从弧度到度角 x 的转换
radians(x)	从角度到弧度角 x 的转换

数学常数：
该模块还定义了两个数学常数：

常数	描述
pi	数学常数pi
e	数学常数e

$\hspace{1cm}$ 注意：1.Python允许使用一个小写L表示长整型，但建议您只使用一个大写的L到避免和数字1得一样不容易分辨，Python显示长整数用一个大写L；2.复数包含一个有序对表示为a + bj，其中，a是实部，b是复数的虚部实浮点数。

Python字符串

$\hspace{1cm}$ 在Python中的字符串被确定为一组连续的字符在引号之间。 Python允许在任何对单引号或双引号。串的子集，可以使用切片操作符可采用（[]和[:]），索引从0开始的字符串的开始和结束（-1）。
加号（+）符号的字符串连接操作符，而星号（*）表示重复操作。例如：

#!/usr/bin/python

str = 'Hello World!'

print(str)          # Prints complete string
print(str[0])       # Prints first character of the string
print(str[2:5])     # Prints characters starting from 3rd to 5th
print(str[2:])      # Prints string starting from 3rd character
print(str * 2)      # Prints string two times
print(str + "TEST") # Prints concatenated string

Python列表

$\hspace{1cm}$ 列表是最通用的Python复合数据类型。列表中包含以逗号分隔，并在方括号（[]）包含的项目。在一定程度上，列表相似C语言中的数组，它们之间的一个区别是，所有属于一个列表中的项目可以是不同的数据类型的。
$\hspace{1cm}$ 存储在一个列表中的值可以使用切片操作符来访问（[]和[：]）用索引从0开始，在列表的开始位置和结束为- 加号（+）符号列表连接运算符，星号（*）重复操作。例如：

#!/usr/bin/python

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

print(list)         # Prints complete list
print(list[0])      # Prints first element of the list
print(list[1:3])    # Prints elements starting from 2nd till 3rd 
print(list[2:])     # Prints elements starting from 3rd element
print(tinylist * 2) # Prints list two times
print(list + tinylist) # Prints concatenated lists

这将产生以下结果：
[‘abcd’, 786, 2.23, ‘john’, 70.200000000000003]
abcd
[786, 2.23]
[2.23, ‘john’, 70.200000000000003]
[123, ‘john’, 123, ‘john’]
[‘abcd’, 786, 2.23, ‘john’, 70.200000000000003, 123, ‘john’]

Python元组

元组是类似于列表中的序列数据类型。一个元组由数个逗号分隔的值。不同于列表，不过，元组圆括号括起来。

列表和元组之间的主要区别是：列表括在括号（[]）和它们的元素和大小是可以改变的，而元组在圆括号()，不能被更新。元组可以被认为是只读列表。例如：

#!/usr/bin/python

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
tinytuple = (123, 'john')

print(tuple)           # Prints complete list
print(tuple[0])        # Prints first element of the list
print(tuple[1:3])      # Prints elements starting from 2nd till 3rd 
print(tuple[2:])       # Prints elements starting from 3rd element
print(tinytuple * 2)   # Prints list two times
print(tuple + tinytuple) # Prints concatenated lists

Python字典

Python字典是一种哈希表型。字典键几乎可以是任何Python类型，但通常是数字或字符串。值可以是任意Python的对象。字典是由花括号括号（{}），可分配值，并用方括号（[]）访问。例如：

 #!/usr/bin/python

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

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


print(dict['one'])       # Prints value for 'one' key
print(dict[2])           # Prints value for 2 key
print(tinydict)          # Prints complete dictionary
print(tinydict.keys())   # Prints all the keys
print(tinydict.values()) # Prints all the values

数据类型转换

类型之间的转换，只需使用类名作为函数。

int	long	float	complex
函数 描述
int(x [,base])	将x转换为一个整数。基数指定为base，如果x是一个字符串。
long(x [,base] )	将x转换为一个长整数。基数指定为base，如果x是一个字符串。
float(x)	将x转换到一个浮点数。
complex(real [,imag])	创建一个复数。
str(x)	转换对象x为字符串表示形式。
repr(x)	对象x转换为一个表达式字符串。
eval(str)	计算一个字符串，并返回一个对象。
tuple(s)	把s转换为一个元组。
list(s)	把s转换为一个列表。
set(s)	把s转换为一个集合。
dict(d)	创建一个字典。 d必须的（键，值）元组序列。
frozenset(s)	把s转换为冻结集。
chr(x)	整数转换为一个字符。
unichr(x)	整数转换为一个Unicode字符。
ord(x)	转换单个字符为整数值。
hex(x)	将整数转换为十六进制字符串。
oct(x)	将整数转换为以八进制的字符串。

基本运算操作符

$\hspace{1cm}$ 简单的回答可以使用表达式4+5等于9，在这里4和5被称为操作数，+被称为操符。Python语言支持操作者有以下几种类型。

• 算术运算符
• 比较(即关系)运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 会员操作符
• 标识操作符

算术运算符

假设变量a持有10和变量b持有20，则：

操作符	描述符	例子
+	加法 - 对操作符的两侧增加值	a + b = 30
-	减法 - 减去从左侧操作数右侧操作数	a - b = -10
*	乘法 - 相乘的运算符两侧的值	a * b = 200
/	除 - 由右侧操作数除以左侧操作数	b / a = 2
%	模 - 由右侧操作数和余返回除以左侧操作数	b % a = 0
**	指数- 执行对操作指数（幂）的计算	a**b = 10 的幂 20
//	地板除 - 操作数的除法，其中结果是将小数点后的位数被除去的商。	9//2 = 4 而 9.0//2.0 = 4.0

比较操作符

运算符	描述	示例
==	检查，两个操作数的值是否相等，如果是则条件变为真。	(a == b) 不为 true.
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	(a != b) 为 true.
<>	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	(a <> b) 为 true。这个类似于 != 运算符
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	(a > b) 不为 true.
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	(a < b) 为 true.
=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	(a >= b) 不为 true.
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	(a <= b) 为 true.

赋值运算符

运算符	描述	示例
=	简单的赋值运算符，赋值从右侧操作数左侧操作数 c = a + b将指定的值	a + b 到 c
+=	加法AND赋值操作符，它增加了右操作数左操作数和结果赋给左操作数	c += a 相当于 c = c + a
-=	减AND赋值操作符，它减去右边的操作数从左边操作数，并将结果赋给左操作数	c -= a 相当于 c = c - a
*=	乘法AND赋值操作符，它乘以右边的操作数与左操作数，并将结果赋给左操作数	c = a 相当于 c = c a
/=	除法AND赋值操作符，它把左操作数与正确的操作数，并将结果赋给左操作数	c /= a 相当于= c / a
%=	模量AND赋值操作符，它需要使用两个操作数的模量和分配结果左操作数	c %= a is equivalent to c = c % a
**=	指数AND赋值运算符，执行指数（功率）计算操作符和赋值给左操作数	c = a 相当于 c = c a
//=	板除，并分配一个值，执行地板除对操作和赋值给左操作数	c //= a 相当于 c = c // a

位运算符

位运算符作用于位和位操作执行位。假设，如果a =60;且b =13;现在以二进制格式它们将如下：

a = 0011 1100

b = 0000 1101

---

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

操作符	描述	示例
&	二进制和复制操作了一下，结果，如果它存在于两个操作数。	(a & b) = 12 即 0000 1100
|	二进制或复制操作了一个比特，如果它存在一个操作数中。	(a
^	二进制异或运算符的副本，如果它被设置在一个操作数而不是两个比特。	(a ^ b) = 49 即 0011 0001
~	二进制的补运算符是一元的，并有“翻转”位的效果。	(~a ) = -61 即 1100 0011以2的补码形式由于带符号二进制数。
<<	二进位向左移位运算符。左操作数的值左移由右操作数指定的位数。	a << 2 = 240 即 1111 0000
>>	二进位向右移位运算符。左操作数的值是由右操作数指定的位数向右移动。	a >> 2 = 15 即 0000 1111

逻辑运算符

Python语言支持以下逻辑运算符。

运算符	描述	示例
and	所谓逻辑与运算符。如果两个操作数都是真的，那么则条件成立。	(a and b) 为 true.
or	所谓逻辑OR运算符。如果有两个操作数都是非零然后再条件变为真。	(a or b) 为 true.
not	所谓逻辑非运算符。用于反转操作数的逻辑状态。如果一个条件为真，则逻辑非运算符将返回false。	not(a and b) 为 false.

成员运算符

操作符	描述	示例
in	计算结果为true，如果它在指定找到变量的顺序，否则false。	x在y中，在这里产生一个1，如果x是序列y的成员。
not in	计算结果为true，如果它不找到在指定的变量顺序，否则为false。	不在y中，这里产生结果不为1，如果x不是序列y的成员。

标识运算符

标识符比较两个对象的内存位置。

运算符	描述	例子
is	计算结果为true，如果操作符两侧的变量指向相同的对象，否则为false。	x是y，这里结果是1，如果id（x）的值为id（y）。
is not	计算结果为false，如果两侧的变量操作符指向相同的对象，否则为true。	x不为y，这里结果不是1，当id（x）不等于id（y）。

运算符优先级

所有运算符从最高优先级到最低。

运算符	描述
**	幂（提高到指数）
~ + -	补码，一元加号和减号（方法名的最后两个+@和 - @）
* / % //	乘，除，取模和地板除
+ -	加法和减法
>> <<	左，右按位转移
&	位’AND’
^ |	按位异’或'和定期或’
<= < > >=	比较运算符
<> == !=	等式运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	标识运算符
in not in	成员运算符
not or and	逻辑运算符

判断语句

$\hspace{1cm}$ 在Python编程语言中，假定任何非零和非null为true；如果是零或null，则假定为false值。Python编程语言提供了以下几种类型的决策语句。

语句	描述
if 语句	if语句由一个布尔表达式后跟一个或多个语句。
if…else 语句	if语句后面可以跟一个可选的else语句，该语句执行时，布尔表达式为假。
内嵌 if 语句	可以使用一个if或else if语句，如果另一个if 或 else if语句中声明。
如果一个if语句只包含一行，会在同一行作为头语句。

如：

#!/usr/bin/python

var = 100
if ( var  == 100 ) : print("Value of expression is 100")
print("Good bye!")

循环语句

$\hspace{1cm}$ Python编程语言提供了以下类型的循环处理循环的要求。点击以下链接，查看其详细信息。

循环类型	描述
while循环	重复一个或一组声明语句，当给定的条件为真。它测试的条件在执行循环体之前。
for循环	执行的语句多次的顺序，它管理循环变量的代码。
内嵌循环	您可以使用一个或多个循环内部，使用任何while在do..while循环。

循环控制语句：
循环控制语句改变其正常的顺序执行。当执行留下作用域，在该范围内创建的所有对象自动销毁。

Python支持以下控制语句。点击以下链接，查看其详细信息。

控制语句	描述
break语句	终止循环语句并将执行立即循环下面的语句。
continue语句	导致循环跳过循环体的其余部分，并立即重新测试其状态重申之前状态位置。
pass语句	在Python中的pass语句使用当语句要求不希望任何命令或代码来执行。

日期和时间

$\hspace{1cm}$ Python程序可以处理多种方式的日期和时间。日期格式之间的转换是一种常见计算机的杂活。 Python的时间和日历模块，能帮助处理日期和时间。

Tick是什么?
时间间隔为浮点数以秒为单位的数字。在特定的时间瞬间自上午12时00分，1970年1月1日(纪元)表示，单位为秒。

Python中可用的流行时间模块，它提供功能转换。该功能time.time()返回当前系统时间，因为上午12点，1970年1月1日(时代)。

例子:

#!/usr/bin/python
import time;  # This is required to include time module.

ticks = time.time()
print "Number of ticks since 12:00am, January 1, 1970:", ticks

这将产生一个结果如下：

Number of ticks since 12:00am, January 1, 1970: 7186862.73399
日期计算是很容易。不过当日的时代之前，不能以这种形式来表示。在遥远的将来的日期也不能代表这种方式- 分界点是一段2038年在UNIX和Windows。

什么是TimeTuple？
Python的时间函数处理时间为9个数字的元组，如下图所示：

索引	字段	值
0	年（四位数字）	2015
1	月份	1 - 12
2	日期	1 - 31
3	小时	0 - 23
4	分钟	0 - 59
5	秒	0 - 61 (60 或 61是闰秒)
6	星期	0 - 6 (0 为星期一)
7	一年中的第几天	1 - 366 (Julian日期)
8	夏令时	-1, 0, 1, -1 表示库决定DST

上面的元组相当于struct_time结构。这种结构具有以下属性：

索引	属性	值
0	tm_year	2018
1	tm_mon	1 - 12
2	tm_mday	1 - 31
3	tm_hour	0 - 23
4	tm_min	0 - 59
5	tm_sec	0 - 61 (60 或 61 是闰秒)
6	tm_wday	0 to 6 (0 为星期一)
7	tm_yday	1 to 366 (Julian日期)
8	tm_isdst	-1, 0, 1, -1 表示库决定DST

获取当前时间 ：
转换一个时刻从秒epoch浮点值转换成时元组，浮点值传递给函数（例如，本地时间）返回时间元组的全部九项有效。

#!/usr/bin/python
import time;

localtime = time.localtime(time.time())
print "Local current time :", localtime

这将产生下面的结果，这可以在任何其他像样形式被格式化：

Local current time : time.struct_time(tm_year=2013, tm_mon=7,
tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=198, tm_isdst=0)
获取格式化的时间 ：
可以随时根据要求格式化，但简单的方法来获取时间，可读的格式是asctime()：

#!/usr/bin/python
import time;

localtime = time.asctime( time.localtime(time.time()) )
print "Local current time :", localtime

这将产生以下结果:

Local current time : Tue Jan 13 10:17:09 2009
获取日历月份：
日历模块提供了广泛的方法，如有年和月的日历。在这里，我们打印日历给定月份（2015年1月）：

 #!/usr/bin/python
import calendar

cal = calendar.month(2015, 1)
print "Here is the calendar:"
print cal;

这将产生以下结果:

Here is the calendar:
January 2008
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 29 30 31
time模块:
Python中可用的流行时间模块，时间之间转换提供了以下一些函数。下面是所有可用方法的列表：

SN	方法	描述
1	time.altzone	当地DST时区的偏移量，如果一个定义在UTC西部秒钟。这是负值，如果当地的DST时区为UTC东边（如西欧，包括英国）。如果白天不为零只用这个。
2	time.asctime([tupletime])	接受一个时间元组，并返回一个可读的24个字符的字符串，如“Tue Dec 11 18:07:14 2015’。
3	time.clock( )	返回当前CPU时间为几秒钟的浮点数。以测量不同方法的计算成本，time.clock的值比time.time()更有用
4	time.ctime([secs])	类似asctimeasctime(localtime(secs))，不带参数就像asctime()
5	time.gmtime([secs])	接收表示从epoch秒钟的瞬间，并返回一个时间元组t及UTC时间。注意：t.tm_isdst始终为0
6	time.localtime([secs])	接收表示从epoch秒钟的瞬间，并返回一个时间元组t与被本地时间（t.tm_isdst是0或1，这取决于是否DST的适用于即时秒通过本地规则）
7	time.mktime(tupletime)	接受表示为一个时间的元组中的本地时间瞬间，并返回浮点值从epoch以秒表示的时刻
8	time.sleep(secs)	暂停secs秒钟调用线程
9	time.strftime(fmt[,tupletime])	接收表示为一个时间的元组中的本地时间瞬间并返回表示所指定的字符串fmt瞬间的字符串
10	time.strptime(str,fmt=’%a %b %d %H:%M:%S %Y’)	根据格式字符串格式化解析str并返回时间元组格式
11	time.time( )	返回当前时刻，自时代浮点秒数
12	time.tzset()	重置所使用的库例程的时间转换规则。环境变量TZ指定如何完成此操作。

下列是时间time模块提供两个重要的属性：

SN	属性及描述
1	time.timezone 属性time.timezone是从UTC（>0，在美洲;<=0，在大多数欧洲，亚洲，非洲），抵销了本地时区的秒钟（不含DST）。
2	time.tzname属性time.tzname是一对语言环境相关的字符串，这是本地时区的名称。

calendar 模块
日历calendar模块提供与日历相关的功能，包括功能来打印一个文本日历对于给定的月份或年份。

默认情况下，日历把星期一作为一周的第一天，周日为最后一天。要改变这种情况，调用calendar.setfirstweekday()函数。

下面是日历calendar模块可用的功能列表：

SN	方法	描述
1	calendar.calendar(year,w=2,l=1,c=6)	返回为多行字符串的逐年日历格式化成用c空格分隔的三列。 w是中的每一个日期字符的宽度;每行的长度为21* w +18+2* c。 l为每个星期的行数。
2	calendar.firstweekday( )	返回当前设置为每个星期开始工作日。默认情况下，当先导入calendar，这是0，意思是星期一。
3	calendar.isleap(year)	如果今年是闰年返回true，否则为false。
4	calendar.leapdays(y1,y2)	返回范围内的总数在range(y1,y2)。
5	calendar.month(year,month,w=2,l=1)	返回为多行字符串与日历月month年year，每周一条线加上两个标题行。 w是中的每一个日期字符的宽度;每行的长度为7* W +6。 l为每个星期的行数。
6	calendar.monthcalendar(year,month)	返回整数的列表。每个子列表表示一个星期。月month年year都设置为0;在一个月内，day都被设置为一天，月份，1及以上的数字。
7	calendar.monthrange(year,month)	返回两个整数。第一个是星期几月month年year的第一天的代码;第二个是在所述月份的天数。星期代码是0（星期一）至6日（星期日）;月数是1〜12。
8	calendar.prcal(year,w=2,l=1,c=6)	打印类似calendar.calendar(year,w,l,c).
9	calendar.prmonth(year,month,w=2,l=1)	打印类似calendar.month(year,month,w,l).
10	calendar.setfirstweekday(weekday)	将每个星期的第一天工作日代码设置。星期代码是0（星期一）至6日（星期日）。
11	calendar.timegm(tupletime)	time.gmtime的反向：接受一个时刻在时间元组的形式，并返回同一时刻为从epoch浮点秒数。
12	calendar.weekday(year,month,day)	返回给定日期的星期代码。星期代码0（星期一）至6日（星期日）;月份数字代码为1（一月）到12（12月）。

其它日期和时间模块和函数：

• datetime 模块
• pytz 模块
• dateutil 模块

函数

函数是有组织的，可重复使用的代码，用于执行一个单一的，相关的动作的块。函数为应用程序和代码重用的高度提供了更好的模块。
Python的print()等许多内置函数，但也可以创建自己的函数。这些函数称为用户定义函数。

定义一个函数

可以定义函数，以提供所需的功能。下面是简单的规则来定义Python函数。

• 函数块以开始关键字def后跟函数名和括号中(())。
• 任何输入参数或参数应该放在这些括号内。还可以定义这些括号内的参数。
• 函数的第一个语句可以是​​一个可选的声明 - 该函数或文档字符串的文档字符串。
• 每个函数中的代码块以冒号(:)开头并缩进。
• 该语句返回[表达式]退出功能，可选地传递回一个表达式给调用者。不带参数return语句返回None。

语法:
···
def functionname( parameters ):
“function_docstring”
function_suite
return [expression]
···
默认情况下，参数具有一个位置的行为和需要，它们被定义为通知他们以相同的顺序。

例子：
这是最简单的Python函数形式。这个函数接受一个字符串作为输入参数，并打印标准的屏幕上。
···
def printme( str ):
“This prints a passed string into this function”
print str
return
···
调用函数
定义一个函数只给出它的名称，指定要被包括在功能和结构的代码块的参数。

一旦函数的基本结构确定后，可以通过从其他函数或直接从Python提示符调用它执行它。以下是示例调用printme()函数：

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str;
   return;

# Now you can call printme function
printme("I'm first call to user defined function!");
printme("Again second call to the same function");

当执行上面的代码中，产生以下结果：

I’m first call to user defined function!
Again second call to the same function
引用VS值传递
所有参数（参数）在Python语言是通过引用传递。这意味着，如果你在一个函数中改变了一个参数的值，变化也反映了在调用函数中。例如：

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

这里，我们保持传递的对象的参考，并在同一个对象附加的值。这样，这将产生以下结果：

Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]
Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

还有就是参数通过引用传递和引用被覆盖在被调用的函数里面一个例子。

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4]; # This would assig new reference in mylist
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

参数myList上局部函数changeme。更改函数内mylist不影响mylist。函数没有作用，最后这会产生以下结果：

Values inside the function:  [1, 2, 3, 4]
Values outside the function:  [10, 20, 30]

函数参数

可以通过使用形参的类型如下调用函数：

• 必需的参数
• 关键字参数
• 默认参数
• 可变长度参数

必需的参数

所需的参数为传递给正确的位置顺序的函数的参数。这里，在函数调用的参数的数目应与函数定义完全匹配。

调用函数printme()，一定要传递一个参数，否则会如下给出一个语法错误：

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str;
   return;

# Now you can call printme function
printme();

当执行上面的代码，产生以下结果：

Traceback (most recent call last):
  File "test.py", line 11, in <module>
    printme();
TypeError: printme() takes exactly 1 argument (0 given)

关键字参数

关键字参数是关系到函数调用。当在一个函数调用中使用关键字参数，调用者通过参数名称标识的参数。

这可以跳过参数或脱离顺序，因为Python解释器能够使用提供的参数使用匹配的值的关键字。还可以使关键字调用在以下方面printme()函数：

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str;
   return;

# Now you can call printme function
printme( str = "My string");

当执行上面的代码中，产生以下结果：

My string
下面的例子给出了更清晰的画面。请注意，这里跟参数秩序没有关系。

#!/usr/bin/python

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print "Name: ", name;
   print "Age ", age;
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" );

当执行上面的代码，产生以下结果：

Name:  miki
Age  50

默认参数：
默认参数是，假设一个默认值，如果不提供的函数调用的参数值的参数。下面的例子给出了默认参数一个主意，它会默认打印age，如果不通过传值：

#!/usr/bin/python

# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print "Name: ", name;
   print "Age ", age;
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" );
printinfo( name="miki" );

当执行上面的代码，产生以下结果：

Name:  miki
Age  50
Name:  miki
Age  35

可变长度参数

可能需要处理函数比在定义函数指定多个参数。这些参数被称为可变长度参数，在函数定义没有被命名，不像必需默认参数。

非关键字可变参数的函数的一般语法是这样的：

def functionname([formal_args,] *var_args_tuple ):
   "function_docstring"
   function_suite
   return [expression]

星号（*）被放置，将持有的所有非关键字变量参数的值在变量名前。该元组保持为空，如果函数调用期间没有指定任何其他参数。下面是一个简单的例子：

#!/usr/bin/python

# Function definition is here
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print "Output is: "
   print arg1
   for var in vartuple:
      print var
   return;

# Now you can call printinfo function
printinfo( 10 );
printinfo( 70, 60, 50 );

当执行上面的代码，产生以下结果：

Output is:
10
Output is:
70
60
50

匿名函数

可以使用lambda关键字来创建小的匿名函数。这些函数被称为匿名，因为它们不是以标准方式通过使用def关键字声明。

Lambda形式可以采取任何数量的参数，但在表现形式上只返回一个值。它们不能包含命令或多个表达式。

匿名函数不能直接调用打印，因为需要lambda表达式。

lambda函数都有自己的命名空间，并且不能访问变量高于在其参数列表和那些在全局命名空间等。

尽管似乎lambda是一个函数的单行版本，它们不是在C或C++，其宗旨是通过调用出于性能原因在传递函数的堆栈分配相当于一行的声明。

语法
lambda函数的语法仅包含单个语句，如下：

lambda [arg1 [,arg2,…..argn]]:expression
以下为例子来说明函数lambda形式是如何工作的：

#!/usr/bin/python

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;



# Now you can call sum as a function
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )

当执行上面的代码，产生以下结果：

Value of total :  30
Value of total :  40

return语句：
该语句返回[表达式]退出功能，可选地传递回一个表达式给调用者。不带参数return语句返回None。

以上所有的例子都没有返回任何值，但如果喜欢，可以从一个函数返回值：

#!/usr/bin/python

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print "Inside the function : ", total
   return total;

# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total 

当执行上面的代码，产生以下结果：

Inside the function :  30
Outside the function :  30

变量的作用域

程序中的所有变量可能不会在该程序中的所有位置进行访问。这取决于所声明的变量。

变量的作用域确定了程序，可以访问一个特定的标识符的一部分。在Python中的变量两个基本范畴：

全局变量
局部变量

全局与局部变量：
这是一个函数体内部定义的变量具有局部范围，而那些之外定义具有全局范围。

局部变量只能在函数内部被声明和访问，而全局变量可以在整个程序主体由所有函数进行访问。当调用一个函数，它里面声明的变量都纳入范围。下面是一个简单的例子：

 #!/usr/bin/python

total = 0; # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print "Inside the function local total : ", total
   return total;

# Now you can call sum function
sum( 10, 20 );
print "Outside the function global total : ", total 

当执行上面的代码，产生以下结果：

Inside the function local total :  30
Outside the function global total :  0

模块

一个模块可以在逻辑上组织Python代码。将相关的代码到一个模块中，使代码更容易理解和使用。模块是可以绑定和借鉴任意命名属性的Python对象。

简单地说，一个模块是由Python代码的文件。一个模块可以定义函数，类和变量。模块还可以包括可运行的代码。

例子:
Python代码的模块名为aname通常位于一个名为aname.py。下面是一个简单的模块，support.py作为例子

def print_func( par ):
   print "Hello : ", par
   return

import语句

可以通过在其他一些Python源文件执行import语句来使用任何Python源文件作为一个模块。import的语法如下：

import module1[, module2[,… moduleN]
当解释器遇到import语句，它导入(import)模块如果模块出现在搜索路径。搜索路径是一个目录列表，该解释器导入模块之前搜索。例如，导入模块hello.py，需要把下面的命令在脚本的顶部：

#!/usr/bin/python

# Import module support
import support

# Now you can call defined function that module as follows
support.print_func("Zara")

当执行上面的代码，产生以下结果：

Hello : Zara

一个模块被加载一次，不管导入的次数。这可防止模块执行发生多次导入。

from…import 语句

Python的from语句可以从一个模块中导入特定的属性到当前的命名空间。from…import 语法如下：

from modname import name1[, name2[, ... nameN]]

例如，从模块fib导入函数fibonacci，使用下面的语句：

from fib import fibonacci

此语句不导入整个模块fib到当前的命名空间;它只是介绍了fibonacci从模块fib导入模块的全局符号表列。

from…import * 语句:
它也可以通过使用下面的import语句导入从模块到当前的命名空间的所有名称：

from modname import *
这提供了导入从模块到当前的命名空间中的所有项目一个简单的方法;不过，这个语句应谨慎使用。

定位模块：
当导入一个模块，在下列序列模块由Python解释器搜索：

当前目录

如果未找到该模块，然后Python搜索在shell变量PYTHONPATH每个目录

如果这些方法都失败，Python会检查默认路径。在UNIX上，默认路径是正常是/usr/local/lib/python/

模块搜索路径被存储在系统模块sys作为所述的sys.path变量。在sys.path的变量包含当前目录，PYTHONPATH和相关的默认安装。

PYTHONPATH变量：
在PYTHONPATH是一个环境变量，包括目录列表中。 PYTHONPATH的语法shell变量PATH相同。

下面是Windows系统的典型PYTHONPATH：

set PYTHONPATH=c:python20lib;
这里是UNIX系统的典型PYTHONPATH：

set PYTHONPATH=/usr/local/lib/python

命名空间和作用域

变量名称（标识）映射到对象。名称空间是变量名（键）及其相应的对象（的值）的字典。

Python语句可以在本地命名空间和全局命名空间访问变量。如果局部和全局变量同名，局部变量屏蔽全局变量。

每个函数都有自己的命名空间。类方法遵循相同的作用域规则为普通函数。

Python对变量是否为局部或全局进行假定猜测。它假定任何变量赋值函数中的值是局部的。

因此为了使一个函数内的值赋给一个全局变量，必须先使用global语句。

声明 global VarName 告诉Python VarName是一个全局变量。Python 停止寻找该变量的局部命名空间。

例如，我们在全局命名空间中定义的变量Money 。在该函数的Money ，我们给定Money 的值，因此Python 假定Money 为局部变量。但是，我们设定它，所以一个UnboundLocalError是结果之前访问的局部变量Money 的值。取消global语句解决了这个问题。

#!/usr/bin/python

Money = 2000
def AddMoney():
   # Uncomment the following line to fix the code:
   # global Money
   Money = Money + 1

print Money
AddMoney()
print Money

dir( ) 函数:
使用dir()内置函数返回一个包含一个模块中定义名称的字符串的排序列表。

该列表包含在一个模块中定义的所有模块，变量和函数的名称。下面是一个简单的例子：

#!/usr/bin/python

# Import built-in module math
import math

content = dir(math)

print content;

当执行上面的代码，产生以下结果：

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 
'sqrt', 'tan', 'tanh']

在这里，特殊字符串变量name是模块的名称，file是从中加载的模块的文件名。

globals()和 locals()函数：
globals() 和 locals() 函数可用于返回在根据在它们被称为位置的全局和局部名称空间的名称。

如果locals()被一个函数中调用时，它会返回所有可以在局部从函数访问的名称。

如果globals()从一个函数中调用时，它会返回所有可以从全局函数进行访问的名称。

这两个函数的返回类型是字典。因此，名称可以使用keys()函数提取出来。

reload()函数：
当该模块被导入到一个脚本，在一个模块的顶层部分的代码只执行一次。

因此，如果你想重新执行的顶级代码模块中，可以使用reload()函数。reload()函数导入先前导入的模块了。reload()函数的语法是这样的：

reload(module_name)
在这里，module_name是要重装，不包含模块名字符串的模块的名称。例如，要重新加载hello模块，请执行以下操作：

reload(hello)
Python中的包：
包是用于定义由模块和子包和子子包等的单一的Python应用环境的分层文件目录结构。

考虑一个文件Pots.py在Phone目录中可用。此文件的源代码如下一行：

#!/usr/bin/python

def Pots():
   print "I'm Pots Phone"

类似的方法，我们具有不同功能的另两个文件具有相同的名称如上：

Phone/Isdn.py文件有函数 Isdn()
Phone/G3.py 文件有函数 G3()

现在，创建在Phone目录中多了一个文件init.py：

Phone/init.py
为了让所有的功能可用，当导入Phone，需要把init.py明确的import语句如下：

from Pots import Pots
from Isdn import Isdn
from G3 import G3

当添加完这些行到init.py，那么已经导入了Phone包所有这些类的使用。

#!/usr/bin/python

# Now import your Phone Package.
import Phone

Phone.Pots()
Phone.Isdn()
Phone.G3()

当执行上面的代码，产生以下结果：

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

在上面的例子我们采取示例每个文件单个函数，但可以保留文件中多个函数。还可以在这些文件定义不同的Python类，可以在包外创建那些类。

I/O文件

打印到屏幕上：
产生输出最简单的方法是使用print语句，可以通过用逗号分隔的零个或多个表达式。该函数将传递到一个字符串表达式，并将结果写到标准输出，如下所示：

#!/usr/bin/python

print "Python is really a great language,", "isn't it?";

这将产生结果输出在标准屏幕上，结果如下：

Python is really a great language, isn't it?

读取键盘输入：
Python提供了两个内置的函数来读取一行，从标准输入，默认情况下是来自键盘的文本。这些函数包括：

• raw_input
• input

raw_input 函数:
语法：raw_input([prompt])
功能描述：从标准输入读取一行并返回一个字符串(去掉结尾的换行)。

#!/usr/bin/python

str = raw_input("Enter your input: ");
print("Received input is : ", str)

这将提示您输入字符串，它会在屏幕上显示相同的字符串。当输入“Hello Python!”，它的输出是这样的：

Enter your input: Hello Python
Received input is :  Hello Python

input函数:
语法：input([prompt])
功能描述：功能相当于raw_input，只是它假设输入的是一个有效的Python表达式，并返回计算结果。

#!/usr/bin/python

str = input("Enter your input: ");
print "Received input is : ", str

对所输入这将产生结果如下：

Enter your input: [x*5 for x in range(2,10,2)]
Recieved input is :  [10, 20, 30, 40]

打开和关闭文件

可以使用一个文件对象file来做大部分文件操作。

open函数:
语法: file object = open(file_name [, access_mode][, buffering])
功能描述：想要读取或写入文件，必须使用Python内置的open()函数来打开它。该函数创建一个文件对象，这将用来调用与之关联的其他支持方式。
参数描述：
file_name: file_name参数是一个字符串值，包含您要访问的文件的名称。
access_mode:它决定了文件必须被打开，即，读，写，追加等的可能值是下表中给定的一个完整的列表的模式。这是可选参数，默认文件存取方式为read(r)。
buffering:如果缓冲值被设置为0时，没有缓冲将发生。如果该缓冲值是1，行缓冲会在访问一个文件来执行。如果指定的缓冲值为大于1的整数，则缓冲作用将与所指示的缓冲区的大小进行。如果为负，则缓冲区的大小是系统默认（默认行为）。

这里是打开一个文件的​​不同模式的列表：

模式	描述
r	打开一个文件为只读。文件指针置于该文件的开头。这是默认模式。
rb	打开一个文件只能以二进制格式读取。文件指针置于该文件的开头。这是默认模式。
r+	打开用于读取和写入文件。文件指针将会在文件的开头。
rb+	打开用于读取和写入二进制格式的文件。文件指针将会在文件的开头。
w	打开一个文件只写。覆盖该文件，如果该文件存在。如果该文件不存在，则创建用于写入一个新的文件。
wb	打开一个文件只能以二进制格式写入。覆盖该文件，如果该文件存在。如果该文件不存在，则创建用于写入一个新的文件。
w+	打开用于写入和读取的文件。覆盖现有的文件，如果文件存在。如果该文件不存在，则创建读取和写入新的文件。
wb+	打开用于写入和读取的二进制格式的文件。覆盖现有的文件，如果文件存在。如果该文件不存在，则创建读取和写入新的文件。
a	将打开追加文件。文件指针是在文件的结尾。也就是说，该文件是在附加模式。如果该文件不存在，它创造了写入一个新的文件。
ab	将打开追加的二进制格式的文件。文件指针在该文件的结束。也就是说，该文件为追加模式。如果该文件不存在，它创建并写入一个新的文件。
a+	打开为追加和读取文件。文件指针在该文件的结束。该文件将为追加模式。如果该文件不存在，它创建并读取和写入的新文件。
ab+	打开两个追加和读取的二进制格式的文件。文件指针在该文件的结束。该文件将在追加模式。如果该文件不存在，它创建并读取和写入的新文件。

file 对象属性:
一旦文件被打开，文件对象可以得到有关该文件的各种信息。

下面是文件对象相关的所有属性的列表：

属性	描述
file.closed	如果文件被关闭则返回true，否则返回false。
file.mode	返回该文件被打开的访问模式。
file.name	返回文件的名称。
file.softspace	如果空间明确要求具有打印返回false，否则返回true。

例子：

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
print "Name of the file: ", fo.name
print "Closed or not : ", fo.closed
print "Opening mode : ", fo.mode
print "Softspace flag : ", fo.softspace

这将产生以下结果:

Name of the file:  foo.txt
Closed or not :  False
Opening mode :  wb
Softspace flag :  0

close()方法:
功能描述：刷新未写入的信息，并关闭该文件的对象。
语法： fileObject.close();
例子：

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
print "Name of the file: ", fo.name

# Close opend file
fo.close()

这将产生以下结果:

Name of the file: foo.txt

读取和写入文件

file对象提供了一组访问方法。我们来看看如何使用read()和write()方法来读取和写入文件。

write() 方法:
write()方法写入字符串到任何一个打开的文件。要注意的是Python字符串可以具有二进制数据，而不仅仅是文字。

write()方法不要将换行字符（’ ‘）添加到字符串的结尾：

语法：fileObject.write(string);
参数描述：
string 要写入到打开的文件的内容。

例子

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
fo.write( "Python is a great language. Yeah its great!!");

# Close opend file
fo.close()

上面的方法会创建 foo.txt 文件，并会将给定的内容写在该文件中，并最终将关闭该文件。

Python is a great language.
Yeah its great!!

read() 方法:
read()方法读取一个打开的文件的字符串。要注意的是Python字符串可以具有二进制数据，而不仅仅是文本。
语法: fileObject.read([count]);
这里，传递的参数是从打开的文件中读出的字节数。此方法从该文件的开头读取，如果计数丢失，那么它会尝试尽可能多地读取，直到文件的末尾。

例子, 这里以一个文件foo.txt作为例子，这是在上面创建的。

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10);
print "Read String is : ", str
# Close opend file
fo.close()

这将产生以下结果:

Read String is :  Python is

文件位置

tell()方法告诉该文件中的当前位置;换句话说，下一个读取或写入将发生在从该文件的开头的字节数。

seek(offset[, from])
功能描述：方法会更改当前的文件位置。偏移参数指示要移动的字节数。从该参数指定字节将被移至参考点。如果from被设置为0，这意味着使用该文件的开始处作为基准位置，设置为1则是使用当前位置作为基准位置，如果它被设置为2，则该文件的末尾将被作为基准位置。

例子，让我们以一个文件foo.txt，这是上面创建。

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10);
print "Read String is : ", str

# Check current position
position = fo.tell();
print "Current file position : ", position

# Reposition yiibaier at the beginning once again
position = fo.seek(0, 0);
str = fo.read(10);
print "Again read String is : ", str
# Close opend file
fo.close()

这将产生以下结果:

Read String is :  Python is
Current file position :  10
Again read String is :  Python is

重命名和删除文件

Python的os模块提供了一些方法，可以帮助执行文件处理操作，如重命名和删除文件。要使用这个模块，需要先导入它，然后调用相关的功能。

rename()方法:
参数描述：有两个参数，当前文件名和新文件名。
语法: os.rename(current_file_name, new_file_name)
例子，以下是例子来重命名文件test1.txt：

#!/usr/bin/python
import os

# Rename a file from test1.txt to test2.txt
os.rename( "test1.txt", "test2.txt" )

remove()方法:
功能描述：删除文件。
语法: os.remove(file_name)
例子，以下为示例删除现有文件test2.txt：

#!/usr/bin/python
import os

# Delete file test2.txt
os.remove("text2.txt")

Python中的目录

所有的文件都包含不同的目录中，而在Python中处理这些没有问题。os模块有几种方法，可以帮助创建，删除和更改目录。

mkdir()方法:
功能描述：创建目录。
语法: os.mkdir(“newdir”)
例子，以下为示例在当前目录下创建test目录如下所示：

#!/usr/bin/python
import os

# Create a directory "test"
os.mkdir("test")

chdir()方法:
功能描述：改变当前目录。chdir()方法接受一个参数，那就是要成为当前目录的目录的名称。
语法: os.chdir(“newdir”)
例子，下面是一个进入“/home/newdir”目录的例子：

#!/usr/bin/python
import os

# Changing a directory to "/home/newdir"
os.chdir("/home/newdir")

getcwd() 方法:
功能描述：得到当前的工作目录。
例子，以下是例子给定为当前目录：

#!/usr/bin/python
import os

# This would give location of the current directory
os.getcwd()

rmdir()方法：
功能描述：删除目录。
语法: os.rmdir(‘dirname’)
例子,下面是一个例子删除“/tmp/test”目录。它是必需的，得到的目录完全的名称，否则将搜索在当前目录中的目录。

#!/usr/bin/python
import os

# This would  remove "/tmp/test"  directory.
os.rmdir( "/tmp/test"  )

异常处理

Python提供了两个非常重要的异常处理功能，以处理在Python程序任何异常错误，并增加调试功能：

• 异常处理：这将包括在本教程中。这是在Python中可用列表标准异常：标准异常 。
• 断言：这将Python断言教程中介绍。

什么是异常？
异常是一个事件，其中一个程序，破坏程序的指令的正常流的执行过程中而发生的。一般情况下，当一个Python脚本遇到一些情况不能处理，就抛出一个异常。异常是一个Python对象，它表示一个错误。

当Python脚本抛出一个异常，它必须处理异常，否则将立即终止。

处理异常：
如果有可能会引发异常的一些可疑的代码，就可以通过将可疑的代码在一个try块，来保卫你的程序。

语法：
这里是try….except…else 块的简单语法：

try:
   You do your operations here;
   ......................
except ExceptionI:
   If there is ExceptionI, then execute this block.
except ExceptionII:
   If there is ExceptionII, then execute this block.
   ......................
else:
   If there is no exception then execute this block. 

上述语法要点：

单个try语句可以有多个不同的语句。当try块中包含可能会引发不同类型的异常语句，这是很有用的。

也可以提供一个通用的except子句，它用来处理任何异常。

except子句后，可以包括其他子句。块没有引发异常：在别的块中的代码，如果在try中的代码执行。

在else块是不需要try：块的代码的保护。

例子
这里是简单的例子，这将打开一个文件并写入内容的文件中并移出正常：

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can't find file or read data"
else:
   print "Written content in the file successfully"
   fh.close()

这将产生以下结果：

Written content in the file successfully

示例：
这里有一个更简单的例子，它试图打开没有权限并在文件中写入内容，所以它会引发一个异常：

#!/usr/bin/python

try:
   fh = open("testfile", "r")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can't find file or read data"
else:
   print "Written content in the file successfully"

这将产生以下结果：

Error: can’t find file or read data
在except子句无异常：
还可以使用不同的定义如下无异常的声明：

try:
   You do your operations here;
   ......................
except:
   If there is any exception, then execute this block.
   ......................
else:
   If there is no exception then execute this block. 

try-except 语句捕获所有出现的异常。使用这种try-except 声明不被认为是一个良好的编程习惯，但因为它捕获所有异常，但不会使程序员找出可能出现的问题的根本原因。

在except子句的多个异常：
也可以使用相同的除语句来处理多个异常，如下所示：

try:
   You do your operations here;
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list, 
   then execute this block.
   ......................
else:
   If there is no exception then execute this block. 

try-finally 语句:
可以使用finally:块连同try:块。在try块是否引发异常或没有任何代码 finally块是一个必须执行的块。try-finally语句的语法是这样的：

try:
   You do your operations here;
   ......................
   Due to any exception, this may be skipped.
finally:
   This would always be executed.
   ......................

请注意，可以提供except子句或finally子句，但不能同时使用。不能同时使用else子句与finally子句。

例子：

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
finally:
   print "Error: can't find file or read data"

如果没有权限，以写入方式打开文件，那么这将产生以下结果：

Error: can't find file or read data

同样的例子可以写入更简洁，如下所示：

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   try:
      fh.write("This is my test file for exception handling!!")
   finally:
      print "Going to close the file"
      fh.close()
except IOError:
   print "Error: can't find file or read data"

当一个异常被抛出在try块中，执行立即传递到finally块。finally块中的所有语句都执行，该异常被再次抛出，并在被处理 except 语句如果出现在一个更高的层在try-except语句。

Exception参数：
异常可以有一个参数，参数是一个值，它给出了关于这个问题的其他信息。参数按异常内容改变。可以通过不同的子句提供一个变量，如下所示捕获异常的参数：

try:
   You do your operations here;
   ......................
except ExceptionType, Argument:
   You can print value of Argument here...

如果正在编写代码来处理一个异常，可以有一个变量按照异常的名称在不同的声明。如果捕捉多个异常，可以有一个变量按照异常的元组。

这个变量将接收主要包含异常原因的异常值。该变量可以在一个元组的形式接收一个或多个值。该元组通常包含错误串，错误码和一个错误的位置。

示例：下面是一个异常的例子：

#!/usr/bin/python

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError, Argument:
      print "The argument does not contain numbers
", Argument

# Call above function here.
temp_convert("xyz");

这将产生以下结果:

The argument does not contain numbers
invalid literal for int() with base 10: ‘xyz’

抛出异常

可以通过使用raise语句抛出多个方面的异常。
一般raise语句的语法：

raise [Exception [, args [, traceback]]]

$\hspace{0.5cm}$ 这里，Exception是异常的类型（例如，NameError）；参数是用于异常的参数值，该参数是可选的，如果未提供，则异常的参数是None；最后一个参数traceback，也是可选的（并且在实践中很少使用），并且如果存在的话，那么用于异常回溯对象。

$\hspace{0.5cm}$ 例子：异常可以是一个字符串，一个类或一个对象。大多数Python核心抛出是类，有参数认为是类的实例的异常。定义新的异常是很容易的，可以参考如下：

def functionName( level ):
   if level < 1:
      raise "Invalid level!", level
      # The code below to this would not be executed
      # if we raise the exception

注意：为了捕获一个异常，“except”语句必须引用抛出类对象或简单的字符串相同的异常。例如，捕捉到上面的异常，必须写except子句，如下所示：

try:
   Business Logic here...
except "Invalid level!":
   Exception handling here...
else:
   Rest of the code here...

用户定义的异常

$\hspace{0.5cm}$ Python中，还可以通过内置的异常标准的派生类来创建自己的异常。
$\hspace{0.5cm}$下面是有关RuntimeError一个例子。这里是从RuntimeError子类的类被创建。当需要显示更多的具体信息时，一个异常被捕获，这是很有用的。在try块中，用户定义的异常引发，并夹在except块。变量e被用来创建类Networkerror的一个实例。

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

所以一旦在上面定义的类，可以按如下方法抛出异常：

try:
   raise Networkerror("Bad hostname")
except Networkerror,e:
   print(e.args)