Python break 语句

Python 的​break ​语句，与C语言类似，可以用来跳出 ​for ​或 ​while ​循环。

​break ​语句用来终止循环语句，即循环条件没有 False 条件或者序列还没被完全递归完，也会停止执行循环语句。

​break ​语句用在 ​while ​和 ​for ​循环中。

如果您使用嵌套循环，​break​ 语句将停止执行最深层的循环，并开始执行下一行代码。

Python语言 break 语句语法：

break

流程图：

实例：

#!/usr/bin/python# -*- coding: UTF-8 -*- for letter in 'Python':     # 第一个实例   if letter == 'h':      break   print '当期字母 :', letter  var = 10                    # 第二个实例while var > 0:                 print '当期变量值 :', var   var = var -1   if var == 5:   # 当变量 var 等于 5 时退出循环      break print "Good bye!"

以上实例执行结果：

 当期字母 : P

当期字母 : y

当期字母 : t

当期变量值 : 10

当期变量值 : 9

当期变量值 : 8

当期变量值 : 7

当期变量值 : 6

Good bye!

Python continue 语句

Python ​continue ​语句跳出本次循环，而 ​break ​跳出整个循环。

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

​continue ​语句用在 ​while ​和 ​for​循环中。

 continue和break都是作用在其代码块的（也就是跟他缩进相同的代码块），而且遇到它们后在对应语句后的代码都不执行。不同的是，continue只跳过单次循环，而break结束这个循环。

举个例子，有一个循环十次的循环，其中有个条件判定，当执行到第五次的时候执行​break​或者​continue​语句。如果是执行​continue​语句，当执行到第五次的时候结束这次循环进入第六次循环，也就是所这个循环执行了9次。如果执行的是​break​语句的话，当执行到第五次循环的时候结束这次循环（也就是说不再继续循环了），结果是这个循环循环了5次。

Python 语言 continue 语句语法格式如下：

continue

流程图：

实例：

#!/usr/bin/python# -*- coding: UTF-8 -*-for letter in 'Python':     # 第一个实例   if letter == 'h':      continue   print '当前字母 :', lettervar = 10                    # 第二个实例while var > 0:                 var = var -1   if var == 5:      continue   print '当前变量值 :', varprint "Good bye!"

以上实例执行结果：

当前字母 : P

当前字母 : y

当前字母 : t

当前字母 : o

当前字母 : n

当前变量值 : 9

当前变量值 : 8

当前变量值 : 7

当前变量值 : 6

当前变量值 : 4

当前变量值 : 3

当前变量值 : 2

当前变量值 : 1

当前变量值 : 0

Good bye!

实例：

可以使用 Python 的 ​continue ​语句跳过某些循环，只打印 0-10 之间的奇数：

#!/usr/bin/python# -*- coding: UTF-8 -*-n = 0while n < 10:    n = n + 1    if n % 2 == 0:      # 如果n是偶数，执行continue语句        continue        # continue语句会直接继续下一轮循环，后续的print()语句不会执行    print(n)

运行结果：

1

3

5

7

9

Python pass 语句

Python ​pass ​是空语句，是为了保持程序结构的完整性。

​pass ​不做任何事情，一般用做占位语句。

Python 语言 pass 语句语法格式如下：

pass

实例：

# -*- coding: UTF-8 -*- #!/usr/bin/python# 输出 Python 的每个字母for letter in 'Python':   if letter == 'h':      pass      print '这是 pass 块'   print '当前字母 :', letterprint "Good bye!"

以上实例执行结果：

当前字母 : P

当前字母 : y

当前字母 : t

这是 pass 块

当前字母 : h

当前字母 : o

当前字母 : n

Good bye!

Python 数字

Python 数字数据类型用于存储数值。

数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。

以下实例在变量赋值时数字对象将被创建：

var1 = 1var2 = 10

您也可以使用 ​del ​语句删除一些数字对象引用。

​del ​语句的语法是：

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

您可以通过使用 del 语句删除单个或多个对象，例如：

del vardel var_a, var_b

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

• 整型 (int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
• 长整型 (long int) - 无限大小的整数，整数最后带一个大写或小写的L。(实际上还是有范围的)
• 浮点型( float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10² = 250）
• 复数 ( complex) - 复数的虚部以字母J 或 j结尾 。如：2+3i

• 长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python 使用"L"来显示长整型。
• Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj, 或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型

Python数字类型转换

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 转换为一个列表  chr(x )                 将一个整数转换为一个字符  unichr(x )              将一个整数转换为Unicode字符  ord(x )                 将一个字符转换为它的整数值  hex(x )                 将一个整数转换为一个十六进制字符串  oct(x )                 将一个整数转换为一个八进制字符串 

import math

查看 ​math ​包中的内容:

>>> import math>>> dir(math)['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']>>>

下文会介绍各个函数的具体应用。

查看 ​cmath ​包中的内容：

>>> import cmath>>> dir(cmath)['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']>>>

实例：

>>> import cmath>>> cmath.sqrt(-1)1j>>> cmath.sqrt(9)(3+0j)>>> cmath.sin(1)(0.8414709848078965+0j)>>> cmath.log10(100)(2+0j)>>>

Python数学函数

Python随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python 包含以下常用随机数函数：

Python三角函数

Python 包括以下三角函数：

Python数学常量

Python 字符串

字符串是 Python 中最常用的数据类型之一。我们可以使用引号来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'var2 = "Python 51coolma"

Python访问字符串中的值

Python不支持单字符类型，单字符也在Python也是作为一个字符串使用。

Python访问子字符串，可以使用方括号来截取字符串，如下实例：

#!/usr/bin/pythonvar1 = 'Hello World!'var2 = "Python 51coolma"print "var1[0]: ", var1[0]print "var2[1:5]: ", var2[1:5]

以上实例执行结果：

var1[0]:  Hvar2[1:5]:  ytho

Python字符串更新

你可以对已存在的字符串进行修改，并赋值给另一个变量，如下实例：

#!/usr/bin/python# -*- coding: UTF-8 -*-var1 = 'Hello World!'print "更新字符串 :- ", var1[:6] + '51coolma!'

以上实例执行结果

更新字符串 :-  Hello 51coolma!

Python转义字符

在需要在字符中使用特殊字符时，Python 用反斜杠()转义字符。如下表：

Python字符串运算符

下表实例变量a值为字符串"Hello"，b 变量值为"Python"：

实例如下：

#!/usr/bin/python# -*- coding: UTF-8 -*-a = "Hello"b = "Python"print "a + b 输出结果：", a + b print "a * 2 输出结果：", a * 2 print "a[1] 输出结果：", a[1] print "a[1:4] 输出结果：", a[1:4] if( "H" in a):    print "H 在变量 a 中" else:    print "H 不在变量 a 中" if( "M" not in a) :    print "M 不在变量 a 中" else :    print "M 在变量 a 中"print r'
'print R'
'

以上程序执行结果为：

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中

Python字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 ​%s​ 的字符串中。

在 Python 中，字符串格式化使用与 C 中的 printf 函数一样的语法。

如下实例：

#!/usr/bin/pythonprint "My name is %s and weight is %d kg!" % ('Zara', 21) 

以上实例输出结果：

My name is Zara and weight is 21 kg!

Python 字符串格式化符号:

格式化操作符辅助指令:

Python三引号（triple quotes）

Python 中三引号可以将复杂的字符串进行复制:

Python 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。

 >>> hi = '''hi there'''>>> hi   # repr()'hi
there'>>> print hi  # str()hi there  

三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的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 字符串

Python 中定义一个 Unicode 字符串和定义一个普通字符串一样简单：

>>> u'Hello World !'u'Hello World !'

引号前小写的"u"表示这里创建的是一个 Unicode 字符串。如果你想加入一个特殊字符，可以使用 Python 的 Unicode-Escape 编码。如下例所示：

>>> u'Hellou0020World !'u'Hello World !'

被替换的 u0020 标识表示在给定位置插入编码值为 0x0020 的 Unicode 字符（空格符）。

Python的字符串内建函数

字符串方法是从 Python1.6 到 2.0 慢慢加进来的——它们也被加到了 Python 中。

这些方法实现了 string 模块的大部分方法，如下表所示列出了目前字符串内建支持的方法，所有的方法都包含了对 Unicode 的支持，有一些甚至是专门用于 Unicode 的。

Python 列表(Lists)

序列是 Python 中最基本的数据结构。序列中的每个元素都分配一个数字用来表示它的位置，索引，第一个索引是 0，第二个索引是 1，依此类推。

Python有 6 个序列的内置类型，但最常见的是列表和元组。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

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

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['physics', 'chemistry', 1997, 2000];list2 = [1, 2, 3, 4, 5 ];list3 = ["a", "b", "c", "d"];

与字符串的索引一样，列表索引从 0 开始。列表可以进行截取、组合等。

访问列表中的值

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

#!/usr/bin/pythonlist1 = ['physics', 'chemistry', 1997, 2000];list2 = [1, 2, 3, 4, 5, 6, 7 ];print "list1[0]: ", list1[0]print "list2[1:5]: ", list2[1:5]

以上实例输出结果：

list1[0]:  physicslist2[1:5]:  [2, 3, 4, 5]

更新列表

你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项，如下所示：

#!/usr/bin/pythonlist = ['physics', 'chemistry', 1997, 2000];print "Value available at index 2 : "print list[2];list[2] = 2001;print "New value available at index 2 : "print list[2];

注意：我们会在接下来的章节讨论 append() 方法的使用

以上实例输出结果：

Value available at index 2 :1997New value available at index 2 :2001

删除列表元素

可以使用 del 语句来删除列表的的元素，如下实例：

#!/usr/bin/pythonlist1 = ['physics', 'chemistry', 1997, 2000];print list1;del list1[2];print "After deleting value at index 2 : "print list1;

以上实例输出结果：

['physics', 'chemistry', 1997, 2000]After deleting value at index 2 :['physics', 'chemistry', 2000]

注意：我们会在接下来的章节讨论 remove() 方法的使用

Python 列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

Python 列表截取

Python 的列表截取与字符串操作类型，如下所示：

L = ['spam', 'Spam', 'SPAM!']

操作：

Python 列表函数&方法

Python 包含以下函数:

Python 包含以下方法:

实例：

如果 Python 列表无法正常输出汉字，则可以采取以下的解决方法：

#encoding=utf-8import json#以下代码是用来保证在线环境中运行不报错的。import sys  # 导入sys库reload(sys)sys.setdefaultencoding('utf-8')  # 设置默认的编码字符集为utf-8,避免第14行的print在在线情况下报错#本地环境可以不需要这部分代码list_words = [ '你', '我', '他' ]print( list_words )                                        # 无法正常显示汉字print( str(list_words).decode( 'string_escape' ) )         # 正常显示汉字list_words_result = json.dumps( list_words, encoding='UTF-8', ensure_ascii=False )print( list_words_result )

以上实例输出结果：

['xe4xbdxa0', 'xe6x88x91', 'xe4xbbx96']['你', '我', '他']["你", "我", "他"]

Python 元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

如下实例：

tup1 = ('physics', 'chemistry', 1997, 2000);tup2 = (1, 2, 3, 4, 5 );tup3 = "a", "b", "c", "d";

创建空元组

tup1 = ();

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,);

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

#!/usr/bin/pythontup1 = ('physics', 'chemistry', 1997, 2000);tup2 = (1, 2, 3, 4, 5, 6, 7 );print "tup1[0]: ", tup1[0]print "tup2[1:5]: ", tup2[1:5]

以上实例输出结果：

tup1[0]:  physicstup2[1:5]:  (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

#coding=utf-8#!/usr/bin/pythontup1 = (12, 34.56);tup2 = ('abc', 'xyz');# 以下修改元组元素操作是非法的。# tup1[0] = 100;# 创建一个新的元组tup3 = tup1 + tup2;print tup3;

以上实例输出结果：

(12, 34.56, 'abc', 'xyz')

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

#!/usr/bin/pythontup = ('physics', 'chemistry', 1997, 2000);print tup;del tup;print "After deleting tup : "print tup;

以上实例元组被删除后，控制台会有异常信息输出，输出如下所示：

('physics', 'chemistry', 1997, 2000)After deleting tup :Traceback (most recent call last):  File "test.py", line 9, in <module>    print tup;NameError: name 'tup' is not defined

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

L = ('spam', 'Spam', 'SPAM!')

无关闭分隔符

任意无符号的对象，以逗号隔开，默认为元组，如下实例：

#!/usr/bin/pythonprint 'abc', -4.24e93, 18+6.6j, 'xyz';x, y = 1, 2;print "Value of x , y : ", x,y;

以上实例运行结果：

abc -4.24e+93 (18+6.6j) xyzValue of x , y : 1 2

元组内置函数

Python 元组包含了以下内置函数

Python 字典(Dictionary)

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 (key=>value) 对用冒号(:)分割，每个对之间用逗号 (,) 分割，整个字典包括在花括号 ({}) 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

也可如此创建字典：

dict1 = { 'abc': 456 };dict2 = { 'abc': 123, 98.6: 37 };

访问字典里的值

把相应的键放入熟悉的方括号内，如下实例:

#!/usr/bin/python dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; print "dict['Name']: ", dict['Name'];print "dict['Age']: ", dict['Age'];

以上实例输出结果：

dict['Name']:  Zaradict['Age']:  7

如果用字典里没有的键访问数据，会输出错误如下：

#!/usr/bin/python dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; print "dict['Alice']: ", dict['Alice'];

以上实例输出结果：

dict['Zara']:Traceback (most recent call last):  File "test.py", line 4, in <module>    print "dict['Alice']: ", dict['Alice'];KeyError: 'Alice'

修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

#!/usr/bin/python dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; dict['Age'] = 8; # update existing entrydict['School'] = "DPS School"; # Add new entry  print "dict['Age']: ", dict['Age'];print "dict['School']: ", dict['School'];

以上实例输出结果：

dict['Age']:  8dict['School']:  DPS School

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用 del 命令，如下实例：

#coding=utf-8#!/usr/bin/python dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; del dict['Name']; # 删除键是'Name'的条目dict.clear();     # 清空词典所有条目del dict ;        # 删除词典 print "dict['Age']: ", dict['Age'];print "dict['School']: ", dict['School'];

但这会引发一个异常，因为用 del 后字典不再存在：

dict['Age']:Traceback (most recent call last):  File "test.py", line 8, in <module>    print "dict['Age']: ", dict['Age'];TypeError: 'type' object is unsubscriptable

注：del() 方法后面也会讨论。

字典键的特性

字典值可以没有限制地取任何 Python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，只会保存后一次赋值，如下实例：

#!/usr/bin/python dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}; print "dict['Name']: ", dict['Name'];

以上实例输出结果：

dict['Name']:  Manni

2）键必须不可变，所以可以用数，字符串或元组充当，所以用列表就不行，如下实例：

#!/usr/bin/python dict = {['Name']: 'Zara', 'Age': 7}; print "dict['Name']: ", dict['Name'];

以上实例输出结果：

Traceback (most recent call last):  File "test.py", line 3, in <module>    dict = {['Name']: 'Zara', 'Age': 7};TypeError: list objects are unhashable

字典内置函数&方法

Python字典包含了以下内置函数：

Python字典包含了以下内置方法：

实例：

使用Python编写字典程序：

1. 用户添加单词和定义
2. 查找这些单词
3. 如果查不到，请让用户知道
4. 循环

代码如下：

#coding:utf-8# 字典创建  while开关 字典添加   字典寻找dictionary = {}flag = 'a'pape = 'a'off = 'a'while flag == 'a' or 'c' :    flag = raw_input("添加或查找单词 ?(a/c)")    if flag == "a" :                             # 开启        word = raw_input("输入单词(key):")        defintion = raw_input("输入定义值(value):")        dictionary[str(word)] = str(defintion)  # 添加字典        print "添加成功!"        pape = raw_input("您是否要查找字典?(a/0)")   #read        if pape == 'a':            print dictionary        else :            continue    elif flag == 'c':        check_word = raw_input("要查找的单词:")  # 检索        for key in sorted(dictionary.keys()):            # yes            if str(check_word) == key:                print "该单词存在! " ,key, dictionary[key]                break            else:                                       # no                off = 'b'        if off == 'b':            print "抱歉，该值不存在！"    else:                               # 停止        print "error type"        break

 在线运行的展示效果不是很好，建议使用本地代码环境进行运行！

测试结果如下所示：

添加或查找单词 ?(a/c)a
输入单词(key):w3c
输入定义值(value):51coolma.cn
添加成功!
您是否要查找字典?(a/0)0
添加或查找单词 ?(a/c)c
要查找的单词:w3c
该单词存在!  w3c 51coolma.cn
添加或查找单词 ?(a/c)

Python 日期和时间

#!/usr/bin/python# -*- coding: UTF-8 -*-import time;  # 引入time模块ticks = time.time()print "当前时间戳为:", ticks

当前时间戳为: 1459994552.51

什么是时间元组？

很多 Python 函数用一个元组装起来的9组数字处理时间:

上述也就是struct_time元组。这种结构具有如下属性：

获取当前时间

从返回浮点数的时间辍方式向时间元组转换，只要将浮点数传递给如 localtime 之类的函数。

#!/usr/bin/python# -*- coding: UTF-8 -*-import timelocaltime = time.localtime(time.time())print "本地时间为 :", localtime

以上实例输出结果：

本地时间为 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)

获取格式化的时间

你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():

#!/usr/bin/python# -*- coding: UTF-8 -*-import timelocaltime = time.asctime( time.localtime(time.time()) )print "本地时间为 :", localtime

以上实例输出结果：

本地时间为 : Thu Apr  7 10:05:21 2016

格式化日期

我们可以使用 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"))

以上实例输出结果：

2021-09-06 07:08:04Mon Sep 06 07:08:04 20211459203864.0

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 模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：

#!/usr/bin/python# -*- coding: UTF-8 -*-import calendarcal = calendar.month(2016, 1)print "以下输出2016年1月份的日历:"print cal;

以上实例输出结果：

以下输出2016年1月份的日历:    January 2016Mo Tu We Th Fr Sa Su             1  2  3 4  5  6  7  8  9 1011 12 13 14 15 16 1718 19 20 21 22 23 2425 26 27 28 29 30 31

Time 模块

Time 模块包含了以下内置函数，既有时间处理相的，也有转换时间格式的：

Time 模块包含了以下 2 个非常重要的属性：

日历（Calendar）模块

此模块的函数都是日历相关的，例如打印某月的字符月历。

星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用 calendar.setfirstweekday() 函数。模块包含了以下内置函数：

其他相关模块和函数

在 Python 种，其他处理日期和时间的模块还有：

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

Python函数

函数是封装好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高程序的模块性，和代码的重复利用率。你已经知道 Python 提供了许多内建函数，比如 print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

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

语法

def functionname( parameters ):   "函数_文档字符串"   function_suite   return [expression]

默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

实例

以下为一个简单的 Python 函数，它将一个字符串作为传入参数，再打印到标准显示设备上。

def printme( str ):   "打印传入的字符串到标准显示设备上"   print str   return

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 提示符执行。

如下实例调用了 printme() 函数：

#coding=utf-8#!/usr/bin/python # Function definition is heredef printme( str ):   "打印任何传入的字符串"   print str;   return; # Now you can call printme functionprintme("我要调用用户自定义函数!");printme("再次调用同一函数");

以上实例输出结果：

我要调用用户自定义函数!再次调用同一函数

参数传递

在 Python 中，类型属于对象，变量是没有类型的：

a=[1,2,3] a="51coolma"

以上代码中，[1,2,3] 是 list 类型，"51coolma"是 string 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 list 类型对象，也可以指向 是 string 类型对象。

可更改 (mutable) 与不可更改 (immutable) 对象

在 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 函数的参数传递：

• 不可变类型：类似 c++的值传递，如 整数、字符串、元组。如 fun（a），传递的只是 a 的值，没有影响 a 对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
• 可变类型：类似 c++的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

 Python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

Python 传不可变对象实例

实例（Python 2.0+）

#!/usr/bin/python# -*- coding: UTF-8 -*- def ChangeInt( a ):    a = 10 b = 2ChangeInt(b)print b # 结果是 2

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

按值传递参数和按引用传递参数（传可变对象实例）

所有参数（自变量）在 Python 里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

#coding=utf-8#!/usr/bin/python # 可写函数说明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]]

参数

以下是调用函数时可使用的正式参数类型：

• 必备参数
• 命名参数
• 缺省参数
• 不定长参数

必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：

#coding=utf-8#!/usr/bin/python #可写函数说明def printme( str ):   "打印任何传入的字符串"   print str;   return; #调用printme函数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# -*- coding: UTF-8 -*-#可写函数说明def printme( str ):   "打印任何传入的字符串"   print str;   return;#调用printme函数printme( str = "My string");

以上实例输出结果：

My string

下例能将关键字参数顺序不重要展示得更清楚：

#!/usr/bin/python# -*- coding: UTF-8 -*-#可写函数说明def printinfo( name, age ):   "打印任何传入的字符串"   print "Name: ", name;   print "Age ", age;   return;#调用printinfo函数printinfo( age=50, name="miki" );

以上实例输出结果：

Name:  miki
Age  50

命名参数

命名参数和函数调用关系紧密，调用方用参数的命名确定传入的参数值。你可以跳过不传的参数或者乱序传参，因为 Python 解释器能够用参数名匹配参数值。用命名参数调用 printme() 函数：

#coding=utf-8#!/usr/bin/python #可写函数说明def printme( str ):   "打印任何传入的字符串"   print str;   return; #调用printme函数printme( str = "My string");

以上实例输出结果：

My string

下例能将命名参数顺序不重要展示得更清楚：

#coding=utf-8#!/usr/bin/python #可写函数说明def printinfo( name, age ):   "打印任何传入的字符串"   print "Name: ", name;   print "Age ", age;   return; #调用printinfo函数printinfo( age=50, name="miki" );

以上实例输出结果：

Name:  mikiAge  50

缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的 age，如果 age 没有被传入：

#coding=utf-8#!/usr/bin/python #可写函数说明def printinfo( name, age = 35 ):   "打印任何传入的字符串"   print "Name: ", name;   print "Age ", age;   return; #调用printinfo函数printinfo( age=50, name="miki" );printinfo( name="miki" );

以上实例输出结果：

Name:  mikiAge  50Name:  mikiAge  35

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):   "函数_文档字符串"   function_suite   return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。选择不多传参数也可。如下实例：

