Python语句大全

　　泉州白癜风医院 http://pf.39.net/bdfyy/bdfjc/190525/7168769.html
表达式语句

语句分为简单语句和复合语句，简单语句由一个单独的逻辑行构成。多条简单语句可以存在于同一行内并以分号分隔。表达式语句属于简单语句。

表达式语句用于计算和写入值（大多是在交互模式下），或者调用一个过程(过程就是不返回有意义结果的函数。在Python中，过程的返回值为None)。

表达式语句会对指定的表达式进行求值。

在交互模式下，它会通过内置的repr()函数转换为一个字符串，该结果字符串将以单独一行的形式写入标准输出（例外情况是如果结果为None，则该过程调用不产生任何输出）。

以下均是一个表达式语句（可包含多个表达式）：

python

python

1

1

(a:=1)#3.8新功能，赋值表达式

1

a

1

a\n,fb{1}#两个表达式

(a\n,b1)

1+2*3/5,TrueandFalse#两个表达式

(2.2,False)

lambdax:x**2

function__main__.lambda(x)

0if23else(1if56else2)

1

[1,2,3]+[4]

[1,2,3,4]

[].append(1)#返回None

[].append(1)isNone

True

#返回值为None，输出并不是表达式的值print(非表达式的值)isNone

非表达式的值True

sum(iforiin[3,2,5])

10

list(zip(abc,[1,2,3]))[1:]

[(b,2),(c,3)]

用分号分隔多个表达式语句，输出最后一个的值。

1;print(非表达式的值);1+2*3/5,TrueandFalse

非表达式的值(2.2,False)赋值语句

赋值语句用于将名称绑定或重新绑定到特定值，以及修改属性或可变对象的成员项。

赋值语句使用赋值操作符和增强赋值操作符。详见操作符概述。

#将值1绑定到变量aa=1print(a=,a)#变量a重新绑定值aa=aprint(a=,a)

a=1a=a

同时进行多个值多个名称绑定，值和名称数量要相等：

#一个名称时，右边为元组a=1,2,3,4a

(1,2,3,4)

#多个名称a,b,c,d=1,[2,3],4,5fa={a},b={b},c={c},d={d}

a=1,b=[2,3],c=4,d=5

#可迭代对象拆包，则需要更多名称a,b,c,d,e=1,*[2,3],4,5fa={a},b={b},c={c},d={d},e={e}

a=1,b=2,c=3,d=4,e=5

赋值一般左右两边一一对应“同时”赋值，但赋值给变量的多项集时可能不一样（例如列表的某一项）：

x=[0,1]i=0i,x[i]=1,2fx={x},i={i}

x=[0,2],i=1

修改属性或可变对象的成员项：

#新增属性classA:x=1a=A()#右边的a.x是访问类属性#左边的a.x是新增实例属性,值为类属性值+1a.x=a.x+1a.x,A.x

(2,1)

#修改列表项a=[1,2,3]a[0]=[0,1]a

[[0,1],2,3]

#修改或新增字典项d={a:1}d[a]=10d[b]=2d

{a:10,b:2}

赋值操作符=，可以进行连续赋值，绑定多个名称，但赋值语句非表达式语句，不能被求值，因此不能被括号包围或分隔：

a=b=c=1a,b,c

(1,1,1)

a=(b=c=1)

File"ipython-input-40-5daee91ce",line1a=(b=c=1)^SyntaxError:invalidsyntax

不可变容器的增强赋值操作，是重新绑定对象；可变容器的增强赋值操作是增、删、改成员项：

s=print(id(s),s)#因为不可变，相当于新建了一个字符串4重新绑定ss+=4print(id(s),s)

823719591796324

l=[1,2,3]print(id(l),l)#可变，相当于在原列表l中增加元素4l+=[4]print(id(l),l)

2[1,2,3]2[1,2,3,4]

l=[1,2,3]print(id(l),l)l*=0#清空列表print(id(l),l)

8[1,2,3]8[]

s={1,2,3}print(id(s),s)s

={0}print(id(s),s)

0{1,2,3}0{0,1,2,3}

带标注的赋值语句。单个语句中将变量或属性标注和可选的赋值语句合为一体。标注对提高代码的可读性非常有用，看标注而不需要看代码上下文就大概知道代码的使用。

#标注函数参数的类型及默认值deff(n:int=1):print(Hi*n)f(2)

HiHi

name:str=小张name

小张if条件判断

if语句用于有条件的执行。语法如下：

