python自动化_day4_迭代器生成器内置函数和匿名函数

什么是可迭代的   含有__iter__方法的就是可迭代的:
    python 可迭代对象——Iterable
        Python中经常使用for来对某个对象进行遍历，此时被遍历的这个对象就是可迭代对象，
        像常见的list、tuple、dict、set、str都是。如果给一个准确的定义的话，就是只要它
        定义了可以返回一个迭代器的iter方法，或者定义了可以支持下标索引的getitem方法，
        那么它就是一个可迭代对象。
    python 迭代器对象——Iterator
        迭代器是通过next()来实现的，每调用一次他就会返回下一个元素，
        当没有下一个元素的时候返回一个StopIteration异常，所以实际上定义
        了这个方法的都算是迭代器。迭代器一定是可迭代对象，反过来则不一定
        成立。用iter()函数可以把list、dict、str等Iterable变成Iterator
什么是迭代器     含有__iter__方法和__next__方法的就是迭代器
Iterable 判断是不是可迭代的。Iterator判断是不是迭代器

l = [1,2,3]
new_l = iter(l)
print(new_l.__next__())
from collections import Iterable,Iterator
print(range(1000000))
print(isinstance(range(10000000),Iterable))
print(isinstance(range(10000000),Iterator))

py2 rangge 不管range多少 会生成一个列表用来存储所有的值
py3 range  不管range多少 都不会实际的生成任何一个值
迭代器的优势：
          节省内存
          取一个值就能进行接下来的计算，而不需要等待所有的值都计算出来才开始接下来的运算--快
迭代器的特性：惰性运算

for i in range(100):
    print(i)
f = open()
for line in f:
    print(f)

列表 字典 元组 字符串 集合 rangge 文件句柄 enumerate  所有能for循环的都是可迭代的，都可以使用next
方法变成一个迭代器

生成器 Genareter
自己写的迭代器就是一个生成器
两种自己写生成器（迭代器）的机制：生成器函数  生成器表达式

生成器函数

def close(num):
    ret = []
    for i in range(num):
        ret.append('cloth%s'%i)
    return ret
def close_g(num):
    for i in range(num):
        yield 'cloth%s' %i  #凡是带有yield的函数就是一个生成器函数
g = close_g(10000)
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())

def func1():
    print('1111')
    yield 1
    print('222222')
    yield 2
    yield 3     #记录当前所在的位置，等待下一次next来触发函数的状态
    yield 4
g = func1()
print(g.__next__())
print(g.__next__())
for i in g:
    print(i)

凡是带有yield的函数就是一个生成器函数
生成器函数的调用不会触发代码的执行，而是会返回一个生成器（迭代器）
想要生成器函数执行，需要用next

s使用生成器监听文件输入的例子

def listen_file():
    with open('userinfo') as f:
        while True:
            line = f.readline()
            if line.strip():
                yield line.strip()
            time.sleep(0.1)
g = listen_file()
for line in g:
    print(line)

send 关键字

def func():
    print(1111)
    ret1 = yield 1
    print(2222,ret1)
    ret2 = yield 2
    print(3333,ret2)
    yield 3

g = func()
ret = g.__next__()
print(ret)
g1 = g.send('alex')  #send 就是在执行next的过程中，生成一个参数，给生成器函数的内部
print(g1)

向生成器中传递值，有一个激活的过程，第一次必须用next触发，后边才可以使用send传参
例子
计算移动平均值
月度 的 天平均收入
第一天200元收入，第二天300元，第三天500元
200  250  333.3333

def average():
    sum_money = 0
    day = 0
    avg = 0
    while True:
        money = yield avg
        sum_money += money
        day += 1
        avg = sum_money / day
g = average()
next(g)
print(g.send(200))
print(g.send(300))

 

预激生成器

def init(func):
    def inner(*args,**kwargs):
        ret = func(*args,**kwargs)
        next(ret)  #
        return ret
    return inner
@init
def average():
    sum_money = 0
    day = 0
    avg = 0
    while True:
        money = yield avg
        sum_money += money
        day += 1
        avg = sum_money / day
g = average()
next(g)         #预激活
print(g.send(200))
print(g.send(300))
预激活做成装饰器，可以节省很多时间  叫做预激生成器
yield from
def generator_func():
    for i in range(5):
        yield i
    for j  in 'hello':
        yield j

g = generator_func()

如何从生成器中取值
第一种  使用next取值  随时可以停止，最后一次会报错
print(next(g))
第二种  使用for循环取值 从头到尾遍历一次，不遇到break不停止
for i in g:
    print(i)
第三种   list取值或者tuple取值 数据类型的强转 会把所有的数据都加载到内存里，非常的浪费内存

print(g)
print(list(g))
def generator_func():
    for i in range(5):
        yield i
    for j  in 'hello':
        yield j
    yield from range(5)
    yield from 'hello'
