Python2.3-原理之语句和语法

此节来自于《Python学习手册第四版》第三部分

一、python语句简介(第10章)

   1、首先记得一个概念:a、程序由模块构成;b、模块包含语句;c、语句包含表达式;d、表达式建立并处理对象。python的语法是由语句和表达式组成,表达式处理对象并嵌套在语句中,语句编码实现程序操作中更大的逻辑关系,语句是对象生成的地方,有些语句会完全生成新的对象类型(函数、类)。语句总是存在于模块中,而模块本身则又是由语句来管理的。

    2、下面是一个python的语句表:




a、赋值语句以不同的语法形式呈现,例如:基本的、序列的、扩展的等等;b、print在3.0中不是一个保留字,也不是一条语句,而是一个内置的函数调用,因为总是自己单独一行,通常将其看作是一条语句类型;c、yield实际上是一个表达式,而不是一条语句,他通常单独用在一行,所以它包含在上表中,但是脚本偶尔会赋值惑使用其结果,与print不同,作为一个表达式,yield也是一个保留字。

    3、上表中大多数也适用于2.6,不过如果使用2.6或者更早的版本注意:a、nonlocal不可用;b、print是一条语句,不是内置函数;c、3.0的exec代码执行内置函数是一条语句,具有特定的语法;因为它支持带有圆括号的形式,通常在2.6中使用其3.0的调用形式;d、2.5中try/except和try/finally语句合并了;即用谁都行;e、whit/as是一个可选的扩展,并且通常它是不可用的,除非你通过运行__future__import with_statement来打开它。

    4、在c系列中判别表达式需要圆括号括起来(x>y),而且语句需要用大括号{}括起来;而在python中在使用冒号:代替,而且无需花括号,一般首行以冒号结尾,下一行嵌套的代码按缩进的格式书写:

在python中:a、括号是可选的,比如if(x>y)写成 if  x>Y;b、在python中不会出现的语法成分就是分号,一行结束就结束了(这个观点是好,是坏不评论,我是喜欢分号的);c、缩进结束就是代码块的结束,不需要和c语言一样,输入大括号,或者和matlab等一样输入begin/end,then/endif,在python中,是靠缩进来确定代码块的开头和结尾的,python不在乎缩进的方式和距离,只知道一个单独的嵌套块中所有的语句都必须缩进在相同的距离,不然会报错。

    5、在上述4中 python还是有几个特例的:a、虽然很多时候是一行一个,但是也有一行多个的,这时候中间用分号隔开,作为语句界定符:a = 1;b = 2;print(a+b),不过这三个不能是复合语句,必须是简单语句,比如赋值操作,打印和函数调用等等;b、上面是一行多个,这里是多行一个,在括号(),方括号【】和字典的大括号{},这几个中程序的代码可以横跨好几行:

在不用这三个括号的时候,还有个方法:

(这个方法不推荐)。而且对于当行的语句可以跟在比如if x>Y:print(X).

    6、在需要写一个标准的“读取、计算、打印”的循环程序:在python中交互式循环的典型模版代码可能如下图:


while是最通用的循环语句;input用于通用控制台输出,打印可选的参数字符串作为提示,并返回用户输入的回复字符串;用了嵌套代码块中特殊的单行if语句;break跳出循环。

    7、用测试输入数据来处理错误,来个例子if语句避免错误导致的异常:



    8、用try语句处理上面的错误:


在try后面跟着的是代码主要代码块(我们尝试运行的代码),再跟except部分,给异常处理器代码,再接else部分,如果try部分没有异常,就执行这一部分代码。Python会先执行try部分,然后运行except部分(如果有异常发生)或else部分(如果没有异常发生),这里else是和try结合,不是和if结合。

    9、嵌套代码三层:


这个代码while包含一个if-elif-else 其中else包含一个if-else。之后while外部在加了一个print().

二、赋值、表达式和打印(第11章)

    赋值:(前面说过了,其实本书真的和知乎上说的一样,好啰嗦,1162页很多都是在啰嗦):a、赋值语句建立对象引用值;b、变量名在首次赋值时会被创建;c、变量名在引用前必须被赋值;d、执行隐式赋值的一些操作。赋值语句的形式如下图:


上面第五行,是将右边字符串的第一个字母来匹配a,用剩下的部分来匹配b:也就是a赋值为‘s’,b赋值为‘pam’。

    1、元组赋值语句可以在不建立零时变量的时候进行变量互换,比如:nudge = 1;wink = 2;  >>>A,B = nudge,wink;或者>>>[C,D] = [nudge,wink];互换可以这样>>>nudge,wink = wink,nudge。在python中原始的元组和列表赋值语句形式,最后已被通用化,右侧可以是任何类型的序列,只要长度相等就行,例如下面的:


不过其实序列赋值语句实际上支持右侧任何可迭代的对象,而不仅局限于任何序列,这是更为通用的概念。不过想要更通用,可以使用分片例如:



或者低端的使用for循环来进行循环赋值:


序列解包赋值语句也会产生另一种python常见的用法:



    2、在3.0的扩展序列解包中,序列赋值变得更为通用,从而使这一过程变得容易,一个带有单个星号的名称,可以在赋值目标中使用,以指定对序列的一个更为通用的匹配--一个列表付给了带星号的名称,该列表收集了序列中没有赋值给其他名称的所有项;

 

 

这种扩展的序列解包语法对于任何序列类型都是有效的,而不只是针对列表有效,比如>>>a,*b='spam';或者>>>a,*b,c = 'spam';在扩展的序列解包中,一些边界情况值得注意,如果在分配不够的时候带星号的名称可能只匹配单个的项,但是总会向其赋值一个列表:,其次如果没有剩下的内容给带星号的,那么就会赋值一个空的列表给他,而不管该名称出现在哪:

 


不过如果有多个带星号的名称,或者如果值少了,而没有带星号的名称(像前面一样),以及如果带星号的名称自身没有边写到一个列表中,都将会引发错误:

>>>a,*b,c,*d = seq;>>>a,b = seq;>>>*a = seq;这三个都是错的;>>>*a, = seq这个加了逗号,表明就是一个列表 结果就是a = [1,2,3,4];

    3、这里一个有用的便利形式,不过说必须在python 2.X中使用,所以这里略

    4、在3.0中,扩展赋值可能出现在单词for之后,而更常见的用法就是一个简单的变量名称:

结果就是a,*b,c = (1,2,3,4);*b = [2,3];或者在2.6中用下面的形式来模拟:

    5、多目标赋值:a=b=c='spam',这里三个变量但是共享一个对象,不过如果对>>>a=b=0; >>>b = b+1;这样,a和b是两个对象,因为数字或者字符串是不能更改的,所以赋值之后b得到的是一个新的对象,而不是原对象;不过将变量初始值设为空的可变对象时(列表或者字典),就要小心了:

 

所以如果是可变对象的,最好单独初始化。

    6、增强赋值语句,从c语言中借鉴过来的:

如果需要增加单个元素到列表末尾时,可以合并或调用append,不过要把一组元素增加到末尾,可以再次使用合并,或者调用列表的extend方法:

 

这两种情况下,合并对共享对象引用产生的副作用可能会更小,不过会比对等的原处形式运行的更慢,合并操作是创建一个新的对象,将左侧的复制到列表中,然后右侧的复制到列表中,而原处方法调用就是直接在一个内存快末尾添加项。不过在使用增强赋值语句来扩展列表时,python会自动调用较快的extend方法,而不是较慢的“+”合并运算,所以“+=”是隐含了对列表进行原处处理的。就所有的共享引用情况而言,只有其他变量名引用的对象被修改,其差别才可能体现出来:

 

这只对列表和字典这类可变对象才重要,而且是相当罕见的情况(至少,直到影响程序代码时才算),所以如果不想被默认的共享引用值,那么就对可变对象进行拷贝。

    7、变量命名规则:a、语法:(下划线或字母)+(任意数目的字母、数字或下划线);b、区分大小写;c、禁止使用保留字:


上表是针对3.0的,2.6的略有不同:print是保留字,exec是保留字,nonlocal不是保留字,更早的就略P305页。大多数的python保留字都是小写的,不过后续介绍的内置作用域中的变量名不同。因为import语句中的模块变量名会变成脚本中的变量,这种限制也会扩展到模块的文件名:比如可以写and.py和my-code.py这类的文件,但是没法导入,因为其变量名没有“.py”扩展名时,就会变成代码中的变量,就会与保留字冲突了。ps:在Jpython版的python实现中,用户定义的变量名偶尔可以和python的保留字相同。