#coding=utf-8#!/usr/bin/python # 可写函数说明def printinfo( arg1, *vartuple ):   "打印任何传入的参数"   print "输出: "   print arg1   for var in vartuple:      print var   return; # 调用printinfo 函数printinfo( 10 );printinfo( 70, 60, 50 );

以上实例输出结果：

输出:10输出:706050

匿名函数

python 使用 lambda 来创建匿名函数。

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

语法

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

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

如下实例：

#coding=utf-8#!/usr/bin/python #可写函数说明sum = lambda arg1, arg2: arg1 + arg2; #调用sum函数print "Value of total : ", sum( 10, 20 )print "Value of total : ", sum( 20, 20 )

以上实例输出结果：

Value of total :  30Value of total :  40

return 语句

return 语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：

#coding=utf-8#!/usr/bin/python # 可写函数说明def sum( arg1, arg2 ):   # 返回2个参数的和."   total = arg1 + arg2   print "Inside the function : ", total   return total; # 调用sum函数total = sum( 10, 20 );print "Outside the function : ", total 

以上实例输出结果：

Inside the function :  30Outside the function :  30

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

• 全局变量
• 局部变量

变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

#coding=utf-8#!/usr/bin/python total = 0; # This is global variable.# 可写函数说明def sum( arg1, arg2 ):   #返回2个参数的和."   total = arg1 + arg2; # total在这里是局部变量.   print "Inside the function local total : ", total   return total; #调用sum函数sum( 10, 20 );print "Outside the function global total : ", total 

以上实例输出结果：

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

Python 模块

模块让你能够有逻辑地组织你的 Python 代码段。

把相关的代码分配到一个 模块里能让你的代码更好用，更易懂。

模块也是 Python 对象，具有随机的名字属性用来绑定或引用。

简单地说，模块就是一个保存了 Python 代码的文件。模块能定义函数，类和变量。模块里也能包含可执行的代码。

例子

一个叫做 aname 的模块里的 Python 代码一般都能在一个叫 aname.py 的文件中找到。下例是个简单的模块 support.py。

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

import 语句

想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：

import module1[, module2[,... moduleN]

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 hello.py，需要把命令放在脚本的顶端：

#coding=utf-8#!/usr/bin/python # 导入模块import support # 现在可以调用模块里包含的函数了support.print_func("Zara")

以上实例输出结果：

Hello : Zara

一个模块只会被导入一次，不管你执行了多少次 import。这样可以防止导入模块被一遍又一遍地执行。

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 下的每个目录。
• 如果都找不到，Python 会察看默认路径。UNIX下，默认路径一般为 /usr/local/lib/python/

模块搜索路径存储在 system 模块的 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 赋值，然后 Python 会假定 money 是一个局部变量。然而，我们并没有在访问前声明一个局部变量 money，结果就是会出现一个 UnboundLocalError 的错误。取消 global 语句的注释就能解决这个问题。

#coding=utf-8#!/usr/bin/python Money = 2000def AddMoney():   # 想改正代码就取消以下注释:   # global Money   Money = Money + 1 print MoneyAddMoney()print Money

dir()函数

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

返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：

#coding=utf-8#!/usr/bin/python # 导入内置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(module_name)

在这里，module_name 要直接放模块的名字，而不是一个字符串形式。比如想重载 hello 模块，如下：

reload(hello)

Python 中的包

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。

考虑一个在 Phone 目录下的 pots.py 文件。这个文件有如下源代码：

#coding=utf-8#!/usr/bin/python def Pots():   print "I'm Pots Phone"

同样地，我们有另外两个保存了不同函数的文件：

• Phone/Isdn.py 含有函数 Isdn()
• Phone/G3.py 含有函数 G3()

现在，在 Phone 目录下创建 file __init__.py：

• Phone/__init__.py

当你导入 Phone 时，为了能够使用所有函数，你需要在 __init__.py 里使用显式的导入语句，如下：

from Pots import Potsfrom Isdn import Isdnfrom G3 import G3

当你把这些代码添加到__init__.py之后，导入 Phone 包的时候这些类就全都是可用的了。

#coding=utf-8#!/usr/bin/python # Now import your Phone Package.import Phone Phone.Pots()Phone.Isdn()Phone.G3()

以上实例输出结果：

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

如上，为了举例，我们只在每个文件里放置了一个函数，但其实你可以放置许多函数。你也可以在这些文件里定义 Python 的类，然后为这些类建一个包。

Python 文件 I/O

本章只讲述所有基本的的 I/O 函数，更多函数请参考 Python 标准文档。

 关于python文件读写和基本输入输出的代码，由于在线示例的限制并不能较好的展现出应有的运行结果，建议在本地环境下运行！

打印到屏幕

最简单的输出方法是用 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# -*- coding: UTF-8 -*-  str = raw_input("请输入：");print "你输入的内容是: ", str

这将提示你输入任意字符串，然后在屏幕上显示相同的字符串。当我输入"Hello Python！"，它的输出如下：

请输入：Hello Python！你输入的内容是:  Hello Python！

input函数

input([prompt]) 函数和 raw_input([prompt]) 函数基本可以互换，但是 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]