g1 = generator_func()
g2 = generator_func()
for i in g:
    print(i)
print(g1,g2)
next(g1)
print(next(g1))
print(next(g1))

生成器函数 是我们python程序员实现迭代器的一种手段
主要手段，在函数中 含有yield  有yield就不建议使用return
调用一个生成器函数，不会执行这个函数中的代码，只是会获得一个生成器（迭代器）
只有从生成器中取值的时候，才会执行函数内部的代码，且每获取一个数据才执行得到这个数据的代码
获取数据的方式包括， next send 循环数据类型的强制转换
yield 返回值的简便方法，如果本身就是循环一个可迭代的，且要把可迭代数据中的每一个元素都返回，可以用yield from
使用send的时候，在生成器创造出来之后需要进行预激活，这一步可以使用装饰器完成
生成器的特点：节省内存  惰性运算
生成器用来解决内存问题和程序功能之间的解耦

列表推导式

new_list=[]
for i in range(10):
    new_list.append(i**2)
print(new_list)
print([i**2 for i in range(10)])
print([abs(i) for i in  [1,2,3,-5,6,20,17]])

l = [1,2,3,41,-5]
print([num for num in l if num%2 == 1])
#30以内所有能被3整除的数
print([num for num in range(30) if num%3 == 0])
#30以内所有能被3整除的数的平方
print([num**2 for num in range(30) if num%3 == 0])
#知道嵌套列表中名字含有两个‘e’的所有名字
names = [['Tom','Billy','Jefferson','Arderm','Wesley','Steven','Joe'],
        ['alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva']]
print([name for name_list in names for name in name_list if name.count('e') == 2])

生成器表达式

#30以内所有能被3整除的数
l = [num for num in range(30) if num%3 == 0]  #列表推倒式 排序的时候使用列表推导式
g = (num for num in range(30) if num%3 == 0)  #生成器表达式 庞大数据量的时候使用生成器表达式
print(l)
print(g)

林海峰

egg_list = ['jidan%s' %i for i in range(10)]  #列表解析多少鸡蛋
laomuji = ('jidan%s' %i for i in range(10))   #生成器表达式 用一个鸡蛋拿一个鸡蛋
print(laomuji)
print(laomuji.__next__())
print(egg_list)

面试题

#第一个
def demo():
    for i in range(4):
        yield i
g = demo()
g1 = (i for i in g)
g2 = (i for i in g1)
print(list(g1))
print(list(g2))

#第二个
def add(n,i):
    return n+i
def test():
    for i in range(4):
        yield i

g=test()
for n in [1,10]:
    g = (add(n,i) for i in g)

n = 1
g = (add(n, i) for i in g)
下边的g是上边g的生成器表达式 n永远都是最后的10
n = 10
g = (add(10, i) for i in (add(10, i) for i in [0,1,2,3])) #(add(10, i) for i in [0,1,2,3])=[10,11,12,13]
g = (add(10, i) for i in [10,11,12,13])
g = [20,21,22,23]
print(list(g))

#第三题  这种问题跟循环前面的数字没关系 只跟最后一个和有多少个有关系。
def add(n,i):
    return n+i
def test():
    for i in range(4):
        yield i
g=test()
for n in [1,3,10]:
    g = (add(n,i) for i in g)
n = 1
g = (add(n,i) for i in g)
n = 3
g = (add(n,i) for i in g)
n = 10
g = (add(n,i) for i in (add(n,i) for i in (add(n,i) for i in [0,1,2,3])))
#然后 n = 10 相加
g = (add(n,i) for i in (add(n,i) for i in [10,11,12,13]))
g = (add(n,i) for i in [20,21,22,23])
g = [30,31,32,33]
print(list(g))

一个生成器只能取一次值
生成器在不找他要值的时候，始终不执行
当他执行的时候，要以执行时候的所有变量值为准


迭代器
什么是可迭代的   含有__iter__方法的就是可迭代的:
    python 可迭代对象——Iterable
        Python中经常使用for来对某个对象进行遍历，此时被遍历的这个对象就是可迭代对象，
        像常见的list、tuple、dict、set、str都是。如果给一个准确的定义的话，就是只要它
        定义了可以返回一个迭代器的iter方法，或者定义了可以支持下标索引的getitem方法，
        那么它就是一个可迭代对象。
    python 迭代器对象——Iterator
        迭代器是通过next()来实现的，每调用一次他就会返回下一个元素，
        当没有下一个元素的时候返回一个StopIteration异常，所以实际上定义
        了这个方法的都算是迭代器。迭代器一定是可迭代对象，反过来则不一定
        成立。用iter()函数可以把list、dict、str等Iterable变成Iterator