ifassignment_expression:suiteelifassignment_expression:#可选子句suite...#可以多个elifelse:#可选子句suite

对于简单语句，可以写为一行，但不推荐。

它通过对表达式逐个求值直至找到一个真值。然后执行该if语句或子句体下的代码，从而if语句的其他部分不会被执行或求值。

如果所有表达式均为假值，else子句体如果存在就会被执行。

foriinrange(5):ifi%2==0:print(i)

foriinrange(5):ifi%2==0:print(i)

i,j=0,1ifi0:print(i)#不执行elifi==0:print(i)#执行，下面的则不再执行elifj==1:print(j)else:print(i,j)

0

i,j=0,1ifi0:print(i)#不执行elifi==1:print(i)#不执行elifj==0:print(j)#不执行else:print(i,j)#执行

01

多个if语句连用，则分别判断，互不影响：

i,j=0,1ifi0:print(i)#不执行else:print(i,j)#执行ifi==0:print(i)#执行ifj==1:print(j)#执行else:print(i,j)#不执行

for循环

for语句用于对可迭代对象中的元素进行迭代。语法如下：

fortarget_listinexpression_list:suiteelse:#可选子句suite

对于简单语句可以写为一行，但不推荐。

表达式expression_list被求值一次，它应该产生一个可迭代对象。系统将为expression_list的结果创建一个迭代器，然后每一项会按标准赋值规则（详见见赋值语句）被依次赋值给target_list，每赋值一次执行一次语句下的代码。

当所有项被耗尽时，else子句如果存在将会被执行，并终止循环。

foriinrange(3):print(i)

foriinzip(,abc):print(i)

(1,a)(2,b)(3,c)

fori,jinzip(,abc):print(f{i}-{j})else:print(end)

1-a2-b3-cend

for循环会对target_list中的变量进行赋值。这将覆盖之前对这些变量的所有赋值，包括在for循环体中的赋值。

变量在循环结束时不会被删除，但如果序列为空，则它们根本不会被循环所赋值。

i=aforiinrange(3):print(i)print(i)

2

foriinrange(0):print(i)print(i)

2while循环

while语句用于在表达式保持为真的情况下重复地执行。语法如下：

whileassignment_expression:suiteelse:#可选子句suite

对于简单语句可以写为一行，但不推荐。

这将重复地检验表达式，如果其值为真就执行其下的代码；表达式值为假则如果else子句存在就会被执行并终止循环。

i=0whilei3:print(i);i+=1

i=0whilei3:print(i)i+=1else:#i为3时执行print(fi={i})print(end)

i=3endbreak语句

break在语法上只会出现于for或while循环所嵌套的代码。

它会终结最近的外层循环，如果循环有可选的else子句，也会跳过该子句。

如果一个for循环被break所终结，该循环的控制变量会保持其当前值。

当break将控制流传出一个带有finally子句的try语句时，该finally子句会先被执行然后再真正离开该循环。

foriinrange(6):forjinrange(6):ifi**2==j:print(fi={i},j={j})print(fi={i},j={j})

i=0,j=0i=1,j=1i=2,j=4i=5,j=5

foriinrange(6):forjinrange(6):ifi**2==j:print(fi={i},j={j})breakprint(fi={i},j={j})

i=0,j=0i=5,j=0

foriinrange(6):forjinrange(6):ifi**2==j:print(fi={i},j={j})break#控制内层循环else:#不会执行print(fi={i},j={j})

i=0,j=0

foriinrange(6):forjinrange(6):ifi**2==j:print(fi={i},j={j})breakelse:#属于外层循环，会执行print(fi={i},j={j})

i=0,j=0i=5,j=0

foriinrange(5):try:print(f3/i={3/i})exceptZeroDivisionErrorase:print(e)finally:print(fi={i})

divisionbyzeroi=03/i=3.0i=13/i=1.5i=23/i=1.0i=33/i=0.75i=4

#引发异常直接跳过break#无异常则继续执行完finally才终止循环foriinrange(5):try:print(f3/i={3/i})breakexceptZeroDivisionErrorase:print(e)finally:print(fi={i})

divisionbyzeroi=03/i=3.0i=1continue语句

continue在语法上只会出现于for或while循环所嵌套的代码中。

它会继续执行最近的外层循环的下一个轮次，或者在没有下一轮次时转往else子句执行。

当continue将控制流传出一个带有finally子句的try语句时，该finally子句会先被执行然后再真正开始循环的下一个轮次。

