Python精要参考第二版.docx

《Python精要参考第二版.docx》由会员分享，可在线阅读，更多相关《Python精要参考第二版.docx（25页珍藏版）》请在冰豆网上搜索。

Python精要参考第二版

1.第一章　Python快速入门

本章是Python的快速入门，在这一章并不涉及python的特殊规则和细节，目标是通过示例使你快速了解Python语言的特点。

本章简要介绍了变量,表达式,控制流,函数以及输入/输出的基本概念,在这一章不涉及Python语言的高级特性。

尽管如此，有经验的程序员还是能够通过阅读本章的材料创建高级程序。

我们鼓励新手通过运行示例，亲身体验一把Python。

1.1.运行Python

Python程序通过解释器执行。

如果你的机器已经装好了python，简单的在命令行键入python即可运行python解释器。

在解释器运行的时，会有一个命令提示符>>>，在提示符后键入你的程序语句，键入的语句将会立即执行。

在下边的例子中，我们在>>>提示符后边键入最常见的显示"HelloWorld"的命令:

Python2.4.2（#67,Sep282005,12:

41:

11）[MSCv.131032bit（Intel）]onwin32

Type"copyright","credits"or"license（）"formoreinformation.

>>>print"HelloWorld"

HelloWorld

>>>

程序也可以像下面一样放置在一个文件中

#helloworld.py

print"HelloWorld"

Python源代码文件使用.py后缀.'#'表示注释（到行末结束）

执行文件helloworld.py

%pythonhelloworld.py

HelloWorld

%

在Windows下，只需双击一个.py文件就能执行这个python程序。

windows会自动调用python解释程序，然后启动一个终端窗口（类DOS窗口）来执行它。

在这种情况下,终端窗口会在程序执行完毕后立即关闭（经常是在你看到它的输出之前）。

为避免这个问题,你可以使用python集成开发环境,例如IDLE或Pythonwin。

另一个可行的方法是建立一个bat文件,在文件写入这样一行语句，如python-ihelloworld.py。

运行这个批处理，程序在执行完成后会自动进入python解释器。

在解释器中,也可以通过函数execfile（）来运行一个保存在磁盘上的程序,如下例:

>>>execfile（"helloworld.py"）

HelloWorld

在UNIX下,你可以在程序的首行写入#!

魔法字符串来自动调用python解释器执行你的脚本。

1.#!

/usr/local/bin/python

2.print"HelloWorld"

解释器会一直运行直到文件结束。

如果在交互模式下,键入EOF字符退出解释器。

在UNIX下,EOF字符是Ctrl+D;在Windows下,EOF字符是Ctrl+Z.也可以在程序中使用sys.exit（）函数或者通过引发SystemExit异常来退出程序:

1.>>>importsys

2.>>>sys.exit（）

或者

1.>>>raiseSystemExit

1.2.变量和表达式

通过Listing1.1所示的程序示例变量和表达式的用法

Listing1.1复利计算器（SimpleCompound-InterestCalculation）

1.principal=1000      #Initialamount（本金）

2.rate=0.05        #Interestrate（利率）

3.numyears=5        #Numberofyears（期数,年）

4.year=1

5.whileyear<=numyears:

6.      principal=principal*（1+rate）

7.      printyear,principal

8.      year+=1

程序输出:

11050.0

21102.5

31157.625

41215.50625

51276.2815625

Python是一种动态语言,在程序运行过程中，同一变量名可以（在程序运行的不同阶段）代表不同形式的值（整型,浮点,列表,元组...）。

事实上，程序中使用的变量名只是各种数据及对象的引用。

这与C语言不同,C语言中变量名代表的是用来存放结果的一个固定位置及长度的内存片段。

从例子Listing1.1中的变量principal可以看出Python语言的动态特性.最初,它被赋值为一个整数,但是稍后程序将它再次赋值:

principal=principal*（1+rate）

这个语句计算表达式的值，然后将计算结果赋给principal变量做为它的新值。

当赋值动作发生时,principal最初绑定的值1000被丢弃。

赋值结束，不但principal绑定的值发生了变化，它的类型也随着赋值动作发生了相应的变化。

在这个例子中，由于rate是一个浮点数,所以在赋值完成后,principal也变成一个浮点数。

