python手册.docx

python手册.docx

《python手册.docx》由会员分享，可在线阅读，更多相关《python手册.docx（90页珍藏版）》请在冰豆网上搜索。

python手册

1.深入Python流程控制

1.1if语句

1.2for语句

1.3range（）函数

1.4break和continue语句,以及循环中的else子句

1.5pass语句

1.6定义函数

1.7深入Python函数定义

1.8插曲：

编码风格

2.数据结构

2.1关于列表list更多的内容

2.2del语句

2.3元组和序列

2.4集合

2.5字典

2.6循环技巧

2.7深入条件控制

2.8比较序列和其它类型

3.模块

3.1深入模块

3.2标准模块

3.3dir（）函数

3.4包

4.输入和输出

4.1格式化输出

4.2文件读写

5.错误和异常

5.1语法错误

5.2异常

5.3异常处理

5.4抛出异常

5.5用户自定义异常

5.6定义清理行为

5.7预定义清理行为

6.类

6.1术语相关

6.2Python作用域和命名空间

6.3初识类

6.4一些说明

6.5继承

6.6私有变量

6.7补充

6.8异常也是类

6.9迭代器

6.10生成器

6.11生成器表达式

7.Python标准库概览

7.1操作系统接口

7.2文件通配符

7.3命令行参数

7.4错误输出重定向和程序终止

7.5字符串正则匹配

7.6数学

7.7互联网访问

7.8日期和时间

7.9数据压缩

7.10性能度量

7.11质量控制

7.12“瑞士军刀”

8.标准库浏览–PartII

8.1.输出格式

8.2.模板

8.3.使用二进制数据记录布局

8.4.多线程

8.5.日志

8.6.弱引用

8.7.列表工具

8.8.十进制浮点数算法

9.虚拟环境和包

9.1.简介

9.2.创建虚拟环境

9.3.使用pip管理包

4.深入Python流程控制

除了前面介绍的 while 语句，Python还从其它语言借鉴了一些流程控制功能，并有所改变。

4.1. if 语句

也许最有名的是 if 语句。

例如:

>>>x=int（input（"Pleaseenteraninteger:

"））

Pleaseenteraninteger:

42

>>>ifx<0:

...x=0

...print（'Negativechangedtozero'）

...elifx==0:

...print（'Zero'）

...elifx==1:

...print（'Single'）

...else:

...print（'More'）

...

More

可能会有零到多个 elif 部分，else 是可选的。

关键字‘elif‘是’elseif’的缩写，这个可以有效地避免过深的缩进。

if ... elif ... elif ...序列用于替代其它语言中的 switch 或 case 语句。

4.2. for 语句

Python中的 for 语句和C或Pascal中的略有不同。

通常的循环可能会依据一个等差数值步进过程（如Pascal），或由用户来定义迭代步骤和中止条件（如C），Python的 for 语句依据任意序列（链表或字符串）中的子项，按它们在序列中的顺序来进行迭代。

例如（没有暗指）：

>>>#Measuresomestrings:

...words=['cat','window','defenestrate']

>>>forwinwords:

...print（w,len（w））

...

cat3

window6

defenestrate12

在迭代过程中修改迭代序列不安全（只有在使用链表这样的可变序列时才会有这样的情况）。

如果你想要修改你迭代的序列（例如，复制选择项），你可以迭代它的复本。

使用切割标识就可以很方便的做到这一点:

>>>forwinwords[:

]:

#Loopoveraslicecopyoftheentirelist.

...iflen（w）>6:

...words.insert（0,w）

...

>>>words

['defenestrate','cat','window','defenestrate']

4.3. range（） 函数

如果你需要一个数值序列，内置函数 range（） 会很方便，它生成一个等差级数链表:

>>>foriinrange（5）:

...print（i）

...

0

1

2

3

4

range（10） 生成了一个包含10个值的链表，它用链表的索引值填充了这个长度为10的列表，所生成的链表中不包括范围中的结束值。

也可以让 range（） 操作从另一个数值开始，或者可以指定一个不同的步进值（甚至是负数，有时这也被称为“步长”）:

range（5,10）

5through9

range（0,10,3）

0,3,6,9