foriinrange(3):forjinrange(3):ifj==1:print(fi={i},j={j})continue

i=0,j=1i=1,j=1i=2,j=1

foriinrange(3):forjinrange(3):ifj==2:print(fi={i},j={j})continueelse:#属于内层循环，每次内层循环结束都执行print(end)

i=0,j=2endi=1,j=2endi=2,j=2end

foriinrange(3):forjinrange(3):ifj==2:print(fi={i},j={j})continueelse:#属于外层循环，外层循环结束才执行print(end)

i=0,j=2i=1,j=2i=2,j=2end

#引发异常直接跳过continue#无异常则继续执行完finally才继续下一次循环foriinrange(3):try:print(f3/i={3/i})continueexceptZeroDivisionErrorase:print(e)finally:print(fi={i})print(i)#无异常时被跳过else:print(end)

divisionbyzeroi=/i=3.0i=13/i=1.5i=2enddel语句

del语句用来删除名称的绑定，删除对象的属性引用或删除可抽取、切片的可变容器的元素。

删除名称绑定：

#将值(1,2)绑定到名称a,b,ca=b=c=(1,2)#删除名称b,cdelb,ca

(1,2)

b#名称b已被删除

---------------------------------------------------------------------------NameErrorTraceback(mostrecentcalllast)ipython-input-27-c0ba25e7inmodule----1b#名称b已被删除NameError:namebisnotdefined

classA:x=y=1A.x,A.y

(1,1)

delA.yprint(A.x)A.y#属性名称y已被删除，不可引用值1

1---------------------------------------------------------------------------AttributeErrorTraceback(mostrecentcalllast)ipython-input-29-8ed1b3eb1inmodule1delA.y2print(A.x)----3A.y#属性名称y已被删除，不可引用值1AttributeError:typeobjectAhasnoattributey

#删除字典元素d={a:1,b:2}deld[a]#删除键为a的元素print(d)d[a]

{b:2}---------------------------------------------------------------------------KeyErrorTraceback(mostrecentcalllast)ipython-input-30-5d91af82einmodule3deld[a]#删除键为a的元素4print(d)----5d[a]KeyError:a

#删除列表切片_list=[1,2,3,4]del_list[::2]_list

[2,4]

#删除列表切片_list=[1,2,3,4]del_list[:]#相当于_list[:]=[]_list

[]pass语句

pass是一个空操作——当它被执行时，什么都不发生。

它适合当语法上需要一条语句但并不需要执行任何代码时用来临时占位，例如:

pass

#什么也不做的函数deff():pass#没有任何自定义属性的类classA:passdef定义函数

def语句是定义函数的语句。语法如下：

assignment_expressiondeffuncname(parameter_list)-expression:suite

其中的装饰器

assignment_expression，形参parameter_list和标注-expression是可选项。

函数定义是一条可执行语句。它执行时会将函数名称funcname绑定到一个函数对象（函数可执行代码的包装器）。

例如，用必选项定义一个什么也不做的函数如下：

deff():passf

function__main__.f()

一个函数定义可以被一个或多个装饰器表达式所包装。

装饰器必须是可调用对象，它会以该函数对象作为唯一参数被发起调用。

其返回值将被绑定到函数名称。多个装饰器会以嵌套方式被应用。

str

typedeff():passf

"classfunction"

大致相当于：

deff():passf=str(type(f))f

"classfunction"

函数形参parameter_list详见函数形参。

函数标注-expression可以是任何表达式，标注对提高代码的可读性非常有用，看标注而不需要看代码上下文就大概知道代码的使用。例如：

#标注函数的参数和返回值类型deff(arg:int)-list:returnlist(str(arg))f()

[1,2,3]return语句

return在语法上只会出现于函数定义所嵌套的代码，不会出现于类定义所嵌套的代码。

如果提供了表达式，它将被求值，否则以None替代（类似省略return语句结果）。

return会离开当前函数调用，并以表达式的值(或None)作为返回值。

当return将控制流传出一个带有finally子句的try语句时，该finally子句会先被执行然后再真正离开该函数。

deff2():x=1print(f2())

None

deff1():x=1returnprint(f1())

None

#return结束函数调用deff(x):returnx**2print(end)#retrun结束函数调用，不会被执行f(2)

4

#finally总是被执行再结束函数调用deff(x):try:return3/xexceptZeroDivisionErrorase:print(e)finally:returnx,x**2f(0),f(2)