命名惯例:这些不是必须的,不过实际上通常大家都会遵守,a、以单一下划线开头的变量名(_X)不会被from module import *语句导入(22章说明);b、前后有下划线的变量名(__X__)是系统定义的变量名,对解释器有特殊意义;c、以两个下划线开头,但结尾没有两个下划线的变量名(__X)是类的本地变量(30章说明);d、通过交互模式运行时,只有单个下划线的变量名(_)会保存最后表达式的结果。还有一些比如类变量名通常以一个大写字母开头,而模块变量名以小写字母开头,此外,变量名self虽然并非保留字,但在类中一般都有特殊的角色,在第17章中会有接着讲解,涉及到内置变量名,这些是预先定义的变量名,但并非保留字。更多信息可以通过搜索“Python PEP 8”。

    8、通常在下面两种情况下表达式用作语句:a、调用函数和方法;b、在交互模式提示符下打印值,下表是一些常见的表达式语句的形式,函数和方法的调用写在函数、方法变量名后的括号中,具有零个或多个参数的对象(这就是计算对象的表达式):


上表最后两条是特殊的,在3.0中,打印是一个函数调用而通常独自边写一行,并且生成器函数中的yield操作通常也编写为一条语句,二者都只是表达式语句的实际例子。

    9、对于初学者来说经常犯得错误就是>>>L = L.append(X)这样,可是得到的结果是L= None,因为对列表调用append、sort或reverse这类在原处的修改的运算,一定是对列表做原处的修改,但是这些方法在修改之后,不会把列表返回,而是返回None。

    10、python中打印与文件和流的概念紧密相连:a、文件对象方法,第九章说了一些写入文件的文件对象方法(如;file.write(str)),文件写入方法是将字符串写入到任意文件,print默认把对象打印到stdout流,添加一些自动的格式化,和文件方法不同,在使用打印操作的时候,不需要将对象转换成字符串;b、标准输出流,在python中可以作为内置的sys模块中的stdout文件对象使用(如sys.stdout),使得用文件的写入方法调用来模拟print成为可能,不过print很容易使用,所以很容易将文本打印到其他流或文件。

    11、在3.0中print函数的形式为:

,方括号是可选的,=后面的值都给了参数的默认值,这个内置函数将字符串sep所分隔开的一个或多个对象的文本表示,后面跟着字符串end,都打印到流file中。sep、end和file如果都给出的话,必须作为关键字参数给定,使用“name=value”语法来根据名称而不是位置来传递参数(18章深入介绍):a、sep是在每个对象的文本间插入一个字符串,默认是一个单个空格,传递一个空字符串将会抑制分隔符;b、end是添加在打印文本末尾的一个字符串,默认是\n换行符,传递一个空字符串将会避免在打印的文本末尾移动到下一个输入行----下一个print将会保持添加到当前输出行的末尾;c、file指定了文本将要发送到的文件、标准留或者其他类似文件的对象;默认是sys.stdout,带有一个类似文件的write(string)方法的任何对象都可以传递,但真正的文件应该已经为了输出而打开。

    12、在3.0中print可能要更简单一些,下面就是个例子:

右边的就是通过将sep赋值来进行分隔符的处理

 


上图中是对end赋值和对sep混合赋值,至少一点,这些都要在参数之后。


如果想要更具体的格式,不要这样,还是按照之前的字符串格式化,然后一次性打印

    13、print语句只是python的人性化的特性,提供了sys.stdout对象的简单接口,再加上一些默认的格式设置,复杂点可以如下:


这段程序调用了sys.stdout的write方法,通常来说print和sys.stdout的关系如下:print(X,Y)等价于>>>import sys;>>>sys.stdout.write(str(X)+‘ ’+str(Y)+‘\n');后者更复杂,不过后者也更灵活,例如:

这里我们把sys.stdout重设成已打开的文件对象(附加模式)。重设之后,程序中任何print语句都会将结果写道文件log.txt的末尾,而不是原始的输出流。甚至可以将sys.stdout重设为非文件的对象,只要该对象有预期的协议(write方法)。当该对象是类时,打印的文字可以定位并通过任意方式进行处理。

    14、那么如何保存原来的输出流使得在打印完文件之后可以切换回来,在2.6和3.0中,可以使用sys模块中的__stdout__属性,这也就是程序启动时sys.stdout的原始值。不过,等修改之后还是需要将sys.stdout恢复成sys.__stdout__从而回到原始流的值:


上图可以看出这样一个print扩展功能有时候会很多余,在3.0中file关键字允许一个单个的print调用将其文本发送给一个文件的write方法,而不用真正的重设sys.stdout,这种设定是暂时的,普通的print还是会接着打印到原始输出流的。(2.6中是用print >> log,x,y,z;这里的log是“log.txt”)。

    15、上面的是和版本相关的打印,这里介绍下版本独立的打印:如果写的是2.6的print语句,那么使用3.0中的2to3转换脚本来在3.0中调用。或者可以在2.6的代码中写3.0的print函数,通过下面的语句支持该函数调用的变体:

这条语句将2.6修改为支持3.0的print函数,如果需要真的可移植,那么就把打印字符串格式化为一个单个的对象,使用字符串格式化表达式或者方法调用:


    16、print和sys.stdout之间等效,print语句只是传送文本给sys.stdout.write方法而已,例如可以传送打印的文字给GUI窗口,或者定义一个有write方法的对象,他会做所需要的发送工作,后面介绍类的时候会有这种技巧:


上述代码可以工作是因为print是一种多态运算:sys.stdout重要的是有个方法(接口)称为write:


print内置的raw_input()函数会从sys.stdout文件读入。ps:因为打印的文字进入stdout流,这也是在CGI脚本中打印HTML的方式,这也可以在os中用shell语法形式实现:


三、if测试和语法规则  (第12章)

     python中的if功能差不多:

,

,

    1、在python中没有switch或case语句,在python中多路分支是写成一系列的if/elif测试的,或者对字典进行索引运算或搜索列表:


因为在if系列中有个默认选项,而在字典中也可以使用get来实现:


    2、python中的语法规则:python都有简单的和基于语句的语法,不过有些特性还是需要知道的:a、语句是逐个运行的,除非不这样写,if这种会影响流程的叫做控制流程语句;b、块和语句的边界会自动检测;c、复合语句 = 首行+“:”+缩进语句,复合语句都遵循相同的格式:首行以冒号终止,再第二行接一个或多个嵌套语句,通常都是在首行下缩进的,缩进的语句叫做块(组);d、空白行、空格以及注释通常都会忽略;e、文档字符串(docstring)会忽略,但会保持并由工具显示:与#注释不同,文档字符串会在运行时保留下来以便查看,文档字符串只出现在程序文件和一些语句顶端的字符串中,虽然python会忽略这些内容,不过在运行时会自动将其附在对象上,而且可以由文档工具显示。

   3、一般来说python的语句没法跨行,不过:a、使用如(),【】,{}这类括号就可以跨行;b、反斜线结尾;c、字符串的三重引号字符串块,相邻的字符串常量可以隐式的连接起来;d、其他规则,比如分号可以把多行放在一行。

    4、如这个括号:

,括号内可以存放表达式、函数参数、函数的首行、元组和生成器表达式,以及可以放到花括号中的任何内容(字典以及3.0中的集合常量、集合和字典解析)等内容。

     5、python的布尔运算符和c这类的布尔运算服有些不同,在python中:a、任何非零数字或非空对象都为真;b、数字零、空对象以及特殊对象None都被认为是假;c、比较和相等测试会递归地应用在数据结构中;d、比较和相等测试会返回True或False;e、布尔and和or运算符会返回真或假的操作对象。:X and Y ;X or Y ; not X。

    6、在python中布尔and 和or 返回的是真或假的对象,而不是True或False:or测试中从左到右进行计算对象,返回第一个真的操作对象,如果or两边都是假,那么返回第二个;and测试中从左到右进行计算对象,返回第一个假的对象:


    7、if/else的三元表达式,就例如CPP中的?:三元表达式一样:

当X为真的时候执行Y,当X为假的时候执行Z。而且在python中使用下列表达式也是类似的,因为bool函数会把X转换成对应的整数1或0。然后就能用于从一个列表中挑选真假值:

;举例:


    8、

这两个就是or的好处,可以用来做选择一个固定大小集合中非空的对象,不过因为or的截断操作,左右两边是函数的话,提前执行,然后比较结果,不要直接比较函数;表达式((A and B)or C)即总是可以用来模拟if/else语句。ps在后面的运算符重载部分,当我们用类定义新的对象类型的时候,可以用_bool_或_len_方法指定其布尔特性(2.6中叫做_nonzero_).

四、while和for循环(第13章)

    while语句是python语句中最通用的迭代结构,简而言之,只要顶端测试一直计算到真值,就会一直执行下面的语句块,格式为:


    1、break,略;continue,略;pass,什么事也不做,只是占位置;else,只有当循环正常离开时才会执行(也就是之前没遇到break):


对于pass来说,在3.0中允许在可以使用表达式的任何地方使用...(三个连续的点)来省略代码,因为省略号什么也不做,可以当作pass语句的一种替代方案。

    2、因为在python中赋值语句只是语句,不是表达式,这样就排除了一个c容易犯的错误,“==”打成“=”,所以在循环的测试部分不需要写上赋值语句,有三种代替方法:

    for是一个通用的序列迭代器,可以遍历任何有序的序列对象内的元素,可以用于字符串、列表、元组、其他内置可迭代对象以及之后通过类所创建的新对象。它的一般格式是:


它的完整格式:

    3、在运行for的时候,会逐个将序列对象中的元素赋值给目标,然后为每个元素执行循环主体,循环主体一般使用赋值的目标来引用序列中当前的元素,就好像那是遍历序列的游标。首行中用作赋值目标的变量名通常是for所在作用域中的变量,这个变量没什么特别,甚至可以在循环主体中修改,不过当控制权回到循环顶端的时候,会自动被设成序列中的下一个元素,循环之后,该变量一般都还是引用了最近所用过的元素,也就是序列中最后的元素,除非通过一个break语句退出循环。

    4、任何赋值目标在语法上都能用在for这个关键字之后:

其他例子没写,不过也不用写

    5、在文件读取的时候,有几种方法:

 

 


最后一种是推荐的方法,它不但简单,而且对任意大小的文件都有效,而且不会一次性就把整个文件都载入到内存中,迭代器版本可能更快,不过在3.0中I/O性能稍差。

    6、一般来说for比while容易写,而且执行也更快,不过有时候需要特定的方式来迭代,比如每隔一个元素或者两个元素,或者在同一个for循环内,并行遍历一个以上的序列。虽然可以用while循环以及手动索引运算完成,不过python提供了两个内置函数,在for循环内制定迭代:a、内置range函数返回一系列连续增加的整数,作为for中的索引;b、内置zip函数返回并行元素的元组的列表,可用于for中内遍历整个序列。

    7、接上6:range函数是通用的工具,虽然常用在for循环中产生索引,但是也可以用在任何需要整数列表的地方,在3.0中,这是一个迭代器,可以按照需要产生元素,所以需要将其包含到一个list调用中以一次性显示器结果:

range当只有一个参数时,会有【0,X);两个参数时【X,Y);三个参数时【X,Y),Z为步长。通常来说,for好于while,而且尽可能少的使用range,因为它没有in 表达式快速。例如下面的代码:

,这个可以实现跳跃,这种方法容易编写,而且更容易阅读,使用range唯一的优点在于它没有复制字符串,而且不会在3.0中创建一个列表,对于很大的字符串来说,这会节省内存。

,左边这段代码再次提醒我们这里的x只是引用,而且就算在for中用了,也还是无法改变L中的值,当下一次for循环时,x就自动变成和L中下一个值,相当于遍历位置,而不是元素;右边的通过索引实现修改列表中的值。如果用while的话,可能运行很慢,不过可以使用【x+1 for x in L】来重新生成一个列表。

    8、内置函数zip也让我们在for中并行使用多个序列。在基本运算中,zip会取得一个或多个序列作为参数,然后返回元组的列表,将这些序列中的并排的元素配成对,因为zip在3.0中也是一个可迭代对象,所以必须将其包含在一个list调用中以便一次性显示所有的结果:

 

这是2个参数的,三个参数也是一样的,当参数的长度不同的时候,zip会以最短序列的长度为准来截断所得到的元组。(2.6中的map这里不介绍,略)

    9、zip调用也可以用来产生字典,:

不过在2.2极其之后的版本中,可以完全跳过for循环,直接将zip的键/值列表传给内置的dict构造函数:

   10、在for循环中,会有一个记录当前偏移值的计数器,一个新的内置函数,叫做enumerate:

enumerat函数返回一个生成器对象:简单来说,这个对象有一个__next__方法,有下一个内置函数调用它,并且循环中每次迭代的时候它会返回一个(index,value)元组。可以在for循环中通过元组赋值运算将元组解包:

它会自动执行迭代协议:

五、迭代器和解析,第一部分(第14章)

    “可迭代对象”的概念在python中是相当新颖的,但在语言的设计中很普遍,基本上,这就是序列观念的通用化:如果对象是实际保存的序列,或者可以在迭代工具环境中(如for)一次产生一个结果的对象,就看作是可迭代的。总之,可迭代对象包括实际序列和按照需求而计算的虚拟序列。

    1、文件迭代器:每次调用readline方法,就会前进到下一列。到达文件末尾时,就会返回空字符串。不过文件也有一个方法,叫做_next_,差不多有相同的效果:每次调用时,就会返回文件中的下一行,唯一的区别在于到达文件末尾时,_next_会引发内置的StopIteration异常,而不是返回空字符串:

 


这部分中“可迭代的”指的是支持iter的一个对象,而“迭代器”指的是iter所返回的一个支持next(I)的对象。这个接口就是python中的迭代协议:有_next_方法的对象会前进到下一个结果,而在一系列结果的末尾时,则会引发StopIteration。在python中,任何这类对象都认为是可迭代的,任何这类对象也能以for循环或其他迭代工具遍历,因为所有迭代工具内部工作起来都是在每次迭代中调用_next_,并且捕捉StopIteration异常来确定何时离开:

这个代码是读取文本文件最佳的方法,因为简单、运行最快、而且从内存使用来看也是最好的。虽然>>>for line in open('scripy1.py').readlines():这个依然能用,不过却不是最好的方法,而且从内存上看效果也很差,因为实际上,该版本是一次性把整个文件加载到内存,虽然用while方法:

可是因为for是c语言实现的,而while是通过python虚拟机运行python字节码,所以相对慢一些,不过在3.0中有一种计时技术,可以用来衡量方法的速度情况。

    2、为了支持手动迭代代码,3.0提供了一个内置函数next,可以自动调用一个对象的_next_方法,next(X)等同于X._next_(),不过前者简单很多。技术上说,迭代协议有一点值得注意,for循环开始的时候,会通过它传给iter内置函数,以便从可迭代对象中获得一个迭代器,返回的对象含有需要的next方法。不过对于文件来说,不需要这样,因为文件对象自己就是自己的迭代器,文件有自己的_next_方法,所以不需要返回一个不同的对象:


文件


不过列表以及很多其他的内置对象,不是自身的迭代器,因为他们支持多次打开迭代器,这样的对象就需要调用iter来启动迭代:



    3、除了文件以及列表,其他类型也有其适用的迭代器,比如遍历字典键的经典方法就是获取键的列表,不过在较新的python中,字典有一个迭代器,在迭代环境中,会自动一次返回一个键:>>>I = iter(D);>>>next(I);>>>next(I);其他的python对象蕾西也支持迭代协议,所以可以在for中使用,例如shelves和os.open的结果都是可迭代的:

在2.6中popen对象支持P.next()方法,在3.0中支持P._next_()方法,不支持next(P)内置函数。所以现在也知道enumerate工具的工作方式了:

    4、列表解析看上去就像是一个反向的for循环,例子:

,将列表解析写在一个方括号中,该方法写容易,而且运行快,要运行该表达式,python在解释器内部执行一个遍历L的迭代,按照顺序把 x 赋给每个元素,并收集对各元素运行左边表达式的结果。推荐用。

    5、因为文件对象中的readlines方法是会在行的末尾包含一个换行符号(\n),如何去掉呢,

