The Fourth Day

迭代器

 迭代器：迭代的工具
 .什么是迭代：指的是一个重复的过程，每次重复称为一次迭代，并且每次重复的结果是下一次重复的初始值
 例：
     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))