divisionbyzero((0,0),(2,4))yield语句

yield语句，仅在定义生成器函数时使用，并且仅被用于生成器函数的函数体内部。语法如下：

yieldfromexpression

from和表达式expression是可选的，没有表达式默认是None。

yield语句整体也是一个可被求值的表达式语句，初始值也是默认None，可通过send方法设置yield表达式的值。

在函数定义中使用yield使得该定义创建的是生成器函数而非普通函数。当一个生成器函数被调用的时候，它返回一个生成器迭代器。

yieldfrom相当于将一个可迭代对象“拆包”，然后逐项被生成器迭代时使用。

#创建一个简单的生成器函数deff():yieldprint(f)#调用它获得一个生成器print(f())#next()函数迭代生成器获取表达式的值print(next(f()))

functionfat0xAgeneratorobjectfat0x6CB88None

#获取并设置yield语句的值deff(n):x=yieldnprint(x)g=f(1)print(next(g))#迭代结束，打印出yield语句x的初始值为Noneprint(next(g,end))

1Noneend

#可通过send方法设置当前yield表达式的值#并返回生成器产生的下一个值deff(n):x=yieldnprint(fyield表达式的值为:{x})n+=1yieldng=f(0)next(g),g.send(10)

yield表达式的值为:10(0,1)

deff(*args):yieldfromargsg=f(1,2,3)next(g),next(g),next(g),next(g,end)

(1,2,3,end)

deff(arg):yieldfromargg=f()next(g),next(g),next(g),next(g,end)

(1,2,3,end)class定义类

class语句用来定义类，语法如下：

assignment_expressionclassclassname(argument_list):suite

其中的装饰器

assignment_expression，基类参数及圆括号(argument_list)是可选项。

类定义是一条可执行语句。它执行时会将类名称classname绑定到一个新建的类对象。

没有继承基类参数argument_list的类默认继承自基类object。下列是一个必选参数定义的类，默认继承自object:

#创建一个类名为A的类classA:passA.__bases__#查看基类

(object,)

#创建一个类B继承自int和AclassB(int,A):passB.__bases__

(int,__main__.A)

类也可以被装饰，就像装饰函数一样，装饰器表达式的求值规则与函数装饰器相同（详见def定义函数）。结果随后会被绑定到类名称。

str

typeclassC:passC

"classtype"

大致相当于：

classC:passC=str(type(C))C

"classtype"try语句

try语句可为一组语句指定异常处理器和/或清理代码。语法结构有两种如下。

有try和except子句（可多个），以及可选的else和finally子句：

try:suiteexceptexpressionasidentifier:suiteelse:#可选suitefinally:#可选suite只有try和finally子句：

try:suitefinally:suite

except子句之后的表达式（通常为异常）expression，关键字as以及指定的别名identifier都是可选的。

当try子句中没有发生异常时，没有异常处理器会被执行。当try子句中发生异常时，将启动对异常处理器的搜索。此搜索会依次检查except子句，直至找到与该异常相匹配的子句。

except子句可指定一个或多个异常，如果与发生的异常“兼容”则该子句将匹配该异常。

指定的异常如果是发生的异常所属的类或基类，则该子句将匹配该异常；指定的异常可以置于一个元组，其中包含有与发生的异常“兼容”的异常，该子句将匹配该异常。

当一个异常完全未被处理时，解释器会终止程序的执行。

foriinrange(3):try:print(3/i)except(ZeroDivisionError,AssertionError)ase:print(e)

divisionbyzero3.01.5

foriinrange(3):try:print(3/i)exceptZeroDivisionError:print(fi={i}引发异常)

i=0引发异常3.01.5

foriinrange(3):print(3/i)

---------------------------------------------------------------------------ZeroDivisionErrorTraceback(mostrecentcalllast)ipython-input-5-ddbcfc1a1b1binmodule1foriinrange(3):----2print(3/i)ZeroDivisionError:divisionbyzero

如果存在无表达式的except子句，它必须是最后一个，它将匹配任何异常：

try:3/0exceptNameErrorasn:print(n)except:pass

如果没有except子句与异常相匹配，则会在周边代码和发起调用栈上继续搜索异常处理器，除非存在一个finally子句正好引发了另一个异常。新引发的异常将导致旧异常的丢失:

deff():try:return3/0exceptNameErrorasn:print(n)try:f()exceptZeroDivisionErrorasz:print(z)

divisionbyzero

