python day13
1.复习
# 函数 —— 2天 # 函数的定义和调用 # def 函数名(形参): #函数体 #return 返回值 #调用 函数名(实参) # 站在形参的角度上 ： 位置参数，*args，默认参数（陷阱），**kwargs # 站在实参的角度上 ： 按照位置传，按照关键字传 # 返回值：没有返回值 返回一个值 返回多个值 # 接收返回值：没有返回值不接收，返回一个值用一个变量接收，返回多个值用一个变量或者对应数目的变量接收 # 闭包函数 —— 在内部函数引用外部函数的变量 # 装饰器函数—— 装饰器一定是闭包函数 # 装饰器的作用 ： 在不改变原来函数的调用方式的情况下 在这个函数的前后添加新的功能 # 完美的符合了一个开发原则 ：开放封闭原则 # 对扩展是开发的 # 对修改是封闭的 # 基础的装饰器 # from functools import wraps # def wrapper(func): # @wraps(func) # def inner(*args,**kwargs): # '''在函数被调用之前添加的代码''' # ret = func(*args,**kwargs) # func是被装饰的函数 在这里被调用 # '''在函数被调用之后添加的代码''' # return ret # return inner # 使用 —— @wrapper # @wrapper # def func(): #inner # pass # # func.__name__ # 带参数的装饰器 # @wrapper -- > @warapper(argument) # 三层嵌套函数 # def outer(形参): # def wrapper(func): # def inner(*args,**kwargs): # '''在函数被调用之前添加的代码''' # ret = func(*args,**kwargs) # func是被装饰的函数 在这里被调用 # '''在函数被调用之后添加的代码''' # return ret # return inner # return wrapper # @outer(True) # def func(): # pass # 多个装饰器装饰一个函数 # 俄罗斯套娃 #def wrapper1(func): # @wraps(func) # def inner(*args,**kwargs): # print('before 1') # print('******') # ret = func(*args,**kwargs) # func是被装饰的函数 在这里被调用 # '''在函数被调用之后添加的代码''' # return ret # def wrapper2(func): # @wraps(func) # def inner(*args,**kwargs): # print('before 2') # ret = func(*args,**kwargs) # func是被装饰的函数 在这里被调用 # '''在函数被调用之后添加的代码''' # return ret # @wrapper1 # @wrapper2 # def func(): # print('111') # 迭代器和生成器 —— 两天 # 内置函数 —— 两天
2.迭代器
可循环的：
字符串、元组、列表、字典、集合，file=open()、range()、enumerate(枚举)
print(dir([])) #告诉我列表拥有的所有方法
# 双下方法 print([1].__add__([2])) print([1]+[2])
快速判断__iter__：
只要是能被for循环的数据类型 就一定拥有__iter__方法
print(dir([])) #告诉我列表拥有的所有方法
ret = set(dir([]))&set(dir({}))&set(dir(''))&set(dir(range(10)))
print(ret) #iterable
print('__iter__' in dir(int))
print('__iter__' in dir(bool))
print('__iter__' in dir(list))
print('__iter__' in dir(dict))
print('__iter__' in dir(set))
print('__iter__' in dir(tuple))
print('__iter__' in dir(enumerate([])))
print('__iter__' in dir(range(1)))
一个列表执行了__iter__()之后的返回值就是一个迭代器：
print(dir([])) print(dir([].__iter__())) print(set(dir([].__iter__())) - set(dir([]))) print([1,'a','bbb'].__iter__().__length_hint__()) #元素个数 l = [1,2,3] iterator = l.__iter__() print(iterator.__next__()) print(iterator.__next__()) print(iterator.__next__()) print(iterator.__next__()) # Iterable 可迭代的 -- > __iter__ #只要含有__iter__方法的都是可迭代的 # [].__iter__() 迭代器 -- > __next__ #通过next就可以从迭代器中一个一个的取值
只要含有__iter__方法的都是可迭代的 —— 可迭代协议
迭代器协议————内部含有__next__和__iter__方法的就是迭代器
print('__iter__' in dir( [].__iter__()))
print('__next__' in dir( [].__iter__()))
from collections import Iterable from collections import Iterator print(isinstance([],Iterator)) print(isinstance([],Iterable))
执行结果：
False True
列表是可迭代的，但不是迭代器。
例子1：既是迭代器又是可迭代的
class A:
def __iter__(self):pass
def __next__(self):pass
a = A()
print(isinstance(a,Iterator))
print(isinstance(a,Iterable))
执行结果：
True True
例子2：不是迭代器，但是可迭代的
class A:
def __iter__(self):pass
#def __next__(self):pass
a = A()
print(isinstance(a,Iterator))
print(isinstance(a,Iterable))
执行结果：
False True
例子3：既不是迭代器，又不是可迭代的
class A:
# def __iter__(self):pass
def __next__(self):pass
a = A()
print(isinstance(a,Iterator))
print(isinstance(a,Iterable))
执行结果：
False False
# 迭代器协议和可迭代协议
# 可以被for循环的都是可迭代的
# 可迭代的内部都有__iter__方法
# 只要是迭代器 一定可迭代
# 可迭代的.__iter__()方法就可以得到一个迭代器
# 迭代器中的__next__()方法可以一个一个的获取值
l = [1,2,3,4]
for i in l.__iter__():
print(i)
for
只有 是可迭代对象的时候 才能用for
当我们遇到一个新的变量，不确定能不能for循环的时候，就判断它是否可迭代
print("__iter__" in dir(range(2)))
#迭代器的好处：
# 从容器类型中一个一个的取值，会把所有的值都取到。
# 节省内存空间
#迭代器并不会在内存中再占用一大块内存，
# 而是随着循环 每次生成一个
# 每次next每次给我一个
例子：
本质上range并没有现在内存空间中生成相应的那么多数据，而是一个个生成。文件一行行访问也是
range
f
模仿for循环一个迭代的例子，回报StopIteration的错误。
l = [1,2,3,45]
iterator = l.__iter__()
while True:
print(iterator.__next__())
print(range(100000000000000))
print(range(3))
print(list(range(3)))
3.生成器
查看python day 12生成器概念
普通函数：
def generator():
print(1)
return 'a'
ret = generator()
print(ret)
执行结果：
1 a
生成器函数例子1：
#只要含有yield关键字的函数都是生成器函数
# yield不能和return共用且需要写在函数内
def generator():
print(1)
yield 'a'
# #生成器函数 ： 执行之后会得到一个生成器作为返回值
ret = generator()
print(ret)
print(ret.__next__())
执行结果：
<generator object generator at 0x000000000563BAF0> 1 a
生成器函数例子2：
def generator():
print(1)
yield 'a'
print(2)
yield 'b'
yield 'c'
g = generator()
print(g)
ret = g.__next__()
print(ret)
执行结果：
<generator object generator at 0x0000000005755468> 1 a
生成器函数例子3：
def generator():
print(1)
yield 'a'
print(2)
yield 'b'
yield 'c'
g = generator()
print(g)
ret = g.__next__()
print(ret)
ret = g.__next__()
print(ret)
ret = g.__next__()
print(ret)
执行结果：
<generator object generator at 0x0000000005755410> 1 a 2 b c
生成器函数例子4：
def generator():
print(1)
yield 'a'
print(2)
yield 'b'
yield 'c'
g = generator()
print(g)
for i in g:
print(i)
执行结果：
<generator object generator at 0x000000000563BAF0> 1 a 2 b
生成器函数例子5： 生产200万个娃哈哈
#娃哈哈%i
def wahaha():
for i in range(100):
yield '娃哈哈%s'%i
g = wahaha()
count = 0
for i in g:
print(i)
生成器函数例子6：for取了所有，但是我只想要50个
def wahaha():
for i in range(100):
yield '娃哈哈%s'%i
g = wahaha()
count = 0
for i in g:
count += 1
print(i)
if count > 50:
break
生成器函数例子7：接着往后一直取
#娃哈哈%i
def wahaha():
for i in range(100):
yield '娃哈哈%s'%i
g = wahaha()
count = 0
for i in g:
count += 1
print(i)
if count > 50:
break
print(g.__next__())
生成器函数例子8：接着往后一直取，比如先取50个，再取50个
#娃哈哈%i
def wahaha():
for i in range(100):
yield '娃哈哈%s'%i
g = wahaha()
count = 0
for i in g:
count += 1
print(i)
if count > 50:
break
for i in g:
count += 1
print(i)
if count > 100:
break
疑惑1：列表是可迭代的，并不是迭代器。
执行结果：
相当于：
def wahaha():
for i in range(100):
yield '娃哈哈%s'%i
g = wahaha()
g1 = wahaha()
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g1.__next__())
监听文件输入的例子：
一边在文件file，中输入，一边输出查看
def tail(filename):
f = open(filename,encoding='utf-8')
while True:
line = f.readline()
if line.strip():
yield line.strip()
g = tail('file')
for i in g:
if 'python' in i:
print('***',i)