range（-10,-100,-30）

-10,-40,-70

需要迭代链表索引的话，如下所示结合使用 range（） 和 len（）

>>>a=['Mary','had','a','little','lamb']

>>>foriinrange（len（a））:

...print（i,a[i]）

...

0Mary

1had

2a

3little

4lamb

不过，这种场合可以方便的使用 enumerate（），请参见 循环技巧。

如果你只是打印一个序列的话会发生奇怪的事情:

>>>print（range（10））

range（0,10）

在不同方面 range（） 函数返回的对象表现为它是一个列表，但事实上它并不是。

当你迭代它时，它是一个能够像期望的序列返回连续项的对象；但为了节省空间，它并不真正构造列表。

我们称此类对象是 可迭代的，即适合作为那些期望从某些东西中获得连续项直到结束的函数或结构的一个目标（参数）。

我们已经见过的 for 语句就是这样一个迭代器。

list（） 函数是另外一个（ 迭代器 ），它从可迭代（对象）中创建列表:

>>>list（range（5））

[0,1,2,3,4]

稍后我们会看到更多返回可迭代（对象）和以可迭代（对象）作为参数的函数。

4.4. break 和 continue 语句,以及循环中的 else 子句

break 语句和C中的类似，用于跳出最近的一级 for 或 while 循环。

循环可以有一个 else 子句；它在循环迭代完整个列表（对于 for ）或执行条件为false（对于 while ）时执行，但循环被 break 中止的情况下不会执行。

以下搜索素数的示例程序演示了这个子句:

>>>forninrange（2,10）:

...forxinrange（2,n）:

...ifn%x==0:

...print（n,'equals',x,'*',n//x）

...break

...else:

...#loopfellthroughwithoutfindingafactor

...print（n,'isaprimenumber'）

...

2isaprimenumber

3isaprimenumber

4equals2*2

5isaprimenumber

6equals2*3

7isaprimenumber

8equals2*4

9equals3*3

（Yes,这是正确的代码。

看仔细：

else 语句是属于 for 循环之中， 不是 if 语句。

）

与循环一起使用时，else 子句与 try 语句的 else 子句比与 if 语句的具有更多的共同点：

try 语句的 else 子句在未出现异常时运行，循环的 else 子句在未出现 break 时运行。

更多关于 try 语句和异常的内容，请参见 异常处理。

continue 语句是从C中借鉴来的，它表示循环继续执行下一次迭代:

>>>fornuminrange（2,10）:

...ifnum%2==0:

...print（"Foundanevennumber",num）

...continue

...print（"Foundanumber",num）

Foundanevennumber2

Foundanumber3

Foundanevennumber4

Foundanumber5

Foundanevennumber6

Foundanumber7

Foundanevennumber8

Foundanumber9

4.5. pass 语句

pass 语句什么也不做。

它用于那些语法上必须要有什么语句，但程序什么也不做的场合，例如:

>>>whileTrue:

...pass#Busy-waitforkeyboardinterrupt（Ctrl+C）

...

这通常用于创建最小结构的类:

>>>classMyEmptyClass:

...pass

...

另一方面，pass 可以在创建新代码时用来做函数或控制体的占位符。

可以让你在更抽象的级别上思考。

pass 可以默默的被忽视:

>>>definitlog（*args）:

...pass#Remembertoimplementthis!

...

4.6.定义函数

我们可以创建一个用来生成指定边界的斐波那契数列的函数:

>>>deffib（n）:

#writeFibonacciseriesupton

..."""PrintaFibonacciseriesupton."""

...a,b=0,1

...whilea

...print（a,end=''）

...a,b=b,a+b

...print（）

...

>>>#Nowcallthefunctionwejustdefined:

...fib（2000）

011235813213455891442333776109871597

关键字 def 引入了一个函数 定义。

在其后必须跟有函数名和包括形式参数的圆括号。

函数体语句从下一行开始，必须是缩进的。

函数体的第一行语句可以是可选的字符串文本，这个字符串是函数的文档字符串，或者称为 docstring。

（更多关于docstrings的信息请参考 文档字符串）有些工具通过docstrings自动生成在线的或可打印的文档，或者让用户通过代码交互浏览；在你的代码中包含docstrings是一个好的实践，让它成为习惯吧。