deff():try:return3/0exceptNameErrorasn:print(n)finally:name1try:f()exceptZeroDivisionErrorasz:#该异常已丢失print(z)exceptNameErrorasn:print(n)

namename1isnotdefined

使用as将匹配的异常赋值给一个别名，才能在except子句之后引用它，并且它将在except子句结束时被清除：

foriinrange(3):try:print(3/i)except(ZeroDivisionError,AssertionError)ase:print(e)print(e)

divisionbyzero3.01.5---------------------------------------------------------------------------NameErrorTraceback(mostrecentcalllast)ipython-input-16-a87ebaccbinmodule4except(ZeroDivisionError,AssertionError)ase:5print(e)----6print(e)NameError:nameeisnotdefined

如果控制流离开try子句体时没有引发异常，并且没有执行return,continue或break语句，可选的else子句将被执行:

try:print(开始)except:print(捕获)else:print(结束)

开始结束

whileTrue:try:print(开始)breakexcept:print(捕获)else:print(结束)

开始

如果存在finally，它用来指定一个“清理”处理程序。try，except或else子句中发生任何未处理的异常，会被临时保存。finally始终被执行，被保存的异常，它会在finally子句执行后被重新引发：

try:print(3/0)except:name2else:#未被执行range(3)[5]finally:print(end)

end---------------------------------------------------------------------------ZeroDivisionErrorTraceback(mostrecentcalllast)ipython-input-24-7d6fe0dinmodule1try:----2print(3/0)3except:ZeroDivisionError:divisionbyzeroDuringhandlingoftheaboveexception,anotherexceptionoccurred:NameErrorTraceback(mostrecentcalllast)ipython-input-24-7d6fe0dinmodule2print(3/0)3except:----4name25else:#未被执行6range(3)[5]NameError:namename2isnotdefined

如果finally子句引发了另一个异常，被保存的异常会被设为新异常的上下文。如果finally子句执行了return,break或continue语句，则被保存的异常会被丢弃:

whileTrue:try:print(开始)except:print(捕获)else:range(3)[5]finally:print(3/0)

开始---------------------------------------------------------------------------IndexErrorTraceback(mostrecentcalllast)ipython-input-25-1fbfbdinmodule6else:----7range(3)[5]8finally:IndexError:rangeobjectindexoutofrangeDuringhandlingoftheaboveexception,anotherexceptionoccurred:ZeroDivisionErrorTraceback(mostrecentcalllast)ipython-input-25-1fbfbdinmodule7range(3)[5]8finally:----9print(3/0)ZeroDivisionError:divisionbyzero

whileTrue:try:print(开始)except:print(捕获)else:range(3)[5]finally:break

开始

当return,break或continue语句在finally语句之前被执行时，finally子语句也会‘在离开时’被执行:

whileTrue:try:print(开始)except:print(捕获)else:breakfinally:print(结束)

开始结束

deff():try:return开始finally:print(结束)f()#先执行finally再离开函数调用

结束开始raise语句

raise语句用来引发异常。语法如下：

raiseexpressionfromexpression

如果不带表达式，raise会重新引发当前作用域内最后一个激活的异常。如果当前作用域内没有激活的异常，将会引发RuntimeError来提示错误。

raise

---------------------------------------------------------------------------RuntimeErrorTraceback(mostrecentcalllast)ipython-input-1-9c9a2cba73bfinmodule----1raiseRuntimeError:Noactiveexceptiontoreraise

raise会将第一个表达式求值为异常对象。它必须为BaseException的子类或实例。如果它是一个类，当需要时会通过不带参数地实例化该类来获得异常的实例。

type(ZeroDivisionError)

type

raiseZeroDivisionError#无提示信息

---------------------------------------------------------------------------ZeroDivisionErrorTraceback(mostrecentcalllast)ipython-input-2-b08dcinmodule----1raiseZeroDivisionError#无提示信息ZeroDivisionError:

raiseZeroDivisionError(分母不能为0)#自定义提示信息

---------------------------------------------------------------------------ZeroDivisionErrorTraceback(mostrecentcalllast)ipython-input-17-b4accf1f2inmodule----1raiseZeroDivisionError(分母不能为0)#自定义提示信息ZeroDivisionError:分母不能为0

from子句用于异常串连：如果有该子句，则第二个表达式必须为另一个异常类或实例，它将被关联到所引发的异常:

raiseIndexError("索引错误")fromNameError(名称错误)