什么是迭代器     含有__iter__方法和__next__方法的就是迭代器
Iterable 判断是不是可迭代的。Iterator判断是不是迭代器

  生成器
自己写的迭代器就是一个生成器

生成器函数
凡是带有yield的函数就是一个生成器函数
生成器函数的调用不会触发代码的执行，而是会返回一个生成器（迭代器）
想要生成器函数执行，需要用next

生成器的预激活过程
预激活做成装饰器，可以节省很多时间  叫做预激生成器


列表推倒式  和   生成器表达式
l = [num for num in range(30) if num%3 == 0]  #列表推倒式 排序的时候使用列表推导式
g = (num for num in range(30) if num%3 == 0)  #生成器表达式 庞大数据量的时候使用生成器表达式

如何从生成器中取值
第一种  使用next取值  随时可以停止，最后一次会报错
print(next(g))
第二种  使用for循环取值 从头到尾遍历一次，不遇到break不停止
for i in g:
    print(i)
第三种   list取值或者tuple取值 数据类型的强转 会把所有的数据都加载到内存里，非常的浪费内存

预激活做成装饰器，可以节省很多时间  叫做预激生成器


内置函数 不def 定义函数可以直接 加()的都是内置函数
print()
input()
len()
open()
tuple()
list()
bool()
set()
id()
str()
abs()
作用域相关  平时不用
locals()  #返回本地作用域中的所有名字
globals() #返回全局作用域中的所有名字

enumerate 可以按照索引和
l = [1,23,45]
ret = enumerate(l)
for i in ret:
    print(i)

global 变量  关键字   声明函数内部变量对全局生效
nonlocal 变量  关键字 声明函数内部变量对本层以及下边生效

迭代器 生成器相关
range() 是一个可迭代对象 不是迭代器
range(10)
range(1,10,2)
迭代器 .__next__()
next(迭代器)
iter() .__iter__()

其他 dir  查看一个变量拥有的所有方法 不长写在代码里
print(dir([]))
dir([])

callable()  检查一个变量是否可以被调用  后边加（） 就是可以被调用的
print(callable(print))

help 帮助

import os  导入模块 __import__()
某个方法属于某个数据类型的变量，就用.调用
如果某个方法不依赖于任何数据类型，就直接调用 只有内置函数和自己定义的函数是可以直接调用的
剩下的所有内容都是属于数据类型的

open
f = open('file')
f.readline()
f.writable() #可不可以写

跟内存相关
id()
hash()
对于相同可hash的数据的hash值再一次程序的执行过程中总是不变得
 print(hash(12345))
print(hash('12312332'))
print(hash('12312332'))
print(hash(('1','2')))
print(hash([]))  #不可以哈希

输入输出相关
input() #输入一个值才结束
print(self, *args, sep=' ', end='\n', file=None)   # 打印 每一次打印会自动换行
print('我们的祖国是花园',end = '')  #指定输出的结尾
print('我们的祖国是花园')
print('我们的祖国是花园')
print('我们的祖国是花园')

print(1,2,3,4,5,sep = '|') #sep 指定输出分割符

指定一个文件 把文件写入一个文件名为f的文件里
f = open('file','w')
print('a',file=f)
f.close()


打印进度条

import time
for i in range(0,101,2):  #0,2,4,6,8
     time.sleep(0.1)
     char_num = i//2      #打印多少个'*'     4
     if i == 100:
         per_str = '\r%s%% : %s\n' % (i, '*' * char_num)  #\r 回到行首
     else:
        per_str =  '\r%s%% : %s\n'%(i,'*'*char_num)
     print(per_str,end='',flush=True)   # 0.01

exec  eval   都可以执行字符串的看起来是python语句的

exec('print(123)')
eval('print(123)')
print(1+2+3+4)
print(exec('1+2+3+4'))
print(eval('1+2+3+4'))

两个都可以执行字符串类型的代码  eval有返回值简单的计算，exec没有返回值简单的流程控制
eva 只能用在你明确知道你要执行的代码是什么

code = '''for i in range(10):
        print(i*'*')
'''
exec(code)

compile()  将字符串进行编译变成字节码  然后用exec 和eval执行

复数  ---- complex
实数  ---- 有理数：整数 有限循环小数 无限循环小数  和 无理数：π
虚数  ---- 虚无缥缈的数
5 + 12j == 复合的数 == 复数 复数之间不能比较大写

和数字相关 只在数据类型转换的时候才用
float  浮点数（有限循环小数 和  无限循环小数） ！== 小数：有限循环小数 和  无限循环小数 无线不循环小数
浮点数
    354.123 = 3.54123*10**2 = 35.4123*10
f = 1.43287432846824235244645645646
print(f)


进制转换
bin() 二进制
oct() 八进制
hex() 十六进制
0b 二进制
0o 八进制
0x 十六进制