函数 调用 会为函数局部变量生成一个新的符号表。

确切的说，所有函数中的变量赋值都是将值存储在局部符号表。

变量引用首先在局部符号表中查找，然后是包含函数的局部符号表，然后是全局符号表，最后是内置名字表。

因此，全局变量不能在函数中直接赋值（除非用 global 语句命名），尽管他们可以被引用。

函数引用的实际参数在函数调用时引入局部符号表，因此，实参总是 传值调用 （这里的 值 总是一个对象引用，而不是该对象的值）。

[1] 一个函数被另一个函数调用时，一个新的局部符号表在调用过程中被创建。

一个函数定义会在当前符号表内引入函数名。

函数名指代的值（即函数体）有一个被Python解释器认定为 用户自定义函数 的类型。

这个值可以赋予其他的名字（即变量名），然后它也可以被当做函数使用。

这可以作为通用的重命名机制:

>>>fib

>>>f=fib

>>>f（100）

01123581321345589

如果你使用过其他语言，你可能会反对说：

fib 不是一个函数，而是一个方法，因为它并不返回任何值。

事实上，没有 return 语句的函数确实会返回一个值，虽然是一个相当令人厌烦的值（指None）。

这个值被称为 None （这是一个内建名称）。

如果 None 值是唯一被书写的值，那么在写的时候通常会被解释器忽略（即不输出任何内容）。

如果你确实想看到这个值的输出内容，请使用 print（） 函数:

>>>fib（0）

>>>print（fib（0））

None

定义一个返回斐波那契数列数字列表的函数，而不是打印它，是很简单的:

>>>deffib2（n）:

#returnFibonacciseriesupton

..."""ReturnalistcontainingtheFibonacciseriesupton."""

...result=[]

...a,b=0,1

...whilea

...result.append（a）#seebelow

...a,b=b,a+b

...returnresult

...

>>>f100=fib2（100）#callit

>>>f100#writetheresult

[0,1,1,2,3,5,8,13,21,34,55,89]

和以前一样，这个例子演示了一些新的Python功能：

∙return 语句从函数中返回一个值，不带表达式的 return 返回 None。

过程结束后也会返回 None。

∙语句 result.append（b） 称为链表对象 result 的一个 方法。

方法是一个“属于”某个对象的函数，它被命名为 obj.methodename，这里的 obj 是某个对象（可能是一个表达式）， methodename 是某个在该对象类型定义中的方法的命名。

不同的类型定义不同的方法。

不同类型可能有同样名字的方法，但不会混淆。

（当你定义自己的对象类型和方法时，可能会出现这种情况，class 的定义方法详见 类 ）。

示例中演示的 append（）方法由链表对象定义，它向链表中加入一个新元素。

在示例中它等同于 result = result + [a]，不过效率更高。

4.7.深入Python函数定义

在Python中，你也可以定义包含若干参数的函数。

这里有三种可用的形式，也可以混合使用。

默认参数值

最常用的一种形式是为一个或多个参数指定默认值。

这会创建一个可以使用比定义时允许的参数更少的参数调用的函数，例如:

defask_ok（prompt,retries=4,complaint='Yesorno,please!

'）:

whileTrue:

ok=input（prompt）

ifokin（'y','ye','yes'）:

returnTrue

ifokin（'n','no','nop','nope'）:

returnFalse

retries=retries-1

ifretries<0:

raiseOSError（'uncooperativeuser'）

print（complaint）

这个函数可以通过几种不同的方式调用:

∙只给出必要的参数:

ask_ok（'Do you really want to quit?

'）

∙给出一个可选的参数:

ask_ok（'OK to overwrite the file?

', 2）

∙或者给出所有的参数:

ask_ok（'OK to overwrite the file?

', 2, 'Come on, only yes or no!

'）

这个例子还介绍了 in 关键字。

它测定序列中是否包含某个确定的值。

默认值在函数 定义 作用域被解析，如下所示:

i=5

deff（arg=i）:

print（arg）

i=6

f（）

将会输出 5。

重要警告:

 默认值只被赋值一次。