打开和关闭文件

到现在为止，你已经可以向标准输入和输出进行读写。现在，来看看怎么读写实际的数据文件。

Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用file对象做大部分的文件操作。

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 对象相关的所有属性的列表：

如下实例：

#!/usr/bin/python# -*- coding: UTF-8 -*- # 打开一个文件fo = open("foo.txt", "wb")print "文件名: ", fo.nameprint "是否已关闭 : ", fo.closedprint "访问模式 : ", fo.modeprint "末尾是否强制加空格 : ", fo.softspace

以上实例输出结果：

文件名:  foo.txt是否已关闭 :  False访问模式 :  wb末尾是否强制加空格 :  0

Close()方法

File对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。

当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close（）方法关闭文件是一个很好的习惯。

语法：

fileObject.close();

例子：

#coding=utf-8#!/usr/bin/python # 打开一个文件fo = open("foo.txt", "wb")print "文件名: ", fo.name # 关闭打开的文件fo.close()

以上实例输出结果：

文件名:  foo.txt

读写文件：

file 对象提供了一系列方法，能让我们的文件访问更轻松。来看看如何使用 read() 和 write() 方法来读取和写入文件。

write() 方法

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

write() 方法不在字符串的结尾添加换行符 (' ')：

语法：

fileObject.write(string);

在这里，被传递的参数是要写入到已打开文件的内容。

例子：

#coding=utf-8#!/usr/bin/python # 打开一个文件fo = open("/tmp/foo.txt", "wb")fo.write( "Python is a great language.
Yeah its great!!
"); # 关闭打开的文件fo.close()#!/usr/bin/python

上述方法会创建 foo.txt 文件，并将收到的内容写入该文件，并最终关闭文件。如果你打开这个文件，将看到以下内容:

Python is a great language.Yeah its great!!

read()方法

read() 方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python 字符串可以是二进制数据，而不是仅仅是文字。

语法：

fileObject.read([count]);

在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。

例子：

就用我们上面创建的文件 foo.txt。

#coding=utf-8#!/usr/bin/python # 打开一个文件fo = open("/tmp/foo.txt", "r+")str = fo.read(10);print "读取的字符串是: ", str# 关闭打开的文件fo.close()

以上实例输出结果：

读取的字符串是:  Python is

文件位置：

tell() 方法告诉你文件内的当前位置；换句话说，下一次的读写会发生在文件开头这么多字节之后：

seek（offset [,from]）方法改变当前文件的位置。Offset 变量表示要移动的字节数。From 变量指定开始移动字节的参考位置。

如果 from 被设为 0，这意味着将文件的开头作为移动字节的参考位置。如果设为 1，则使用当前的位置作为参考位置。如果它被设为 2，那么该文件的末尾将作为参考位置。

例子：

就用我们上面创建的文件 foo.txt。

#coding=utf-8#!/usr/bin/python # 打开一个文件fo = open("/tmp/foo.txt", "r+")str = fo.read(10);print "读取的字符串是: ", str # 查找当前位置position = fo.tell();print "当前文件位置: ", position # 把指针再次重新定位到文件开头position = fo.seek(0, 0);str = fo.read(10);print "重新读取字符串: ", str# 关闭打开的文件fo.close()

以上实例输出结果：

读取的字符串是:  Python is当前文件位置:  10重新读取字符串:  Python is

重命名和删除文件

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

要使用这个模块，你必须先导入它，然后可以调用相关的各种功能。

rename() 方法：

rename() 方法需要两个参数，当前的文件名和新文件名。

语法：

os.rename(current_file_name, new_file_name)

例子：

下例将重命名一个已经存在的文件 test1.txt。

#coding=utf-8#!/usr/bin/pythonimport os # 重命名文件test1.txt到test2.txt。os.rename( "test1.txt", "test2.txt" )

remove() 方法

你可以用 remove() 方法删除文件，需要提供要删除的文件名作为参数。

语法：

os.remove(file_name)

例子：

下例将删除一个已经存在的文件 test2.txt。

#coding=utf-8#!/usr/bin/pythonimport os # 删除一个已经存在的文件test2.txtos.remove("text2.txt")

Python 里的目录：

所有文件都包含在各个不同的目录下，不过 Python 也能轻松处理。os 模块有许多方法能帮你创建，删除和更改目录。

mkdir() 方法

可以使用 os 模块的 mkdir() 方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。

语法：

os.mkdir("newdir")

例子：

下例将在当前目录下创建一个新目录 test。

#coding=utf-8#!/usr/bin/pythonimport os # 创建目录testos.mkdir("test")

chdir() 方法

可以用 chdir() 方法来改变当前的目录。chdir() 方法需要的一个参数是你想设成当前目录的目录名称。

语法：

os.chdir("newdir")

例子：

下例将进入 "/home/newdir" 目录。

#coding=utf-8#!/usr/bin/pythonimport os # 将当前目录改为"/home/newdir"os.chdir("/home/newdir")

getcwd() 方法：

getcwd() 方法显示当前的工作目录。

语法：

os.getcwd()

例子：

下例给出当前目录：

#coding=utf-8#!/usr/bin/pythonimport os # 给出当前的目录os.getcwd()

rmdir()方法

rmdir() 方法删除目录，目录名称以参数传递。

在删除这个目录之前，它的所有内容应该先被清除。

语法：

os.rmdir('dirname')

例子：

以下是删除" /tmp/test"目录的例子。目录的完全合规的名称必须被给出，否则会在当前目录下搜索该目录。

#coding=utf-8#!/usr/bin/pythonimport os # 删除”/tmp/test”目录os.rmdir( "/tmp/test"  )

文件、目录相关的方法

三个重要的方法来源能对 Windows 和 Unix 操作系统上的文件及目录进行一个广泛且实用的处理及操控，如下：

• File 对象方法: file 对象提供了操作文件的一系列方法。
• OS 对象方法: 提供了处理文件及目录的一系列方法。

Python 异常处理

Python 提供了两个非常重要的功能来处理 Python 程序在运行中出现的异常和错误。你可以使用该功能来调试 Python 程序。

• 异常处理: 本站 Python 教程会具体介绍。
• 断言 (Assertions): 本章 Python 教程会具体介绍。

Python 标准异常

什么是异常？

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

一般情况下，在 Python 无法正常处理程序时就会发生一个异常。

异常是 Python 对象，表示一个错误。

当 Python 脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

异常处理

捕捉异常可以使用 try/except 语句。

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

如果你不想在异常发生时结束你的程序，只需在 try 里捕获它。

语法：

以下为简单的 try....except...else 的语法：

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

try 的工作原理是，当开始一个 try 语句后，Python 就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try 子句先执行，接下来会发生什么依赖于执行时是否出现异常。

• 如果当 try 后的语句执行时发生异常，Python 就跳回到 try 并执行第一个匹配该异常的 except 子句，异常处理完毕，控制流就通过整个 try 语句（除非在处理异常时又引发新的异常）。
• 如果在 try 后的语句里发生了异常，却没有匹配的 except 子句，异常将被递交到上层的 try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。
• 如果在 try 子句执行时没有发生异常，Python 将执行 else 语句后的语句（如果有 else 的话），然后控制流通过整个 try 语句。

实例

下面是简单的例子，它打开一个文件，在该文件中的内容写入内容，且并未发生异常：

#!/usr/bin/pythontry:   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/pythontry:   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"

以上程序输出结果：

Error: can't find file or read data

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

你可以不带任何异常类型使用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语句捕获所有发生的异常。但这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常。

使用 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 语句

try-finally 语句无论是否发生异常都将执行最后的代码。

try:<语句>finally:<语句>    #退出try时总会执行raise

注意：你可以使用 except 语句或者 finally 语句，但是两者不能同时使用。else 语句也不能与 finally 语句同时使用

实例

#!/usr/bin/pythontry:   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/pythontry:   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 块代码。

参数的内容不同于异常。

异常的参数

一个异常可以带上参数，可作为输出的异常信息参数。

你可以通过 except 语句来捕获异常的参数，如下所示：

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

变量接收的异常值通常包含在异常的语句中。在元组的表单中变量可以接收一个或者多个值。

元组通常包含错误字符串，错误数字，错误位置。

实例

以下为单个异常的实例：

#!/usr/bin/python# 定义函数def temp_convert(var):   try:      return int(var)   except ValueError, Argument:      print "The argument does not contain numbers
", Argument# 调用函数temp_convert("xyz");

以上程序执行结果如下：

The argument does not contain numbersinvalid literal for int() with base 10: 'xyz'

触发异常

我们可以使用 raise 语句自己触发异常

raise 语法格式如下：

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

语句中 Exception 是异常的类型（例如，NameError）参数是一个异常参数值。该参数是可选的，如果不提供，异常的参数是"None"。

最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。

实例

一个异常可以是一个字符串，类或对象。 Python 的内核提供的异常，大多数都是实例化的类，这是一个类的实例的参数。

定义一个异常非常简单，如下所示：

def functionName( level ):    if level < 1:        raise Exception("Invalid level!", level)        # 触发异常后，后面的代码就不会再执行

注意：为了能够捕获异常，"except"语句必须有用相同的异常来抛出类对象或者字符串。

例如我们捕获以上异常，"except"语句如下所示：

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

用户自定义异常

通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自 Exception 类，通过直接或间接的方式。

以下为与 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

异常处理代码执行说明：

#!/usr/bin/python# -*- coding: UTF-8 -*-#This is note foe exceptiontry:  code    #需要判断是否会抛出异常的代码，如果没有异常处理，python会直接停止执行程序except:  #这里会捕捉到上面代码中的异常，并根据异常抛出异常处理信息#except ExceptionName，args：    #同时也可以接受异常名称和参数，针对不同形式的异常做处理  code  #这里执行异常处理的相关代码，打印输出等else:  #如果没有异常则执行else  code  #try部分被正常执行后执行的代码finally:  code  #退出try语句块总会执行的程序#函数中做异常检测def try_exception(num):  try:    return int(num)  except ValueError,arg:    print arg,"is not a number"  else:    print "this is a number inputs"try_exception('xxx')#输出异常值Invalide literal for int() with base 10: 'xxx' is not a number

Python 内置函数

Python 面向对象

面向对象技术简介

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

创建类

使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾，如下实例:

class ClassName:   '类的帮助信息'   #类文档字符串   class_suite  #类体

类的帮助信息可以通过 ClassName.__doc__查看。

class_suite 由类成员，方法，数据属性组成。

实例

以下是一个简单的 Python 类实例:

#coding=utf-8class Employee:   '所有员工的基类'   empCount = 0   def __init__(self, name, salary):      self.name = name      self.salary = salary      Employee.empCount += 1      def displayCount(self):     print "Total Employee %d" % Employee.empCount   def displayEmployee(self):      print "Name : ", self.name,  ", Salary: ", self.salary

• empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。
• 第一种方法 __init__() 方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
• self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

self 代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Test:    def prt(self):        print(self)        print(self.__class__)t = Test()t.prt()

以上实例执行结果为：

<__main__.Test instance at 0x10d066878>__main__.Test

从执行结果可以很明显的看出，self代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

self 不是 Python 关键字，我们把他换成 51coolma 也是可以正常执行的:

实例：

class Test:    def prt(51coolma):        print(51coolma)        print(51coolma.__class__)t = Test()t.prt()

以上实例执行结果为：

<__main__.Test instance at 0x10d066878>__main__.Test

创建实例对象

要创建一个类的实例，你可以使用类的名称，并通过__init__方法接受参数。

"创建 Employee 类的第一个对象"emp1 = Employee("Zara", 2000)"创建 Employee 类的第二个对象"emp2 = Employee("Manni", 5000)

访问属性

您可以使用点 (.) 来访问对象的属性。使用如下类的名称访问类变量:

emp1.displayEmployee()emp2.displayEmployee()print "Total Employee %d" % Employee.empCount

完整实例：

#coding=utf-8#!/usr/bin/pythonclass Employee:   '所有员工的基类'   empCount = 0   def __init__(self, name, salary):      self.name = name      self.salary = salary      Employee.empCount += 1      def displayCount(self):     print "Total Employee %d" % Employee.empCount   def displayEmployee(self):      print "Name : ", self.name,  ", Salary: ", self.salary"创建 Employee 类的第一个对象"emp1 = Employee("Zara", 2000)"创建 Employee 类的第二个对象"emp2 = Employee("Manni", 5000)emp1.displayEmployee()emp2.displayEmployee()print "Total Employee %d" % Employee.empCount

执行以上代码输出结果如下：

Name :  Zara ,Salary:  2000Name :  Manni ,Salary:  5000Total Employee 2

你可以添加，删除，修改类的属性，如下所示：

emp1.age = 7  # 添加一个 'age' 属性emp1.age = 8  # 修改 'age' 属性del emp1.age  # 删除 'age' 属性