---------------------------------------------------------------------------NameErrorTraceback(mostrecentcalllast)NameError:名称错误Theaboveexceptionwasthedirectcauseofthefollowingexception:IndexErrorTraceback(mostrecentcalllast)ipython-input-18-f83b49e6finmodule----1raiseIndexError("索引错误")fromNameError(名称错误)IndexError:索引错误

try:print(1/0)exceptExceptionase:raiseRuntimeError("Somethingbadhappened")frome

---------------------------------------------------------------------------ZeroDivisionErrorTraceback(mostrecentcalllast)ipython-input-13-83aaca0b7e7finmodule1try:----2print(1/0)3exceptExceptionase:ZeroDivisionError:divisionbyzeroTheaboveexceptionwasthedirectcauseofthefollowingexception:RuntimeErrorTraceback(mostrecentcalllast)ipython-input-13-83aaca0b7e7finmodule2print(1/0)3exceptExceptionase:----4raiseRuntimeError("Somethingbadhappened")fromeRuntimeError:Somethingbadhappened

如果一个异常在异常处理器或finally中被引发，类似的机制会隐式地发挥作用：

try:print(1/0)except:raiseRuntimeError("Somethingbadhappened")

---------------------------------------------------------------------------ZeroDivisionErrorTraceback(mostrecentcalllast)ipython-input-16-c5c08e42inmodule1try:----2print(1/0)3except:ZeroDivisionError:divisionbyzeroDuringhandlingoftheaboveexception,anotherexceptionoccurred:RuntimeErrorTraceback(mostrecentcalllast)ipython-input-16-c5c08e42inmodule2print(1/0)3except:----4raiseRuntimeError("Somethingbadhappened")RuntimeError:Somethingbadhappened

try:print(1/0)finally:raiseRuntimeError("Somethingbadhappened")

---------------------------------------------------------------------------ZeroDivisionErrorTraceback(mostrecentcalllast)ipython-input-15-8bdb5ainmodule1try:----2print(1/0)3finally:ZeroDivisionError:divisionbyzeroDuringhandlingoftheaboveexception,anotherexceptionoccurred:RuntimeErrorTraceback(mostrecentcalllast)ipython-input-15-8bdb5ainmodule2print(1/0)3finally:----4raiseRuntimeError("Somethingbadhappened")RuntimeError:Somethingbadhappenedwith语句

with语句用于包装代码块的执行，代码块带有使用上下文管理器定义的函数或方法。语法如下：

withexpressionastarget,expressionastarget,...:suite

带有一个表达式expression的with语句的执行过程如下:

对上下文表达式求值以获得一个上下文管理器。载入上下文管理器的__enter__()以便后续使用。载入上下文管理器的__exit__()以便后续使用。发起调用上下文管理器的__enter__()方法。如果with语句中包含目标target，来自__enter__()的返回值将被赋值给它。执行语句体。发起调用上下文管理器的__exit__()方法。

with语句会保证如果__enter__()方法返回时未发生错误，则__exit__()将总是被调用。因此，如果在对目标赋值期间发生错误，则会将其视为在语句体内部发生的错误。

如果语句体的退出是由异常导致的，则其类型、值和回溯信息将被作为参数传递给__exit__()。否则的话，将提供三个None参数（相当于无异常地退出）。

如果语句体的退出是由异常导致的，并且来自__exit__()方法的返回值为真，则该异常会被抑制，并会继续执行with语句之后的语句。如果返回值为假，则该异常会被重新引发（__exit__()方法不应该重新引发被传入的异常，这是调用者的责任）。

如果语句体由于异常以外的任何原因退出，则来自__exit__()的返回值会被忽略，并会在该类退出正常的发生位置继续执行。

以下代码:

withEXPRESSIONasTARGET:SUITE

在语义上等价于:

manager=(EXPRESSION)enter=type(manager).__enter__exit=type(manager).__exit__value=enter(manager)hit_except=False#False表示正常执行try:TARGET=valueSUITEexcept:hit_except=True#发生了异常#忽略或抑制异常，继续退出；或退出并引发异常ifnotexit(manager,*sys.exc_info()):raisefinally:ifnothit_except:#正常执行#正常退出exit(manager,None,None,None)

可见使用with语句，无论有没有发生异常，都会“清理”程序（保存和恢复各种全局状态，锁定和解锁资源，关闭打开的文件等等）。

有多个表达式，则会视作存在多个with语句嵌套来处理多个上下文管理器:

withA()asa,B()asb:SUITE#在语义上等价于:withA()asa:withB()asb:SUITE

with语句常用来打开文件而不需要显式地关闭文件：

withopen(../11_built-in_function/test.txt,r,encoding=utf-8)asf:print(f.read())

xue.cn自学是门手艺

#相当于f=open(../11_built-in_function/test.txt,r,encoding=utf-8)print(f.read())f.close()

xue.cn自学是门手艺assert语句

assert语句是在程序中插入调试性断言的简便方式。在表达式条件为False的时候触发异常。

简单形式为：assertexpression。

assert1+1==2

assert1+1!=2

---------------------------------------------------------------------------AssertionErrorTraceback(mostrecentcalllast)ipython-input-2-5cd89e6dd50binmodule----1assert1+1!=2AssertionError:

扩展形式为：assertexpression1,expression2。expression2通常是提示信息。

assert1+1!=2,计算错误

---------------------------------------------------------------------------AssertionErrorTraceback(mostrecentcalllast)ipython-input-7-3b85a53ffinmodule----1assert1+1!=2,计算错误AssertionError:计算错误

foriinrange(5):try:asserti%2==0,f{i}是奇数print(i)exceptAssertionErrorasa:print(a)

01是奇数23是奇数4import导入语句

import语句用于从模块中导入子模块，类，函数等。语法大致有三种：

#第一种importmoduleasname,moduleasname,...#第二种#import之后可以置于一个元组frommoduleimportidentifierasname,identifierasname,...#第三种frommoduleimport*

模块module可以是高层级到低层级用属性表示法引用的模块，例如pandas.core.series。

as及其后的别名name是可选的。

语句可以导入单个或多个对象，用逗号分隔实际是多个子句。

第一种导入方法，如果成功获取到模块，则可以通过以下方式之一在import语句所在命名空间中使用它：

如果被导入模块是最高层级模块，模块名被绑定；如果导入的模块不是最高层级的模块，则该模块的最高层级模块名被绑定，该模块必须使用完整限定名访问；如果有as，则as之后的别名被绑定，模块名不绑定。

如果没有指定模块，引发ModuleNotFoundError。

importpandaspandas

modulepandasfromF:\\anaconda\\lib\\site-packages\\pandas\\__init__.py

delpandasimportpandas.core.seriespandas,pandas.core,pandas.core.series

(modulepandasfromF:\\anaconda\\lib\\site-packages\\pandas\\__init__.py,modulepandas.corefromF:\\anaconda\\lib\\site-packages\\pandas\\core\\__init__.py,modulepandas.core.seriesfromF:\\anaconda\\lib\\site-packages\\pandas\\core\\series.py)

series#必须完成限定名访问

---------------------------------------------------------------------------NameErrorTraceback(mostrecentcalllast)ipython-input-6-d6f2binmodule----1seriesNameError:nameseriesisnotdefined

delpandasimportpandas.core.seriesaspdspds

modulepandas.core.seriesfromF:\\anaconda\\lib\\site-packages\\pandas\\core\\series.py

pandas#只能使用别名访问

---------------------------------------------------------------------------NameErrorTraceback(mostrecentcalllast)ipython-input-8-b6dfbinmodule----1pandasNameError:namepandasisnotdefined

deff():importpandas#局部命名空间导入pandas#全局命名空间不能访问

---------------------------------------------------------------------------NameErrorTraceback(mostrecentcalllast)ipython-input-10-0b76dinmodule1deff():2importpandas#局部命名空间导入----3pandasNameError:namepandasisnotdefined

第二种导入方法，如果成功获取到模块，from之后的模块名不会被绑定，对于import子句导入的属性或子模块，如果有as子句，则只能使用其指定的别名使用它，否则使用该属性或子模块的名称identifier使用它。

如果属性或子模块不存在，或不能导入，引发ImportError。

frompandas.coreimportbasebase

modulepandas.core.basefromF:\\anaconda\\lib\\site-packages\\pandas\\core\\base.py

pandas.core#只导入了该模块下的子模块base

---------------------------------------------------------------------------NameErrorTraceback(mostrecentcalllast)ipython-input-2-de79a89inmodule----1pandas.coreNameError:namepandasisnotdefined

#导入多个可置于元组中fromrandomimport(randomasr1,randintasr2,)r1,r2

(functionRandom.random(),boundmethodRandom.randintofrandom.Randomobjectat0xEA)