这使得当默认值是可变对象时会有所不同，比如列表、字典或者大多数类的实例。

例如，下面的函数在后续调用过程中会累积（前面）传给它的参数:

deff（a,L=[]）:

L.append（a）

returnL

print（f

（1））

print（f

（2））

print（f（3））

这将输出:

[1]

[1,2]

[1,2,3]

如果你不想让默认值在后续调用中累积，你可以像下面一样定义函数:

deff（a,L=None）:

ifLisNone:

L=[]

L.append（a）

returnL

关键字参数

函数可以通过 关键字参数 的形式来调用，形如 keyword = value。

例如，以下的函数:

defparrot（voltage,state='astiff',action='voom',type='NorwegianBlue'）:

print（"--Thisparrotwouldn't",action,end=''）

print（"ifyouput",voltage,"voltsthroughit."）

print（"--Lovelyplumage,the",type）

print（"--It's",state,"!

"）

接受一个必选参数（voltage）以及三个可选参数（state, action,和 type）。

可以用以下的任一方法调用:

parrot（1000）#1positionalargument

parrot（voltage=1000）#1keywordargument

parrot（voltage=1000000,action='VOOOOOM'）#2keywordarguments

parrot（action='VOOOOOM',voltage=1000000）#2keywordarguments

parrot（'amillion','bereftoflife','jump'）#3positionalarguments

parrot（'athousand',state='pushingupthedaisies'）#1positional,1keyword

不过以下几种调用是无效的:

parrot（）#requiredargumentmissing

parrot（voltage=5.0,'dead'）#non-keywordargumentafterakeywordargument

parrot（110,voltage=220）#duplicatevalueforthesameargument

parrot（actor='JohnCleese'）#unknownkeywordargument

在函数调用中，关键字的参数必须跟随在位置参数的后面。

传递的所有关键字参数必须与函数接受的某个参数相匹配（例如 actor 不是 parrot 函数的有效参数），它们的顺序并不重要。

这也包括非可选参数（例如 parrot（voltage=1000） 也是有效的）。

任何参数都不可以多次赋值。

下面的示例由于这种限制将失败:

>>>deffunction（a）:

...pass

...

>>>function（0,a=0）

Traceback（mostrecentcalllast）:

File"",line1,in?

TypeError:

function（）gotmultiplevaluesforkeywordargument'a'

引入一个形如 **name 的参数时，它接收一个字典（参见 MappingTypes—dict ），该字典包含了所有未出现在形式参数列表中的关键字参数。

这里可能还会组合使用一个形如 *name （下一小节详细介绍）的形式参数，它接收一个元组（下一节中会详细介绍），包含了所有没有出现在形式参数列表中的参数值（ *name 必须在 **name 之前出现）。

例如，我们这样定义一个函数:

defcheeseshop（kind,*arguments,**keywords）:

print（"--Doyouhaveany",kind,"?

"）

print（"--I'msorry,we'realloutof",kind）

forarginarguments:

print（arg）

print（"-"*40）

keys=sorted（keywords.keys（））

forkwinkeys:

print（kw,":

",keywords[kw]）

它可以像这样调用:

cheeseshop（"Limburger","It'sveryrunny,sir.",

"It'sreallyvery,VERYrunny,sir.",

shopkeeper="MichaelPalin",

client="JohnCleese",

sketch="CheeseShopSketch"）

当然它会按如下内容打印:

--DoyouhaveanyLimburger?

--I'msorry,we'realloutofLimburger

It'sveryrunny,sir.

It'sreallyvery,VERYrunny,sir.

----------------------------------------

client:

JohnCleese

shopkeeper:

MichaelPalin

sketch:

CheeseShopSketch

注意在打印关键字参数之前，通过对关键字字典 keys（） 方法的结果进行排序，生成了关键字参数名的列表；如果不这样做，打印出来的参数的顺序是未定义的。

可变参数列表

最后，一个最不常用的选择是可以让函数调用可变个数的参数。

这些参数被包装进一个元组（参见 元组和序列 ）。

在这些可变个数的参数之前，可以有零到多个普通的参数:

defwrite_multiple_items（file,separator,*args）:

file.write（separator.join（args））

通常，这些 可变 参数是参数列