Python 学习笔记 基础篇

整理：Jims of 肥肥世家

[email protected]

Copyright © 2004，2005，2006 本文遵从GNU 的自由文档许可证(Free Document License)的条款，欢迎转载、修改、散布。

发布时间：2004年07月10日

更新时间：2006年06月14日，把参考篇的内容合并进来。

Abstract

现时国内python的中文资料极少，使学习Python较困难。国外的资料虽多，但都是英文的，使我们学习起来很不方便。有鉴于此，我开始了Python中文资料库的整理工作，以推动Python的发展和在中国的应用。在自由的世界里，正因为有你的支持和帮助，才使我得以不断前进。我相信我们每人一小步就可带动python在中国前进一大步。

Table of Contents

Chapter 1. 绪论

1.1. Python历史

Python是一种开源的面向对象的脚本语言，它起源于1989年末，当时，CWI（阿姆斯特丹国家数学和计算机科学研究所）的研究员Guido van Rossum需要一种高级脚本编程语言，为其研究小组的Amoeba分布式操作系统执行管理任务。为创建新语言，他从高级数学语言ABC（ALL BASIC CODE）汲取了大量语法，并从系统编程语言Modula-3借鉴了错语处理机制。Van Rossum把这种新的语言命名为Python（大蟒蛇）—来源于BBC当时正在热播的喜剧连续剧“Monty Python”。

Python于1991年初公开发行，由于功能强大和采用开源方式发行，Python的发展得很快，用户越来越多，形成了一个强大的社区力量。2001年，Python的核心开发团队移师Digital Creations公司，该公司是Zope（一个用Python编写的web应用服务器）的创始者。现在最新的版本是python2.3.4，大家可到http://www.python.org上了解最新的Python动态和资料 。

1.2. Python功能简介

Python是一种解析性的，交互式的，面向对象的编程语言，类似于Perl、Tcl、Scheme或Java。

Python一些主要功能介绍:

  • Python使用一种优雅的语法，可读性强。

  • Python是一种很灵活的语言，能帮你轻松完成编程工作。并可作为一种原型开发语言，加快大型程序的开发速度。

  • 有多种数据类型：numbers (integers, floating point, complex, and unlimited-length long integers), strings (ASCII 和 Unicode), lists, dictionaries。

  • Python支持类和多层继承等的面向对象编程技术。

  • 代码能打包成模块和包，方便管理和发布。

  • 支持异常处理，能有效捕获和处理程序中发生的错误。

  • 强大的动态数据类型支持，不同数据类型相加会引发一个异常。

  • Python支持如生成器和列表嵌套等高级编程功能。

  • 自动内存碎片管理，有效利用内存资源。

  • 强大的类库支持，使编写文件处理、正则表达式，网络连接等程序变得相当容易。

  • Python的交互命令行模块能方便地进行小代码调试和学习。

  • Python易于扩展，可以通过C或C++编写的模块进行功能扩展。

  • Python解析器可作为一个编程接口嵌入一个应用程序中。

  • Python可运行在多种计算机平台和操作系统中，如各位unix，windows，MacOS,OS/2等等。

  • Python是开源的，可自由免费使用和发布，并且可用于商业用途以获取利润。如想详细了解Python的许可协议可到以下网址查询http://www.python.org/psf/license.html

1.3. 应用范围

  • 系统编程，提供大量系统接口API，能方便进行系统维护和管理。

  • 图形处理，有PIL、Tkinter等图形库支持，能方便进行图形处理。

  • 数学处理，NumPy扩展提供大量与许多标准数学库的接口，

  • 文本处理，python提供的re模块能支持正则表达式，还提供SGML，XML分析模块，许多程序员利用python进行XML程序的开发。

  • 数据库编程，程序员可通过遵循Python DB-API（数据库应用程序编程接口）规范的模块与Microsoft SQL Server，Oracle，Sybase，DB2，Mysql等数据库通信。python自带有一个Gadfly模块，提供了一个完整的SQL环境。

  • 网络编程，提供丰富的模块支持sockets编程，能方便快速地开发分布式应用程序。

  • 作为Web应用的开发语言，支持最新的XML技术。

  • 多媒体应用，Python的PyOpenGL模块封装了“OpenGL应用程序编程接口”，能进行二维和三维图像处理。PyGame模块可用于编写游戏软件。