你也可以使用以下函数的方式来访问属性：

• getattr(obj, name[, default]) : 访问对象的属性。
• hasattr(obj,name) : 检查是否存在一个属性。
• setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
• delattr(obj, name) : 删除属性。

hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。getattr(emp1, 'age')    # 返回 'age' 属性的值setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8delattr(empl, 'age')    # 删除属性 'age'

Python 内置类属性

• __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
• __doc__ :类的文档字符串
• __name__: 类名
• __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块 mymod 中，那么 className.__module__ 等于 mymod）
• __bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）

Python 内置类属性调用实例如下：

#coding=utf-8#!/usr/bin/pythonclass Employee:   '所有员工的基类'   empCount = 0   def __init__(self, name, salary):      self.name = name      self.salary = salary      Employee.empCount += 1      def displayCount(self):     print "Total Employee %d" % Employee.empCount   def displayEmployee(self):      print "Name : ", self.name,  ", Salary: ", self.salaryprint "Employee.__doc__:", Employee.__doc__print "Employee.__name__:", Employee.__name__print "Employee.__module__:", Employee.__module__print "Employee.__bases__:", Employee.__bases__print "Employee.__dict__:", Employee.__dict__

执行以上代码输出结果如下：

Employee.__doc__: 所有员工的基类Employee.__name__: EmployeeEmployee.__module__: __main__Employee.__bases__: ()Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x10a939c80>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x10a93caa0>, '__doc__': 'xe6x89x80xe6x9cx89xe5x91x98xe5xb7xa5xe7x9ax84xe5x9fxbaxe7xb1xbb', '__init__': <function __init__ at 0x10a939578>}

Python 对象销毁(垃圾回收)

同 Java 语言一样，Python 使用了引用计数这一简单技术来追踪内存中的对象。

在 Python 内部记录着所有使用中的对象各有多少引用。

一个内部跟踪变量，称为一个引用计数器。

当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为 0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。

a = 40      # 创建对象  <40>b = a       # 增加引用， <40> 的计数c = [b]     # 增加引用.  <40> 的计数del a       # 减少引用 <40> 的计数b = 100     # 减少引用 <40> 的计数c[0] = -1   # 减少引用 <40> 的计数

垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充， 垃圾收集器也会留心被分配的总量很大（及未通过引用计数销毁的那些）的对象。 在这种情况下， 解释器会暂停下来， 试图清理所有未引用的循环。

实例

析构函数 __del__ ，__del__在对象消逝的时候被调用，当对象不再被使用时，__del__方法运行：

#coding=utf-8#!/usr/bin/pythonclass Point:   def __init( self, x=0, y=0):      self.x = x      self.y = y   def __del__(self):      class_name = self.__class__.__name__      print class_name, "destroyed"pt1 = Point()pt2 = pt1pt3 = pt1print id(pt1), id(pt2), id(pt3) # 打印对象的iddel pt1del pt2del pt3

以上实例运行结果如下：

3083401324 3083401324 3083401324Point destroyed

注意：通常你需要在单独的文件中定义一个类，

类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。

在 Python 中继承中的一些特点：

• 1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
• 2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
• 3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

语法：

派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：

class SubClassName (ParentClass1[, ParentClass2, ...]):   'Optional class documentation string'   class_suite

实例：

#coding=utf-8#!/usr/bin/pythonclass Parent:        # 定义父类   parentAttr = 100   def __init__(self):      print "调用父类构造函数"   def parentMethod(self):      print '调用父类方法'   def setAttr(self, attr):      Parent.parentAttr = attr   def getAttr(self):      print "父类属性 :", Parent.parentAttrclass Child(Parent): # 定义子类   def __init__(self):      print "调用子类构造方法"   def childMethod(self):      print '调用子类方法 child method'c = Child()          # 实例化子类c.childMethod()      # 调用子类的方法c.parentMethod()     # 调用父类方法c.setAttr(200)       # 再次调用父类的方法c.getAttr()          # 再次调用父类的方法

以上代码执行结果如下：

调用子类构造方法调用子类方法 child method调用父类方法父类属性 : 200

你可以继承多个类

class A:        # 定义类 A.....class B:         # 定义类 B.....class C(A, B):   # 继承类 A 和 B.....

你可以使用 issubclass() 或者 isinstance() 方法来检测。

• issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
• isinstance(obj, class) 布尔函数如果obj是Class类的实例对象或者是一个 class 子类的实例对象则返回 true。

方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法：

实例：

#coding=utf-8#!/usr/bin/pythonclass Parent:        # 定义父类   def myMethod(self):      print '调用父类方法'class Child(Parent): # 定义子类   def myMethod(self):      print '调用子类方法'c = Child()          # 子类实例c.myMethod()         # 子类调用重写方法

执行以上代码输出结果如下：

调用子类方法

基础重载方法

下表列出了一些通用的功能，你可以在自己的类重写：

运算符重载

Python 同样支持运算符重载，实例如下：

#!/usr/bin/pythonclass Vector:   def __init__(self, a, b):      self.a = a      self.b = b   def __str__(self):      return 'Vector (%d, %d)' % (self.a, self.b)      def __add__(self,other):      return Vector(self.a + other.a, self.b + other.b)v1 = Vector(2,10)v2 = Vector(5,-2)print v1 + v2

以上代码执行结果如下所示:

Vector(7,8)

类属性与方法

类的私有属性

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

类的方法

在类地内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数

类的私有方法

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

实例

#coding=utf-8#!/usr/bin/pythonclass JustCounter:	__secretCount = 0  # 私有变量	publicCount = 0    # 公开变量	def count(self):		self.__secretCount += 1		self.publicCount += 1		print self.__secretCountcounter = JustCounter()counter.count()counter.count()print counter.publicCountprint counter.__secretCount  # 报错，实例不能访问私有变量

Python 通过改变名称来包含类名:

122Traceback (most recent call last):  File "test.py", line 17, in <module>    print counter.__secretCount  # 报错，实例不能访问私有变量AttributeError: JustCounter instance has no attribute '__secretCount'

Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName 访问属性，将如下代码替换以上代码的最后一行代码：

.........................print counter._JustCounter__secretCount

执行以上代码，执行结果如下：

1222

单下划线、双下划线、头尾双下划线说明：

• __foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
• _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
• __foo: 双下划线的表示的是私有类型 (private) 的变量, 只能是允许这个类本身进行访问了。

Python 正则表达式

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。Python 自 1.5 版本起增加了 re 模块，它提供 Perl 风格的正则表达式模式。

re 模块使 Python 语言拥有全部的正则表达式功能。

compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。

re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

本章节主要介绍 Python 中常用的正则表达式处理函数。

re.match 函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 None。

函数语法：

re.match(pattern, string, flags=0)

函数参数说明：

匹配成功 re.match 方法返回一个匹配的对象，否则返回 None。

我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。

实例：

#!/usr/bin/pythonimport reline = "Cats are smarter than dogs"matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)if matchObj:   print "matchObj.group() : ", matchObj.group()   print "matchObj.group(1) : ", matchObj.group(1)   print "matchObj.group(2) : ", matchObj.group(2)else:   print "No match!!"

以上实例执行结果如下：

matchObj.group() :  Cats are smarter than dogsmatchObj.group(1) :  CatsmatchObj.group(2) :  smarter

re.search方法

re.search 会在字符串内查找模式匹配，直到找到第一个匹配。

函数语法：

re.search(pattern, string, flags=0)

函数参数说明：

匹配成功 re.search 方法返回一个匹配的对象，否则返回 None。

我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。

实例：

#!/usr/bin/pythonimport reline = "Cats are smarter than dogs";searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)if matchObj:   print "searchObj.group() : ", searchObj.group()   print "searchObj.group(1) : ", searchObj.group(1)   print "searchObj.group(2) : ", searchObj.group(2)else:   print "Nothing found!!"

以上实例执行结果如下：

searchObj.group() :  Cats are smarter than dogssearchObj.group(1) :  CatssearchObj.group(2) :  smarter

re.match 与 re.search 的区别

re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None；而 re.search 匹配整个字符串，直到找到一个匹配。

实例：

#!/usr/bin/pythonimport reline = "Cats are smarter than dogs";matchObj = re.match( r'dogs', line, re.M|re.I)if matchObj:   print "match --> matchObj.group() : ", matchObj.group()else:   print "No match!!"matchObj = re.search( r'dogs', line, re.M|re.I)if matchObj:   print "search --> matchObj.group() : ", matchObj.group()else:   print "No match!!"

以上实例运行结果如下：

No match!!search --> matchObj.group() :  dogs

检索和替换

Python 的 re 模块提供了 re.sub 用于替换字符串中的匹配项。

语法：

re.sub(pattern, repl, string, max=0)

返回的字符串是在字符串中用 RE 最左边不重复的匹配来替换。如果模式没有发现，字符将被没有改变地返回。

可选参数 count 是模式匹配后替换的最大次数；count 必须是非负整数。缺省值是 0 表示替换所有的匹配。

实例：

#!/usr/bin/python# -*- coding: UTF-8 -*- import re phone = "2004-959-559 # 这是一个国外电话号码" # 删除字符串中的 Python注释 num = re.sub(r'#.*$', "", phone)print "电话号码是: ", num # 删除非数字(-)的字符串 num = re.sub(r'D', "", phone)print "电话号码是 : ", num

以上实例执行结果如下：

电话号码 :  2004-959-559电话号码 :  2004959559

repl 参数是一个函数

以下实例中将字符串中的匹配的数字乘以 2：

实例：

#!/usr/bin/python# -*- coding: UTF-8 -*- import re # 将匹配的数字乘以 2def double(matched):    value = int(matched.group('value'))    return str(value * 2) s = 'A23G4HFD567'print(re.sub('(?P<value>d+)', double, s))

执行输出结果为：

A46G8HFD1134

re.compile 函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

语法格式为：

re.compile(pattern[, flags])

参数：

• pattern : 一个字符串形式的正则表达式
• flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
  1. re.I 忽略大小写
  2. re.L 表示特殊字符集 w, W, , B, s, S 依赖于当前环境
  3. re.M 多行模式
  4. re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
  5. re.U 表示特殊字符集 w, W, , B, d, D, s, S 依赖于 Unicode 字符属性数据库
  6. re.X 为了增加可读性，忽略空格和 # 后面的注释

实例

>>>import re>>> pattern = re.compile(r'd+')                    # 用于匹配至少一个数字>>> m = pattern.match('one12twothree34four')        # 查找头部，没有匹配>>> print mNone>>> m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配>>> print mNone>>> m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配>>> print m                                         # 返回一个 Match 对象<_sre.SRE_Match object at 0x10a42aac0>>>> m.group(0)   # 可省略 0'12'>>> m.start(0)   # 可省略 03>>> m.end(0)     # 可省略 05>>> m.span(0)    # 可省略 0(3, 5)

在上面，当匹配成功时返回一个 match 对象，其中：

• group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
• start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
• end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
• span([group]) 方法返回 (start(group), end(group))。

再看看一个例子：

>>>import re>>> pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)   # re.I 表示忽略大小写>>> m = pattern.match('Hello World Wide Web')>>> print m                               # 匹配成功，返回一个 Match 对象<_sre.SRE_Match object at 0x10bea83e8>>>> m.group(0)                            # 返回匹配成功的整个子串'Hello World'>>> m.span(0)                             # 返回匹配成功的整个子串的索引(0, 11)>>> m.group(1)                            # 返回第一个分组匹配成功的子串'Hello'>>> m.span(1)                             # 返回第一个分组匹配成功的子串的索引(0, 5)>>> m.group(2)                            # 返回第二个分组匹配成功的子串'World'>>> m.span(2)                             # 返回第二个分组匹配成功的子串(6, 11)>>> m.groups()                            # 等价于 (m.group(1), m.group(2), ...)('Hello', 'World')>>> m.group(3)                            # 不存在第三个分组Traceback (most recent call last):  File "<stdin>", line 1, in <module>IndexError: no such group

findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

注意： match 和 search 是匹配一次 findall 匹配所有。

语法格式为：

findall(string[, pos[, endpos]])

参数：

• string : 待匹配的字符串。
• pos : 可选参数，指定字符串的起始位置，默认为 0。
• endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。

查找字符串中的所有数字：

# -*- coding:UTF8 -*- import re pattern = re.compile(r'd+')   # 查找数字result1 = pattern.findall('school 123 google 456')result2 = pattern.findall('sch88ool123google456', 0, 10) print(result1)print(result2)

输出结果：

['123', '456']['88', '12']

re.finditer

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

re.finditer(pattern, string, flags=0)

参数：

实例：

# -*- coding: UTF-8 -*- import re it = re.finditer(r"d+","12a32bc43jf3") for match in it:     print (match.group() )

输出结果：

12 32 43 3

re.split

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

re.split(pattern, string[, maxsplit=0, flags=0])

参数：

实例：

>>>import re>>> re.split('W+', '51coolma, 51coolma, 51coolma.')['51coolma', '51coolma', '51coolma', '']>>> re.split('(W+)', ' 51coolma, 51coolma, 51coolma.') ['', ' ', '51coolma', ', ', '51coolma', ', ', '51coolma', '.', '']>>> re.split('W+', ' 51coolma, 51coolma, 51coolma.', 1) ['', '51coolma, 51coolma, 51coolma.'] >>> re.split('a*', 'hello world')   # 对于一个找不到匹配的字符串而言，split 不会对其作出分割['hello world']

