foxdiege 的BLOG
用户名：foxdiege
文章数：54
访问量：485150
注册日期：
阅读量：5863
阅读量：12276
阅读量：374510
阅读量：1068049
[匿名]yia sir：
51CTO推荐博文
一、对象类型
数字:不可变
字符串:不可原处修改【修改需要创建新的对象】，有顺序，支持求长(len)，合并(+)，重复(*)，索引S[0]，分片(S[1:3]]，成员测试(in)，迭代(for);
特有的查找find，替换replace，拆分支持list(S)将字符串分解成一个字符列表，tuple(S)将字符串分解成一个字符组成的元组，复制可用分片和copy标准库，
不支持排序sort和删除del(因为不可原处修改)
元组:不可以原处修改，有顺序,支持求长(len)，合并(+)，重复(*)，索引T[0]，分片T[2:-1]，成员测试（in），迭代(for) ，可以嵌套列表，字典，元组，
支持list(T)将元组转换列表，转换的时候生成新的对象。 复制可用分片和copy标准库；不支持排序sort和删除del(不可变)【没有方法】
注意：元组的不可变性只适用与元组本身顶层而非其内容，元组的内部的列表，字典可以像往常那样修改。
列表：可在原处修改，有顺序，支持求长(len)，合并(+)，重复(*)，索引L[0]，分片L[0:3]，成员测试(in)，迭代(for)，包含任何对象，可以嵌套列表，字典，元组。
可变体现在支持 增加单个对象:L.append(4)，增加多个对象:L.extend([5,6,7])，在I位置插入X:L2.insert(I,X)，索引赋值:L2[i]=1，分片赋值:L2[i:j]=[4,5,6]
移除数据(参数对象)：L.remove('b')，移除数据(参数序列) ：L.pop('b')，裁剪索引:del L[K]，裁剪分片del L[i:j]，裁剪列表:del L，
排序:L2.sort()，顺序反转:L.reverse()，通过对象查找对象索引(和索引相反的操作):L.index('abc')，复制可用分片和copy标准库
支持rang(起,始,步进)创建列表
支持list(L)本身
可以将列表转换为元组：T=tuple(L)#转换的时候生成新的对象.
可以将元组转换为列表：list(T)#产生新的列表对象
不能先创建空列表再添加元素。
&&& L=[1,2,3,4,5]
&&& L=[x+10 for x in L]
将列表中行的换行符去掉
&&& lines=[line.rstrip() for line in lines]
&&& lines=[line.rstrip() for line in open('/etc/rc.conf')]
扩展列表解析
重复上一个例子，但我们只需开头不为#的文字行。
&&& lines=[line.rstrip() for line in open('/etc/rc.conf') if line[0]!='#']
完整的语句可接纳任意数目的for分句，而每个分区都可以结合一个可选的if分句
&&& [x+y for x in 'abc' for y in 'lmn']
['al', 'am', 'an', 'bl', 'bm', 'bn', 'cl', 'cm', 'cn']
对一个字符串中的每个x,以及另一个字符串中的每个y,创建x+y合并的列表。收集两个字符串字符的排列组合
字典：可在原处修改[通过键修改]，无顺序，支持求长(len)，索引D['name'],成员测试(in)，迭戈（for)(keys,values方法返回的列表支持),del D[&name'],del D,
不支持合并，重复，分片，包含任何对象，可以嵌套列表，字典，元组。 不支持排序sort.
支持list（D），获取字典KEY的列表 复制可用.Dcopy(),copy标准库
可以创建空字典，然后再添加元素.
&&& D={}&&&&
&&& D={'one':1}
{'one': 1}
列表不能通过这样的方法来增加数据，列表只能通过append方法，列表之能通过L[1]='A'这样的方法来修改已存在序列的数据。
对象灵活性
* 列表，字典，元组可以包含任何种类的对象。
* 列表，字典，元组可以任意嵌套
* 列表，字典可以动态扩大和缩小。
有些地方的确需要拷贝，那么可以明确要求
* 没有限制条件的分片表达式（L[:]）能够赋值序列
* 字典copy方法（D.copy())能够复制字典
* 有写内置函数（例如,List）能够生产拷贝(list(L))
* copy标准库模块能够生成完整拷贝
二、赋值表达式和打印
1、赋值运算
变量命名规则
语句：（下划线或者字母）+（任意数目的字母，数字或下划线）
注意：区分大小写，禁止使用保留字，前后有下划线的变量名（__X__)是系统定义的变量名，对解释器有特殊意义
变量名没有类型，但对象有
运算&&&&&&&&&&&&&&&&&&& 解释
diege='diege'&& 基本形式
diege,lily='yum','wang' 元组赋值运算（位置性） 序列赋值语句
[diege,lily]=['yum','YUM'] 列表赋值运算（位置性） 序列赋值语句
a,b,c=string[0],string[1],string[2] 高级赋值
((a,b),c)=('DI','GE')&&& 可以赋值嵌套序列
a,b,c,d='dieg' #序列赋值运算，通用性 #MS不行，数量要一致。 序列赋值语句
name=uname='diege' 多目标赋值运算
diege += 43 增强赋值运算（相当于diege=diege+43)
2、表达式语句介绍
在Python中可以使用表达式作为语句 （本身只占一行）。但是，因为表达式结果不会被存储，只有当表达式工作并作为附加的效果，这样才有意义。
通常在两种情况下表达式用作语句。
*调用函数和方法
有些函数和方法会做很多工作，而不会返回值，这种函数在其他语言中有时称为流程。因为他们不会返回你可能想保留的值，所以你可以用表达式语句调用这些函数。
*在交互模式提示符下打印值
常见的python表达式语句
运算&&&&&&&&&&&&&&& 解释
spam(eggs,ham) 函数调用
spam.ham(eggs)& 方法调用
spam&&&&&&&&&&&&&&& 在交互模式解释器内打印变量
spam & ham and ham != eggs 符合表达式
spam & ham & eggs 范围表达式
注意：虽然表达式在python中可以作为语句出现，但语句不能作为表达式。
表达式语句和在原处修改
对列表调用append,sort,reverse这类在原处修改的元算，一定是对列表在原处的修改，但这些方法在列表修改后并不会把列表返回。
&&&print 'diege,test' #把对象打印至sys.stdout,在元素之间增加一个空格，以及在末尾增加换行符。
&&& name='diege'
&&& age=18
&&& print 'my name is:%s age is:%s'%(name,age)
my name is:diege age is:18
print x 等价于
import sys
sys.stdout.write(str(x)+'\n'
当print 语句以&&开始，后面再跟着输出的文件对象（或其他对象）时，该print语句可以将文字传给该对象的write方法，但是不用重设sys.stdout。因为这种重定向是暂时的。普通的print语句还是会继续打印到原始的输出流的。
&&& log=open('log.txt','a',0)
&&& x,y,z=10,11,12
&&& print && log,x,y,z
&&& print && 输出的文件,输入,的,内容
三、流程语句
1、while循环
while &test&:
&&& &statements1&
&&& if &test2&:break
&&& if &test3&:continue
&&& if &test4&:pass
&&& &statements2&
&&& 跳出最近所在的循环（跳出整个循环语句）
&&& 跳到最近所在循环的开头处（来到循环的首行，跳过本次循环）
&&& 什么事也不做，只是空占位语句
循环else块
&&& 只有当循环正常离开时才会执行（也就是没有碰到break语句）
2、for循环
for循环在Python中是一个通用的序列迭代器：可以遍历任何有序的序列对象内的元素。for语句可用于字符串，列表，元组，其他内置可迭代对象以及之后我们能够通过类所创建的新对象。
for循环的首行定义了一个赋值目标（或【一些目标】），以及你想遍历的对象，首行后面是你想重复的语句块（一般都有缩进）
当ptyhon运行for循环时，会逐个将序列对象中的元素赋值给目标，然后为每个元素执行循环主体。
for &target& in &object&:
&&& &statements&
&&& if &test&:break
&&& if &test&:conitnue
&&& &statements&
可以多层嵌套
三元表达式
A=Y if X else Z
只有当X为真时才会执行表达式Y，而只有当X为假时，才会执行表达式Z
for循环可以用在任何【可迭代的对象】。这些迭代工具包括了for循环，列表解析，in成员关系测试，以及map内置函数等。
next()文件迭代方法，无需将文件读取。
逐行读取文本的最佳方式就是根本不要去读取，其替代的方法就是，让for循环在每轮自动调用next从而前进到下一行
&&& for line in open('/etc/rc.conf'):
...&&&& print line.upper(),
&&& for key in D:&&&&&
...&&&& print key,D[key]
其他迭代环境
[line.upper() for line in open('/etc/rc.conf')]
in成员关系
map内置函数以及其他内置工具（如sorted,sum）
map(str.upper,open('/etc/rc.conf'))
&&& sorted(open('/etc/rc.conf')) #这个工具排序了，较新的内置函数，采用了迭代协议。应用于任何可迭代的对象上。
&&& sum([3,5,6,9]) #sum调用会计算任何可迭代对象内所有数字的和
list和tuple内置函数（从可迭代对象创建新的对象），字符串join方法（在可迭代对象内字符串之间放入子字符串），以及序列赋值语句等。
&&& list(open('/etc/rc.conf'))
&&& tuple(open('/etc/rc.conf'))
&&& '&&'.join(open('/etc/rc.conf'))
&&& a,d,c,d=open('/etc/rc.conf')
4、编写循环的技巧
遍历序列时，首选for循环，for循环包括多数计数器式的循环，for比while容易写，执行时也比较快。
Python提供了两个内置函数，在for循环内定制迭代：
* 内置range函数返回连续整数列表，可作为for中的索引。
&&& range(5,10,2)
&&& range(5,-5,-1)
[5, 4, 3, 2, 1, 0, -1, -2, -3, -4]
尽量使用简单的for循环，不要用while,并且不要在for循环中使用range调用，只将其视为最后的选择，更简单的办法总是更好。
&&& for i in X:
...&&&& print i
for x in S[::2]:print x# 步长2的
*内置 zip函数返回并行的元素元组的列表，可用于在for中遍历数个序列
并行遍历：zip 和map
&&& L1=[1,2,3,4]
&&& L2=[5,6,7,8]
&&& zip(L1,L2)
[(1, 5), (2, 6), (3, 7), (4, 8)]
&&& for (x,y) in zip(L1,L2):
...&&&& print x,y,'--',x+y
当参数长度不同时，zip会以最短序列的长度为准来截断所得到的元组：
内置map函数，用类似的方式把序列的元素配对起来，但是如果参数长度，不同则会为较短的序列用None补齐。
&&& map(None,S1,S2)&
[('A', 'x'), ('B', 'y'), ('C', 'z'), (None, '1'), (None, '2'), (None, '3')]
使用zip构造字典
&&& keys=['name','age','class']
&&& vals=['diege',18,2012]&
&&& dict(zip(keys,vals))
{'age': 18, 'name': 'diege', 'class': 2012}
&&& D5=dict(zip(keys,vals))
enumerate内置函数，同时产生偏移和元素
&&& S='diege'
&&& for (offset,item) in enumerate(S):
...&&&& print item,offset
这个方法有个next方法，每次遍历列表时，会返回一个(index,value)的元组，而我们能在for中通过元组赋值运算将其分解。
&&& E=enumerate(S)
&&& E.next()
&&& E.next()
Traceback (most recent call last):
& File &&stdin&&, line 1, in &module&
StopIteration
5、列表解析
列表解析是写在方括号中的，因为它毕竟是一种创建新的列表的方式。
[【表达式】 for x in L【for循环行首】]
&&& L=[1,2,3,4,5]
&&& L=[x+10 for x in L]
将列表中行的换行符去掉
&&& lines=[line.rstrip() for line in lines]
&&& lines=[line.rstrip() for line in open('/etc/rc.conf')]
扩展列表解析
重复上一个例子，但我们只需开头不为#的文字行。
&&& lines=[line.rstrip() for line in open('/etc/rc.conf') if line[0]!='#']
完整的语句可接纳任意数目的for分句，而每个分区都可以结合一个可选的if分句
&&& [x+y for x in 'abc' for y in 'lmn']
['al', 'am', 'an', 'bl', 'bm', 'bn', 'cl', 'cm', 'cn']
对一个字符串中的每个x,以及另一个字符串中的每个y,创建x+y合并的列表。收集两个字符串字符的排列组合
&本文出自 “” 博客，请务必保留此出处
了这篇文章
类别：┆阅读(0)┆评论(0)
本文收录至博客专题：《》Python（26）
if expression:
expr_true_suite
单个if语句可以通过使用布尔操作符and、or和not实现多重判断条件和否定判断条件。
2、else语句
if expression:
expr_true_suite
expr_false_suite
避免“悬挂else”(C语言代码)
①if(balance&0.00)
②if(((balance-atm)&min_bal)&&(atm_cashout()==1))
printf("Here'...");
printf("Your balance is ...");
本来①与③匹配，但C语言默认②与③匹配。
3、elif(即else-if)语句
if expression1:
expr1_true_suite
elif expression2:
expr2_true_suite
none_of_the_above_suite
Python没有提供switch/case语句，可以用if-elif、序列和成员关系操作符、Python字典来代替。
4、条件表达式（三元操作符）
(C and [x] or [y])[0](2.5之前条件表达式的模拟实现之一)
x if C else y（2.5）
&&&smaller=x if x&y else y
5、while语句
while expression：
suite_to_repeat
6、for语句（像C#中的foreach循环）
可以遍历序列成员，可以用在列表解析和生成器表达式中。
for iter_var in iterable:
suite_to_repeat
（1）遍历序列对象：字符串、列表及元组。
①通过序列项迭代：
&&&nameList=['adas','adaw','eew']
&&&for eachName in nameList:
print eachName
②通过序列索引迭代
&&&nameList=['adas','adaw','eew']
&&&for nameIndex in range(len(nameList)):
print nameList[nameIndex]
③使用项和索引迭代
&&&nameList=['adas','adaw','eew']
&&&for i,eachName in enumerate(nameList):
print i,eachName
（2）遍历迭代器类型
迭代器对象有一个next()方法，调用后返回下一个条目。所有条目迭代完后，迭代器会引发一个StopIteration异常告诉程序循环结束。for语句在内部调用next()方法并捕获异常。
（3）range()和xrange()内建函数
①range()标准用法
range(start,end,step=1)
range()函数会返回一个包含所有k的列表，k大于等于start且小于end，从start到end，k每次递增step。step不可以为0，否则会发生错误。step默认为1。
②range()简略用法
range(end)
start默认为0，step默认为1
range(start,end)
step默认为1
③xrange()函数
xrange()适用于很大范围的列表。其性能高于range()，因为它不生成整个列表。它不会在内存里创建列表的完整拷贝。只被用在for循环，for循环外使用它无意义。xrange()返回一个可迭代对象（不是列表也不是迭代器）
④与序列相关的内建函数
sorted() 返回列表
reversed()返回迭代器
enumerate()返回迭代器
zip()返回列表
8、break与continue语句
break语句结束当前循环然后跳转到下条语句
continue语句结束当前循环开始下一次循环
9、pass语句（不做任何事情）
def foo_func():
10、在while和for循环中使用else语句（循环后处理）
while expression：
suite_to_repeat
else_suite
else子句只在循环完成后执行，也就是说break语句也会跳到else块。
11、迭代器和iter()函数
（1）迭代器
迭代器，为类序列对象提供了一个类序列的接口。（2.2）
Python的迭代无缝地支持序列对象，且允许程序员迭代非序列类型，包括用户定义的对象。例如：字典的键，一个文件的行，等等。
迭代器有一个next()方法，当你循环时，需要下一个项，调用迭代器的next()方法便可以获得它。条目全部取出后，会引发StopIteration异常，告诉调用者迭代完成。将迭代器看作序列，只是不能通过索引来计数。
reversed()内建函数将返回一个反序访问的迭代器；
enumerate()内建函数同样也返回迭代器。
all()和any()内建函数（2.5），如果迭代器中某个/所有条目的值都为布尔真时，则它们返回值为真。
迭代器限制：不能向后移动，不能回到开始，不能复制一个迭代器。
itertools模块，包含各种迭代器。
（2）使用迭代器
①序列中使用迭代器
for循环会自动调用迭代器的next()方法以及监视StopIteration异常。
②字典中使用迭代器
字典的迭代器会遍历它的键（key），语句for eachKey in myDict.keys()可以缩写为for eachKey in myDict。Python还提供了myDict.iterkeys()、myDict.itervalues() 、myDict.iteritems()三个内建字典方法来定义迭代。
③文件中使用迭代器
文件对象生成的迭代器会自动调用readline()方法。可以使用更简单的for eachLine in myFile替换for eachLine in myFile.readlines()。
注意：在迭代可变对象（列表）时修改它们不是一个好主意。因迭代器是与实际对象绑定在一起，更改元素会立即反映到你所迭代的条目上。
（3）iter()方法
iter(obj)方法可以得到obj的迭代器。iter()方法会检查入参obj是不是一个序列，如果是，根据索引从0一直迭代到序列结束。一个实现了__iter__()和next()方法的类可以作为迭代器使用。
iter(func,sentinel)重复调用func，直到迭代器的下个值等于sentinel。
12、列表解析（2.0）（用来动态创建列表）
（1）列表解析的语法
[expr for iter_var in iterable]
&&&[x**2 for x in range(6)]&=&map(lambda x:x**2,range(6))
列表解析可取代内建的map()及lambda,且效率更高
（2）列表解析语法的扩展版本
[expr for iter_var in iterable if cond_expr]
&&&[x**2 for x in seq if x%2]&=&filter(lambda x:x%2,seq)
13、生成器表达式（是列表解析的一个扩展）
（2.2引入生成器，2.4引入生成器表达式）
列表解析的不足是必须生成所有的数据，用以创建整个列表，不适用于有大量数据的迭代器。生成器是特定的函数，允许你返回一个值，然后“暂停”代码的执行，稍后恢复。
生成器表达式结合列表解析和生成器来解决列表解析的不足。生成器表达式并不真正创建列表，而是返回一个生成器，这个生成器在每次计算出一个条目后，把这个条目“产生”（yield）出来。生成器表达式使用了“延迟计算”，在使用内存上更高效。
列表解析语法
[expr for iter_var in iterable if cond_expr]
生成器表达式语法
(expr for iter_var in iterable if cond_expr)
只是将方括号变成圆括号，却得到一个内存使用更友好的结构。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：526083次
积分：7919
积分：7919
排名：第1992名
原创：264篇
转载：42篇
评论：85条
(11)(11)(22)(2)(27)(4)(3)(1)(10)(2)(10)(10)(8)(1)(1)(1)(2)(14)(10)(4)(3)(4)(10)(16)(5)(6)(19)(24)(22)(17)(16)(1)(3)(1)(1)(3)python（1）
8.1 基本操作
raise Exception('异常演示')
Traceback (most recent call last):
File "/xxx/07.python/project/demo/__init__.py", line 8, in &module&
raise Exception('异常演示')
Exception: 异常演示
内建的异常
可以在exceptions模块找到，使用dir函数列出来。
&&& import exceptions
&&& dir(exceptions)
['ArithmeticError', 'AssertionError', ...]
所有异常的基类
AttributeError
特性引用或赋值失败时引发
试图打开不存在文件（包括其他情况）时引发
IndexError
使用序列中不存在的索引
使用映射中不存在的键
找不到名字（变量）
SyntaxError
代码为错误形式
内建操作或函数应用于错误类型的对象
ValueError
内建操作或函数应用于正确类型的对象，但该对象使用不合适的值
ZeroDivisionError
除法或模除操作的第二个参数为0
8.2 自定义异常
class SomeCustomException(Exception): pass
8.3 捕捉异常
使用try/except：
x = input("first: ")
y = input("second: ")
except ZeroDivisionError, e:
except (TypeError, NameError):
The second number cant be zero!
second: "how"
Traceback (most recent call last):
File "xxx/__init__.py", line 11, in &module&
TypeError: unsupported operand type(s) for /: 'int' and 'str'
Traceback (most recent call last):
File "/xxx/__init__.py", line 10, in &module&
y = input("second: ")
File "&string&", line 1, in &module&
NameError: name 'j' is not defined
8.4 else、finally
while True:
x = input("first: ")
y = input("second: ")
print x / y
print '捕捉所有异常'
print '未发生异常时执行'
print "总是执行"
捕捉所有异常
未发生异常时执行
8.5 新函数
warnings.filterwarnings(actiong, …)
用于过滤警告
9. 魔法方法、属性和迭代器
9.1 准备工作
赋值语句metaclass=type放在模块最开始，或者子类化object。
class NewStyle(object):
9.2 构造方法
class FooBar:
def __init__(self):
self.somevar = 42
f = FooBar()
print f.somevar
9.2.1 重写构造方法
调用未绑定的超类构造方法
class Bird:
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print 'Aaaah...'
self.hungry = False
print 'No, tks'
class SongBird(Bird):
def __init__(self):
Bird.__init__(self)
self.sound = 'Squawk!'
def sing(self):
print self.sound
sb = SongBird()
使用super函数
__metaclass__ = type
class Bird:
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print 'Aaaah...'
self.hungry = False
print 'No, tks'
class SongBird(Bird):
def __init__(self):
super(SongBird, self).__init__()
self.sound = 'Squawk!'
def sing(self):
print self.sound
sb = SongBird()
9.3 成员访问
9.3.1 基本的序列和映射规则
序列和映射是对象的集合。
__len_(self)：返回集合中所含项目的数量。
__getitem__(self, key)：返回与所给键对应的值。
__setitem__(self, key, value)：设置和key相关的value。只能为可以修改的对象定义这个方法。
__delitem__(self, key)：对一部分对象使用del语句时被调用，同时必须删除和元素相关的键。
对于序列，如果键是负数，从末尾开始计数。
如果键是不合适的类型，会引发TypeError异常。
如果序列是正确的类型，但超出范围，引发IndexError异常。
9.3.1 子类化列表、字典和字符串
通过子类化超类，进行扩展。
class CounterList(list):
def __init__(self, *args):
super(CounterList, self).__init__(*args)
self.counter = 0
def __getitem__(self, index):
self.counter += 1
return super(CounterList, self).__getitem__(index)
cl = CounterList(range(10))
cl.reverse()
del cl[3:6]
print cl.counter
print cl[4] + cl[2]
print cl.counter
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[9, 8, 7, 3, 2, 1, 0]
9.5.1 property函数
property函数有4个参数，分别为fget、fset、fdel和doc
class Rectangle:
def __init__(self):
self.width = 0
self.height = 0
def setSize(self, size):
self.width, self.height = size
def getSize(self):
return self.width, self.height
size = property(getSize, setSize)
r = Rectangle()
r.width = 10
r.height = 5
print r.size
r.size = 150, 100
print r.width
9.5.2 静态方法和类成员方法
静态方法和类成员方法分别在创建时被装入Staticmethod类型和Classmethod类型的对象中。
class MyClass:
def smeth():
print "this is a static method"
smeth = staticmethod(smeth)
def cmeth(cls):
print 'this is a class method of', cls
cmeth = classmethod(cmeth)
MyClass.smeth()
MyClass.cmeth()
this is a static method
this is a class method of &class '__main__.MyClass'&
9.5.3 __getattr__、__setattr__
__getattribute__(self, name)：当特性name被访问时自动被调用（只能在新式类中使用）。
__getattr__(self, name)：当特性name被访问且对象没有相应的特性时被自动调用。
__setattr__(self, name, value)：当试图给特性name赋值时会被自动调用。
__delattr__(self, name)：当试图删除特性name时被自动调用。
9.5 迭代器
9.5.1 迭代器规则
__iter__方法返回一个迭代器（iterator），如果next方法被调用，但迭代器没有值可以返回，就会引发一个StopIteration异常。
class Fibs:
def __init__(self):
self.a = 0
self.b = 1
def next(self):
self.a, self.b = self.b, self.a + self.b
return self.a
def __iter__(self):
return self
fibs = Fibs()
for f in fibs:
if f & 1000:
9.5.2 从迭代器得到序列
示例：使用list构造方法显式地将迭代器转化为列表
class TestIterator:
def next(self):
self.value += 1
if self.value & 10:
raise StopIteration
return self.value
def __iter__(self):
return self
ti = TestIterator()
print list(ti)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
9.5 生成器
生成器是一种用普通的函数语法定义的迭代器。
9.5.1 创建生成器
任何包含yield语句的函数称为生成器。每次产生值（使用yield语句），函数就会被冻结：即函数停在那点等待被激活。函数被激活后就从停止的那点开始执行。
def flattern(nested):
for sublist in nested:
for element in sublist:
yield element
nested = [[1, 2], [3, 4], [5]]
for num in flattern(nested):
print list(flattern(nested))
[1, 2, 3, 4, 5]
9.5.2 递归生成器
def flattern(nested):
for sublist in nested:
for element in flattern(sublist):
yield element
except TypeError:
yield nested
print list(flattern([[[1], 2], 3, 4, [5, [6, 7]], 8]))
[1, 2, 3, 4, 5, 6, 7, 8]
9.5.3 生成器方法
生成器和“外部世界”进行交流的渠道，要注意以下两点：
外部作用域访问生成器的send方法，就像访问next方法一样，只不过前者使用一个参数（要发送的“消息”——任意对象）。
在内部则挂起生成器，yield现在作为表达式而不是语句使用，换句话说，当生成器重新运行的时候，yield方法返回一个值，也就是外部通过send方法发送的值。如果next方法被使用，那么yield方法返回None。
def repeater(value):
while True:
new = (yield value)
if new is not None:
value = new
r = repeater(43)
print r.next()
print r.send("Hello, world!")
Hello, world!
生成器还有其他两个方法：
throw方法用于在生成器内引发一个异常。
close方法用于停止生成器。
9.5.4 模拟生成器
使用普通的函数模拟生成器。
def flattern(nested):
result = []
try: nested + ' '
except TypeError: pass
else: raise TypeError
for sublist in nested:
for element in flattern(sublist):
result.append(element)
except TypeError:
result.append(nested)
return result
print list(flattern([[[1], 2], 3, 4, [5, [6, 7]], 8]))
[1, 2, 3, 4, 5, 6, 7, 8]
9.6 新函数
从一个可迭代的对象得到迭代器
property(fget, fset, fdel, doc)
返回一个属性，所有的参数都是可选的
super(class, obj)
返回一个类的超类的绑定实例
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：32952次
排名：千里之外
原创：39篇
转载：55篇
评论：21条
(3)(6)(10)(15)(5)(5)(3)(2)(1)(2)(1)(4)(2)(1)(2)(5)(15)(4)(3)(2)(1)(1)(3)