数学运算
print(abs(-7))  绝对值
divmod()  接收两个参数 求商取余  div 是除法  mod 是取余
print(divmod(10,2))
print(round(3.12312,2))  #做精确值 会四舍五入
print(pow(2,3)) #pow 幂运算2的3次方
print(pow(1,23,4)) # 1的23次幂取余4

sum  min  max
sum 求和必须是可迭代的 必须是数字
print(sum(range(10)))
print(sum([1,3,4,5,6],10))


min(iterable, *[, default=obj, key=func]) -> value
min(arg1, arg2, *args, *[, key=func]) -> value
print(min([1,23,4,5,]))
print(min(1,23,4,-4))
print(min([111,-23,4,5],key=abs),)  #可以添加参数key 以绝对值的求最小值
max(*args, key=None)  #可以添加参数key 以绝对值的求最小值
##数据类型有多少：int str list tuple set dict bool。。。。。
##数据结构有多少：容器数据类型list tuple set dict str
##重要的内置函数  reverse
l = [1,23,4]
l.reverse()  #翻转
print(l)
l = [1,2,34,5,6]
l2 = reversed(l) #反转之后成生一个迭代器 不改变原来的列表 保留原来的列表生成一个反序迭代器
print(list(l2))

slice
l = (1,2,3,421,321,3,2131,321)
sli = slice(1,5,2)
print(l[sli])


 format 如果以后对数学相关可以使用format
print(format('test','<20'))
print(format('test','>20'))
print(format('test','^20'))


###bytes 转换成bytes类型
我拿到的是gbk编码，想转换成utf-8类型 需要先转换成Unicode类型在转换成bytes的utf-8

bytearray byte类型的数组
print(bytearray('ninhao',encoding='utf-8'))

l = '2132134214sdasasdsadsa'
memoryview 切片内存
ord()  #字符串转换成数字
chr()  #数字转换成字符串
ascii()

print(repr('1'),repr(1)) #可以原封不动的打印出来
name = 'egg'
print('nihao%r' %name)

dict set
frozenset #集合不可变

最重要的几个  len  enumerate  zip filter map sorted
all 可迭代的  如果里面有一个FALSE就是FALSE
any 可迭代的  有一个True就是True

zip   #拉链 可迭代的 把两个拉到一起组成新的展示  按照最短的
l = [1,2,3]
l2 = ['a','b','c']
l3 = (1,3,4)
l4 = {'k':1,'v':2}
for i in zip(l,l2,l3,l4):
    print(i)

filter() 跟生成器表达式，列表推导式类似 必须跟函数的名字一起使用  用于筛选

def is_odd(x):
    return x and str(x).strip()
ret = filter(is_odd, ['',None,' ',1,2,3,4,7,9]) #filter 生成一个迭代器 节省内存
for i in ret:
    print(i)
print([i for i in [1,2,3,4,7,9] if i % 2 == 1])
from math import sqrt
def m(x):
    return sqrt(x) % 1 == 0
ret = filter(m,range(100))
print(list(ret))
for i in ret:
    print(i)

map()

ret = map(abs,[1,-4,5,19])
print(ret)
for i in ret:
    print(i)

filter 执行了filter之后的结果集合一定是<= 执行之前的个数
        filter 只管筛选，不会改变原来的值
map   元素执行前后个数不变，值可能改变了

sorted 排序 是可迭代的 可以根据要求排序

l = [1,3,4,-5,-7]
l.sort(key=abs)  #sort 在愿列表的基础上进行排序
print(l)
l1 = sorted(l,key=abs) #生成一个全新的列表  排序必须读取所有的数据才可以排序，消耗内存
print(l1)

练习
l = ['     ',[1,2],'hello','wordle']
l1 = sorted(l,key=len)
print(l1)



匿名函数 lambda

cale = lambda n:n**n
print(cale(10))
add = lambda a,b:a+b
print(add(1,2))
dic = {'k1':1,'k2':3,'k3':1}
print(dic[max(dic,key=lambda k:dic[k])])

res = filter(lambda x:x>10,[5,8,11,9,15])
print(list(res))

带key的内置函数：max mix filter map sorted 都可以跟key参数使用 或者说都可以跟lanbda合作

d = lambda p:p*2
t = lambda p:p*3
x = 2
x = d(x)   # x = 4
x = t(x)   # x = 12
x = d(x)
print(x)

现有两元组(('a'),('b')),(('c'),('d')),请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]
匿名函数 ==  内置函数和匿名函数组合  max min map filter sorted

ret = zip((('a'),('b')),(('c'),('d')))
('a', 'c') ('b', 'd')
def func(tup):
    return {tup[0]:tup[1]}
res  = map(lambda tup:{tup[0]:tup[1]},ret)
print(list(res))

3.以下代码的输出是什么？请给出答案并解释。

def multipliers():
    return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()])