正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

多数字母和数字前加一个反斜杠时会拥有不同的含义。

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

反斜杠本身需要使用反斜杠转义。

由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'/t'，等价于'//t')匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

正则表达式实例

字符匹配

字符类

特殊字符类

python操作mysql数据库

Python 标准数据库接口为 Python DB-API，Python DB-API为开发人员提供了数据库应用编程接口。

Python 数据库接口支持非常多的数据库，你可以选择适合你项目的数据库：

• GadFly
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server 2000
• Informix
• Interbase
• Oracle
• Sybase

你可以访问 Python数据库接口及API 查看详细的支持数据库列表。

不同的数据库你需要下载不同的 DB API 模块，例如你需要访问 Oracle 数据库和 Mysql 数据，你需要下载 Oracle 和 MySQL 数据库模块。

DB-API 是一个规范. 它定义了一系列必须的对象和数据库存取方式, 以便为各种各样的底层数据库系统和多种多样的数据库接口程序提供一致的访问接口 。

Python的DB-API，为大多数的数据库实现了接口，使用它连接各数据库后，就可以用相同的方式操作各数据库。

Python DB-API 使用流程：

• 引入 API 模块。
• 获取与数据库的连接。
• 执行 SQL 语句和存储过程。
• 关闭数据库连接。

什么是 MySQLdb?

MySQLdb 是用于 Python 链接 Mysql 数据库的接口，它实现了 Python 数据库 API 规范 V2.0，基于 MySQL C API 上建立的。

如何安装 MySQLdb?

为了用 DB-API 编写 MySQL 脚本，必须确保已经安装了 MySQL。复制以下代码，并执行：

# encoding: utf-8#!/usr/bin/pythonimport MySQLdb

如果执行后的输出结果如下所示，意味着你没有安装 MySQLdb 模块：

Traceback (most recent call last):  File "test.py", line 3, in <module>    import MySQLdbImportError: No module named MySQLdb

安装 MySQLdb，请访问 http://sourceforge.net/projects/mysql-python ，(Linux 平台可以访问：https://pypi.python.org/pypi/MySQL-python) 从这里可选择适合您的平台的安装包，分为预编译的二进制文件和源代码安装包。

如果您选择二进制文件发行版本的话，安装过程基本安装提示即可完成。如果从源代码进行安装的话，则需要切换到 MySQLdb 发行版本的顶级目录，并键入下列命令:

$ gunzip MySQL-python-1.2.2.tar.gz$ tar -xvf MySQL-python-1.2.2.tar$ cd MySQL-python-1.2.2$ python setup.py build$ python setup.py install

注意：请确保您有 root 权限来安装上述模块。

数据库连接

连接数据库前，请先确认以下事项：

• 您已经创建了数据库 TESTDB.
• 在 TESTDB 数据库中您已经创建了表 EMPLOYEE
• EMPLOYEE 表字段为 FIRST_NAME, LAST_NAME, AGE, SEX 和 INCOME。
• 连接数据库 TESTDB 使用的用户名为 "testuser" ，密码为 "test123",你可以可以自己设定或者直接使用 root 用户名及其密码，Mysql 数据库用户授权请使用 Grant 命令。
• 在你的机子上已经安装了 Python MySQLdb 模块。
• 如果您对 sql 语句不熟悉，可以访问我们的 SQL基础教程

实例：

以下实例链接 Mysql 的 TESTDB 数据库：

# encoding: utf-8#!/usr/bin/pythonimport MySQLdb# 打开数据库连接db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )# 使用cursor()方法获取操作游标 cursor = db.cursor()# 使用execute方法执行SQL语句cursor.execute("SELECT VERSION()")# 使用 fetchone() 方法获取一条数据库。data = cursor.fetchone()print "Database version : %s " % data# 关闭数据库连接db.close()

执行以上脚本输出结果如下：

Database version : 5.0.45

创建数据库表

如果数据库连接存在我们可以使用 execute() 方法来为数据库创建表，如下所示创建表 EMPLOYEE：

# encoding: utf-8#!/usr/bin/pythonimport MySQLdb# 打开数据库连接db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )# 使用cursor()方法获取操作游标 cursor = db.cursor()# 如果数据表已经存在使用 execute() 方法删除表。cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")# 创建数据表SQL语句sql = """CREATE TABLE EMPLOYEE (         FIRST_NAME  CHAR(20) NOT NULL,         LAST_NAME  CHAR(20),         AGE INT,           SEX CHAR(1),         INCOME FLOAT )"""cursor.execute(sql)# 关闭数据库连接db.close()

数据库插入操作

以下实例使用执行 SQL INSERT 语句向表 EMPLOYEE 插入记录：

# encoding: utf-8#!/usr/bin/pythonimport MySQLdb# 打开数据库连接db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )# 使用cursor()方法获取操作游标 cursor = db.cursor()# SQL 插入语句sql = """INSERT INTO EMPLOYEE(FIRST_NAME,         LAST_NAME, AGE, SEX, INCOME)         VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""try:   # 执行sql语句   cursor.execute(sql)   # 提交到数据库执行   db.commit()except:   # Rollback in case there is any error   db.rollback()# 关闭数据库连接db.close()

以上例子也可以写成如下形式：

# encoding: utf-8#!/usr/bin/pythonimport MySQLdb# 打开数据库连接db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )# 使用cursor()方法获取操作游标 cursor = db.cursor()# SQL 插入语句sql = "INSERT INTO EMPLOYEE(FIRST_NAME,        LAST_NAME, AGE, SEX, INCOME)        VALUES ('%s', '%s', '%d', '%c', '%d' )" %        ('Mac', 'Mohan', 20, 'M', 2000)try:   # 执行sql语句   cursor.execute(sql)   # 提交到数据库执行   db.commit()except:   # 发生错误时回滚   db.rollback()# 关闭数据库连接db.close()

实例：

以下代码使用变量向 SQL 语句中传递参数:

..................................user_id = "test123"password = "password"con.execute('insert into Login values("%s", "%s")' %              (user_id, password))..................................

数据库查询操作

Python 查询 Mysql 使用 fetchone() 方法获取单条数据, 使用 fetchall() 方法获取多条数据。

• fetchone(): 该方法获取下一个查询结果集。结果集是一个对象
• fetchall(): 接收全部的返回结果行.
• rowcount:  这是一个只读属性，并返回执行 execute() 方法后影响的行数。

实例：

查询 EMPLOYEE 表中 salary（工资）字段大于 1000 的所有数据：

# encoding: utf-8#!/usr/bin/pythonimport MySQLdb# 打开数据库连接db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )# 使用cursor()方法获取操作游标 cursor = db.cursor()# SQL 查询语句sql = "SELECT * FROM EMPLOYEE        WHERE INCOME > '%d'" % (1000)try:   # 执行SQL语句   cursor.execute(sql)   # 获取所有记录列表   results = cursor.fetchall()   for row in results:      fname = row[0]      lname = row[1]      age = row[2]      sex = row[3]      income = row[4]      # 打印结果      print "fname=%s,lname=%s,age=%d,sex=%s,income=%d" %              (fname, lname, age, sex, income )except:   print "Error: unable to fecth data"# 关闭数据库连接db.close()

以上脚本执行结果如下：

fname=Mac, lname=Mohan, age=20, sex=M, income=2000

数据库更新操作

更新操作用于更新数据表的的数据，以下实例将 TESTDB 表中的 SEX 字段全部修改为 'M'，AGE 字段递增 1：

# encoding: utf-8#!/usr/bin/pythonimport MySQLdb# 打开数据库连接db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )# 使用cursor()方法获取操作游标 cursor = db.cursor()# SQL 更新语句sql = "UPDATE EMPLOYEE SET AGE = AGE + 1        WHERE SEX = '%c'" % ('M')try:   # 执行SQL语句   cursor.execute(sql)   # 提交到数据库执行   db.commit()except:   # 发生错误时回滚   db.rollback()# 关闭数据库连接db.close()

删除操作

删除操作用于删除数据表中的数据，以下实例演示了删除数据表 EMPLOYEE 中 AGE 大于 20 的所有数据：

#!/usr/bin/python# -*- coding: UTF-8 -*-import MySQLdb# 打开数据库连接db = MySQLdb.connect("localhost", "testuser", "test123", "TESTDB", charset='utf8' )# 使用cursor()方法获取操作游标 cursor = db.cursor()# SQL 删除语句sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)try:   # 执行SQL语句   cursor.execute(sql)   # 提交修改   db.commit()except:   # 发生错误时回滚   db.rollback()# 关闭连接db.close()

执行事务

事务机制可以确保数据一致性。

事务应该具有 4 个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为 ACID 特性。

• 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
• 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
• 隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
• 持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

Python DB API 2.0 的事务提供了两个方法 commit 或 rollback。

实例：

# SQL删除记录语句sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)try:   # 执行SQL语句   cursor.execute(sql)   # 向数据库提交   db.commit()except:   # 发生错误时回滚   db.rollback()

对于支持事务的数据库， 在 Python 数据库编程中，当游标建立之时，就自动开始了一个隐形的数据库事务。

commit() 方法游标的所有更新操作，rollback() 方法回滚当前游标的所有操作。每一个方法都开始了一个新的事务。

错误处理

DB API 中定义了一些数据库操作的错误及异常，下表列出了这些错误和异常:

Python 使用 SMTP 发送邮件

SMTP（Simple Mail Transfer Protocol）即简单邮件传输协议, 它是一组用于由源地址到目的地址传送邮件的规则，由它来控制信件的中转方式。

python 的 smtplib 提供了一种很方便的途径发送电子邮件。它对 smtp 协议进行了简单的封装。

Python 创建 SMTP 对象语法如下：

import smtplibsmtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )

参数说明：

• host: SMTP 服务器主机。 你可以指定主机的ip地址或者域名如: 51coolma.cn，这个是可选参数。
• port: 如果你提供了 host 参数, 你需要指定 SMTP 服务使用的端口号，一般情况下 SMTP 端口号为 25。
• local_hostname: 如果 SMTP 在你的本机上，你只需要指定服务器地址为 localhost 即可。

Python SMTP 对象使用 sendmail 方法发送邮件，语法如下：

