day18

l=[1,2,3,4,5]
print(list(map(lambda i:str(i),l)))

from functools import reduce
reduce(lambda x,y:x+y,l,init=3)

name=['alex_sb','linhaifeng']
print(list(filter(lambda n:not n.endswith('sb'),name)))

#f=open('test11','rb',encoding='utf-8') #b的方式不能指定编码
f=open('test11.py','rb')
data=f.read()
print(data)
print(data.decode('utf-8')) #二进制转换为字符串

f=open('test22.py','wb')
f.write('11111 '.encode('utf-8')) #字符串转换为二进制
f.write(bytes('2222 ',encoding='utf-8'))
f.close()

f=open('test22.py','ab')
f.write('33333 '.encode('utf-8'))
f.write(bytes('44444 ',encoding='utf-8'))
f.close()

#文件操作的其他方法
f=open('a.txt','w',encoding='utf-8')
print(f.closed) #判断文件是否是关闭的
print(f.encoding) #文件打开的编码
f.flush() #刷新
f.name #文件名
print(f.tell()) #光标当前所在位置（以字节为单位）

f.close()

f=open('a.txt','r',encoding='utf-8',newline='') #读取文件中真正的换行符
print(f.readlines())
print(f.tell())
f.seek(0) #控制光标的移动 read(3)代表读取三个字符，其余的文件内光标移动都是以字节为单位
f.seek(3)
print(readlines()) #从当前光标往后读
data=read(4) #读取四个字符
print(data)
f.truncate(10) #相当于写 w+形式不行 r+或a+
f.close()

f=open('seek.txt','r',encoding='utf-8')
print(f.tell())

f=open('seek.txt','rb')
print(f.tell())
f.seek(10)
print(f.tell())
f.seek(3) #默认是从光标为0开始的
print(f.tell())
f.seek(3,1) #相对于上一次光标停留的位置 seek 的时候以b的形式去操作
print(f.tell())
f.close()

f=open('seek.txt','rb')
print(f.tell())
f.seek(-5,2) #从文件末尾开始seek
print(f.read())
print(f.tell())
f.close()

f=open('日志文件','b')
data=f.readlines()
print(data[-1].decode('utf-8'))
f.close()

#for i in f.readlines(): 形成列表 一行一行取
　　# print(i)

#循环文件的推荐方式（一行一行） 要一行取一行
for i in f:
　　print(i)

f=open('日志文件','rb')
for i in f:
　　offs=10
　　while True:
　　　　f.seek(-offs,2)
　　　　data=f.readlines() #读成列表的形式，一行为一个元素
　　　　if len(data)>1:
　　　　　　print('文件的最后一行是%s' %data[-1].decode('utf-8'))
　　　　　　break

　　offs*=2

迭代器和生成器

递归和迭代

1、迭代器协议：
迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，
要么引起一个stoplteration异常，以终止迭代（只能往后走不能往前退）
2、可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个_iter_()方法）
3、协议是一种约定，可迭代对象实现了迭代协议，Python的内部工具（如for,sum,min,max函数等）
使用迭代器协议访问对象

（字符串，列表，元组，字典，集合，文件对象）这些都不是可迭代对象，只不过for循环，
调用了他们内部的_iter_方法，把他们变成了可迭代对象

x='hello'
iter_test=x.__iter__()
print(iter_test)
print(iter_test.__next__())
print(iter_test.__next__())
print(iter_test.__next__())
print(iter_test.__next__())

l=[1,2,3]
for i in l: #i_l=l.__iter__() i_l.__next__()
　　print(i)

l=[1,2,3]
#print(l[0])
iter_l=l.__iter__() #遵循迭代器协议，生成可迭代对象
print(iter_l.__next__())

i=0
while i<len(l):
　　print(l[i])
　　i+=1

无序类型 字典 集合 文件对象 for循环就可以

s={1,2,3}
for i in s:
　　print(i)

iter_s=s.__iter__()
print(iter_s)
iter_s.__next__()
iter_s.__next__()

dic={'a':1,'b':2}
iter_d=dic.__iter__()
print(iter_d.__next__()) #key值

f=open('test.txt','w+',encoding='utf-8')
for i in f:
　　print(i)


iter_f=f.__iter__()
print(iter_f.__next__())

for循环就是基于迭代器协议提供了一个统一的可以遍历所有对象的方法

l=['die','erzi','sunzi','chongsunzi']
iter_l=l.__iter__()
print(iter_l.__next__())
print(iter_l.__next__())
next(iter_l)
print(next(iter_l)) #next----->iter_l.__next__()

生成器
可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要调用自己内置的__iter__方法）
所以生成器就是可迭代对象

x
x.__next__()
生成器分类及在python中的表现形式（python有两种不同的方式提供生成器）
1、生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。
yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下一次从他离开的地方继续执行

def test():
　　yield 1
　　yield 2
　　yield 3
g=test()
print(g)
g.__next__()

2、生成器表达式：类似于列表推导，但生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

#三元表达式
name='alex'
#name='linhaifeng'
res='SB' if name=='alex' else 'shuaige' #表达式为真返回前面的值，否则返回后面的值

#列表解析
egg_list=[]
for i in range(10):
　　egg_list.append('鸡蛋%s' %i)
print(egg_list)

l=['鸡蛋%s' %i for i in range(10)] #列表
print(l) #['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']

l1=['鸡蛋%s' %i for i in range(10) if i>5]
print(l1) #['鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']

laomuji=('鸡蛋%s' %i for i in range(10)) #生成器表达式
print(laimuji) #生成器
print(laomuji.__next__())
print(next(laomuji))

总结
1、把列表解析的[]换乘()得到的是生成器表达式
2、列表解析和生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3、python不但使用迭代器协议，让for循环更加通用。一部分内置函数也是使用迭代器协议访问对象。
例如，sum函数式python的内置函数，该函数使用迭代器协议访问对象，二生成器实现了迭代器协议，
所以，我们可以直接这样计算一系列值得和：

l=[1,2,3,34]
print(sum(l))
sum(i for i in range(1000))

 2018-08-20