1.4. 如何开始？

  • 进入交互命令行方式。如果是linux类的系统，python解析器应该已经安装在/usr/local/bin/python中，直接打python就可进入交互式命令行界面，如下所示:

    1
    2
    3
    4
    Python 2.3.3 (#1, Apr 27 2004, 15:17:58)
    [GCC 3.2 20020903 (Red Hat Linux 8.0 3.2-7)] on linux2
    Type "help", "copyright", "credits" or "license" for more information.
    >>>

    “>>>”符号是Python命令行界面的提示符，可按CTRL+D退出，如果是windows环境的话就要按CTRL+Z了。还可以用以下命令退出命令行界面：“import sys；sys.exit()”。如果是windows系统，可到http://www.python.org/download/下载最新的安装程序进行安装。安装完成后直接打python也可进入命令行界面。命令行是python最简单直观，也是最方便的一种执行环境，我们可以在这里学习python语法和调试程序。如果要打印”hello world”可以输入以下命令：

    1
    2
    >>>print "hello world"
    hello world

  • 以模块文件方式运行。模块文件是包含python语句的文本，以.py结尾。运行模块文件只要输入python xxx.py就可以了。

  • 以linux脚本方式运行。和shell脚本差不多，以vi或其它文本编辑器输入以下内容:

    1
    2
    #!/usr/local/bin/python
    print "test ............"

    存盘后，把文件属性改为可执行，就可象shell脚本一样执行了。

  • Table 1.1. Python命令行选项

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    | 选项 | 作用 |
    | --- | --- |
    | -c cmd | 在命令行直接执行python代码。如python -c 'print "hello world"'。 |
    | -d | 脚本编译后从解释器产生调试信息。同PYTHONDEBUG=1。 |
    | -E | 忽略环境变量。 |
    | -h | 显示python命令行选项帮助信息。 |
    | -i | 脚本执行后马上进入交互命令行模式。同PYTHONINSPECT=1。 |
    | -O | 在执行前对解释器产生的字节码进行优化。同 PYTHONOPTIMIZE=1。 |
    | -OO | 在执行前对解释器产生的字节码进行优化，并删除优化代码中的嵌入式文档字符串。 |
    | -Q arg | 除法规则选项，-Qold(default)，-Qwarn，-Qwarnall，-Qnew。 |
    | -S | 解释器不自动导入site.py模块。 |
    | -t | 当脚本的tab缩排格式不一致时产生警告。 |
    | -u | 不缓冲stdin、stdout和stderr，默认是缓冲的。同PYTHONUNBUFFERED=1。 |
    | -v | 产生每个模块的信息。如果两个-v选项，则产生更详细的信息。同PYTHONVERBOSE=x。 |
    | -V | 显示Python的版本信息。 |
    | -W arg | 出错信息控制。(arg is action:message:category:module:lineno) |
    | -x | 忽略源文件的首行。要在多平台上执行脚本时有用。 |
    | file | 执行file里的代码。 |
    | - | 从stdin里读取执行代码。 |

Chapter 2. Python编程习惯与特点

2.1. 代码风格

  • 在Python中，每行程序以换行符代表结束，如果一行程序太长的话，可以用“\”符号扩展到下一行。在python中以三引号(“””)括起来的字符串，列表，元组和字典都能跨行使用。并且以小括号(…)、中括号[…]和大括号{…}包围的代码不用加“\”符也可扩展到多行。如：

  • 在Python中是以缩进来区分程序功能块的，缩进的长度不受限制，但就一个功能块来讲，最好保持一致的缩进量。

  • 如果一行中有多条语句，语句间要以分号（;）分隔。

  • 以“#”号开头的内容为注释，python解释器会忽略该行内容。

  • 在python中，所有标识符可以包括英文、数字以及下划线（_），但不能以数字开头。python中的标识符是区分大小写的。

  • 以下划线开头的标识符是有特殊意义的。以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用“from xxx import *”而导入；以双下划线开头的（__foo）代表类的私有成员；以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如__init__（）代表类的构造函数。

  • 在交互模式下运行python时，一个下划线字符(_)是特殊标识符，它保留了表达式的最后一个计算结果。

    1
    2
    3
    4
    5
    6
    7
    8
    >>> "hello"
    'hello'
    >>> _
    'hello'
    >>> 10+10
    20
    >>> _
    20

  • 在python中，函数、类、模块定义的第一段代码如果是字符串的话，就把它叫作文件字串，可通过__doc__属性访问。如:

    1
    2
    3
    4
    5
    6
    7
    def test():
    "this is a document string"

    return 100+1000

    >>>print test.__doc__
    this is a document string

2.2. 保留字

1
2
3
4
5
6
7
and		elif		global		or          yield
assert		else		if		pass
break		except		import		print
class		exec		in		raise
continue	finally		is		return
def		for		lambda		try
del		from		not		while

2.3. Python运算符和表达式

2.3.1. Python运算符

Table 2.1. Python运算符列表

运算符 描述
x+y，x-y 加、减，“+”号可重载为连接符
x*y，x**y，x/y，x%y 相乘、求平方、相除、求余，“*”号可重载为重复，“%”号可重载为格式化
<，<=，>，>=，==，<>，!= 比较运算符
+=，-=，*=，/=，%=，**=，<<=，>>=，&=，^=，|= 自变运算符
x|y 按位或
x^y 按位异或
x&y 按位与
~x 按位取反
x<<，x>>y x向左或向右移y位
is, is not 等同测试
in, not in 是否为成员测试
or，and，not 逻辑运算符
x[i]，x[i:j]，x.y，x(…) 索引，分片，限定引用，函数调用
(…)，[…]，{…}，’…’ 元组，列表，字典，转化为字符串

2.3.2. 运算符优先顺序

Table 2.2. 运算符优先顺序列表(从最高到最低)

运算符 描述
‘expr’ 字符串转换
{key:expr,…} 字典
[expr1,expr2…] 列表
(expr1,expr2,…) 元组
function(expr,…) 函数调用
x[index:index] 切片
x[index] 下标索引取值
x.attribute 属性引用
~x 按位取反
+x，-x 正，负
x**y 幂
x*y，x/y，x%y 乘，除，取模
x+y，x-y 加，减
x<<y，x>>y 移位
x&y 按位与
x^y 按位异或
x|y 按位或
x<y，x<=y，x==y，x!=y，x>=y，x>y 比较
x is y，x is not y 等同测试
x in y，x not in y 成员判断
not x 逻辑否
x and y 逻辑与
x or y 逻辑或
lambda arg,…:expr Lambda匿名函数

2.3.3. 真值表

Table 2.3.

对象/常量 值
“” 假
“string” 真
0 假
>=1 真
<=-1 真
()空元组 假
[]空列表 假
{}空字典 假
None 假

2.3.4. 复合表达式

  • 对于and，当计算a and b时，python会计算a，如果a为假，则取a值，如果a为真，则python会计算b且整个表达式会取b值。如：

    1
    2
    3
    4
    5
    6
    >>> a,b=10,20
    >>> a and b   #a is true
    20
    >>> a,b=0,5   #a is false
    >>> a and b
    0

  • 对于or，当计算a or b时，python会计算a，如果a为真，则整个表达式取a值，如果a为假，表达式将取b值。如：

    1
    2
    3
    4
    5
    6
    >>> a,b=10,20
    >>> a or b
    10
    >>> a,b=0,5
    >>> a or b
    5

  • 对于not，not将反转表表达式的“实际值”，如果表达式为真，not为返回假，如为表达式为假，not为返回真。如：

    1
    2
    3
    4
    5
    6
    7
    8
    >>> not 2
    False
    >>> not 0
    True
    >>> not "test"
    False
    >>> not ""
    True

2.4. 给变量赋值

  • 简单赋值，Variable(变量)=Value(值)。

    1
    2
    3
    4
    >>>a=1
    >>>b=2
    >>>print a,b
    1 2

  • 多变量赋值，Variable1,variable2,…=Value1,Value2,…

    1
    2
    3
    4
    5
    6
    7
    >>>a,b,c=1,2,3
    >>>print a
    1
    >>>print b
    2
    >>>print c
    3

    多变量赋值也可用于变量交换，接上例：

    1
    2
    3
    4
    5
    6
    7
    >>>a,b,c=c,b,a
    >>>print a
    3
    >>>print b
    2
    >>>print c
    1

  • 多目标赋值，a=b=variable

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    >>> a=b=1
    >>> a
    1
    >>> b
    1
    >>> a=2
    >>> a
    2
    >>> b
    1

  • 自变赋值，如+=，-=，*=等。在自变赋值中，python仅计算一次，而普通写法需计算两次；自变赋值会修改原始对象，而不是创建一个新对象。

Chapter 3. Python内建对象类型

在Python中，所有数据都是对象，数据有各种类型，如数值型、列表型、字符串型等。除系统内建的数据类型外，程序员也可以创建自已的数据类型。以下主要介绍Python内建的数据类型。

3.1. Number数值型

在python中，数值有四种类型，分别是整型、长整形、浮点型和复数。

  • 整型—从-2147483648至2147483647，有符号位32位长，可表达的最大数为2^31-1。如：number=123，number1=-123。在数字前加0x或0X 前缀表示十六进制数，在数字前加前缀0表示八进制数，与C/C++ and perl一样。

    为方便起见，sys模块包含一个maxint成员，该成员保留了整形变量的最大正数值。

    1
    2
    3
    >>> import sys
    >>> print sys.maxint
    2147483647

  • 长整型—python支持任意长度的长整型，长整型的最大值和最小值由可用的内存确定。长整型数在数字常量尾加L or l，一般都是用L，因为小写的l太容易与数字1混淆了。如：long=1232132131231232132132131L。

  • 浮点数—python支持普通十进制和科学计数法表示的浮点数。如：number=123.456，nubmer1=123.2E10。浮点数在python中的存储格式与C中的双精度数相同。

  • 复数—复数的实部和虚部用加号分开，虚部使用后缀j表示，如：number=1.2+2j

3.2. String字符串型

  • 字符串在python被看成是单个字符的序列，具有序列对象的特殊功能，字符串是固定的，不可变的。如：string=”hello world”。

  • 可在字符串中使用单引号和双引号。如：string=”I’m a boy”。

  • 字符串内部的一个反斜杠“\”可允许把字符串放于多行：如：

    1
    2
    3
    >>> "test \
    ... python"
    'test python'

  • 使用三个单引号或双引号可使字符串跨行显示。如：

    1
    2
    3
    helptext="""this a help test.if you have any quesions.
                please call me anytime.I will help you.I
                like python.I hope so as you."""

  • 使用“+”号可连接字符串。如：string = “hello” + “world”，注意，不能将字符串与其它对象进行连接。如string = “ok” + 5。其实不用“+”号，直接用空格也可连接两个字符串。如：string=”hello” “world”。

  • 可用“*”号重复字符串，如：’hello’*5会生成’hellohellohellohellohello’。

  • 可用索引访问字符串中的字符。如：string=”hello world”，print string[1]将显示字符e。

  • 字符串可用in或not in运算符来测试字符是不属于一个字符串的成员。

  • 可对字符串分片，如string=”hello world”,print string[6:]将显示world。分片的格式为：

    1
    string[start:end]

    分片和索引的规则如下：

    • 返回的字符串包含从start起始到end但不包括end结束的所有字符。

    • 若指定了start但未指定end，则一直向后分片，直至字符串结束。

    • 若指定了end但未指定start，则从0开始分片直至end，但不包括end指定的字符。

    • 若start和end为负数，则索引从字符串尾部开始算起，最后一个字符为-1。

python提供了一个string模块来进行字符串处理。

3.2.1. 字符串的格式化

象C 中的sprintf函数一样，可以用“%”来格式化字符串。

Table 3.1. 字符串格式化代码

格式 描述
%% 百分号标记
%c 字符及其ASCII码
%s 字符串
%d 有符号整数(十进制)
%u 无符号整数(十进制)
%o 无符号整数(八进制)
%x 无符号整数(十六进制)
%X 无符号整数(十六进制大写字符)
%e 浮点数字(科学计数法)
%E 浮点数字(科学计数法，用E代替e)
%f 浮点数字(用小数点符号)
%g 浮点数字(根据值的大小采用%e或%f)
%G 浮点数字(类似于%g)
%p 指针(用十六进制打印值的内存地址)
%n 存储输出字符的数量放进参数列表的下一个变量中

%格式化符也可用于字典，可用%(name)引用字典中的元素进行格式化输出。

负号指时数字应该是左对齐的，“0”告诉Python用前导0填充数字，正号指时数字总是显示它的正负(+，-)符号，即使数字是正数也不例外。

可指定最小的字段宽度，如：”%5d” % 2。也可用句点符指定附加的精度，如：”%.3d” % 3。

3.2.2. 转义字符

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

Table 3.2. python支持的转义字符表

转义字符 描述
(在行尾时) 续行符
\ 反斜杠符号
\’ 单引号
\” 双引号
\a 响铃
\b 退格(Backspace)
\e 转义
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数yy代表的字符，例如：\o12代表换行
\xyy 十进制数yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出

3.2.3. Unicode字符串

在python2.0中才完全支持Unicode字符串，Unicode字符采用16位(0—65535)值表示，能进行多语言支持。要使用Unicode字符串，只要在字符串前加上“u”即可。如：

1
2
3
>>> a=u"test"
>>> print a
test

原始Unicode字符串用ur前缀，如：

1
2
3
4
>>> u'hello world\0020'
u'hello world\x020'
>>> ur'hello world\0020'
u'hello world\\0020'

3.2.3.1. Unicode转换

只要和Unicode连接，就会产生Unicode字串。如：

1
2
3
4
>>> 'help'
'help'
>>> 'help，' + u'python'     
u'help，python'

对于ASCII(7位)兼容的字串，可和内置的str()函数把Unicode字串转换成ASCII字串。如：

1
2
>>> str(u'hello world')
'hello world'

转换非ASCII兼容的字串会出错。编码和译码字符串时的错误引发UnicodeError异常。

可使用encode()函数转换Unicode字串格式：

1
2
3
u'unicode\xb1\xe0\xc2\xeb\xb2\xe2\xca\xd4'
>>> a.encode('utf-8')   #转换成utf-8，显示结果会根据终端的字符集支持不同而不同，下面是在GB18030下的显示结果
'unicode\xc2\xb1\xc3\xa0\xc3\x82\xc3\xab\xc2\xb2\xc3\xa2\xc3\x8a\xc3\x94'

可使用unicode()函数把字符串转换成unicode格式，如：

1
2
3
4
5
6
7
8
9
10
>>> a=u'unicode测试'
>>> a
u'unicode\xb2\xe2\xca\xd4'
>>> a.encode('utf-8')     #把unicode字串转换成utf-8
'unicode\xc2\xb2\xc3\xa2\xc3\x8a\xc3\x94'
>>> b=a.encode('utf-8')   #给变量b赋值
>>> b
'unicode\xc2\xb2\xc3\xa2\xc3\x8a\xc3\x94'
>>>unicode(b,'utf-8')           #用unicode()函数把utf-8格式字串转换回unicode格式。
u'unicode\xb2\xe2\xca\xd4'      #和原始的这是a相同

ord()支持unicode，可以显示特定字符的unicode号码，如：

1
2
>>>ord('A')
65

使用unichr()函数可将unicode号码转换回unicode字符，如：

1
2
>>> unichr(65)
u'A'

3.2.4. 原始字符串

有时我们并不想让转义字符生效，我们只想显示字符串原来的意思，这就要用r和R来定义原始字符串。如：

1
print r'\t\r'

实际输出为“\t\r”。

3.3. List列表

  • 列表是序列对象，可包含任意的Python数据信息，如字符串、数字、列表、元组等。列表的数据是可变的，我们可通过对象方法对列表中的数据进行增加、修改、删除等操作。可以通过list(seq)函数把一个序列类型转换成一个列表。列表的几个例子：

    • list = [ "a", "b", "c" ]，这是字符列表。

    • list = [ 1, 2, 3, 4 ]，这是数字列表。

    • list = [ [1,2,3,4], ["a","b","c"] ]，这是列表的列表。

    • list = [ (1,2,3,4), ("a","b","c") ]，这是元组列表。

    • list((1,2))把一个元组转换成一个列表[1,2]，list(‘test’)可把字符串转换成[‘t’,’e’,’s’,’t’]列表。

  • 访问列表可通过索引来引用，如：list[0]将引用列表的第一个值。list[0:1]返回第一和第二个元素。

  • 用range()和xrange()函数可自动生成列表，具体用法请参考“python参考篇”的内容。

  • 可通过列表综合来创建列表，该功能是在python2.0版本中新增加的。如果想对列表中的每个项进行运算并把结果存储在一个新列表中，可者想创建一个仅包含特定满足某种条件的项，采用该方法是很适合的。如：[x*x for x in range(1,10)]会得到一个X的平方的新列表；我们还可添加if条件控制输出，如：[x*x for x in range(1,10) if x%2==0]；还可在列表中使用多个for语句，如：

    1
    2
    >>> [x+y for x in "123" for y in "abc"]
    ['1a', '1b', '1c', '2a', '2b', '2c', '3a', '3b', '3c']

    x,y值可取列表或元组等，以构成更复杂的结构。

  • “+”号可连接两个列表。

  • 访问列表的列表(嵌套列表)可用list[1][0]，这将访问嵌套中的第二个列表的第一个元素。

  • 可用数字与列表相乘以复制内容，如：list*2会得到一个[1,2,3,4,1,2,3,4]的列表。注意，不能用列表与列表相乘。

  • 由于列表是可变的，我们可用赋值语句进行操作，如：list[0] = 2。

  • 列表对象方法可对列表进行操作，如列表内容的添加，删除，排序等。如list.sort()可对list列表进行排序。

**Table 3.3\. 列表对象支持的方法**


1
2
3
4
5
6
7
8
9
10
11
| 方法 | 描述 |
| --- | --- |
| append(x) | 在列表尾部追加单个对象x。使用多个参数会引起异常。 |
| count(x) | 返回对象x在列表中出现的次数。 |
| extend(L) | 将列表L中的表项添加到列表中。返回None。 |
| Index(x) | 返回列表中匹配对象x的第一个列表项的索引。无匹配元素时产生异常。 |
| insert(i,x) | 在索引为i的元素前插入对象x。如list.insert(0,x)在第一项前插入对象。返回None。 |
| pop(x) | 删除列表中索引为x的表项，并返回该表项的值。若未指定索引，pop返回列表最后一项。 |
| remove(x) | 删除列表中匹配对象x的第一个元素。匹配元素时产生异常。返回None。 |
| reverse() | 颠倒列表元素的顺序。 |
| sort() | 对列表排序，返回none。bisect模块可用于排序列表项的添加和删除。 |

3.4. Tuple元组

Tuple(元组)和List(列表)很相似，但元组是不可变的。不能对元组中的元素进行添加，修改和删除操作。如果需修改元组内容只有重建元组。元组用小括号来表示。如tuple=(1,2,3)。

  • tuple=(1,)，这是单个元素的元组表示，需加额外的逗号。

  • tuple=1，2，3，4，这也可以是一个元组，在不使用圆括号而不会导致混淆时，Python允许不使用圆括号的元组。

  • 和列表一样，可对元组进行索引、分片、连接和重复。也可用len()求元组长度。

    元组的索引用tuple[i]的形式，而不是tuple(i)。

  • 和列表类似，使用tuple(seq)可把其它序列类型转换成元组。

3.5. 序列对象

上面介绍的字符串、列表和元组的对象类型均属于称为序列的Python对象。它是一种可使用数字化索引进行访问其中元素的对象。

  • 可用算术运算符联接或重复序列。

  • 比较运算符(<，<=，>，>=，!=，==)也可用于序列。

  • 可通过下标(test[1])，切片(test[1:3])和解包来访问序列的某部份。解包示例如下：

    1
    2
    3
    4
    >>>s=1,2,3
    >>>x,y,z=s
    >>>print x,y,z
    1,2,3

  • in运算符可判断当有对象是否序列对象成员，如:

    1
    2
    3
    4
    5
    >>>list = [1,2,3]
    >>>1 in list
    1
    >>>4 in list
    0

  • 也可通过循环运算符对序列对象进行迭代操作。如:

    1
    2
    for day in days:
        print day

有关序列的处理函数请参考“python参考篇”相关内容，这里就不详细讲了。

3.6. Dictionary字典

字典是一个用大括号括起来的键值对，字典元素分为两部份，键(key)和值。字典是python中唯一内置映射数据类型。通过指定的键从字典访问值。如：

1
monthdays = { "Jan":31, "Feb":28, "Mar":31, "Apr":30, "May":31, "Jun":30, "Jul":31, "Aug":31, "Sep":30, "Oct":31, "Nov":30,"Dec":31 }

  • 字典可嵌套，可以在一个字典里包含另一个字典。如test={“test”:{“mytest”:10} }

  • 可用键访问字典，如monthdays[“Jan”]，可访问值31。如果没有找到指定的键，则解释器会引起异常。

  • 字典是可修改，如monthdays[“Jan”]=30，可把Jan的值由31改为30。如monthdays[“test”]=30可添加一个新键值对。

  • del monthdays[“test”]可删除字典条目。

  • 字典不属序列对象，所以不能进行连接和相乘操作。字典是没有顺序的。

  • 字典提供keys和values方法，用来返回字典中定义的所有键和值。

  • 和列表一样，字典也提供了对象方法来对字典进行操作。

**Table 3.4\. 字典方法**


1
2
3
4
5
6
7
8
9
10
| 方法 | 描述 |
| --- | --- |
| has_key(x) | 如果字典中有键x，则返回真。 |
| keys() | 返回字典中键的列表 |
| values() | 返回字典中值的列表。 |
| items() | 返回tuples的列表。每个tuple由字典的键和相应值组成。 |
| clear() | 删除字典的所有条目。 |
| copy() | 返回字典高层结构的一个拷贝，但不复制嵌入结构，而只复制对那些结构的引用。 |
| update(x) | 用字典x中的键值对更新字典内容。 |
| get(x[,y]) | 返回键x，若未找到该键返回none，若提供y，则未找到x时返回y。 |

3.7. File文件

可用内置的open()函数对文件进行操作。如：

1
2
3
4
input = open("test.txt")
for line in input.readlines():
    print line
input.close()

3.8. 理解引用

  • Python把一块数据存储在对象中，变量是对象的唯一引用；它们是计算机内存中特殊地点的名字。所有对象都具有唯一的身份号、类型和值。对象的类型不会改变，对于可变类型而言，它的值是可变的。id(obj)函数可用于检索对象的身份，也就是内存中的对象的地址。

  • 每个对象都包含引用计数器，它记录当前有多少个变量正在引用该对象。当给对象指定一个变量或使对象成为列表或其它包容器的成员时，引用计数就增加；当从包容器中撤消、重新分配或删除对象时，引用计数减少。当引用计数达到0值时(即没有任何变量引用这个对象)，python的回收机制会自动回收它使用的内存。注意，del可用来删除变量，但不能删除对象。

    sys.gettrefcount(obj)函数可返回给定对象的引用计数。

3.9. copy and deepcopy

通过给列表分配一个变量能创建对列表的引用，如果要创建列表的副本就要理解浅副本和深副本的概念。

  • 列表或其他包容器对象的浅副本(Shallow)能够生成对象本身的副本，但也会创建对由列表包含的对象的引用。可用分片(object[:])和copy模块的copy(obj)函数创建。

  • 列表或其他对象包容器对象的深副本能够生成对象本身的副本，并递归地生成所有子对象的副本。可用copy模块的deepcopy(obj)函数创建。

比较两种副本，一般情况下表现一样，但当列表内包含另一个列表的情况下，父列表的浅副本将包含对子列表引用，而不是独立副本。其结果是，当更改内部列表时，从父列表的两个副本中都可见，如：

1
2
3
4
5
6
7
8
9
>>> a=[1,2,3,[4,5]]
>>> b=a[:]
>>> b
[1, 2, 3, [4, 5]]
>>> a[3].remove(4)
>>> a
[1, 2, 3, [5]]
>>> b
[1, 2, 3, [5]]

如果是深副本，就不会出现这种情况。如：

1
2
3
4
5
6
7
8
9
>>> a=[1,2,3,[4,5]]
>>> b=copy.deepcopy(a)
>>> b
[1, 2, 3, [4, 5]]
>>> a[3].remove(4)
>>> a
[1, 2, 3, [5]]
>>> b
[1, 2, 3, [4, 5]]

3.10. 标识数据类型

可通过type(obj)函数标识数据类型，如：

1
2
3
4
5
6
>>> type(a)
<type 'list'>
>>> type(copy)
<type 'module'>
>>> type(1)
<type 'int'>

types模块包含Python的内置数据类型的类型对象。如：

1
2
3
4
5
>>> import types
>>> types.ListType
<type 'list'>
>>> types.IntType
<type 'int'>

3.11. 数组对象

数组对象与列表类似，但数组只包含某些类型的简单数据。所以当数据较简单，且要求性能好的情况下，使用数组是一个好的选择。

Table 3.5. 数组类型代码

代码 等价的C类型 以字节为单位的最小尺寸
c char 1
b(B) byte(unsigned byte) 1
h(H) short(unsigned short) 2
i(I) int(unsigned int) 2
l(L) long(unsigned long) 4
f float 4
d double 8

数组创建方法如下：

1
2
3
4
5
>>> import array
>>> z=array.array("b")
>>> z.append(1)
>>> z
array('b', [1])

数组的itemsize和typecode成员可分别检索数组项的大小和数组对象的类型代码，如：

1
2
3
4
>>> z.itemsize
1
>>> z.typecode
'b'

3.1. 数组类型与其它数据类型的转换

  • tolist()方法可把数组转换为列表，如：

    1
    2
    >>> z.tolist()
    [1, 2, 3]

    fromlist(list)方法可把列表项附加到数组的末尾，如：

    1
    2
    3
    >>> z.fromlist([10,11])
    >>> z
    array('b', [1, 2, 3, 10, 11])

    如添加的列表类型与数组类型不同，则fromlist(list)不会把任何项添加到数组对象中。

  • tostring()方法，可以把数组转换为字节的序列，如：

    1
    2
    >>> z.tostring()
    '\x01\x02\x03\n\x0b'

    fromstring(list)方法刚好与tostring()相反，它获取一个字节串，并把它们转换为数组的值。如：

    1
    2
    3
    >>> z.fromstring("\x0b")
    >>> z
    array('b', [1, 2, 3, 10, 11, 11])

  • tofile(file)方法可把数组转换为字节的序列，并把它们写入文件，如：

    1
    2
    3
    >>> f=open("aa","wb")
    >>> z.tofile(f)
    >>> f.close()

    fromfile(file,count)方法用于从文件对象中读取特定数目的项，并把它们附加到数组中，如：

    1
    2
    3
    >>> z.fromfile(open("aa","rb"),2)
    >>> z
    array('b', [1, 2, 3, 10, 11, 11, 1, 2])

    当取数项大于文件数据项时，formfile会产生EOFError异常。

  • 数组对象支持列表中的很多相同函数和方法：len，append等。访问成员的方法也可列表一样，可用下标和分片。

Chapter 4. 控制语句

流程控制是程序设计中一个重要的内容，Python支持三种不同的控制结构：if，for和while。

  • if语句判断表达式是否为真，如果为真则执行指定语句。if语句的格式如下：

    1
    2
    3
    4
    5
    6
    if   EXPRESSION1:
             STATEMENT1
    elif EXPRESSION2:
             STATEMENT2
    else:
             STATEMENT3

    如果第一个表达式为真，则执行statement1，否则进行进一步的测试，如果第二个表达式为真则执行statement2，否则执行statement3。

    注意语句的缩进量要保持一致。在python中没有switch和case语句，我们可通过多重elif来达到相同的效果。

    示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #!/usr/bin/env python

    mytest = raw_input("please input a number:")
    mytest = int(mytest)
    if mytest == 10:
            print "you input number is ten."
    elif mytest == 20:
            print "you input number is twenty."
    else:
            print "another number."

    脚本的执行效果：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    t03:~# python test.py
    please input a number:10
    you input number is ten.
    t03:~# python test.py
    please input a number:20
    you input number is twenty.
    t03:~# python test.py
    please input a number:777
    another number.

  • while进行循环控制，它对表达式进行测试，如果为真，则循环执行循环体。格式如下：

    1
    2
    3
    4
    while EXPRESSION:
              STATEMENT
    else:
              STATEMENT

    如果测试为假，则会执行else块。如果循环被中断(break)，则else块不会执行。

    示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    >>> a = 0
    >>> while a &gt; 5:
    ...     a = a + 1
    ...     print a
    ... else:
    ...     print "a's value is five"
    ...
    1
    2
    3
    4
    5
    a's value is five

  • for循环可遍历对象，并可进行迭代操作。语名格式如下：

    1
    2
    3
    4
    for TARGET in OBJECTS：
           STATEMENT
    else:
           STATEMENT

    和while一样，在循环正常退出时，会执行else块。

    示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    >>> mylist = "for statement"
    >>> for word in mylist:
    ...     print word
    ... else:
    ...     print "End list"
    ...
    f
    o
    r

    s
    t
    a
    t
    e
    m
    e
    n
    t
    End list

  • 在循环的过程中，我们可使用循环控制语句来控制循环的执行。有三个控制语句，分别是break、continue和pass。它们的作用分别是：

    • break语句会立即退出当前循环，不会执行else块的内容。

      示例：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      >>> mylist = ["zope","python","perl","Linux"]
      >>> for technic in mylist:
      ...     if technic == "perl":
      ...             break
      ...     else:
      ...             print technic
      ...
      zope
      python

    • continue语句会忽略后面的语句，强制进入下一次循环。

      示例：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      >>> mylist = ["zope","python","perl","Linux"]
      >>> for technic in mylist:
      ...     if technic == "perl":
      ...             continue
      ...     else:
      ...             print technic
      ...
      zope
      python
      Linux

    • pass不做任何事情。

      示例：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      >>> for technic in mylist:
      ...     if technic == "perl":
      ...             pass
      ...     else:
      ...             print technic
      ...
      zope
      python
      Linux

Chapter 5. 函数

函数是一个能完成特定功能的代码块，可在程序中重复使用，减少程序的代码量和提高程序的执行效率。在python中函数定义语法如下：

1
2
3
def function_name(arg1,arg2[,...]):
    statement
[return value]

返回值不是必须的，如果没有return语句，则Python默认返回值None。

函数名的命名规则：

  • 函数名必须以下划线或字母开头，可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号；

  • 函数名是区分大小写的。

  • 函数名不能是保留字。

Python使用名称空间的概念存储对象，这个名称空间就是对象作用的区域， 不同对象存在于不同的作用域。下面是不同对象的作用域规则：

  • 每个模块都有自已的全局作用域。

  • 函数定义的对象属局部作用域，只在函数内有效，不会影响全局作用域中的对象。

  • 赋值对象属局部作用域，除非使用global关键字进行声明。

LGB规则是Python查找名字的规则，下面是LGB规则：

  • 大多数名字引用在三个作用域中查找：先局部(Local)，次之全局(Global)，再次之内置(Build-in)。

    1
    2
    3
    4
    5
    6
    7
    >>> a=2
    >>> b=2
    >>> def test(b):
    ...     test=a*b
    ...     return test
    >>>print test(10)
    20

    b在局部作用域中找到,a在全局作用域中找到。

  • 如想在局部作用域中改变全局作用域的对象，必须使用global关键字。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #没用global时的情况
    >>> name="Jims"
    >>> def set():
    ...     name="ringkee"
    ...
    >>> set()
    >>> print name
    Jims
    #使用global后的情况
    >>> name="Jims"
    >>> def set1():
    ...     global name
    ...     name="ringkee"
    ...
    >>> set1()
    >>> print name
    ringkee

  • ‘global’声明把赋值的名字映射到一个包含它的模块的作用域中。

函数的参数是函数与外部沟通的桥梁，它可接收外部传递过来的值。参数传递的规则如下：

  • 在一个函数中对参数名赋值不影响调用者。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    >>> a=1
    >>> def test(a):
    ...     a=a+1
    ...     print a
    ...
    >>> test(a)
    2
    >>> a
    1             # a值不变

  • 在一个函数中改变一个可变的对象参数会影响调用者。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    >>> a=1
    >>> b=[1,2]
    >>> def test(a,b):
    ...     a=5
    ...     b[0]=4
    ...     print a,b
    ...
    >>> test(a,b)
    5 [4, 2]
    >>> a
    1
    >>> b
    [4, 2]    # b值已被更改

参数是对象指针，无需定义传递的对象类型。如：

1
2
3
4
5
6
7
8
9
>>> def test(a,b):
...     return a+b
...
>>> test(1,2)   #数值型
3
>>> test("a","b")   #字符型
'ab'
>>> test([12],[11])   #列表
[12, 11]

函数中的参数接收传递的值，参数可分默认参数，如：

1
def function(ARG=VALUE)

元组（Tuples）参数：

1
def function(*ARG)

字典（dictionary）参数：

1
def function(**ARG)

一些函数规则：

  • 默认值必须在非默认参数之后；

  • 在单个函数定义中，只能使用一个tuple参数（*ARG）和一个字典参数（**ARG）。

  • tuple参数必须在连接参数和默认参数之后。

  • 字典参数必须在最后定义。

5.1. 常用函数

  • abs(x)

    abs()返回一个数字的绝对值。如果给出复数，返回值就是该复数的模。

    1
    2
    3
    4
    >>>print abs(-100)
    100
    >>>print abs(1+2j)
    2.2360679775

  • callable(object)

    callable()函数用于测试对象是否可调用，如果可以则返回1(真)；否则返回0(假)。可调用对象包括函数、方法、代码对象、类和已经定义了“调用”方法的类实例。

    1
    2
    3
    4
    5
    >>> a="123"
    >>> print callable(a)
    0
    >>> print callable(chr)
    1

  • cmp(x,y)

    cmp()函数比较x和y两个对象，并根据比较结果返回一个整数，如果x<y，则返回-1；如果x>y，则返回1,如果x==y则返回0。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    >>>a=1
    >>>b=2
    >>>c=2
    >>> print cmp(a,b)
    -1
    >>> print cmp(b,a)
    1
    >>> print cmp(b,c)
    0

  • divmod(x,y)

    divmod(x,y)函数完成除法运算，返回商和余数。

    1
    2
    3
    4
    >>> divmod(10,3)
    (3, 1)
    >>> divmod(9,3)
    (3, 0)

  • isinstance(object,class-or-type-or-tuple) -> bool

    测试对象类型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    >>> a='isinstance test'
    >>> b=1234
    >>> isinstance(a,str)
    True
    >>> isinstance(a,int)
    False
    >>> isinstance(b,str)
    False
    >>> isinstance(b,int)
    True

  • len(object) -> integer

    len()函数返回字符串和序列的长度。

    1
    2
    3
    4
    >>> len("aa")
    2
    >>> len([1,2])
    2

  • pow(x,y[,z])

    pow()函数返回以x为底，y为指数的幂。如果给出z值，该函数就计算x的y次幂值被z取模的值。

    1
    2
    3
    4
    5
    6
    >>> print pow(2,4)
    16
    >>> print pow(2,4,2)
    0
    >>> print pow(2.4,3)
    13.824

  • range([lower,]stop[,step])

    range()函数可按参数生成连续的有序整数列表。

    1
    2
    3
    4
    5
    6
    >>> range(10)
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> range(1,10)
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> range(1,10,2)
    [1, 3, 5, 7, 9]

  • round(x[,n])

    round()函数返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。

    1
    2
    3
    4
    5
    6
    >>> round(3.333)
    3.0
    >>> round(3)
    3.0
    >>> round(5.9)
    6.0

  • type(obj)

    type()函数可返回对象的数据类型。

    1
    2
    3
    4
    5
    6
    >>> type(a)
    <type 'list'>
    >>> type(copy)
    <type 'module'>
    >>> type(1)
    <type 'int'>

  • xrange([lower,]stop[,step])

    xrange()函数与range()类似，但xrnage()并不创建列表，而是返回一个xrange对象，它的行为与列表相似，但是只在需要时才计算列表值，当列表很大时，这个特性能为我们节省内存。

    1
    2
    3
    4
    5
    6
    7
    >>> a=xrange(10)
    >>> print a[0]
    0
    >>> print a[1]
    1
    >>> print a[2]
    2

5.2. 内置类型转换函数

  • chr(i)

    chr()函数返回ASCII码对应的字符串。

    1
    2
    3
    4
    5
    6
    >>> print chr(65)
    A
    >>> print chr(66)
    B
    >>> print chr(65)+chr(66)
    AB

  • complex(real[,imaginary])

    complex()函数可把字符串或数字转换为复数。

    1
    2
    3
    4
    5
    6
    7
    8
    >>> complex("2+1j")
    (2+1j)
    >>> complex("2")
    (2+0j)
    >>> complex(2,1)
    (2+1j)
    >>> complex(2L,1)
    (2+1j)

  • float(x)

    float()函数把一个数字或字符串转换成浮点数。

    1
    2
    3
    4
    5
    6
    >>> float("12")
    12.0
    >>> float(12L)
    12.0
    >>> float(12.2)
    12.199999999999999

  • hex(x)

    hex()函数可把整数转换成十六进制数。

    1
    2
    3
    4
    >>> hex(16)
    '0x10'
    >>> hex(123)
    '0x7b'

  • long(x[,base])

    long()函数把数字和字符串转换成长整数，base为可选的基数。

    1
    2
    3
    4
    >>> long("123")
    123L
    >>> long(11)
    11L

  • list(x)

    list()函数可将序列对象转换成列表。如：

    1
    2
    3
    4
    >>> list("hello world")
    ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
    >>> list((1,2,3,4))
    [1, 2, 3, 4]

  • int(x[,base])

    int()函数把数字和字符串转换成一个整数，base为可选的基数。

    1
    2
    3
    4
    5
    6
    7
    8
    >>> int(3.3)
    3
    >>> int(3L)
    3
    >>> int("13")
    13
    >>> int("14",15)
    19

  • min(x[,y,z…])

    min()函数返回给定参数的最小值，参数可以为序列。

    1
    2
    3
    4
    >>> min(1,2,3,4)
    1
    >>> min((1,2,3),(2,3,4))
    (1, 2, 3)

  • max(x[,y,z…])

    max()函数返回给定参数的最大值，参数可以为序列。

    1
    2
    3
    4
    >>> max(1,2,3,4)
    4
    >>> max((1,2,3),(2,3,4))
    (2, 3, 4)

  • oct(x)

    oct()函数可把给出的整数转换成八进制数。

    1
    2
    3
    4
    >>> oct(8)
    '010'
    >>> oct(123)
    '0173'

  • ord(x)

    ord()函数返回一个字符串参数的ASCII码或Unicode值。

    1
    2
    3
    4
    >>> ord("a")
    97
    >>> ord(u"a")
    97

  • str(obj)

    str()函数把对象转换成可打印字符串。

    1
    2
    3
    4
    5
    6
    >>> str("4")
    '4'
    >>> str(4)
    '4'
    >>> str(3+2j)
    '(3+2j)'

  • tuple(x)

    tuple()函数把序列对象转换成tuple。

    1
    2
    3
    4
    >>> tuple("hello world")
    ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
    >>> tuple([1,2,3,4])
    (1, 2, 3, 4)

5.3. 序列处理函数

  • 常用函数中的len()、max()和min()同样可用于序列。

  • filter(function,list)

    调用filter()时，它会把一个函数应用于序列中的每个项，并返回该函数返回真值时的所有项，从而过滤掉返回假值的所有项。

    1
    2
    3
    4
    5
    6
    >>> def nobad(s):
    ...     return s.find("bad") == -1
    ...
    >>> s = ["bad","good","bade","we"]
    >>> filter(nobad,s)
    ['good', 'we']

    这个例子通过把nobad()函数应用于s序列中所有项，过滤掉所有包含“bad”的项。

  • map(function,list[,list])

    map()函数把一个函数应用于序列中所有项，并返回一个列表。

    1
    2
    3
    4
    >>> import string
    >>> s=["python","zope","linux"]
    >>> map(string.capitalize,s)
    ['Python', 'Zope', 'Linux']

    map()还可同时应用于多个列表。如：

    1
    2
    3
    4
    >>> import operator
    >>> s=[1,2,3]; t=[3,2,1]
    >>> map(operator.mul,s,t)   # s[i]*t[j]
    [3, 4, 3]

    如果传递一个None值，而不是一个函数，则map()会把每个序列中的相应元素合并起来，并返回该元组。如：

    1
    2
    3
    >>> a=[1,2];b=[3,4];c=[5,6]
    >>> map(None,a,b,c)
    [(1, 3, 5), (2, 4, 6)]

  • reduce(function,seq[,init])

    reduce()函数获得序列中前两个项，并把它传递给提供的函数，获得结果后再取序列中的下一项，连同结果再传递给函数，以此类推，直到处理完所有项为止。

    1
    2
    3
    4
    5
    6
    7
    >>> import operator
    >>> reduce(operator.mul,[2,3,4,5])  # ((2*3)*4)*5
    120
    >>> reduce(operator.mul,[2,3,4,5],1) # (((1*2)*3)*4)*5
    120
    >>> reduce(operator.mul,[2,3,4,5],2)  # (((2*2)*3)*4)*5
    240

  • zip(seq[,seq,…])

    zip()函数可把两个或多个序列中的相应项合并在一起，并以元组的格式返回它们，在处理完最短序列中的所有项后就停止。

    1
    2
    >>> zip([1,2,3],[4,5],[7,8,9])
    [(1, 4, 7), (2, 5, 8)]

    如果参数是一个序列，则zip()会以一元组的格式返回每个项，如：

    1
    2
    3
    4
    >>> zip((1,2,3,4,5))
    [(1,), (2,), (3,), (4,), (5,)]
    >>> zip([1,2,3,4,5])
    [(1,), (2,), (3,), (4,), (5,)]

Chapter 6. 模块

模块可把一个复杂的程序按功能分开，分别存放到不同文件中，使程序更容易维护和管理。在Python中的模块是一个以.py结尾的Python代码文件。可通过import命令输入，如：

1
import sys

import会完成以下三个操作：

  • 创建新的名称空间（namespace），该名称空间中拥有输入模块中定义的所有对象；

  • 执行模块中的代码；

  • 创建该名称空间的变量名。

import语句可同时输入多个模块，如：

1
import os,sys,system

也可写成：

1
2
3
import os
import sys
import system

有些模块的名称很长，我们可在输入时给它起个简单的别名，这样在使用模块中的对象就方便很多，如：

1
import ftplib as ftp

有时我们可能只想使用模块中某个对象，又不想把整个模块输入，则可以用from…import语句输入特定对象。如：

1
from ftplib import FTP

这样，我们就可直接使用FTP()，而不用带前缀。

如果装载模块出错，会引发ImportError异常。我们可捕获该异常进行相应处理。

Python脚本和模块都是一个以.py结束的文件，那程序是如何判断一个.py文件是作为脚本还是模块呢？关键是一个名为__name__的变量，如果它的值是__main__，则不能作为模块，只能作为脚本直接运行。所以在很多脚本的最后都有一段类似下面的语句，限制只能以脚本方式运行，不作为模块：

1
2
if __name__ == '__main__':
    main()

几个功能相近的模块我们可组成一个Python包，存放到一个目录结构中，通过输入包的路径来调用对象。要定义包，就要建一个与包名同名的目录，接着在该目录下创建__init__.py文件。该文件是包的初始化文件，可以为空，也可定义一个代码。例如一个WebDesign包的目录如下：

1
2
3
4
5
/WebDesign
        __init_.py
        design.py
        draw.py
        ...

我们可通过以下语句输入design模块：

1
import WebDesign.design

6.1. String模块

  • replace(string,old,new[,maxsplit])

    字符串的替换函数，把字符串中的old替换成new。默认是把string中所有的old值替换成new值，如果给出maxsplit值，还可控制替换的个数，如果maxsplit为1，则只替换第一个old值。

    1
    2
    3
    4
    5
    >>>a="11223344"
    >>>print string.replace(a,"1","one")
    oneone2223344
    >>>print string.replace(a,"1","one",1)
    one12223344

  • capitalize(string)

    该函数可把字符串的首个字符替换成大字。

    1
    2
    3
    >>> import string
    >>> print string.capitalize("python")
    Python

  • split(string,sep=None,maxsplit=-1)

    从string字符串中返回一个列表，以sep的值为分界符。

    1
    2
    3
    4
    5
    >>> import string
    >>> ip="192.168.3.3"
    >>> ip_list=string.split(ip,'.')
    >>> print ip_list
    ['192', '168', '3', '3']

  • join(string[,sep])

    返回用sep连接的字串，默认的sep是空格。

    1
    2
    3
    4
    5
    6
    7
    >>> import string
    >>> a = ['a','b','c']
    >>> b = string.join(a,'-')
    >>> b
    'a-b-c'
    >>> a
    ['a', 'b', 'c']

6.2. time模块

内置模块time包含很多与时间相关函数。我们可通过它获得当前的时间和格式化时间输出。

  • time()，以浮点形式返回自Linux新世纪以来经过的秒数。在linux中，00:00:00 UTC, January 1, 1970是新纪元的开始。

    1
    2
    3
    4
    >>> time.time()
    1150269086.6630149
    >>> time.ctime(1150269086.6630149)
    >>> 'Wed Jun 14 15:11:26 2006'

  • ctime([sec])，把秒数转换成日期格式，如果不带参数，则显示当前的时间。

    1
    2
    3
    4
    5
    >>> import time
    >>> time.ctime()
    >>> 'Wed Jun 14 15:02:50 2006'
    >>> time.ctime(1138068452427683)
    'Sat Dec 14 04:51:44 1901'

  • sleep(secs)，定时。

    1
    2
    >>> time.sleep(10)
    >>>                #10秒后才会出现>>>提示符

Chapter 7. 类

类是面向对象编程的一个重要概念。通过类的创建和继承，可重用代码，减少代码复杂度。Python是一种面向对象的脚本语言，用class语句可创建类，语法规则如下：

1
2
3
4
5
class classnmae([class_parent,...]):
      ...
      def method():
          ...
...

一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/python
#-*- encoding:utf-8 -*-

class test:                              #定义一个test类
        desc = "这是一个测试类。"        #在类中定义一个属性desc

        def __init__(self,name1):        #对象构造函数，初始化类
                self.name1 = name1

        def show(self,name2):            #在类中定义一个方法show()
                print "hello world"
                print 'name1:',self.name1
                print 'name2:',name2

instance = test('这是传递给name1的值')   #生成test类的实例对象instance

print instance.desc                      #调用类中的desc属性

instance.show('这是传递给name2的值')     #调用类中的show()方法

把该脚本命名为test.py，并用chmod +x test.py使脚本有执行的权限 ，运行该脚本结果如下：

1
2
3
4
5
debian:~/python# ./test.py
这是一个测试类。
hello world
name1: 这是传递给name1的值
name2: 这是传递给name2的值

这里只是Python语言中类的一个简单介绍。详细介绍可参考网站上自由文档栏目中的Python资料。

Chapter 8. 异常处理

Python的异常处理能力是很强大的，可向用户准确反馈出错信息。在Python中，异常也是对象，可对它进行操作。所有异常都是基类Exception的成员。异常处理的try语法有两种，一种是：

1
2
3
4
5
6
try:
   block
except [exception,[data...]]:
   block
else:
   block

该种异常处理语法的规则是：

  • 执行try下的语句，如果引发异常，则执行过程会跳到第一个except语句。

  • 如果第一个except中定义的异常与引发的异常匹配，则执行该except中的语句。

  • 如果引发的异常不匹配第一个except，则会搜索第二个except，允许编写的except数量没有限制。

  • 如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中。

  • 如果没有发生异常，则执行else块代码。

try语句的第二种语法是：

1
2
3
4
try:
   block
finally:
   block

该语句的执行规则是：

  • 执行try下的代码。

  • 如果发生异常，在该异常传递到下一级try时，执行finally中的代码。

  • 如果没有发生异常，则执行finally中的代码。

第二种try语法在无论有没有发生异常都要执行代码的情况下是很有用的。例如我们在python中打开一个文件进行读写操作，我在操作过程中不管是否出现异常，最终我都是要把该文件关闭的。

除了系统引发的异常外，我们还可用raise语句手工引发一个异常：

1
raise [exception[,data]]

Chapter 9. 文件处理

文件是我们储存信息的地方，我们经常要对文件进行读、写、删除等的操作，在Python中，我们可用Python提供的函数和方法方便地操作文件。

9.1. 文件处理的函数和方法

使用Open()函数可打开文件，语法格式如下：

1
file_handler = open(filename,[,mode[,bufsize]]

filename是你要操作的文件名，如果不在当前路径，需指出具体路径。mode是打开文件的模式，表示你要如何操作文件，bufsize表示是否使用缓存。

Table 9.1. mode

模式 描述
r 以读方式打开文件，可读取文件信息。
w 以写方式打开文件，可向文件写入信息。
a 以追加方式打开文件，文件指针自动移到文件尾。
r+ 以读写方式打开文件，可对文件进行读和写操作。
w+ 消除文件内容，然后以读写方式打开文件。
a+ 以读写方式打开文件，并把文件指针移到文件尾。
b 以二进制模式打开文件，而不是以文本模式。该模式只对Windows或Dos有效，类Unix的文件是用二进制模式进行操作的。

Table 9.2. bufsize

bufsize取值 描述
0 禁用缓冲
1 行缓冲
>1 指定缓冲区的大小
<1 系统默认的缓冲区大小

open()函数返回一个文件对象，我们可通过read()或write()函数对文件进行读写操作，下面是一些文件对象方法：

Table 9.3. 文件对象方法

方法 描述
f.close() 关闭文件，记住用open()打开文件后一定要记得关闭它，否则会占用系统的可打开文件句柄数。
f.fileno() 获得文件描述符
f.flush() 刷新输出缓存
f.isatty() 如果文件是一个交互终端，则返回True，否则返回False。
f.read([count]) 读出文件，如果有count，则读出count个字节。
f.readline() 读出一行信息。
f.readlines() 读出所有行，也就是读出整个文件的信息。
f.seek(offset[,where]) 把文件指针移动到相对于where的offset位置。offset为0表示文件开始处，这是默认值 ；1表示当前位置；2表示文件结尾。
f.tell() 获得文件指针位置。
f.truncate([size]) 截取文件，使文件的大小为size。
f.write(string) 把string字符串写入文件。
f.writelines(list) 把list中的字符串一行一行地写入文件。

9.2. 示例

  • 文件的打开或创建

    1
    2
    3
    4
    5
    6
    7
    #!/usr/bin/env python
    #-*- encoding:UTF-8 -*-

    filehandler = open('test.txt','w')               #以写模式打开文件，如果文件不存在则创建
    filehandler.write('this is a file open/create test.\nthe second line.')

    filehandler.close()
    1
    2
    3
    4
    5
    6
    7
    8
    #!/usr/bin/env python
    #-*- encoding:UTF-8 -*-

    filehandler = open('test.txt','a')      #以追加模式打开文件，如果文件不存在则创建

    filehandler.write('\nappend the text in another line.\n')

    filehandler.close()

  • 读取文件

    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
    32
    33
    34
    #!/usr/bin/env python
    #-*- encoding:UTF-8 -*-

    filehandler = open('test.txt','r')    #以读方式打开文件，rb为二进制方式(如图片或可执行文件等)

    print 'read() function:'              #读取整个文件
    print filehandler.read()

    print 'readline() function:'          #返回文件头，读取一行
    filehandler.seek(0)
    print filehandler.readline()

    print 'readlines() function:'         #返回文件头，返回所有行的列表
    filehandler.seek(0)
    print filehandler.readlines()

    print 'list all lines'                #返回文件头，显示所有行
    filehandler.seek(0)
    textlist = filehandler.readlines()
    for line in textlist:
          print line

    print 'seek() function'               #移位到第32个字符，从33个字符开始显示余下内容
    filehandler.seek(32)
    print filehandler.read()

    print 'tell() function'               #移位到文件头，从头开始显示2位字符
    filehandler.seek(0)
    print filehandler.readline()          #显示第一行内容
    print filehandler.tell()              #显示当前位置
    print filehandler.readline()          #显示第二行内容
    print filehandler.read()              #显示余下所有内容

    filehandler.close()                   #关闭文件句柄

  • 文件系统操作

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #!/usr/bin/env python
    #-*- encoding:utf-8 -*-

    import os,fnmatch,glob

    for fileName in os.listdir ( '/root' ):                 #列出/root目录内容，不包括.和..
       print fileName

    os.mkdir('py')                  #在当前目录下创建一个py目录，且只能创建一层
    os.rmdir( 'py')                 #在当前目录下删除py目录，且只能删除一层
    os.makedirs('py/aa')            #可创建多层目录
    os.removedirs('py/aa')          #可删除多层目录

    print 'demonstration fnmatch module'                 
    for fileName in os.listdir ( '/root/python/file' ):
            if fnmatch.fnmatch(fileName,'*.txt'):        #利用UNIX风格的通配，只显示后缀为txt的文件
                    print fileName

    print 'demonstration glob module'
    for fileName in glob.glob ( '*.txt' ):               #利用UNIX风格的通配，只显示后缀为txt的文件
            print fileName

  • 获取文件状态

    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
    32
    33
    34
    35
    36
    37
    #!/usr/bin/env python
    #-*- encoding:UTF-8 -*-

    import os,time,stat

    fileStats = os.stat ( 'test.txt' )                         #获取文件/目录的状态
    fileInfo = {
    'Size':fileStats [ stat.ST_SIZE ],                         #获取文件大小
    'LastModified':time.ctime( fileStats [ stat.ST_MTIME ] ),  #获取文件最后修改时间
    'LastAccessed':time.ctime( fileStats [ stat.ST_ATIME ] ),  #获取文件最后访问时间
    'CreationTime':time.ctime( fileStats [ stat.ST_CTIME ] ),  #获取文件创建时间
    'Mode':fileStats [ stat.ST_MODE ]                          #获取文件的模式
    }
    #print fileInfo

    for field in fileInfo:                                     #显示对象内容
            print '%s:%s' % (field,fileInfo[field])

    #for infoField,infoValue in fileInfo:
    #       print '%s:%s' % (infoField,infoValue)
    if stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ):             #判断是否路径
            print 'Directory. '
    else:
            print 'Non-directory.'

    if stat.S_ISREG ( fileStats [ stat.ST_MODE ] ):             #判断是否一般文件
       print 'Regular file.'
    elif stat.S_ISLNK ( fileStats [ stat.ST_MODe ] ):           #判断是否链接文件
       print 'Shortcut.'
    elif stat.S_ISSOCK ( fileStats [ stat.ST_MODe ] ):          #判断是否套接字文件     
       print 'Socket.'
    elif stat.S_ISFIFO ( fileStats [ stat.ST_MODe ] ):          #判断是否命名管道
       print 'Named pipe.'
    elif stat.S_ISBLK ( fileStats [ stat.ST_MODe ] ):           #判断是否块设备
       print 'Block special device.'
    elif stat.S_ISCHR ( fileStats [ stat.ST_MODe ] ):           #判断是否字符设置
       print 'Character special device.'
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #!/usr/bin/env python
    #-*- encoding:UTF-8 -*-

    import os.path

    fileStats = 'test.txt'

    if os.path.isdir ( fileStats ):         #判断是否路径
            print 'Directory.'
    elif os.path.isfile ( fileStats ):      #判断是否一般文件
            print 'File.'
    elif os.path.islink ( fileStats ):      #判断是否链接文件
            print 'Shortcut.'
    elif os.path.ismount ( fileStats ):     #判断是否挂接点
            print 'Mount point.'

    stat模块描述了os.stat(filename)返回的文件属性列表中各值的意义。我们可方便地根据stat模块存取os.stat()中的值。

  • 串行化文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #!/usr/bin/env python
    #-*- encoding:UTF-8 -*-

    import pickle

    filehandler = open('pickle.txt','w')

    text = ['this is a pickle demonstrate','aa','bb']

    pickle.dump(text,filehandler)           #把text的内容序列化后保存到pickle.txt文件中

    filehandler.close()

    filehandler2 = open('pickle.txt')

    textlist = pickle.load(filehandler2)    #还原序列化字符串
    print textlist

    filehandler2.close()

    #cpickle是用C写的pickle模块，比标准的pickle速度快很多，使用方法同pickle。

  • 内存文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #!/usr/bin/env python
    #-*- coding: utf-8 -*-

    import StringIO

    fileHandle = StringIO.StringIO ( "Let freedom ring." )   #create file in memory

    print fileHandle.read() # "Let freedom ring."

    fileHandle.close()

    #cStringIO是用C写的StringIO模块，执行速度比StringIO快。

shutil模块是一个高级的文件处理模块，可实现文件的拷贝、删除等操作。

Chapter 10. 正则表达式

正则表达式是一个很有用的工具，可处理复杂的字符匹配和替换工作。在Python中内置了一个re模块以支持正则表达式。

正则表达式有两种基本的操作，分别是匹配和替换。

  • 匹配就是在一个文本字符串中搜索匹配一特殊表达式；

  • 替换就是在一个字符串中查找并替换匹配一特殊表达式的字符串。

10.1. 基本元素

正则表达式定义了一系列的特殊字符元素以执行匹配动作。

Table 10.1. 正则表达式基本字符

字符 描述
text 匹配text字符串
. 匹配除换行符之外的任意一个单个字符
^ 匹配一个字符串的开头
$ 匹配一个字符串的末尾

在正则表达式中，我们还可用匹配限定符来约束匹配的次数。

Table 10.2. 匹配限定符

最大匹配 最小匹配 描述
* * 重复匹配前表达式零次或多次
+ + 重复匹配前表达式一次或多次
? ? 重复匹配前表达式零次或一次
{m} {m} 精确重复匹配前表达式m次
{m,} {m,} 至少重复匹配前表达式m次
{m,n} {m,n} 至少重复匹配前表达式m次，至多重复匹配前表达式n次

据上所述，”.*“为最大匹配，能匹配源字符串所有能匹配的字符串。”.* “为最小匹配，只匹配第一次出现的字符串。如：d.*g能匹配任意以d开头，以g结尾的字符串，如”debug”和”debugging”，甚至”dog is walking”。而d.* g只能匹配”debug”，在”dog is walking”字符串中，则只匹配到”dog “。

在一些更复杂的匹配中，我们可用到组和运算符。

Table 10.3. 组和运算符

组 描述
[…] 匹配集合内的字符，如[a-z],[1-9]或[,./;’]
[^…] 匹配除集合外的所有字符，相当于取反操作
A|B 匹配表达式A或B，相当于OR操作
(…) 表达式分组，每对括号为一组，如([a-b]+)([A-Z]+)([1-9]+)
\number 匹配在number表达式组内的文本

有一组特殊的字符序列，用来匹配具体的字符类型或字符环境。如\b匹配字符边界，food\b匹配”food”、”zoofood”，而和”foodies”不匹配。

Table 10.4. 特殊字符序列

字符 描述
\A 只匹配字符串的开始
\b 匹配一个单词边界
\B 匹配一个单词的非边界
\d 匹配任意十进制数字字符，等价于r’[0-9]’
\D 匹配任意非十进制数字字符，等价于r’[^0-9]’
\s 匹配任意空格字符（空格符、tab制表符、换行符、回车、换页符、垂直线符号）
\S 匹配任意非空格字符
\w 匹配任意字母数字字符
\W 匹配任意非字母数字字符
\Z 仅匹配字符串的尾部
\ 匹配反斜线字符

有一套声明(assertion)对具体事件进行声明。

Table 10.5. 正则表达式声明

声明 描述
( iLmsux) 匹配空字符串，iLmsux字符对应下表的正则表达式修饰符。
( :…) 匹配圆括号内定义的表达式，但不填充字符组表。
( P<name>) 匹配圆括号内定义的表达式，但匹配的表达式还可用作name标识的符号组。
( P=name) 匹配所有与前面命名的字符组相匹配的文本。
( #…) 引入注释，忽略圆括号内的内容。
( =…) 如果所提供的文本与下一个正则表达式元素匹配，这之间没有多余的文本就匹配。这允许在一个表达式中进行超前操作，而不影响正则表达式其余部分的分析。如”Martin”其后紧跟”Brown”，则”Martin( =Brown)”就只与”Martin”匹配。
( !…) 仅当指定表达式与下一个正则表达式元素不匹配时匹配，是( =…)的反操作。
( <=…) 如果字符串当前位置的前缀字符串是给定文本，就匹配，整个表达式就在当前位置终止。如( <=abc)def表达式与”abcdef”匹配。这种匹配是对前缀字符数量的精确匹配。
( <!…) 如果字符串当前位置的前缀字符串不是给定的正文，就匹配，是( <=…)的反操作。

正则表达式还支持一些处理标志，它会影响正则式的执行方法。

Table 10.6. 处理标志

标志 描述
I或IGNORECASE 忽略表达式的大小写来匹配文本。

10.2. 操作

通过re模块，我们就可在python中利用正则式对字符串进行搜索、抽取和替换操作。如：re.search()函数能执行一个基本的搜索操作，它能返回一个MatchObject对象。re.findall()函数能返回匹配列表。

1
2
3
4
5
6
7
8
9
>>> import re
>>> a="this is my re module test"
>>> obj = re.search(r'.*is',a)
>>> print obj
<_sre.SRE_Match object at 0xb7d7a218>
>>> obj.group()
'this is'
>>> re.findall(r'.*is',a)
['this is']

MatchObject对象方法

Table 10.7. MatchObject对象方法

方法 描述
expand(template) 展开模板中用反斜线定义的内容。
m.group([group,…]) 返回匹配的文本，是个元组。此文本是与给定group或由其索引数字定义的组匹配的文本，如果没有组定组名，则返回所有匹配项。
m.groups([default]) 返回一个元组，该元组包含模式中与所有组匹配的文本。如果给出default参数，default参数值就是与给定表达式不匹配的组的返回值。default参数的默认取值为None。
m.groupdict([default]) 返回一个字典，该字典包含匹配的所有子组。如果给出default参数，其值就是那些不匹配组的返回值。default参数的默认取值为None。
m.start([group]) 返回指定group的开始位置，或返回全部匹配的开始位置。
m.end([group]) 返回指定group的结束位置，或返回全部匹配的结束位置。
m.span([group]) 返回两元素组，此元组等价于关于一给定组或一个完整匹配表达式的(m.start(group),m.end(group)))列表
m.pos 传递给match()或search()函数的pos值。
m.endpos 传递给match()或search()函数的endpos值。
m.lastindex
m.lastgroup
m.re 创建这个MatchObject对象的正则式对象
m.string 提供给match()或search()函数的字符串。

使用sub()或subn()函数可在字符串上执行替换操作。sub()函数的基本格式如下：

1
sub(pattern,replace,string[,count])

示例

1
2
3
4
>>> str = 'The dog on my bed'
>>> rep = re.sub('dog','cat',str)
>>> print rep
The cat on my bed

replace参数可接受函数。要获得替换的次数，可使用subn()函数。subn()函数返回一个元组，此元组包含替换了的文本和替换的次数。

如果需用同一个正则式进行多次匹配操作，我们可把正则式编译成内部语言，提高处理速度。编译正则式用compile()函数来实现。compile()函数的基本格式如下：

1
compile(str[,flags])

str表示需编译的正则式串，flags是修饰标志符。正则式被编译后生成一个对象，该对象有多种方法和属性。

Table 10.8. 正则式对象方法/属性

方法/属性 描述
r.search(string[,pos[,endpos]]) 同search()函数，但此函数允许指定搜索的起点和终点
r.match(string[,pos[,endpos]]) 同match()函数，但此函数允许指定搜索的起点和终点
r.split(string[,max]) 同split()函数
r.findall(string) 同findall()函数
r.sub(replace,string[,count]) 同sub()函数
r.subn(replace,string[,count]) 同subn()函数
r.flags 创建对象时定义的标志
r.groupindex 将r’( Pid)’定义的符号组名字映射为组序号的字典
r.pattern 在创建对象时使用的模式

转义字符串用re.escape()函数。

通过getattr获取对象引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> li=['a','b']
>>> getattr(li,'append')
>>> getattr(li,'append')('c')          #相当于li.append('c')
>>> li
['a', 'b', 'c']
>>> handler=getattr(li,'append',None)
>>> handler
<built-in method append of list object at 0xb7d4a52c>
>>> handler('cc')                      #相当于li.append('cc')
>>> li
['a','b','c','cc']
>>>result = handler('bb')
>>>li
['a','b','c','cc','bb']
>>>print result
None

Chapter 11. 调试

Python自带了一个调试器叫pdb，和Gnu的gbd类似。下面用一个简单的程序来演示pdb的功能。程序代码如下：

1
2
3
4
5
6
7
8
9
#!/usr/bin/python

import pdb
a = "aaa"
pdb.set_trace()
b = "bbb"
c = "ccc"
final = a + b + c
print final

该程序已导入pdb模块，并在代码中添加的pdb.set_trace()跟踪点。现在让我们来运行该程序。

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
32
33
34
35
36
37
38
39
40
localhost:~/python/pdb# python pdbtest.py
--Return--
> /usr/lib/python2.3/pdb.py(992)set_trace()->None
-> Pdb().set_trace()              # 从跟踪点开始执行
(Pdb) n                           # n 读入下一行代码
> /root/python/pdb/pdbtest.py(6) ()
-> b = "bbb"
(Pdb) n
> /root/python/pdb/pdbtest.py(7) ()
-> c = "ccc"
(Pdb) p b                         # p 打印变量值
'bbb'
(Pdb) l                           # l 显示当前执行位置
  2
  3     import pdb
  4     a = "aaa"
  5     pdb.set_trace()
  6     b = "bbb"
  7  -> c = "ccc"
  8     final = a + b + c
  9     print final
 10
[EOF]
(Pdb) n                          
> /root/python/pdb/pdbtest.py(8) ()
-> final = a + b + c
(Pdb) n                           # 如果命令和上次的一样，也可直接按回车，不用输入'n'
> /root/python/pdb/pdbtest.py(9) ()
-> print final
(Pdb) n
aaabbbccc
--Return--
> /root/python/pdb/pdbtest.py(9) ()->None
-> print final
(Pdb) p a,b,c,final
('aaa', 'bbb', 'ccc', 'aaabbbccc')
(Pdb)
('aaa', 'bbb', 'ccc', 'aaabbbccc')
(Pdb) n
localhost:~/python/pdb#           # 返回shell

pdb还有很多命令，用help命令就可以列出所有的pdb命令，用help p可以查询p命令的说明。

Chapter 12. HOW-TO

本章内容记录Python的一些小技巧小知识。来源是网上摘录或自己学习所得。

  • 如何判断操作系统类型

    1
    2
    3
    import sys
    print sys.platform
    print sys.version

  • 显示和修改python的Module搜索路径

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    >>> import sys
    >>> print sys.path
    ['', '/usr/lib/python23.zip', '/usr/lib/python2.3', '/usr/lib/python2.3/plat-linux2',
     '/usr/lib/python2.3/lib-tk', '/usr/lib/python2.3/lib-dynload', '/usr/local/lib/python2.3/site-packages',
     '/usr/lib/python2.3/site-packages']
    >>> sys.path.append('/usr/lib/mypath')
    >>> print sys.path
    ['', '/usr/lib/python23.zip', '/usr/lib/python2.3', '/usr/lib/python2.3/plat-linux2',
    '/usr/lib/python2.3/lib-tk', '/usr/lib/python2.3/lib-dynload', '/usr/local/lib/python2.3/site-packages',
     '/usr/lib/python2.3/site-packages', '/usr/lib/mypath']

  • 把列表转换成字符串

    1
    2
    3
    4
    5
    6
    >>> t=['a','b','c']
    >>> print t
    ['a', 'b', 'c']
    >>> import string
    >>> print string.join(t)
    a b c

  • 运行系统程序

    1
    2
    3
    >>>import os
    >>>os.system('ls')            #用os.system()可执行系统命令
    >>>exec "os.system('ls')"     #用exec可执行字符串中的命令，两个命令的效果一样。

    以上两个命令的输出都是直接显示在屏幕上，不能保存到变量中，如果我们要把输出保存起来，可用os.pope\ n()函数。

    1
    2
    3
    >>>cmd = '/usr/bin/mkntpwd %s' % password
    >>>handler = os.popen(cmd,'r')
    >>>passwordString=handler.read()   #passwordString为mkntpwd程序的输出结果

    使用commands模块也可以获取程序的输出，它包含一些基于os.popen()的封装函数，使我们能更方便地获取运行系统命令和获取命令的输出，但该模块只在Unix系统下有效，不能用于Windows平台。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    >>> import commands
    >>> status,output = commands.getstatusoutput('ls -l')
    >>> print output
    总计 96564
    -rw-r--r--  1 root     root         4459 2005-12-01 10:23 2005.sxw
    -rw-r--r--  1 root     root        27511 2006-04-12 16:54 20060412_user.ods
    -rw-r--r--  1 root     root       202258 2006-01-06 16:48 2006风景-1月.jpg
    ...
    >>> print status
    0

    在Python2.4中引入一个新的模块叫subprocess，用于取代os.system、os.spawn*、os.popen*、popen2.*、commands.*。

  • 编码转换

    1
    2
    3
    4
    5
    6
    7
    #!/usr/bin/python
    #-*-coding:utf-8 -*-

    a=u"测试"
    b=a.encode('gb2312')
    print a
    print b

  • 交换两个变量

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    >>> a,b = 1,2
    >>> a,b
    (1, 2)
    >>> a,b = b,a
    >>> a,b
    (2, 1)
    >>> a
    2
    >>> b
    1

  • 测试数据类型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    >>> a=123
    >>> b='test'
    >>> a
    123
    >>> b
    'test'
    >>> isinstance(a,int)
    True
    >>> isinstance(a,str)
    False
    >>> isinstance(b,int)
    False
    >>> isinstance(b,str)
    True

  • 用in判断是否包含子字符串

    1
    2
    3
    4
    5
    >>> a='this is my test'
    >>> 'is' in a
    True
    >>> 'mm' in a
    False

  • __iter__迭代器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    >>> a = "iterator"
    >>> t = iter(a)
    >>> t.next()
    'i'
    >>> t.next()
    't'
    >>> t.next()
    'e'
    >>> t.next()
    'r'
    >>> t.next()
    'a'
    >>> t.next()
    't'
    >>> t.next()
    'o'
    >>> t.next()
    'r'
    >>> t.next()
    Traceback (most recent call last):
      File "<stdin>", line 1, in  
    StopIteration

    自已写一个迭代器类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    >>> class reverse:
    ...     def __init__(self,data):
    ...             self.data=data
    ...             self.index=len(data)
    ...     def __iter__(self):
    ...             return self
    ...     def next(self):
    ...             if self.index == 0:
    ...                     raise StopIteration
    ...             self.index = self.index - 1
    ...             return self.data[self.index]
    ...
    >>> for char in reverse('iterator'):
    ...     print char
    ...
    r
    o
    t
    a
    r
    e
    t
    i
    >>>

  • 通过getattr可以得到一个在运行时才知道具体函数名的对象的引用，能增强我们程序的灵活性。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    >>> li=['a','b']
    >>> getattr(li,'append')
    >>> getattr(li,'append')('c')          #相当于li.append('c')
    >>> li
    ['a', 'b', 'c']
    >>> handler=getattr(li,'append',None)
    >>> handler
    <built-in method append of list object at 0xb7d4a52c>
    >>> handler('cc')                      #相当于li.append('cc')
    >>> li
    ['a','b','c','cc']
    >>>result = handler('bb')
    >>>li
    ['a','b','c','cc','bb']
    >>>print result
    None

    编程示例：

    1
    2
    3
    4
    5
    import statsout

    def output(data, format="text"):                              
        output_function = getattr(statsout, "output_%s" % format)
        return output_function(data)

    以上代码表示，output函数接收一个data参数和format参数，根据format参数的值，从statsout模块中取出output_text函数运行，data参数通过output_function(data)传递给了statsout模块中的output_text函数。format取不同值可从statsout模块中取出不同的函数运行（output_xxxx）。也就是说我们要运行的函数是在程序运行后才确定的。这样我们可把不同的函数以output_xxx形式命名放在statout模块中，通过以上程序可动态调用各种函数。

  • hasattr用于确定一个对象是否具有某个属性。

    语法：

    1
    hasattr(object, name) -> bool

    判断object中是否有name属性，返回一个布尔值。

  • 拆分序列

    1
    2
    3
    4
    >>> a=[c for c in 'abcdefg']
    >>> a
    ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>>

    按if条件拆分序列

    1
    2
    3
    4
    5
    6
    >>> a=[c for c in '123456' if int(c)<3]      如果if的条件为真，则执行for循环
    >>> a
    ['1', '2']
    >>> a=[c for c in '123456' if int(c)>3]      如果if的条件为假，则不执行for循环
    >>> a
    ['4', '5', '6']

  • __dict__记录模块或类中所有对象的信息，它以字典{name:object}的形式记录这些信息，如果wikiaction是一个模块，则可以这样显示：

    1
    2
    3
    4
    5
    6
    7
    8
    >>>import wikiaction
    >>>print wikiaction.__dict__
    {'do_test': <function do_test at 0xb7c10534>, 'do_diff': <function do_diff at 0xb7c0ef0c>, 'do_refresh': <fun
    ction do_refresh at 0xb7c1025c>, 'do_userform': <function do_userform at 0xb7c103e4>, 'getHandler': <function
     getHandler at 0xb7c105a4>, 'do_raw': <function do_raw at 0xb7c10454>, 'do_chart': <function do_chart at 0xb7
    c104c4>, 're': <module 're' from '/usr/lib/python2.3/re.pyc'>, 'pysupport': <module 'MoinMoin.util.pysupport'
     from '/usr/lib/python2.3/site-packages/MoinMoin/util/pysupport.pyc'>, 'config': <module 'MoinMoin.config' fr
    om '/usr/lib/python2.3/site-packages/MoinMoin/config.pyc'>}

  • ‘and’的特殊用法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    >>> 'a' and 'b'         #如果两个都为真值，返回最后一个真值
    'b'
    >>> 'b' and 'a'         #同上
    'a'
    >>> 'a' and 'b' and 'c' #同上
    'c'
    >>> '' and 'a'          #如果有假值，则返回假值
    ''
    >>> 'a' and '' and 'c'  #同上
    ''
    >>> '' and 0            #如果两个都为假值，返回第一个假值
    ''
    >>> 0 and ''            #同上
    0

  • ‘or’的的特殊用法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    >>> 'a' or 'b'          #如果有一个为真值，则返回第一个真值
    'a'
    >>> 'b' or 'a'          #同上
    'b'
    >>> 'a' or 'b' or ''    #同上
    'a'
    >>> 0 and '' and {}     #如果所有都是假值，则返回第一个假值
    0
    >>> {} and '' and {}    #同上
    {}

  • lambda匿名函数的用法

    1
    2
    3
    4
    5
    6
    7
    >>> a=lambda c:c*2
    >>> a
    <function <lambda> at 0xb7dd710c>
    >>> a(2)
    4
    >>> a(5)
    10