SMTP.sendmail(from_addr, to_addrs, msg[, mail_options, rcpt_options]

参数说明：

• from_addr: 邮件发送者地址。
• to_addrs: 字符串列表，邮件发送地址。
• msg: 发送消息

这里要注意一下第三个参数，msg 是字符串，表示邮件。我们知道邮件一般由标题，发信人，收件人，邮件内容，附件等构成，发送邮件的时候，要注意 msg 的格式。这个格式就是 smtp 协议中定义的格式。

实例

以下是一个使用 Python 发送邮件简单的实例：

#!/usr/bin/pythonimport smtplibsender = 'from@fromdomain.com'receivers = ['to@todomain.com']message = """From: From Person <from@fromdomain.com>To: To Person <to@todomain.com>Subject: SMTP e-mail testThis is a test e-mail message."""try:   smtpObj = smtplib.SMTP('localhost')   smtpObj.sendmail(sender, receivers, message)            print "Successfully sent email"except SMTPException:   print "Error: unable to send email"

使用 Python 发送 HTML 格式的邮件

Python 发送 HTML 格式的邮件与发送纯文本消息的邮件不同之处就是将 MIMEText 中 _subtype 设置为 html。具体代码如下：

import smtplib  from email.mime.text import MIMEText  mailto_list=["YYY@YYY.com"] mail_host="smtp.XXX.com"  #设置服务器mail_user="XXX"    #用户名mail_pass="XXXX"   #口令 mail_postfix="XXX.com"  #发件箱的后缀  def send_mail(to_list,sub,content):  #to_list：收件人；sub：主题；content：邮件内容    me="hello"+"<"+mail_user+"@"+mail_postfix+">"   #这里的hello可以任意设置，收到信后，将按照设置显示    msg = MIMEText(content,_subtype='html',_charset='gb2312')    #创建一个实例，这里设置为html格式邮件    msg['Subject'] = sub    #设置主题    msg['From'] = me      msg['To'] = ";".join(to_list)      try:          s = smtplib.SMTP()          s.connect(mail_host)  #连接smtp服务器        s.login(mail_user,mail_pass)  #登陆服务器        s.sendmail(me, to_list, msg.as_string())  #发送邮件        s.close()          return True      except Exception, e:          print str(e)          return False  if __name__ == '__main__':      if send_mail(mailto_list,"hello","<a href='http://www.51coolma.cn/'>W3Cschool</a>"):          print "发送成功"      else:          print "发送失败"  

或者你也可以在消息体中指定 Content-type 为 text/html,如下实例:

#!/usr/bin/pythonimport smtplibmessage = """From: From Person <from@fromdomain.com>To: To Person <to@todomain.com>MIME-Version: 1.0Content-type: text/htmlSubject: SMTP HTML e-mail testThis is an e-mail message to be sent in HTML format<b>This is HTML message.</b><h1>This is headline.</h1>"""try:   smtpObj = smtplib.SMTP('localhost')   smtpObj.sendmail(sender, receivers, message)            print "Successfully sent email"except SMTPException:   print "Error: unable to send email"

Python 发送带附件的邮件

发送带附件的邮件，首先要创建 MIMEMultipart() 实例，然后构造附件，如果有多个附件，可依次构造，最后利用 smtplib.smtp 发送。

from email.mime.text import MIMETextfrom email.mime.multipart import MIMEMultipartimport smtplib#创建一个带附件的实例msg = MIMEMultipart()#构造附件1att1 = MIMEText(open('d:123.rar', 'rb').read(), 'base64', 'gb2312')att1["Content-Type"] = 'application/octet-stream'att1["Content-Disposition"] = 'attachment; filename="123.doc"'#这里的filename可以任意写，写什么名字，邮件中显示什么名字msg.attach(att1)#构造附件2att2 = MIMEText(open('d:123.txt', 'rb').read(), 'base64', 'gb2312')att2["Content-Type"] = 'application/octet-stream'att2["Content-Disposition"] = 'attachment; filename="123.txt"'msg.attach(att2)#加邮件头msg['to'] = 'YYY@YYY.com'msg['from'] = 'XXX@XXX.com'msg['subject'] = 'hello world'#发送邮件try:    server = smtplib.SMTP()    server.connect('smtp.XXX.com')    server.login('XXX','XXXXX')#XXX为用户名，XXXXX为密码    server.sendmail(msg['from'], msg['to'],msg.as_string())    server.quit()    print '发送成功'except Exception, e:      print str(e) 

以下实例指定了 Content-type header 为 multipart/mixed，并发送 /tmp/test.txt 文本文件：

#!/usr/bin/pythonimport smtplibimport base64filename = "/tmp/test.txt"# 读取文件内容并使用 base64 编码fo = open(filename, "rb")filecontent = fo.read()encodedcontent = base64.b64encode(filecontent)  # base64sender = 'webmaster@tutorialpoint.com'reciever = 'amrood.admin@gmail.com'marker = "AUNIQUEMARKER"body ="""This is a test email to send an attachement."""# 定义头部信息part1 = """From: From Person <me@fromdomain.net>To: To Person <amrood.admin@gmail.com>Subject: Sending AttachementMIME-Version: 1.0Content-Type: multipart/mixed; boundary=%s--%s""" % (marker, marker)# 定义消息动作part2 = """Content-Type: text/plainContent-Transfer-Encoding:8bit%s--%s""" % (body,marker)# 定义附近部分part3 = """Content-Type: multipart/mixed; name="%s"Content-Transfer-Encoding:base64Content-Disposition: attachment; filename=%s%s--%s--""" %(filename, filename, encodedcontent, marker)message = part1 + part2 + part3try:   smtpObj = smtplib.SMTP('localhost')   smtpObj.sendmail(sender, reciever, message)   print "Successfully sent email"except Exception:   print "Error: unable to send email"

Python 多线程

多线程类似于同时执行多个不同程序，多线程运行有如下优点：

• 使用线程可以把占据长时间的程序中的任务放到后台去处理。
• 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度
• 程序的运行速度可能加快
• 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

每个线程都有他自己的一组 CPU 寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。

指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。

• 线程可以被抢占（中断）。
• 在其他线程正在运行时，线程可以暂时搁置（也称为睡眠） -- 这就是线程的退让。

开始学习 Python 线程

Python 中使用线程有两种方式：函数或者用类来包装线程对象。

函数式：调用 thread 模块中的 start_new_thread() 函数来产生新线程。语法如下:

thread.start_new_thread ( function, args[, kwargs] )

参数说明:

• function - 线程函数。
• args - 传递给线程函数的参数,他必须是个 tuple 类型。
• kwargs - 可选参数。

实例：

#!/usr/bin/python# -*- coding: UTF-8 -*-import threadimport time# 为线程定义一个函数def print_time( threadName, delay):   count = 0   while count < 5:      time.sleep(delay)      count += 1      print "%s: %s" % ( threadName, time.ctime(time.time()) )# 创建两个线程try:   thread.start_new_thread( print_time, ("Thread-1", 2, ) )   thread.start_new_thread( print_time, ("Thread-2", 4, ) )except:   print "Error: unable to start thread"while 1:   pass

执行以上程序输出结果如下：

Thread-1: Thu Jan 22 15:42:17 2009Thread-1: Thu Jan 22 15:42:19 2009Thread-2: Thu Jan 22 15:42:19 2009Thread-1: Thu Jan 22 15:42:21 2009Thread-2: Thu Jan 22 15:42:23 2009Thread-1: Thu Jan 22 15:42:23 2009Thread-1: Thu Jan 22 15:42:25 2009Thread-2: Thu Jan 22 15:42:27 2009Thread-2: Thu Jan 22 15:42:31 2009Thread-2: Thu Jan 22 15:42:35 2009

线程的结束一般依靠线程函数的自然结束；也可以在线程函数中调用 thread.exit()，他抛出 SystemExit exception，达到退出线程的目的。

线程模块

Python 通过两个标准库 thread 和 threading 提供对线程的支持。thread 提供了低级别的、原始的线程以及一个简单的锁。

thread 模块提供的其他方法：

• threading.currentThread(): 返回当前的线程变量。
• threading.enumerate(): 返回一个包含正在运行的线程的 list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
• threading.activeCount(): 返回正在运行的线程数量，与 len(threading.enumerate()) 有相同的结果。

除了使用方法外，线程模块同样提供了 Thread 类来处理线程，Thread 类提供了以下方法:

• run():  用以表示线程活动的方法。
• start(): 启动线程活动。

• join([time]):  等待至线程中止。这阻塞调用线程直至线程的 join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
• isAlive():  返回线程是否活动的。
• getName():  返回线程名。
• setName():  设置线程名。

使用 Threading 模块创建线程

使用 Threading 模块创建线程，直接从 threading.Thread 继承，然后重写 __init__ 方法和 run() 方法：

#coding=utf-8#!/usr/bin/pythonimport threadingimport timeexitFlag = 0class myThread (threading.Thread):   #继承父类threading.Thread    def __init__(self, threadID, name, counter):        threading.Thread.__init__(self)        self.threadID = threadID        self.name = name        self.counter = counter    def run(self):                   #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数         print "Starting " + self.name        print_time(self.name, self.counter, 5)        print "Exiting " + self.namedef print_time(threadName, delay, counter):    while counter:        if exitFlag:            thread.exit()        time.sleep(delay)        print "%s: %s" % (threadName, time.ctime(time.time()))        counter -= 1# 创建新线程thread1 = myThread(1, "Thread-1", 1)thread2 = myThread(2, "Thread-2", 2)# 开启线程thread1.start()thread2.start()print "Exiting Main Thread"

以上程序执行结果如下；

Starting Thread-1Starting Thread-2Exiting Main ThreadThread-1: Thu Mar 21 09:10:03 2013Thread-1: Thu Mar 21 09:10:04 2013Thread-2: Thu Mar 21 09:10:04 2013Thread-1: Thu Mar 21 09:10:05 2013Thread-1: Thu Mar 21 09:10:06 2013Thread-2: Thu Mar 21 09:10:06 2013Thread-1: Thu Mar 21 09:10:07 2013Exiting Thread-1Thread-2: Thu Mar 21 09:10:08 2013Thread-2: Thu Mar 21 09:10:10 2013Thread-2: Thu Mar 21 09:10:12 2013Exiting Thread-2

线程同步

如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。如下：

多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。

考虑这样一种情况：一个列表里所有元素都是 0，线程 "set" 从后向前把所有元素改成 1，而线程 "print" 负责从前往后读取列表并打印。

那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半 0 一半 1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。

锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如 "print" 获得锁定了，那么就让线程 "set" 暂停，也就是同步阻塞；等到线程 "print" 访问完毕，释放锁以后，再让线程 "set" 继续。

经过这样的处理，打印列表时要么全部输出 0，要么全部输出 1，不会再出现一半 0 一半 1 的尴尬场面。

实例：

#coding=utf-8#!/usr/bin/pythonimport threadingimport timeclass myThread (threading.Thread):    def __init__(self, threadID, name, counter):        threading.Thread.__init__(self)        self.threadID = threadID        self.name = name        self.counter = counter    def run(self):        print "Starting " + self.name       # 获得锁，成功获得锁定后返回True       # 可选的timeout参数不填时将一直阻塞直到获得锁定       # 否则超时后将返回False        threadLock.acquire()        print_time(self.name, self.counter, 3)        # 释放锁        threadLock.release()def print_time(threadName, delay, counter):    while counter:        time.sleep(delay)        print "%s: %s" % (threadName, time.ctime(time.time()))        counter -= 1threadLock = threading.Lock()threads = []# 创建新线程thread1 = myThread(1, "Thread-1", 1)thread2 = myThread(2, "Thread-2", 2)# 开启新线程thread1.start()thread2.start()# 添加线程到线程列表threads.append(thread1)threads.append(thread2)# 等待所有线程完成for t in threads:    t.join()print "Exiting Main Thread"

线程优先级队列（ Queue）

Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括 FIFO（先入先出)队列 Queue，LIFO（后入先出）队列 LifoQueue，和优先级队列 PriorityQueue。这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。

Queue 模块中的常用方法:

• Queue.qsize() 返回队列的大小
• Queue.empty() 如果队列为空，返回 True, 反之 False
• Queue.full() 如果队列满了，返回 True, 反之 False
• Queue.full 与 maxsize 大小对应
• Queue.get([block[, timeout]]) 获取队列，timeout  等待时间
• Queue.get_nowait() 相当 Queue.get(False)
• Queue.put(item) 写入队列，timeout 等待时间
• Queue.put_nowait(item) 相当 Queue.put(item, False)
• Queue.task_done() 在完成一项工作之后，Queue.task_done() 函数向任务已经完成的队列发送一个信号
• Queue.join() 实际上意味着等到队列为空，再执行别的操作

实例:

#coding=utf-8#!/usr/bin/pythonimport Queueimport threadingimport timeexitFlag = 0class myThread (threading.Thread):    def __init__(self, threadID, name, q):        threading.Thread.__init__(self)        self.threadID = threadID        self.name = name        self.q = q    def run(self):        print "Starting " + self.name        process_data(self.name, self.q)        print "Exiting " + self.namedef process_data(threadName, q):    while not exitFlag:        queueLock.acquire()        if not workQueue.empty():            data = q.get()            queueLock.release()            print "%s processing %s" % (threadName, data)        else:            queueLock.release()        time.sleep(1)threadList = ["Thread-1", "Thread-2", "Thread-3"]nameList = ["One", "Two", "Three", "Four", "Five"]queueLock = threading.Lock()workQueue = Queue.Queue(10)threads = []threadID = 1# 创建新线程for tName in threadList:    thread = myThread(threadID, tName, workQueue)    thread.start()    threads.append(thread)    threadID += 1# 填充队列queueLock.acquire()for word in nameList:    workQueue.put(word)queueLock.release()# 等待队列清空while not workQueue.empty():    pass# 通知线程是时候退出exitFlag = 1# 等待所有线程完成for t in threads:    t.join()print "Exiting Main Thread"

以上程序执行结果：

Starting Thread-1Starting Thread-2Starting Thread-3Thread-1 processing OneThread-2 processing TwoThread-3 processing ThreeThread-1 processing FourThread-2 processing FiveExiting Thread-3Exiting Thread-1Exiting Thread-2Exiting Main Thread

Python XML 解析

什么是 XML？

XML 指可扩展标记语言（eXtensible Markup Language）。 你可以通过本站学习XML教程

XML 被设计用来传输和存储数据。

XML 是一套定义语义标记的规则，这些标记将文档分成许多部件并对这些部件加以标识。

它也是元标记语言，即定义了用于定义其他与特定领域有关的、语义的、结构化的标记语言的句法语言。

python 对 XML 的解析

常见的 XML 编程接口有 DOM 和 SAX，这两种接口处理 XML 文件的方式不同，当然使用场合也不同。

python 有三种方法解析 XML，SAX，DOM，以及 ElementTree:

1.SAX (simple API for XML )

pyhton 标准库包含 SAX 解析器，SAX 用事件驱动模型，通过在解析 XML 的过程中触发一个个的事件并调用用户定义的回调函数来处理 XML 文件。

2.DOM(Document Object Model)

将 XML 数据在内存中解析成一个树，通过对树的操作来操作 XML。

3.ElementTree(元素树)

ElementTree 就像一个轻量级的 DOM，具有方便友好的 API。代码可用性好，速度快，消耗内存少。

注：因 DOM 需要将 XML 数据映射到内存中的树，一是比较慢，二是比较耗内存，而 SAX 流式读取 XML 文件，比较快，占用内存少，但需要用户实现回调函数（handler）。

本章节使用到的 XML 实例文件 movies.xml 内容如下：

<collection shelf="New Arrivals"><movie title="Enemy Behind">   <type>War, Thriller</type>   <format>DVD</format>   <year>2003</year>   <rating>PG</rating>   <stars>10</stars>   <description>Talk about a US-Japan war</description></movie><movie title="Transformers">   <type>Anime, Science Fiction</type>   <format>DVD</format>   <year>1989</year>   <rating>R</rating>   <stars>8</stars>   <description>A schientific fiction</description></movie>   <movie title="Trigun">   <type>Anime, Action</type>   <format>DVD</format>   <episodes>4</episodes>   <rating>PG</rating>   <stars>10</stars>   <description>Vash the Stampede!</description></movie><movie title="Ishtar">   <type>Comedy</type>   <format>VHS</format>   <rating>PG</rating>   <stars>2</stars>   <description>Viewable boredom</description></movie></collection>

python 使用 SAX 解析 xml

SAX 是一种基于事件驱动的 API。

利用 SAX 解析 XML 文档牵涉到两个部分: 解析器和事件处理器。