Python中每个语句以换行结束,当然你也可以在一行中写多个语句，这时语句之间必须使用用分号分隔，就象下面这样:

principal=1000;rate=0.05;numyears=5;

（建议这样的写法仅仅用于调试语句，因为可以很方便的只删一行就删掉全部调试语句）

while语句首先检查在它后边的循环条件,若条件表达式为真,它就执行冒号后面的语句块，然后再次测试循环条件，直至为假。

冒号后面的缩近语句块为循环体。

注意，Python语言使用缩进块来表示程序逻辑（其它大多数语言使用大括号等）。

在Listing1.1中while语句后的三条语句为循环体，在每次循环中均执行。

Python并未指定缩进的空白（空格和制表符）数目，唯一的要求是同一层次的语句必须有相同的缩进空白。

（注意，要么都是空格，要是么都制表符，千万别混用）

Listing1.1中的程序美中不足的就是输出不是很好看，为了让它美观一点,可以用格式字符串将计算结果只保留小数点后两位：

1.print"%3d%0.2f"%（year,principal）

这样,程序的输出就变为:

11050.00

21102.50

31157.63

41215.51

51276.28

格式字符串包含普通文本及格式化字符序列（例如"%d","%s",和"%f"）,这些序列决定特定类型的数据（如整型,字符串,浮点数）的输出格式.'%3d'将一个整数在宽度为3个字符的栏中右对齐,'%0.2f'将一个浮点数的小数点后部分转换为2位。

格式字符串的作用和C语言中的sprintf（）函数基本相同。

详细内容请参阅第四章--操作符及表达式。

1.3.条件语句

if和else语句用来进行简单的测试，如:

1.#Computethemaximum（z）ofaandb（得到a与b中较大的一个）

2.ifa

3.      z=b

4.else:

5.      z=a

if和else的语句块用缩近来表示，else从句在某些情况下可以省略。

如果if或else语句块只有一个语句，也可以不使用缩近。

也就是说:

1.ifa

z=a

2.else:

z=b

这样的写法也是合法的，但这不是推荐的作法。

一直使用缩近可以让你方便的在语句体中添加一个语句，而且读起来更清晰。

若某个子句不需任何操作,就使用pass语句，如:

1.ifa

2.      pass    #Donothing

3.else:

4.      z=a

通过使用or,and和not关键字你可以建立任意的条件表达式:

1.ifb>=aandb<=c:

2.      print"bisbetweenaandc"

3.ifnot（bc）:

4.      print"bisstillbetweenaandc"

用elif语句可以检验多重条件（用于代替其它语言中的switch语句）:

1.ifa=='+':

2.      op=PLUS

3.elifa=='-':

4.      op=MINUS

5.elifa=='*':

6.      op=MULTIPLY

7.else:

8.      raiseRuntimeError,"Unknownoperator"

1.4.文件输入/输出

下面的程序打开一个文件,然后一行行地读出并显示文件内容:

1.f=open（"foo.txt"）      #Returnsafileobject

2.line=f.readline（）      #Invokesreadline（）methodonfile

3.whileline:

4.      printline,      #trailing','omitsnewlinecharacter

5.      line=f.readline（）

6.f.close（）

open（）函数返回一个新文件对象（fileobject）。

通过调用此对象的不同方法可以对文件进行不同的操作。

readline（）方法读取文件的一行（包括换行符'\n'）。

如果读到文件末尾，就返回一个空字符串。

要将程序的输出内容由屏幕重定向到文件中，可以使用'>>'运算符，如下例:

1.f=open（"out","w"）    #Openfileforwriting

2.whileyear<=numyears:

3.      principal=principal*（1+rate）

4.      print>>f,"%3d%0.2f"%（year,principal）  #将格式文本输出到文件对象f

5.      year+=1

6.f.close（）

当然,文件对象也拥有write（）方法，通过它可以向文件对象写入新的数据。

例如上边例子中的print的语句也可以写成这样:

f.write（"%3d  %0.2f\n"%（year,principal））

1.5.字符串

要创建一个字符串，你使用单引号,双引号或三引号将其引起来，如下例:

1.a='HelloWorld'