#pandas下没有base，导入错误frompandasimportbase

---------------------------------------------------------------------------ImportErrorTraceback(mostrecentcalllast)ipython-input-7-cinmodule----1frompandasimportbaseImportError:cannotimportnamebasefrompandas(F:\anaconda\lib\site-packages\pandas\__init__.py)

第三种导入方法，则在模块中定义的全部公有名称都将绑定到import语句所在的命名空间。

公有名称是由在模块的命名空间中检测一个名为__all__的变量来确定的；如果__all__没有被定义，则公有名称的集合将包含模块的命名空间中找到的所有不以下划线字符_打头的名称。

fromrandomimport*randint

boundmethodRandom.randintofrandom.Randomobjectat0xE1DCC

当指定要导入哪个模块时，你不必指定模块的绝对名称。当一个模块或包被包含在另一个包之中时，可以在同一个最高层级包中进行相对导入，而不必提及包名称。

通过在from之后指定的模块或包中使用前缀点号，你可以在不指定确切名称的情况下指明在「当前包」层级结构中要上溯多少级。一个前缀点号表示是执行导入的模块所在的当前包，两个点号表示上溯一个包层级。三个点号表示上溯两级，依此类推。例如：

package/__init__.pysubpackage1/__init__.pymoduleX.pymoduleY.pysubpackage2/__init__.pymoduleZ.pymoduleA.py

假设当前位置是subpackage1/moduleX.py，则：

from.moduleYimportspamfrom.importmoduleYfrom..subpackage1importmoduleYfrom..subpackage2.moduleZimporteggsfrom..moduleAimportfoo

都是有效的。

global语句

global语句作用于整个当前代码块，它后面所列出的标识符将被解读为全局变量。

在global语句中列出的名称不得在同一代码块内该global语句之前的位置中使用。

当前的实现虽然并未强制要求，但在global语句中列出的名称不得被定义为正式形参，不也得出现于for循环的控制目标、class定义、函数定义、import语句或变量标注之中。

举例如下：

deff():a=0f()#调用函数，对a赋值a#a是局部变量，不可访问

---------------------------------------------------------------------------NameErrorTraceback(mostrecentcalllast)ipython-input-5-a24einmodule34f()#调用函数，对a赋值----5a#a是局部变量，不可访问NameError:nameaisnotdefined

deff():globala#将a声明为全局变量a=0f()#调用函数，对a赋值print(a)#a已经是全局变量dela

0

deff():a=1#同一代码块中，不可在global前使用globala#将a声明为全局变量a=0

File"ipython-input-9-51bceb42",line3globala#将a声明为全局变量^SyntaxError:nameaisassignedtobeforeglobaldeclaration

a=1#与global不在一个代码块deff():globala,b#将a,b声明为全局变量a=0#a被重新赋值b=1f()#调用函数，对b赋值，对a重新赋值print(a,b)dela,b

01nonlocal语句

nonlocal语句会使得所列出的名称指向在它之前「已经存在」的，「和它最近」并且「在包含它的作用域中绑定」，「除全局变量以外」的变量。

这种功能很重要，因为绑定的默认行为是先搜索局部命名空间。这个语句允许被封装的代码重新绑定局部作用域以外且非全局（模块）作用域当中的变量。

举例如下：

a=全局deff():a=f#f中已经存在的a,包含f2deff1():a=f1#f1中的局部变量deff2():nonlocala#和他最近且包含的是fa=f2deff3():globalaa=f3#调用f1不改变a=ff1()print(a)#调用f2,nonlocal将a=f重新绑定为a=f2f2()print(a)#调用f3,global将a声明为全局变量，#并将a=全局重新绑定为a=f3#但在f这个局部中，a仍然是f2f3()print(a)f()#调用f使绑定都生效print(a)

ff2f2f3

#不存在不可以绑定deff():nonlocalaa=1f()

File"ipython-input-3-ef",line2nonlocala^SyntaxError:nobindingfornonlocalafound

#不是包含它的作用域，不可以绑定deff():deff1():a=0f1()nonlocalaa=1f()

File"ipython-input-4-adb",line5nonlocala^SyntaxError:nobindingfornonlocalafound

#全局变量，不可以绑定a=0deff():nonlocalaa=1f()

File"ipython-input-5-c0b0eeb",line4nonlocala^SyntaxError:nobindingfornonlocalafound

打开《Python基础知识点自测手册》（

转载请注明：http://www.lwblm.com/bytj/12019.html