解析器负责读取 XML 文档, 并向事件处理器发送事件, 如元素开始跟元素结束事件;

而事件处理器则负责对事件作出相应, 对传递的 XML 数据进行处理。

• 1、对大型文件进行处理；
• 2、只需要文件的部分内容，或者只需从文件中得到特定信息。
• 3、想建立自己的对象模型的时候。

在 python 中使用 sax 方式处理 xml 要先引入 xml.sax 中的 parse 函数，还有 xml.sax.handler 中的 ContentHandler。

ContentHandler 类方法介绍

characters(content) 方法

调用时机：

从行开始，遇到标签之前，存在字符，content 的值为这些字符串。

从一个标签，遇到下一个标签之前， 存在字符，content 的值为这些字符串。

从一个标签，遇到行结束符之前，存在字符，content 的值为这些字符串。

标签可以是开始标签，也可以是结束标签。

startDocument() 方法

文档启动的时候调用。

endDocument() 方法

解析器到达文档结尾时调用。

startElement(name, attrs) 方法

遇到 XML 开始标签时调用，name 是标签的名字，attrs 是标签的属性值字典。

endElement(name) 方法

遇到 XML 结束标签时调用。

make_parser 方法

以下方法创建一个新的解析器对象并返回。

xml.sax.make_parser( [parser_list] )

参数说明:

• parser_list - 可选参数，解析器列表

parser方法

以下方法创建一个 SAX 解析器并解析 xml 文档：

xml.sax.parse( xmlfile, contenthandler[, errorhandler])

参数说明:

• xmlfile - xml 文件名
• contenthandler - 必须是一个 ContentHandler 的对象
• errorhandler - 如果指定该参数，errorhandler 必须是一个 SAX ErrorHandler 对象

parseString 方法

parseString 方法创建一个 XML 解析器并解析 xml 字符串：

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])

参数说明:

• xmlstring - xml 字符串
• contenthandler - 必须是一个 ContentHandler 的对象
• errorhandler - 如果指定该参数，errorhandler 必须是一个 SAX ErrorHandler 对象

Python 解析 XML 实例

#coding=utf-8#!/usr/bin/pythonimport xml.saxclass MovieHandler( xml.sax.ContentHandler ):   def __init__(self):      self.CurrentData = ""      self.type = ""      self.format = ""      self.year = ""      self.rating = ""      self.stars = ""      self.description = ""   # 元素开始事件处理   def startElement(self, tag, attributes):      self.CurrentData = tag      if tag == "movie":         print "*****Movie*****"         title = attributes["title"]         print "Title:", title   # 元素结束事件处理   def endElement(self, tag):      if self.CurrentData == "type":         print "Type:", self.type      elif self.CurrentData == "format":         print "Format:", self.format      elif self.CurrentData == "year":         print "Year:", self.year      elif self.CurrentData == "rating":         print "Rating:", self.rating      elif self.CurrentData == "stars":         print "Stars:", self.stars      elif self.CurrentData == "description":         print "Description:", self.description      self.CurrentData = ""   # 内容事件处理   def characters(self, content):      if self.CurrentData == "type":         self.type = content      elif self.CurrentData == "format":         self.format = content      elif self.CurrentData == "year":         self.year = content      elif self.CurrentData == "rating":         self.rating = content      elif self.CurrentData == "stars":         self.stars = content      elif self.CurrentData == "description":         self.description = content  if ( __name__ == "__main__"):      # 创建一个 XMLReader   parser = xml.sax.make_parser()   # turn off namepsaces   parser.setFeature(xml.sax.handler.feature_namespaces, 0)   # 重写 ContextHandler   Handler = MovieHandler()   parser.setContentHandler( Handler )      parser.parse("movies.xml")

以上代码执行结果如下：

*****Movie*****Title: Enemy BehindType: War, ThrillerFormat: DVDYear: 2003Rating: PGStars: 10Description: Talk about a US-Japan war*****Movie*****Title: TransformersType: Anime, Science FictionFormat: DVDYear: 1989Rating: RStars: 8Description: A schientific fiction*****Movie*****Title: TrigunType: Anime, ActionFormat: DVDRating: PGStars: 10Description: Vash the Stampede!*****Movie*****Title: IshtarType: ComedyFormat: VHSRating: PGStars: 2Description: Viewable boredom

完整的 SAX API 文档请查阅 Python SAX APIs

使用 xml.dom 解析 xml

文件对象模型（Document Object Model，简称 DOM），是 W3C 组织推荐的处理可扩展置标语言的标准编程接口。

一个 DOM 的解析器在解析一个 XML 文档时，一次性读取整个文档，把文档中所有元素保存在内存中的一个树结构里，之后你可以利用 DOM 提供的不同的函数来读取或修改文档的内容和结构，也可以把修改过的内容写入 xml 文件。

python 中用x ml.dom.minidom 来解析 xml 文件，实例如下：

#coding=utf-8#!/usr/bin/pythonfrom xml.dom.minidom import parseimport xml.dom.minidom# 使用minidom解析器打开 XML 文档DOMTree = xml.dom.minidom.parse("movies.xml")collection = DOMTree.documentElementif collection.hasAttribute("shelf"):   print "Root element : %s" % collection.getAttribute("shelf")# 在集合中获取所有电影movies = collection.getElementsByTagName("movie")# 打印每部电影的详细信息for movie in movies:   print "*****Movie*****"   if movie.hasAttribute("title"):      print "Title: %s" % movie.getAttribute("title")   type = movie.getElementsByTagName('type')[0]   print "Type: %s" % type.childNodes[0].data   format = movie.getElementsByTagName('format')[0]   print "Format: %s" % format.childNodes[0].data   rating = movie.getElementsByTagName('rating')[0]   print "Rating: %s" % rating.childNodes[0].data   description = movie.getElementsByTagName('description')[0]   print "Description: %s" % description.childNodes[0].data

以上程序执行结果如下：

Root element : New Arrivals*****Movie*****Title: Enemy BehindType: War, ThrillerFormat: DVDRating: PGDescription: Talk about a US-Japan war*****Movie*****Title: TransformersType: Anime, Science FictionFormat: DVDRating: RDescription: A schientific fiction*****Movie*****Title: TrigunType: Anime, ActionFormat: DVDRating: PGDescription: Vash the Stampede!*****Movie*****Title: IshtarType: ComedyFormat: VHSRating: PGDescription: Viewable boredom

完整的 DOM API 文档请查阅Python DOM APIs。

python GUI 编程 (Tkinter)

Python 提供了多个图形开发界面的库，几个常用 Python GUI 库如下：

• Tkinter： Tkinter 模块("Tk 接口")是 Python 的标准 Tk GUI 工具包的接口 .Tk 和 Tkinter 可以在大多数的 Unix 平台下使用，同样可以应用在 Windows 和 Macintosh 系统里。Tk8.0 的后续版本可以实现本地窗口风格，并良好地运行在绝大多数平台中。
• wxPython：wxPython 是一款开源软件，是 Python 语言的一套优秀的 GUI 图形库，允许 Python 程序员很方便的创建完整的、功能键全的 GUI 用户界面。
• Jython：Jython 程序可以和 Java 无缝集成。除了一些标准模块，Jython 使用 Java 的模块。Jython 几乎拥有标准的Python 中不依赖于 C 语言的全部模块。比如，Jython 的用户界面将使用 Swing，AWT 或者 SWT。Jython 可以被动态或静态地编译成 Java 字节码。

Tkinter 编程

Tkinter 是 Python 的标准 GUI 库。Python 使用 Tkinter 可以快速的创建 GUI 应用程序。

由于 Tkinter 是内置到 Python 的安装包中、只要安装好 Python 之后就能 import Tkinter 库、而且 IDLE 也是用 Tkinter 编写而成、对于简单的图形界面 Tkinter 还是能应付自如。

注意：Python3.x 版本使用的库名为 tkinter，即首写字母 T 为小写：

import tkinter

创建一个 GUI 程序

• 1、导入 Tkinter 模块
• 2、创建控件
• 3、指定这个控件的 master， 即这个控件属于哪一个
• 4、告诉 GM (geometry manager) 有一个控件产生了。

实例:

#!/usr/bin/pythonimport Tkintertop = Tkinter.Tk()# 进入消息循环top.mainloop()

以上代码执行结果如下图:

实例2：

#!/usr/bin/python# -*- coding: UTF-8 -*-from Tkinter import *           # 导入 Tkinter 库root = Tk()                     # 创建窗口对象的背景色                                # 创建两个列表li     = ['C','python','php','html','SQL','java']movie  = ['CSS','jQuery','Bootstrap']listb  = Listbox(root)          #  创建两个列表组件listb2 = Listbox(root)for item in li:                 # 第一个小部件插入数据    listb.insert(0,item)for item in movie:              # 第二个小部件插入数据    listb2.insert(0,item)listb.pack()                    # 将小部件放置到主窗口中listb2.pack()root.mainloop()                 # 进入消息循环

以上代码执行结果如下图:

Tkinter 组件

Tkinter 的提供各种控件，如按钮，标签和文本框，一个 GUI 应用程序中使用。这些控件通常被称为控件或者部件。

目前有 15 种 Tkinter 的部件。我们提出这些部件以及一个简短的介绍，在下面的表:

标准属性

标准属性也就是所有控件的共同属性，如大小，字体和颜色等等。

几何管理

Tkinter 控件有特定的几何状态管理方法，管理整个控件区域组织，一下是 Tkinter 公开的几何管理类：包、网格、位置

Python 的 3​​.0 版本，常被称为 Python 3000，或简称 Py3k。相对于 Python 的早期版本，这是一个较大的升级。

为了不带入过多的累赘，Python 3.0 在设计的时候没有考虑向下相容。

许多针对早期 Python 版本设计的程式都无法在 Python 3.0 上正常执行。

为了照顾现有程式，Python 2.6 作为一个过渡版本，基本使用了 Python 2.x 的语法和库，同时考虑了向 Python 3.0 的迁移，允许使用部分 Python 3.0 的语法与函数。

新的Python程式建议使用 Python 3.0 版本的语法。

除非执行环境无法安装 Python 3.0 或者程式本身使用了不支援 Python 3.0 的第三方库。目前不支援 Python 3.0 的第三方库有 Twisted, py2exe, PIL等。

大多数第三方库都正在努力地相容 Python 3.0 版本。即使无法立即使用 Python 3.0 ，也建议编写相容Python 3.0版本的程式，然后使用 Python 2.6, Python 2.7 来执行。

Python 3.0 的变化主要在以下几个方面:

print 函数

​print​语句没有了，取而代之的是​print()​函数。 Python 2.6 与 Python 2.7 部分地支持这种形式的​print​语法。在 Python 2.6 与 Python 2.7 里面，以下三种形式是等价的：

print "fish"print ("fish") #注意print后面有个空格print("fish") #print()不能带有任何其它参数

然而，Python 2.6 实际已经支持新的​print()​语法：

from __future__ import print_functionprint("fish", "panda", sep=', ')

Unicode

Python 2 有 ​ASCII str()​ 类型，​unicode()​ 是单独的，不是 ​byte​ 类型。

现在， 在 Python 3，我们最终有了​ Unicode (utf-8)​ 字符串，以及一个字节类：​byte​ 和 ​bytearrays​。

由于 Python3.X 源码文件默认使用​utf-8​编码，这就使得以下代码是合法的：

>>> 编程狮 = 'W3Cschool' >>>print(编程狮) W3Cschool

Python 2.x

>>> str = "我爱北京天安门">>> str'xe6x88x91xe7x88xb1xe5x8cx97xe4xbaxacxe5xa4xa9xe5xaex89xe9x97xa8'>>> str = u"我爱北京天安门">>> stru'u6211u7231u5317u4eacu5929u5b89u95e8'

Python 3.x

>>> str = "编程狮">>> str'编程狮'

除法运算

Python 中的除法较其它语言显得非常高端，有套很复杂的规则。Python 中的除法有两个运算符，​/​和​//​

首先来说/除法:

在 python 2.x 中/除法就跟我们熟悉的大多数语言，比如 Java 啊 C 啊差不多，整数相除的结果是一个整数，把小数部分完全忽略掉，浮点数除法会保留小数点的部分得到一个浮点数的结果。

在 python 3.x 中/除法不再这么做了，对于整数之间的相除，结果也会是浮点数。

Python 2.x:

>>> 1 / 20>>> 1.0 / 2.00.5

Python 3.x:

>>> 1/20.5

而对于//除法，这种除法叫做​floor​除法，会对除法的结果自动进行一个​floor​操作，在 python 2.x 和 python 3.x 中是一致的。

python 2.x:

>>> -1 // 2-1

python 3.x:

>>> -1 // 2-1

注意的是并不是舍弃小数部分，而是执行 ​floor​ 操作，如果要截取整数部分，那么需要使用 ​math​ 模块的​ trunc​ 函数

python 3.x:

>>> import math>>> math.trunc(1 / 2)0>>> math.trunc(-1 / 2)0

异常

在 Python 3 中处理异常也轻微的改变了，在 Python 3 中我们现在使用 ​as​ 作为关键词。

捕获异常的语法由 ​except exc​, ​var​ 改为 ​except exc as var​。

使用语法​except (exc1, exc2) as var​可以同时捕获多种类别的异常。 Python 2.6已经支持这两种语法。

1. 在 2.x 时代，所有类型的对象都是可以被直接抛出的，在 3.x 时代，只有继承自​BaseException​的对象才可以被抛出。
2. 2.x ​raise​语句使用逗号将抛出对象类型和参数分开，3.x 取消了这种奇葩的写法，直接调用构造函数抛出对象即可。

