迭代器：迭代的工具

 .什么是迭代：指的是一个重复的过程，每次重复称为一次迭代，并且每次重复的结果是下一次重复的初始值

 例：

     while True：

         print（'====>''）

 l=['a','b','c']

 count=

 while count<len(l):

     print(l[count])

     count+=

 .为什么要有迭代器？

   对于序列类型：str，list，tuple，可以依赖索引来迭代取值，

   但是对于dict，set，文件，python必须为我们提供一种不依赖于索引的迭代取值的方式-》迭代器

 .可迭代的对象（下列 都是）：obj.__iter__

 name='egon'

 l=[,,]

 t=(,,)

 d=['name':'egon','age':,'sex':'male']

 s={'a','b','c'}

 f=open('a.txt','w',encoding='utf-8')

 name.__iter__

 l.__iter__

 t.__iter__

 d.__iter__

 s.__iter__

 f.__iter__

 .迭代器对象（只有文件是）：obj.__iter__,obj.__next__

 f.__iter__

 f.__next__

 总结：

 .可迭代对象不一定是迭代器的对象

 .迭代器对象一定是可迭代器的对象

 .调用obj.__iter__()方法，可迭代对象调用iter就转换成了迭代器对象，文件直接是迭代器对象（对于迭代器对象，执行__iter__得到的仍然是它本身）

 这个例子说明文件执行iter还是迭代器对象，返回值为True

 f=open('a.txt','w',encoding='utf-8')

 f_iter=f.__iter__().__iter__().__iter__().__iter__()

 print(f_iter is f)

 d={'name':'egon','age':,'sex':'male'}

 d_iter=d.__iter__()

  print(d_iter.__next__())

  print(d_iter.__next__())

  print(d_iter.__next__())

  print(d_iter.__next__()) #迭代器d_iter没有值了，就会抛出异常StopIteration

 f=open('a.txt','w',encoding='utf-8')

 f_iter=f.__iter__().__iter__().__iter__().__iter__()

 f=open('F:\python20期\sa.txt','r',encoding='utf-8')

 print(f.__next__())

 print(f.__next__())

 print(f.__next__())

 print(f.__next__())

 f.close()

 l=['a','b','c']

 l_iter=l.__iter__()

 print(l_iter.__next__())

 print(l_iter.__next__())

 print(l_iter.__next__())

 d={'name':'egon','age':,'sex':'male'}

 d_iter=iter(d)  #就相当于d_iter=d.__iter__()和len（obj）=obj__iter__()

 d={'name':'egon','age':,'sex':'male'}

 d_iter=iter(d)  #就相当于d_iter=d.__iter__

 while True:#加上这个是为了取消StopIteration报错

     try:#意思是监测这段代码的行为print(next(d_iter))，如果有异常就判断异常是不是StopIteration:，如果是就break

         print(next(d_iter))

     except StopIteration:

         break

 print('====>')

 print('====>')

 print('====>')

 print('====>')

 d={'name':'egon','age':,'sex':'male'}

 for k in d:

     print(k)

 print('====>')

 print('====>')

 print('====>')

 print('====>')

 for循环总结详解（上为实例）：

 .调用in后面的obj_iter=obj.__iter__()

 .k=obj_iter.__next__()

 .捕捉到StopIteration异常，结束迭代

 #总结迭代器的优缺点：

 #优点:

 #、提供一种统一的、不依赖于索引的取值方式，为for循环的实现提供了依据

 #、迭代器同一时间在内存中只有一个值——》更节省内存，

 #缺点：

 #、只能往后取，并且是一次性的

 #、不能统计值的个数，即长度

 生成器：只有在函数体内出现yield关键字，那么再执行函数就不会执行函数代码，会得到一个结果，该结果就是生成器

 def func():

     print('=====>1')

     yield

     print('=====>2')

     yield

     print('=====>3')

     yield 

 #生成器就是迭代器

 # g=func()

 ##g.__iter__和g.__next__都有，所以说生成器就是迭代器

 #

 #next(g)#返回值是======>

 #

 #res1=next(g)

 # print(res1)

 #

 #

 # res2=next(g)

 # print(res2)

 #

 #

 # res3=next(g)

 # print(res3)

 #yield的功能：

 #、yield为我们提供了一种自定义迭代器对象的方法

 #、yield与return的区别1：yield可以返回多次值 #：函数暂停与再继续的状态是由yield帮我们保存的

 obj=range(,,)

 obj_iter=obj.__iter__()

 print(next(obj_iter))

 print(next(obj_iter))

 print(next(obj_iter))

 print(next(obj_iter))

 print(next(obj_iter))

 def my_range(start,stop,step=):#step步长默认为一

     while start < stop:

         yield start #start=

         start+=step #start=

 g=my_range(,,)

 print(g)

 print(next(g))

 print(next(g))

 print(next(g))

 print(next(g))

 print(next(g))

 print(next(g))

 print(next(g))

 for i in my_range(,,):

     print(i)

 小练习：:tail -f access.log | grep ''

 import time

 def tail(filepath):#文件路径

     with open(filepath,'rb') as f:#把光标放到最后

         f.seek(,)#直接跑到文件末尾去了

         while True:#循环去读

             line=f.readline()#读一行

             if line:#如果有值

                 yield line#把这个值返回，让这个值持续运行

             else:#如果没有值

                 time.sleep(0.05)

 def grep(lines,pattern):#lines，pattern是匹配的东西

     for line in lines:

         line=line.decode('utf-8')#把数字转成字符串类型

         if pattern in line:

             yield line#只干过滤的活

 lines=grep(tail('access.log'),'')

 for line in lines:

     print(line)

 #了解知识点：yield表达式形式的用法

 def eater(name):

     print('%s ready to eat' %name)

     food_list=[]#加一个列表

     while True:

         food=yield food_list#food=yield='一盆骨头'#只要写成yield就是生成器了，

         food_list.append(food)

         print('%s start to eat %s' %(name,food))

 e=eater('alex')

 #首先初始化：#初始化一次就是next（e）

 print(e.send(None)) # 等同于next(e)

 #然后e.send: 从暂停的位置将值传给yield，在用yield给前面的变量 、与（就是next操作）next一样

 print(e.send('一桶泔水'))

 print(e.send('一盆骨头'))

 def my_max(x,y):

     if x >= y:

         return x

     else:

         return y

 x=

 y=

 # res=x if x >= y else y

 # print(res)

 name=input('>>: ').strip()

 res='Sb' if name == 'alex' else 'NB'

 print(res)

 # 列表推导式

 # l=[]

 # for i in range(,):

 #     res='egg'+str(i)

 #     l.append(res)

 #

 # print(l)

 # l=['egg'+str(i) for i in range(,)]

 # print(l)

 # l1=['egg'+str(i) for i in range(,) if i >= ]

 # print(l1)

 # l1=[]

 # for i in range(,):

 #     if i >= :

 #         l1.append('egg'+str(i))

 #

 # 生成器表达式

 # g=('egg'+str(i) for i in range(,))

 # print(g)

 # print(next(g))

 # print(next(g))

 # print(next(g))

 #练习

 names=['egon','alex_sb','wupeiqi','yuanhao']

 # names=[name.upper() for name in names]

 # print(names)

 # sbs=[name for name in names if name.endswith('sb')]

 # print(sbs)

 # obj=list('abcdef')

 # print(obj)

 # print(max([,,,,]))

 # g=(i for i in range())

 # print(max(g))

 #

 # print(max(g))

 with open('a.txt','r',encoding='utf-8') as f:

     # l=[]

     # for line in f:

     #     # print(len(line))

     #     l.append(len(line))

     # g=(len(line) for line in f)

     # res=max(g)

     # print(res)

     # print(max(len(line) for line in f))

     print(sum(len(line) for line in f))

 #递归调用：在调用一个函数的过程中，直接或者间接又调用该函数本身，称之为递归调用

 #递归必备的两个阶段：、递推  、回溯

 # import sys

 # print(sys.getrecursionlimit())

 # sys.setrecursionlimit()

 # print(sys.getrecursionlimit())

 # def func(n):

 #     print('---->',n)

 #     func(n+)

 #

 # func()

 # def bar():

 #     print('from bar')

 #     func()

 #

 # def func():

 #     print('from func')

 #     bar()

 #

 # func()

 # age() = age() +

 # age() = age() +

 # age() = age() +

 # age() = age() +

 #

 # age() = 

 # age(n)=age(n-)+ # n >

 # age() =  #n = 

 # def age(n):

 #     if n == :

 #         return

 #     return age(n-) +

 #

 # res=age()

 # print(res)

 # l=[,[,[,[,[,[,[,]]]]]]]

 #

 #

 # def func(l):

 #     for item in l:

 #         if type(item) is list:

 #             func(item)

 #         else:

 #             print(item)

 # def func():

 #     print('===>')

 #     func()

 #

 # func()

 #了解的知识点

 l=[,,,,,,,,,] #从小到大排列的数字列表

 def binary_search(l,num):

     print(l)

     if len(l) == :

         print('not exists')

         return

     mid_index=len(l) //

     if num > l[mid_index]:

         #往右找

         binary_search(l[mid_index+:],num)

     elif num < l[mid_index]:

         #往左找

         binary_search(l[:mid_index],num)

     else:

         print('find it')

 # binary_search(l,)

 binary_search(l,)

 # def func(): #func=内存地址

 #     print('from func')

 #

 # func()

 # func()

 # 内存地址

 # def my_sum(x,y):

 #     return x+y

 # print(lambda x,y:x+y)

 # print((lambda x,y:x+y)(,))

 # func=lambda x,y:x+y

 # # print(func)

 # print(func(,))

 #max，min，sorted,map,reduce,filter

 # salaries={

 #     'egon':,

 #     'alex':,

 #     'wupeiqi':,

 #     'yuanhao':

 # }

 # print(max(salaries))

 # s='hello'

 # l=[,,]

 # g=zip(s,l)

 # # print(g)

 # print(list(g))

 # g=zip(salaries.values(),salaries.keys())

 # # print(list(g))

 # print(max(g))

 # def func(k):

 #     return salaries[k]

 # print(max(salaries,key=func)) #key=func('egon')

 # print(max(salaries,key=lambda k:salaries[k])) #key=func('egon')

 # print(min(salaries,key=lambda k:salaries[k])) #key=func('egon')

 #sorted

 # salaries={

 #     'egon':,

 #     'alex':,

 #     'wupeiqi':,

 #     'yuanhao':

 # }

 # print(sorted(salaries,key=lambda k:salaries[k]))

 # print(sorted(salaries,key=lambda k:salaries[k],reverse=True))

 #map,reduce,filter

 # names=['alex','wupeiqi','yuanhao']

 # l=[]

 # for name in names:

 #     res='%s_SB' %name

 #     l.append(res)

 #

 # print(l)

 # g=map(lambda name:'%s_SB' %name,names)

 # # print(g)

 # print(list(g))

 # names=['alex_sb','wupeiqi_sb','yuanhao_sb','egon']

 # g=filter(lambda x:x.endswith('sb'),names)

 # print(g)

 # print(list(g))

 from functools import reduce

 print(reduce(lambda x,y:x+y,range(,),))

 #了解

 # print(abs(-))

 # print(all([,'a','b',]))

 # print(all([]))

 # print(any([None,False,,]))

 # print(any([]))

 # print(bin())

 # print(hex())

 # print(oct())

 # print('xxx'.encode('utf-8'))

 # print(bytes('xxx',encoding='utf-8'))

 # print(callable(max))

 # print(chr())

 # # print(chr())

 # # print(chr())

 # print(ord('A'))

 # print(ord('@'))

 # import os

 # print(dir(os))

 # s=set({,,})

 # s.add()

 # print(s)

 # s=frozenset({,,}) #不可变集合

 # print(hash('xxx'))

 # l=[,,'a',]

 # print(list(reversed(l)))

 # s=slice(,,)

 # l=['a','b','c','d','e']

 #

 # # print(l[::])

 # # print(l[::])

 #

 # print(l[s])

 # print(vars() is locals())

 #面向对象

 classmethod

 staticmethod

 property

 hasattr

 getattr

 setattr

 delattr

 isinstance

 issubclass

 object

 super

 # obj.__dict__() #vars(obj)

 #__import__

 # choice=input('>>: ')

 # print(choice,type(choice))

 #

 # # import 'time'

 # m=__import__(choice)

 # m.sleep()

 #掌握：

 #divmod

 # print(divmod(,))

 #enumerate

 # l=['a','b','c']

 # for i in l:

 #     print(l.index(i),i,)

 # for i,v in enumerate(l):

 #     print(i,v)

 #eval:

 # res=eval('[1,2,3]')

 # print(res,type(res))

 # res=exec('[1,2,3]')

 # print(res)

 #pow

 # res=pow(,,) # ( **  )%

 # print(res)

 #round

 # print(round(3.5))