第二个表达式做了许多隐式的工作,python扫描文件并自动构建了操作结果的一个列表,因为大多数工作在python解释器内完成,这可能比等价的语句要快好多,而且对于特别较大的文件,列表解析的速度有明显的优势,而且for前面的表达式可以比如:line.rstrip().upper()等。

    6、表达式中嵌套的for循环可以有一个相关的if子句,来过滤那些测试不为真的结果项:

该if 子句检查从文件读取的每一行,看他的第一个字符是否是p,如果不是,从结果列表中省略该行。更复杂for循环有:

    7、在对象中从左到右扫描的每种工具都使用了迭代协议,比如for循环,列表解析、in成员测试、map内置函数以及像sorted和zip调用这样的内置函数也都使用了迭代协议,当应用于一个文件时,所有的这些使用文件对象的迭代器都自动的按行扫描:

>>>uppers = [line.upper() for line in open('script1.py')];>>>map(str.upper,open('script1.py'));>>>list(map(str.upper,open('script1.py')));>>>'y = 2\n' in open('script1.py');>>>'x = 2\n' in open ('script1.py')。map函数是一个内置函数,将一个函数调用应用于传入的可迭代对象的每一项。map类似于列表解析,但是它更有局限性,因为他需要一个函数而不是一个任意的表达式。在3.0中,它还返回一个可迭代的对象自身,因此,我们需要将它包含到一个list调用中以迫使其一次性给出所有的之,由于map像列表解析一样,与循环和函数都相关,在后续接着介绍。在一些内置函数中,和map以及其他函数不同,sotred在3.0中返回一个真正的列表而不是一个可迭代的对象。

    8、接7,其他内置函数也支持可迭代协议,例如sum计算任何可迭代对象中的总数,如果一个可迭代对象中任何的或所有的项为真的时候,any和all内置函数分别返回True;max和min分别返回一个可迭代对象中最大和最小的项。严格的来说,max和min函数也可应用于文件-他们自动使用迭代协议来扫描文件,并且分别选择具有最高和最低的字符串值的行。在list和tuple内置函数,字符串join方法甚至包括序列复制,所有的这些都将在一个打开的文件上工作并且自动一次读取一行:

    9、相比较上面的dict调用接受一个可迭代的zip结果,set的调用记忆3.0中新的集合解析和字典解析表达式:


不过集合解析和字典解析都支持列表解析的扩张语法,包括if测试:


    10、最后一个介绍的迭代环境,也会在18章学习,在函数调用中用到的一种特殊的*arg形式,他会把一个集合的值解包为单个参数。当然他也会接受任何可迭代对象,包括文件:

由于此调用中的参数解包语法接受可迭代对象,也可能使用zip内置函数来吧zip过得元组unzip,只要对任何另一个zip调用使用之前的或嵌套的zip结果参数:

    11、3.0与2.X来说就是更强调迭代,除了与文件和字典这样的内置类型相关的迭代,字典方法keys、values和items都在3.0中返回和迭代对象,就像内置函数range、map、zip和filter所作的那样,他们返回可迭代的对象,在3.0中根据请求产生结果,而不是和2.6中构建结果列表。虽然这样可以节约内存,不过在某种程度上会影响到我们的编码方式,这意味这要在交互模式下显示结果需要额外的录入,这对较大的程序来说很有用,在计算很大的结果列表的时候,这样的延迟计算可以节约内存并避免暂停。

    12、range迭代器,返回一个迭代器,该迭代器按照需要产生范围中的数字,而不是在内存中构建一个结果列表,如果需要一个范围列表的话,必须使用list(range(...))来强制一个真正的范围列表:>>>R = range(10);结果是R为range(0,10);>>>I = iter(R);>>>next(I) ;结果为0,接着调用next,结果为1,如果用>>>list(range(10)),结果为【0,1,2,3,4,5,6,7,8,9】;在3.0中range对象只支持迭代、索引以及len函数。它们不支持任何其他的序列操作:>>>len(R),;结果为10;>>>R[0]结果为0。

    13、和range类似,map、zip以及filter内置函数在3.0中也变成迭代器以节约内存,而不会在内存中一次性生成一个结果列表,所有的这三个函数不仅像是在2.X中一样处理可迭代对象,而且在3.0中返回可迭代结果。和range不同,他们都是自己的迭代器,换句话说,不能在它们的结果上拥有在那些结果中保持不同位置的多个迭代器:

    14、zip内置函数,返回以同样方式工作的迭代器:

还有后面学习的filter内置函数,也是一样:

filter可以接受一个可迭代对象并进行处理,返回一个可迭代对象并在3.0中产生结果。

    15、range对象支持len和索引,当不是自己的迭代器,并且它支持在其结果上的多个迭代器,这些迭代器会记住他们各自的位置;

,x相反,zip、map和filter不支持相同结果上多个迭代器:也就是这三个的不同的I1会等于I2,结果就是一个迭代器。

    16、在3.0中字典的keys、values和items方法返回可迭代的视图对象,他们一次产生一个结果项,而不是在内存中一次产生全部结果列表。视图项保持和字典中的那些项相同的物理顺序,并且反映对底层的字典做出的修改:

和所有迭代器一样,我们总可以通过把一个3.0字典视图传递到list内置函数中,从而强制构建一个真正的列表,不过这通常不是必须的,除了交互的现实结果或者 应用索引这样的列表操作:

,而且3.0字典仍然有自己的迭代器,它返回连续的键,因此,无需直接在此环境中调用keys:

。由于keys不再返回一个列表,按照排序的键来扫描一个字典的传统编码模式在3.0中不再有效,相反,首先用一个list调用来转换keys视图,或者在一个键视图或者字典自身上使用sorted调用:

    17、在20章有更多介绍,29章也还有,后面会看到:a、使用yield语句,用户定义的函数可以转换为可迭代的生成器函数;b、当编写在圆括号中的时候,列表解析转换变为可迭代的生成器表达式;c、用户定义的类通过__iter__或__getitem__运算符重载变得可迭代。

六、文档(第15章)

    这部分介绍的:a、设计python的语法模型;b、给那些想了解python工具集的读者资源。如下表 ,可以从很多地方查找python信息,而且都是逐渐增加的,因为文档是实际编程中重要的工具:

    1、文档字符串适用于较大型功能的文档,而#注释适用于较小功能的文档。

    2、dir内置函数是抓取对象内可用所有属性列表的简单方式,它能够调用任何有属性的对象。比如>>>import  sys;>>>dir(sys);要找出内置对象类型提供了哪些属性,可运行dir并传入所需要类型的产量,例如>>>dir([])。任何内置类型的dir结果都包含一组属性,这些属性和该类型的实现相关,他们的开头和结尾都是双下划线,从而保证其独特性。而且dir(str)==dir(' ');dir(list)==dir(【】).

   3、除了#注释以外,python也支持可自动附加在对象上的文档,而且在运行时还可保持查看。从语法上说,这类注释是写出字符串,放在模块文件、函数以及类语句的顶端,就在任何可执行程序代码前,python会自动封装这个字符串,也就是成为所谓的文档字符串,使其成为相应对象的__doc__属性。a、例如下面的文件,其文档字符串出现在文件开端以及其中的函数和类的开头,这里文件和函数多汗注释使用的是三重引号块字符串,但是任何类型的字符串都能用:下面左图,该文档协议的重点在于,注释会保存在__doc__属性中以供查看。因此,要显示这个模块以及其对象打算关联的文档字符串,我们只需要导入这个文件,简单的打印其__doc__属性:

ps:一般都需要明确说出要打印的文档字符串,否则会得到嵌有换行字符的单个字符串。

    4、查看内置文档字符串>>>import sys;>>>print(sys.__doc__);>>>print(sys.getrefcount.__doc__);>>print(int.__doc__);不过不需要这么做,还是推荐help方法。

    ps:这里有PyDoc的介绍,略。

    5、常见的编写代码的陷阱:a、冒号;b、从第1行开始,顶层程序代码从第一行开始;c、空白行在交互模式提示符下很重要;d、缩进要一致;e、不要在python中写c代码;f、使用简单的for循环,而不是while或range;g、注意赋值语句中的可变对象;h、不要期待在原处修改对象的函数会返回结果;i、一定要使用括号调用函数,比如file.close();j、不要在导入和重载中使用扩展名或路径,写成import mod ,而不是import mod.py .

posted @ 2015-04-06 09:40  仙守  阅读(759)  评论(0编辑  收藏  举报