Table of Contents
List of Tables
-
1.1.
Python命令行选项
2.1.
Python运算符列表
2.2.
运算符优先顺序列表(从最高到最低)
2.3.
3.1.
字符串格式化代码
3.2.
python支持的转义字符表
3.3.
列表对象支持的方法
3.4.
字典方法
3.5.
数组类型代码
9.1.
mode
9.2.
bufsize
9.3.
文件对象方法
10.1.
正则表达式基本字符
10.2.
匹配限定符
10.3.
组和运算符
10.4.
特殊字符序列
10.5.
正则表达式声明
10.6.
处理标志
10.7.
MatchObject对象方法
10.8.
正则式对象方法/属性
Table of Contents
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动态和资料 。
Python是一种解析性的,交互式的,面向对象的编程语言,类似于Perl、Tcl、Scheme或Java。
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
系统编程,提供大量系统接口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模块可用于编写游戏软件。
进入交互命令行方式。如果是linux类的系统,python解析器应该已经安装在/usr/local/bin/python中,直接打python就可进入交互式命令行界面,如下所示:
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"可以输入以下命令:
>>>print "hello world"
hello world以模块文件方式运行。模块文件是包含python语句的文本,以.py结尾。运行模块文件只要输入python xxx.py就可以了。
以linux脚本方式运行。和shell脚本差不多,以vi或其它文本编辑器输入以下内容:
#!/usr/local/bin/python
print "test ............"存盘后,把文件属性改为可执行,就可象shell脚本一样执行了。
-
Table 1.1. Python命令行选项
选项 作用 -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里读取执行代码。
Table of Contents
在Python中,每行程序以换行符代表结束,如果一行程序太长的话,可以用“/”符号扩展到下一行。在python中以三引号(""")括起来的字符串,列表,元组和字典都能跨行使用。并且以小括号(...)、中括号[...]和大括号{...}包围的代码不用加“/”符也可扩展到多行。如:
在Python中是以缩进来区分程序功能块的,缩进的长度不受限制,但就一个功能块来讲,最好保持一致的缩进量。
如果一行中有多条语句,语句间要以分号(;)分隔。
以“#”号开头的内容为注释,python解释器会忽略该行内容。
在python中,所有标识符可以包括英文、数字以及下划线(_),但不能以数字开头。python中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。以单下划线开头(_foo)的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用“from xxx import *”而导入;以双下划线开头的(__foo)代表类的私有成员;以双下划线开头和结尾的(__foo__)代表python里特殊方法专用的标识,如__init__()代表类的构造函数。
在交互模式下运行python时,一个下划线字符(_)是特殊标识符,它保留了表达式的最后一个计算结果。
>>> "hello"
'hello'
>>> _
'hello'
>>> 10+10
20
>>> _
20在python中,函数、类、模块定义的第一段代码如果是字符串的话,就把它叫作文件字串,可通过__doc__属性访问。如:
def test():
"this is a document string"
return 100+1000
>>>print test.__doc__
this is a document string
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
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(...) | 索引,分片,限定引用,函数调用 |
(...),[...],{...},'...' | 元组,列表,字典,转化为字符串 |
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匿名函数 |
对于and,当计算a and b时,python会计算a,如果a为假,则取a值,如果a为真,则python会计算b且整个表达式会取b值。如:
>>> 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值。如:
>>> a,b=10,20
>>> a or b
10
>>> a,b=0,5
>>> a or b
5对于not,not将反转表表达式的“实际值”,如果表达式为真,not为返回假,如为表达式为假,not为返回真。如:
>>> not 2
False
>>> not 0
True
>>> not "test"
False
>>> not ""
True
简单赋值,Variable(变量)=Value(值)。
>>>a=1
>>>b=2
>>>print a,b
1 2多变量赋值,Variable1,variable2,...=Value1,Value2,...
>>>a,b,c=1,2,3
>>>print a
1
>>>print b
2
>>>print c
3多变量赋值也可用于变量交换,接上例:
>>>a,b,c=c,b,a
>>>print a
3
>>>print b
2
>>>print c
1多目标赋值,a=b=variable
>>> a=b=1
>>> a
1
>>> b
1
>>> a=2
>>> a
2
>>> b
1自变赋值,如+=,-=,*=等。在自变赋值中,python仅计算一次,而普通写法需计算两次;自变赋值会修改原始对象,而不是创建一个新对象。
Table of Contents
在Python中,所有数据都是对象,数据有各种类型,如数值型、列表型、字符串型等。除系统内建的数据类型外,程序员也可以创建自已的数据类型。以下主要介绍Python内建的数据类型。
在python中,数值有四种类型,分别是整型、长整形、浮点型和复数。
整型---从-2147483648至2147483647,有符号位32位长,可表达的最大数为2^31-1。如:number=123,number1=-123。在数字前加0x或0X 前缀表示十六进制数,在数字前加前缀0表示八进制数,与C/C++ and perl一样。
>>> 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
字符串在python被看成是单个字符的序列,具有序列对象的特殊功能,字符串是固定的,不可变的。如:string="hello world"。
可在字符串中使用单引号和双引号。如:string="I'm a boy"。
字符串内部的一个反斜杠“/”可允许把字符串放于多行:如:
>>> "test /
... python"
'test python'使用三个单引号或双引号可使字符串跨行显示。如:
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。分片的格式为:
string[start:end]
分片和索引的规则如下:
返回的字符串包含从start起始到end但不包括end结束的所有字符。
若指定了start但未指定end,则一直向后分片,直至字符串结束。
若指定了end但未指定start,则从0开始分片直至end,但不包括end指定的字符。
若start和end为负数,则索引从字符串尾部开始算起,最后一个字符为-1。
python提供了一个string模块来进行字符串处理。
象C 中的sprintf函数一样,可以用“%”来格式化字符串。
在需要在字符中使用特殊字符时,python用反斜杠(/)转义字符。如下表:
在python2.0中才完全支持Unicode字符串,Unicode字符采用16位(0---65535)值表示,能进行多语言支持。要使用Unicode字符串,只要在字符串前加上“u”即可。如:
>>> a=u"test"
>>> print a
test
原始Unicode字符串用ur前缀,如:
>>> u'hello world/0020'
u'hello world/x020'
>>> ur'hello world/0020'
u'hello world//0020'
只要和Unicode连接,就会产生Unicode字串。如:
>>> 'help'
'help'
>>> 'help,' + u'python'
u'help,python'
对于ASCII(7位)兼容的字串,可和内置的str()函数把Unicode字串转换成ASCII字串。如:
>>> str(u'hello world')
'hello world'
可使用encode()函数转换Unicode字串格式:
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格式,如:
>>> 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号码,如:
>>>ord('A')
65
使用unichr()函数可将unicode号码转换回unicode字符,如:
>>> unichr(65)
u'A'
列表是序列对象,可包含任意的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语句,如:
>>> [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. 列表对象支持的方法
方法 描述 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模块可用于排序列表项的添加和删除。
Tuple(元组)和List(列表)很相似,但元组是不可变的。不能对元组中的元素进行添加,修改和删除操作。如果需修改元组内容只有重建元组。元组用小括号来表示。如tuple=(1,2,3)。
上面介绍的字符串、列表和元组的对象类型均属于称为序列的Python对象。它是一种可使用数字化索引进行访问其中元素的对象。
可用算术运算符联接或重复序列。
比较运算符(<,<=,>,>=,!=,==)也可用于序列。
可通过下标(test[1]),切片(test[1:3])和解包来访问序列的某部份。解包示例如下:
>>>s=1,2,3
>>>x,y,z=s
>>>print x,y,z
1,2,3in运算符可判断当有对象是否序列对象成员,如:
>>>list = [1,2,3]
>>>1 in list
1
>>>4 in list
0也可通过循环运算符对序列对象进行迭代操作。如:
for day in days:
print day
有关序列的处理函数请参考“python参考篇”相关内容,这里就不详细讲了。
字典是一个用大括号括起来的键值对,字典元素分为两部份,键(key)和值。字典是python中唯一内置映射数据类型。通过指定的键从字典访问值。如:
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方法,用来返回字典中定义的所有键和值。
和列表一样,字典也提供了对象方法来对字典进行操作。
可用内置的open()函数对文件进行操作。如:
input = open("test.txt")
for line in input.readlines():
print line
input.close()
Python把一块数据存储在对象中,变量是对象的唯一引用;它们是计算机内存中特殊地点的名字。所有对象都具有唯一的身份号、类型和值。对象的类型不会改变,对于可变类型而言,它的值是可变的。id(obj)函数可用于检索对象的身份,也就是内存中的对象的地址。
每个对象都包含引用计数器,它记录当前有多少个变量正在引用该对象。当给对象指定一个变量或使对象成为列表或其它包容器的成员时,引用计数就增加;当从包容器中撤消、重新分配或删除对象时,引用计数减少。当引用计数达到0值时(即没有任何变量引用这个对象),python的回收机制会自动回收它使用的内存。注意,del可用来删除变量,但不能删除对象。
通过给列表分配一个变量能创建对列表的引用,如果要创建列表的副本就要理解浅副本和深副本的概念。
列表或其他包容器对象的浅副本(Shallow)能够生成对象本身的副本,但也会创建对由列表包含的对象的引用。可用分片(object[:])和copy模块的copy(obj)函数创建。
列表或其他对象包容器对象的深副本能够生成对象本身的副本,并递归地生成所有子对象的副本。可用copy模块的deepcopy(obj)函数创建。
比较两种副本,一般情况下表现一样,但当列表内包含另一个列表的情况下,父列表的浅副本将包含对子列表引用,而不是独立副本。其结果是,当更改内部列表时,从父列表的两个副本中都可见,如:
>>> 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]]
如果是深副本,就不会出现这种情况。如:
>>> 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]]
可通过type(obj)函数标识数据类型,如:
>>> type(a)
<type 'list'>
>>> type(copy)
<type 'module'>
>>> type(1)
<type 'int'>
types模块包含Python的内置数据类型的类型对象。如:
>>> import types
>>> types.ListType
<type 'list'>
>>> types.IntType
<type 'int'>
数组对象与列表类似,但数组只包含某些类型的简单数据。所以当数据较简单,且要求性能好的情况下,使用数组是一个好的选择。
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 |
数组创建方法如下:
>>> import array
>>> z=array.array("b")
>>> z.append(1)
>>> z
array('b', [1])
数组的itemsize和typecode成员可分别检索数组项的大小和数组对象的类型代码,如:
>>> z.itemsize
1
>>> z.typecode
'b'
tolist()方法可把数组转换为列表,如:
>>> z.tolist()
[1, 2, 3]fromlist(list)方法可把列表项附加到数组的末尾,如:
>>> z.fromlist([10,11])
>>> z
array('b', [1, 2, 3, 10, 11])tostring()方法,可以把数组转换为字节的序列,如:
>>> z.tostring()
'/x01/x02/x03/n/x0b'fromstring(list)方法刚好与tostring()相反,它获取一个字节串,并把它们转换为数组的值。如:
>>> z.fromstring("/x0b")
>>> z
array('b', [1, 2, 3, 10, 11, 11])tofile(file)方法可把数组转换为字节的序列,并把它们写入文件,如:
>>> f=open("aa","wb")
>>> z.tofile(f)
>>> f.close()fromfile(file,count)方法用于从文件对象中读取特定数目的项,并把它们附加到数组中,如:
>>> z.fromfile(open("aa","rb"),2)
>>> z
array('b', [1, 2, 3, 10, 11, 11, 1, 2])当取数项大于文件数据项时,formfile会产生EOFError异常。
数组对象支持列表中的很多相同函数和方法:len,append等。访问成员的方法也可列表一样,可用下标和分片。
流程控制是程序设计中一个重要的内容,Python支持三种不同的控制结构:if,for和while。
if语句判断表达式是否为真,如果为真则执行指定语句。if语句的格式如下:
if EXPRESSION1:
STATEMENT1
elif EXPRESSION2:
STATEMENT2
else:
STATEMENT3如果第一个表达式为真,则执行statement1,否则进行进一步的测试,如果第二个表达式为真则执行statement2,否则执行statement3。
示例:
#!/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."
脚本的执行效果:
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进行循环控制,它对表达式进行测试,如果为真,则循环执行循环体。格式如下:
while EXPRESSION:
STATEMENT
else:
STATEMENT如果测试为假,则会执行else块。如果循环被中断(break),则else块不会执行。
示例:
>>> a = 0
>>> while a > 5:
... a = a + 1
... print a
... else:
... print "a's value is five"
...
1
2
3
4
5
a's value is fivefor循环可遍历对象,并可进行迭代操作。语名格式如下:
for TARGET in OBJECTS:
STATEMENT
else:
STATEMENT和while一样,在循环正常退出时,会执行else块。
示例:
>>> 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块的内容。
示例:
>>> mylist = ["zope","python","perl","Linux"]
>>> for technic in mylist:
... if technic == "perl":
... break
... else:
... print technic
...
zope
pythoncontinue语句会忽略后面的语句,强制进入下一次循环。
示例:
>>> mylist = ["zope","python","perl","Linux"]
>>> for technic in mylist:
... if technic == "perl":
... continue
... else:
... print technic
...
zope
python
Linuxpass不做任何事情。
示例:
>>> for technic in mylist:
... if technic == "perl":
... pass
... else:
... print technic
...
zope
python
Linux
Table of Contents
函数是一个能完成特定功能的代码块,可在程序中重复使用,减少程序的代码量和提高程序的执行效率。在python中函数定义语法如下:
def function_name(arg1,arg2[,...]):
statement
[return value]
函数名的命名规则:
函数名必须以下划线或字母开头,可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号;
函数名是区分大小写的。
函数名不能是保留字。
Python使用名称空间的概念存储对象,这个名称空间就是对象作用的区域, 不同对象存在于不同的作用域。下面是不同对象的作用域规则:
每个模块都有自已的全局作用域。
函数定义的对象属局部作用域,只在函数内有效,不会影响全局作用域中的对象。
赋值对象属局部作用域,除非使用global关键字进行声明。
LGB规则是Python查找名字的规则,下面是LGB规则:
大多数名字引用在三个作用域中查找:先局部(Local),次之全局(Global),再次之内置(Build-in)。
>>> a=2
>>> b=2
>>> def test(b):
... test=a*b
... return test
>>>print test(10)
20b在局部作用域中找到,a在全局作用域中找到。
如想在局部作用域中改变全局作用域的对象,必须使用global关键字。
#没用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'声明把赋值的名字映射到一个包含它的模块的作用域中。
函数的参数是函数与外部沟通的桥梁,它可接收外部传递过来的值。参数传递的规则如下:
在一个函数中对参数名赋值不影响调用者。
>>> a=1
>>> def test(a):
... a=a+1
... print a
...
>>> test(a)
2
>>> a
1 # a值不变在一个函数中改变一个可变的对象参数会影响调用者。
>>> 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值已被更改
参数是对象指针,无需定义传递的对象类型。如:
>>> def test(a,b):
... return a+b
...
>>> test(1,2) #数值型
3
>>> test("a","b") #字符型
'ab'
>>> test([12],[11]) #列表
[12, 11]
函数中的参数接收传递的值,参数可分默认参数,如:
def function(ARG=VALUE)
元组(Tuples)参数:
def function(*ARG)
字典(dictionary)参数:
def function(**ARG)
一些函数规则:
默认值必须在非默认参数之后;
在单个函数定义中,只能使用一个tuple参数(*ARG)和一个字典参数(**ARG)。
tuple参数必须在连接参数和默认参数之后。
字典参数必须在最后定义。
abs(x)
abs()返回一个数字的绝对值。如果给出复数,返回值就是该复数的模。
>>>print abs(-100)
100
>>>print abs(1+2j)
2.2360679775callable(object)
callable()函数用于测试对象是否可调用,如果可以则返回1(真);否则返回0(假)。可调用对象包括函数、方法、代码对象、类和已经定义了“调用”方法的类实例。
>>> a="123"
>>> print callable(a)
0
>>> print callable(chr)
1cmp(x,y)
cmp()函数比较x和y两个对象,并根据比较结果返回一个整数,如果x<y,则返回-1;如果x>y,则返回1,如果x==y则返回0。
>>>a=1
>>>b=2
>>>c=2
>>> print cmp(a,b)
-1
>>> print cmp(b,a)
1
>>> print cmp(b,c)
0divmod(x,y)
divmod(x,y)函数完成除法运算,返回商和余数。
>>> divmod(10,3)
(3, 1)
>>> divmod(9,3)
(3, 0)isinstance(object,class-or-type-or-tuple) -> bool
测试对象类型
>>> a='isinstance test'
>>> b=1234
>>> isinstance(a,str)
True
>>> isinstance(a,int)
False
>>> isinstance(b,str)
False
>>> isinstance(b,int)
Truelen(object) -> integer
len()函数返回字符串和序列的长度。
>>> len("aa")
2
>>> len([1,2])
2pow(x,y[,z])
pow()函数返回以x为底,y为指数的幂。如果给出z值,该函数就计算x的y次幂值被z取模的值。
>>> print pow(2,4)
16
>>> print pow(2,4,2)
0
>>> print pow(2.4,3)
13.824range([lower,]stop[,step])
range()函数可按参数生成连续的有序整数列表。
>>> 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值,则代表舍入到小数点后的位数。
>>> round(3.333)
3.0
>>> round(3)
3.0
>>> round(5.9)
6.0type(obj)
type()函数可返回对象的数据类型。
>>> type(a)
<type 'list'>
>>> type(copy)
<type 'module'>
>>> type(1)
<type 'int'>xrange([lower,]stop[,step])
xrange()函数与range()类似,但xrnage()并不创建列表,而是返回一个xrange对象,它的行为与列表相似,但是只在需要时才计算列表值,当列表很大时,这个特性能为我们节省内存。
>>> a=xrange(10)
>>> print a[0]
0
>>> print a[1]
1
>>> print a[2]
2
chr(i)
chr()函数返回ASCII码对应的字符串。
>>> print chr(65)
A
>>> print chr(66)
B
>>> print chr(65)+chr(66)
ABcomplex(real[,imaginary])
complex()函数可把字符串或数字转换为复数。
>>> complex("2+1j")
(2+1j)
>>> complex("2")
(2+0j)
>>> complex(2,1)
(2+1j)
>>> complex(2L,1)
(2+1j)float(x)
float()函数把一个数字或字符串转换成浮点数。
>>> float("12")
12.0
>>> float(12L)
12.0
>>> float(12.2)
12.199999999999999hex(x)
hex()函数可把整数转换成十六进制数。
>>> hex(16)
'0x10'
>>> hex(123)
'0x7b'long(x[,base])
long()函数把数字和字符串转换成长整数,base为可选的基数。
>>> long("123")
123L
>>> long(11)
11Llist(x)
list()函数可将序列对象转换成列表。如:
>>> 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为可选的基数。
>>> int(3.3)
3
>>> int(3L)
3
>>> int("13")
13
>>> int("14",15)
19min(x[,y,z...])
min()函数返回给定参数的最小值,参数可以为序列。
>>> min(1,2,3,4)
1
>>> min((1,2,3),(2,3,4))
(1, 2, 3)max(x[,y,z...])
max()函数返回给定参数的最大值,参数可以为序列。
>>> max(1,2,3,4)
4
>>> max((1,2,3),(2,3,4))
(2, 3, 4)oct(x)
oct()函数可把给出的整数转换成八进制数。
>>> oct(8)
'010'
>>> oct(123)
'0173'ord(x)
ord()函数返回一个字符串参数的ASCII码或Unicode值。
>>> ord("a")
97
>>> ord(u"a")
97str(obj)
str()函数把对象转换成可打印字符串。
>>> str("4")
'4'
>>> str(4)
'4'
>>> str(3+2j)
'(3+2j)'tuple(x)
tuple()函数把序列对象转换成tuple。
>>> tuple("hello world")
('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
>>> tuple([1,2,3,4])
(1, 2, 3, 4)
常用函数中的len()、max()和min()同样可用于序列。
filter(function,list)
调用filter()时,它会把一个函数应用于序列中的每个项,并返回该函数返回真值时的所有项,从而过滤掉返回假值的所有项。
>>> 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()函数把一个函数应用于序列中所有项,并返回一个列表。
>>> import string
>>> s=["python","zope","linux"]
>>> map(string.capitalize,s)
['Python', 'Zope', 'Linux']map()还可同时应用于多个列表。如:
>>> import operator
>>> s=[1,2,3]; t=[3,2,1]
>>> map(operator.mul,s,t) # s[i]*t[j]
[3, 4, 3]如果传递一个None值,而不是一个函数,则map()会把每个序列中的相应元素合并起来,并返回该元组。如:
>>> 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()函数获得序列中前两个项,并把它传递给提供的函数,获得结果后再取序列中的下一项,连同结果再传递给函数,以此类推,直到处理完所有项为止。
>>> 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
240zip(seq[,seq,...])
zip()函数可把两个或多个序列中的相应项合并在一起,并以元组的格式返回它们,在处理完最短序列中的所有项后就停止。
>>> zip([1,2,3],[4,5],[7,8,9])
[(1, 4, 7), (2, 5, 8)]如果参数是一个序列,则zip()会以一元组的格式返回每个项,如:
>>> zip((1,2,3,4,5))
[(1,), (2,), (3,), (4,), (5,)]
>>> zip([1,2,3,4,5])
[(1,), (2,), (3,), (4,), (5,)]