2.b="Pythonisgroovy"

3.c="""Whatisfootnote5?

"""

一个字符串用什么引号开头，就必须用什么引号结尾。

两上三引号之间的一切都作为字符串的内容,对应的单引号与双引号却只能创建单行字符串。

如下例：

1.print'''Content-type:

text/html

2.

3.

HelloWorld

4.Click

//www.python.org">here.

5.'''

字符串是一个以0开始，整数索引的字符序列,要获得字符串s中的第i+1个字符（别忘了0是第一个）,使用索引操作符s:

1.a="HelloWorld"

2.b=a[4]          #b='o'

要获得一个子串,使用切片运算符s[i:

j]。

它返回字符串s中从索引i（包括i）到j（不包括j）之间的子串。

若i被省略，python就认为i=0，若j被省略，python就认为j=len（s）-1:

1.c=a[0:

5]          #c="Hello"

2.d=a[6:

]          #d="World"

3.e=a[3:

8]          #e="loWo"

可以用加（+）运算符来连结字符串:

g=a+"Thisisatest"

通过使用str（）函数,repr（）函数或向后的引号（`）可以将其他类型的数据转换为字符串:

1.s="Thevalueofxis"+str（x）

2.s="Thevalueofyis"+repr（y）

3.s="Thevalueofyis"+`y`

repr（）函数用来取得对象的规范字符串表示，向后的引号（`）是repr（）函数的快捷版。

在大多情况下str（）和repr（）函数会返回同一个结果,但是它们之间有很微妙的差别,后边的章节对此将有详细描述。

1.6.列表和元组（Lists&Tuples）

就如同字符串是字符的序列,列表和元组则是任意对象的序列。

象下面这样就可以创建一个列表:

names=["Dave","Mark","Ann","Phil"]

列表和元组都是以整数0来开始索引的序列,你可以用索引操作符来读取或者修改列表中特定元素的值:

1.a=names[2]        #Returnsthethirditemofthelist,"Ann"

2.names[0]="Jeff"      #Changesthefirstitemto"Jeff"

用len（）函数得到列表的长度:

1.printlen（names）      #prints4

append（）方法可以把一个新元素插入列表的末尾:

1.names.append（"Kate"）

aList.insert（index,aMember）方法可以把新元素aMember插入到列表aList[index]元素之前:

1.names.insert（2,"Sydney"）

用切片操作符可以取出一个子列表或者对子列表重新赋值:

1.b=names[0:

2]              #Returns["Jeff","Mark"]

2.c=names[2:

]                #Returns["Sydney","Ann","Phil","Kate"]

3.names[1]='Jeff'            #Replacethe2nditeminnameswith"Jeff"

4.names[0:

2]=['Dave','Mark','Jeff']#用右边的list替换names列表中的前两个元素

加（+）运算符可以连结列表:

1.a=[1,2,3]+[4,5]    #Resultis[1,2,3,4,5]

列表元素可以是任意的Python对象,当然也包括列表:

1.a=[1,"Dave",3.14,["Mark",7,9,[100,101]],10]

子列表的元素用下面的方式调用:

1.a[1]        #Returns"Dave"

2.a[3][2]      #Returns9

3.a[3][3][1]    #Returns101

Listing1.2中代码从一个文件中读取一系列数字，然后输出其中的最大值和最小值。

通过这个示例我们可以了解到列表的一些高级特性：

Listing1.2列表的高级特性

1.importsys                #Loadthesysmodule（导入sys模块）

2.f=open（sys.argv[1]）        #Filenameonthecommandline（从命令行读取文件名）

3.svalues=f.readlines（）      #Readalllinesintoalist（读出所有行到一个列表）

4.f.close（）

5.

6.#Convertalloftheinputvaluesfromstringstofloats（把输入的值转换为浮点数）

7.fvalues=[float（s）forsinsvalues]

8.

9.#Printminandmaxvalues（输出最大值和最小值）

10.print"Theminimumvalueis",min（fvalues）

11.print"Themaximumvalueis",max（fvalues）

程序第一行用import语句从Pythonlibrary中导入sys模块。

你需要在命令行提供一个文件名给上面的程序，该文件名参数保存在sys.argv列表中，open方法通过读取sys.argv[1]得到这个文件名参数。