在 2.x 时代，异常在代码中除了表示程序错误，还经常做一些普通控制结构应该做的事情，在 3.x 中可以看出，设计者让异常变的更加专一，只有在错误发生的情况才能去用异常捕获语句来处理。

xrange

在 Python 2 中​ xrange() ​创建迭代对象的用法是非常流行的。比如：​ for​ 循环或者是列表/集合/字典推导式。

这个表现十分像生成器（比如。"​惰性求值​"）。但是这个 ​xrange-iterable​ 是无穷的，意味着你可以无限遍历。

由于它的惰性求值，如果你不得仅仅不遍历它一次，​xrange() ​函数 比 ​range()​ 更快（比如 ​for​ 循环）。尽管如此，对比迭代一次，不建议你重复迭代多次，因为生成器每次都从头开始。

在 Python 3 中，​range() ​是像 ​xrange()​ 那样实现以至于一个专门的​ xrange()​ 函数都不再存在（在 Python 3 中​ xrange()​ 会抛出命名异常）。

import timeitn = 10000def test_range(n):    return for i in range(n):        passdef test_xrange(n):    for i in xrange(n):        pass   

Python 2

print 'Python', python_version()print '
timing range()' %timeit test_range(n)print '

timing xrange()' %timeit test_xrange(n)Python 2.7.6timing range()1000 loops, best of 3: 433 µs per looptiming xrange()1000 loops, best of 3: 350 µs per loop

Python 3

print('Python', python_version())print('
timing range()')%timeit test_range(n)Python 3.4.1timing range()1000 loops, best of 3: 520 µs per loop

print(xrange(10))---------------------------------------------------------------------------NameError                                 Traceback (most recent call last)<ipython-input-5-5d8f9b79ea70> in <module>()----> 1 print(xrange(10))NameError: name 'xrange' is not defined

八进制字面量表示

八进制数必须写成​0o777​，原来的形式​0777​不能用了；二进制必须写成​0b111​。

新增了一个​bin()​函数用于将一个整数转换成二进制字串。 Python 2.6 已经支持这两种语法。

在 Python 3.x 中，表示八进制字面量的方式只有一种，就是​0o1000​。

python 2.x

>>> 0o1000512>>> 01000512

python 3.x

>>> 01000  File "<stdin>", line 1    01000        ^SyntaxError: invalid token>>> 0o1000512

不等运算符

Python 2.x 中不等于有两种写法​ !=​ 和 ​<>​

Python 3.x 中去掉了​<>​, 只有​!=​一种写法，还好，我从来没有使用​<>​的习惯

去掉了repr表达式``

Python 2.x 中反引号​``​相当于​repr​函数的作用

Python 3.x 中去掉了​``​这种写法，只允许使用​repr​函数，这样做的目的是为了使代码看上去更清晰么？不过我感觉用​repr​的机会很少，一般只在​debug​的时候才用，多数时候还是用​str​函数来用字符串描述对象。

def sendMail(from_: str, to: str, title: str, body: str) -> bool:    pass

多个模块被改名（根据PEP8）

​StringIO​模块现在被合并到新的​io​模组内。 ​new​, ​md5​, ​gopherlib​等模块被删除。 Python 2.6已经支援新的​io​模组。

​httplib​, ​BaseHTTPServer​, ​CGIHTTPServer​, ​SimpleHTTPServer​, ​Cookie​, ​cookielib​被合并到​http​包内。

取消了​exec​语句，只剩下​exec()​函数。 Python 2.6已经支援​exec()​函数。

5.数据类型

1）Python 3.X 去除了​long​类型，现在只有一种整型——​int​，但它的行为就像 Python 2.X 版本的​long​

2）新增了​bytes​类型，对应于 Python 2.X 版本的八位串，定义一个​bytes​字面量的方法如下：

>>> b = b'china' >>> type(b) <type 'bytes'> 

​str​ 对象和​ bytes ​对象可以使用 ​.encode() (str -> bytes)​ 或 ​.decode() (bytes -> str)​方法相互转化。

>>> s = b.decode() >>> s 'china' >>> b1 = s.encode() >>> b1 b'china' 

3）​dict​的​.keys()​、​.items​ 和​.values()​方法返回迭代器，而之前的​iterkeys()​等函数都被废弃。同时去掉的还有​ dict.has_key()​，用​ in​替代它吧 。

相关教程

• 《Python2 教程》
• 《Python3 教程》

Python IDE

本文为大家推荐几款款不错的 Python IDE（集成开发环境），比较推荐 PyCharm，当然你可以根据自己的喜好来选择适合自己的 Python IDE。

PyCharm

PyCharm 是由 JetBrains 打造的一款 Python IDE。

PyCharm 具备一般 Python IDE 的功能，比如：调试、语法高亮、项目管理、代码跳转、智能提示、自动完成、单元测试、版本控制等。

另外，PyCharm 还提供了一些很好的功能用于Django开发，同时支持Google App Engine，更酷的是，PyCharm 支持 IronPython。

PyCharm 官方下载地址：http://www.jetbrains.com/pycharm/download/

效果图查看：

Sublinme Text 2

Sublime Text 具有漂亮的用户界面和强大的功能，例如代码缩略图，Python 的插件，代码段等。还可自定义键绑定，菜单和工具栏。

Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。

Sublime Text 是一个跨平台的编辑器，同时支持 Windows、Linux、Mac OS X 等操作系统。

使用 Sublinme Text 2 的插件扩展功能，你可以轻松的打造一款不错的 Python IDE，以下推荐几款插件（你可以找到更多）：

• CodeIntel：自动补全+成员/方法提示（强烈推荐）
• SublimeREPL：用于运行和调试一些需要交互的程序（E.G. 使用了Input()的程序）
• Bracket Highlighter：括号匹配及高亮
• SublimeLinter：代码 pep8 格式检查

Eclipse+Pydev

1、安装 Eclipse

Eclipse可以在它的官方网站 Eclipse.org 找到并下载，通常我们可以选择适合自己的Eclipse版本，比如 Eclipse Classic。下载完成后解压到到你想安装的目录中即可。

当然在执行Eclipse之前，你必须确认安装了Java运行环境,即必须安装JRE或JDK，你可以到（http://www.java.com/en/download/manual.jsp）找到 JRE 下载并安装。

2、安装 Pydev

运行 Eclipse 之后，选择 help-->Install new Software，如下图所示。

点击 Add，添加 pydev 的安装地址：http://pydev.org/updates/，如下图所示。

完成后点击"ok"，接着点击 PyDev 的"+"，展开 PyDev 的节点，要等一小段时间，让它从网上获取 PyDev 的相关套件，当完成后会多出 PyDev 的相关套件在子节点里，勾选它们然后按 next 进行安装。如下图所示。

安装完成后，重启 Eclipse 即可

3、设置 Pydev

安装完成后，还需要设置一下 PyDev，选择 Window -> Preferences 来设置 PyDev。设置 Python 的路径，从 Pydev 的 Interpreter - Python 页面选择 New

会弹出一个窗口让你选择 Python 的安装位置，选择你安装 Python 的所在位置。

完成之后 PyDev 就设置完成，可以开始使用。

4、建立 Python Project：

安装好 Eclipse+PyDev 以后，我们就可以开始使用它来开发项目了。首先要创建一个项目，选择 File -> New ->Pydev Project

会弹出一个新窗口，填写 Project Name，以及项目保存地址，然后点击 next 完成项目的创建。

5、创建新的 Pydev Module

光有项目是无法执行的，接着必须创建新的 Pydev Moudle，选择 File -> New -> Pydev Module

在弹出的窗口中选择文件存放位置以及 Moudle Name，注意 Name 不用加 .py，它会自动帮助我们添加。然后点击 Finish 完成创建。

输入"hello world"的代码。

6、执行程序

程序写完后，我们可以开始执行程序,在上方的工具栏上面找到执行的按钮。

之后会弹出一个让你选择执行方式的窗口，通常我们选择 Python Run，开始执行程序。

更多 Python IDE

当然还有非常多很棒的 Python IDE，你可以自由的选择，更多 Python IDE 请参阅：http://wiki.python.org/moin/PythonEditors

Python JSON

本章节我们将为大家介绍如何使用 Python 语言来编码和解码 JSON 对象。

环境配置

在使用 Python 编码或解码 JSON 数据前，我们需要先安装 JSON 模块。本教程我们会下载 Demjson 并安装：

$tar xvfz demjson-1.6.tar.gz$cd demjson-1.6$python setup.py install

JSON 函数

使用 JSON 函数需要导入 json 库：import json。

json.dumps

json.dumps 用于将 Python 对象编码成 JSON 字符串。

语法

json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding="utf-8", default=None, sort_keys=False, **kw)

实例

以下实例将数组编码为 JSON 格式数据：

#!/usr/bin/pythonimport jsondata = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]json = json.dumps(data)print json

以上代码执行结果为：

[{"a": 1, "c": 3, "b": 2, "e": 5, "d": 4}]

使用参数让 JSON 数据格式化输出：

>>> import json>>> print json.dumps({'a': 'W3Cschool', 'b': 7}, sort_keys=True, indent=4, separators=(',', ': ')){    "a": "W3Cschool",    "b": 7}

Python 原始类型向 json 类型的转化对照表：

json.loads

json.loads 用于解码 JSON 数据。该函数返回 Python 字段的数据类型。

语法

json.loads(s[, encoding[, cls[, object_hook[, parse_float[, parse_int[, parse_constant[, object_pairs_hook[, **kw]]]]]]]])

实例

以下实例展示了 Python 如何解码 JSON 对象：

#!/usr/bin/pythonimport jsonjsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}';text = json.loads(jsonData)print text

以上代码执行结果为：

{u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}

json 类型转换到 Python 的类型对照表：

更多内容参考：https://docs.python.org/2/library/json.html。

使用第三方库：Demjson

Demjson 是 python 的第三方模块库，可用于编码和解码 JSON 数据，包含了 JSONLint 的格式化及校验功能。

Github 地址：https://github.com/dmeranda/demjson

官方地址：http://deron.meranda.us/python/demjson/

环境配置

在使用 Demjson 编码或解码 JSON 数据前，我们需要先安装 Demjson 模块。本教程我们会下载 Demjson 并安装：

$ tar -xvzf demjson-2.2.3.tar.gz$ cd demjson-2.2.3$ python setup.py install

更多安装介绍查看：http://deron.meranda.us/python/demjson/install

JSON 函数

encode

Python encode() 函数用于将 Python 对象编码成 JSON 字符串。

语法

demjson.encode(self, obj, nest_level=0)

实例

以下实例将数组编码为 JSON 格式数据：

#!/usr/bin/pythonimport demjsondata = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]json = demjson.encode(data)print json

以上代码执行结果为：

[{"a":1,"b":2,"c":3,"d":4,"e":5}]

decode

Python 可以使用 demjson.decode() 函数解码 JSON 数据。该函数返回 Python 字段的数据类型。

语法

demjson.decode(self, txt)

实例

以下实例展示了 Python 如何解码 JSON 对象：

#!/usr/bin/pythonimport demjsonjson = '{"a":1,"b":2,"c":3,"d":4,"e":5}';text = demjson.decode(json)print  text

以上代码执行结果为：

{u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}

1.pip使用包管理

文档： https://pip.pypa.io/en/latest/installing.html

# 安装，可指定版本号(sudo) pip install Django==1.6.8# 升级(sudo) pip install bpython --upgrade# 一次安装多个(sudo) pip install BeautifulSoup4 fabric virtualenv# 从文本中安装，文本中为包名，一行一个，可以指定版本号(sudo) pip install –r requirements.txt# 删除(sudo) pip uninstall xlrd# 导出当前已经安装包pip freeze > requirements.txt

2. virtualenv独立Python环境管理

文档：  http://virtualenvwrapper.readthedocs.org/en/latest/

virtualenv 是一个创建独立环境的包，Pythonvirtualenvwrapper 是一个更好用的 Pythonvirtualenv

# 安装:(sudo) pip install virtualenv virtualenvwrapper# 修改.bash_profile 或 .zshrc（如果你用 zsh 的话），添加以下语句export WORKON_HOME=$HOME/.virtualenvsexport PROJECT_HOME=$HOME/workspacesource /usr/local/bin/virtualenvwrapper.sh

mkvirtualenv  ENV：创建运行环境ENV

rmvirtualenv  ENV：删除运行环境ENV

mkproject  mic：创建 mic 项目和运行环境 mic

mktmpenv ：创建临时运行环境

workon  bsp: 工作在 bsp 运行环境

lsvirtualenv : 管理者的运行环境

lssitepackages : 当前环境安装了的包

创建的环境是独立的，互不干扰，不需要 sudo 包就可以使用 pip 来进行的管理。

下面是使用演示图：

#coding:utf-8from fabric.api import *# 服务器列表env.hosts = ['user@server1','user2@server2']def ls_home():    with cd('/home/bae/'):        run('ls')'''常用命令lcd(dir): 进入本机某目录local(cmd): 本机上执行命令cd(dir): 进入服务器某目录run(cmd):服务器上执行命令'''

fab 函数名比如：fab ls_home

领取免费资料

扫描下方二维码或打开微信搜一搜“51coolma编程狮”关注公众号回复关键词【Python123】或者【Python资料包】免费领取 Python 学习资料，包含软件安装包，电子书、思维导图等