readlines（）方法读取文件中的所有的行到一个列表中。

表达式[float（s）forsinsvalues]通过循环列表svalues中的所有字符串并对每个元素运行函数float（）来建立一个新的列表,这种特殊的建立列表的方法叫做列表包含（listcomprehension）。

在列表中所有的字符串都转换为浮点数之后,内建函数min（）和max（）计算出列表中的最大值及最小值。

元组（tuple）类型和列表关系很密切,通过用圆括号中将一系列逗号分割的值括起来可以得到一个元组:

1.a=（1,4,5,-9,10）

2.b=（7,）                      #一个元素的元组（注意一定要加一个额外的逗号！

）

3.person=（first_name,last_name,phone）

在某些时候，即使没有圆括号,Python仍然可以根据上下文认出这是一个元组，如:

（为了写出更清晰可读的程序，建议你不要依赖Python的智能）

1.a=1,4,5,-9,10

2.b=7,

3.person=first_name,last_name,phone

元组支持大多数列表的操作,比如索引,切片和连结。

一个关键的不同是你不能在一个tuple创建之后修改它的内容。

也就是说,你不能修改其中的元素,也不能给tuple添加新的元素。

1.7.循环

通过使用while语句，我们在前面已经简单介绍了while循环。

在Python中另一种循环结构是for循环，它通过迭代一个序列（例如字符串,列表,或者tuple等）中的每个元素来建立循环。

下边是一个例子:

1.foriinrange（1,10）:

2.      print"2tothe%dpoweris%d"%（i,2**i）

range（i,j）函数建立一个整数序列,这个序列从第i数开始（包括i）到第j数为止（不包括j）。

若第一个数被省略，它将被认为是0。

该函数还可以有第三个参数，步进值，见下面的例子:

1.a=range（5）      #a=[0,1,2,3,4]

2.b=range（1,8）    #b=[1,2,3,4,5,6,7]

3.c=range（0,14,3）  #c=[0,3,6,9,12]

4.d=range（8,1,-1）  #d=[8,7,6,5,4,3,2]

for语句可以迭代任何类型的序列:

1.a="HelloWorld"

2.#Printoutthecharactersina

3.forcina:

4.      printc

5.b=["Dave","Mark","Ann","Phil"]

6.#Printoutthemembersofalist

7.fornameinb:

8.      printname

range（）函数根据起始值，终止值及步进值三个参数在内存中建立一个列表，当需要一个很大的列表时,这个既占内存又费时间。

为了克服它的缺点,Python提供了xrange（）函数:

1.foriinxrange（1,10）:

2.      print"2tothe%dpoweris%d"%（i,2**i）

3.

4.a=xrange（100000000）    #a=[0,1,2,...,99999999]

5.b=xrange（0,100000000,5）  #b=[0,5,10,...,99999995]

xrange（）函数只有在需要值时才临时通过计算提供值，这大大节省了内存。

1.8.字典

字典就是一个关联数组（或称为哈希表）。

它是一个通过关键字索引的对象的集合。

使用大括号{}来创建一个字典，如下例:

1.a={

2.    "username":

"beazley",

3.    "home":

"/home/beazley",

4.    "uid":

500

5.  }

用关键字索引操作符可以访问字典的某个特定值:

1.u=a["username"]

2.d=a["home"]

用下面的方式插入或者修改对象:

1.a["username"]="pxl"

2.a["home"]="/home/pxl"

3.a["shell"]="/usr/bin/tcsh"

尽管字符串是最常见的关键字（key）类型，你还是可以使用很多其它的python对象做为字典的关键字，比如数字和tuple，只要是不可修改对象，都可以用来做字典的key。

有些对象,例如列表和字典,不可以用来做字典的key,因为他们的内容是允许更改的。

我们可以使用has_key（）方法来检验一个键/值对是否存在（或者in操作符）:

1.ifa.has_key（"username"）:

2.    username=a["username"]

3.else:

4.    username="unknownuser"

上边的操作还可以用更简单的方法完成:

1.username=a.get（"username","unknownuser"）

字典的keys（）方法返回由所有关键字组成的列表:

1.k=a.keys（）      #k=["username"