过了元旦，加油鸭，冲鸭！！！
闲话不说，开始今日份学习整理。
今日目录，今天的学习内容不是很多！
1.函数名的运用
2.闭包（重要）
3.迭代器（重要）
开始今日份总结
1.函数名的运用
1.1函数名是一个特殊的变量
def func():
print(666)
print(func)
#结果
<function func at 0x000001C2D44E7F28>
#返回函数的内存地址
1.2函数名可以当做变量赋值
def func():
print(666) func2 = func
f1 = func2
f2 = f1
f3 = f2
print(f3)
#结果，返回函数的内存空间
<function func at 0x0000020FA58B7F28>
1.3函数名可以当做容器类数据类型的元素
def func1():
print('func1') def func2():
print('func2') def func3():
print('func3') li =[func1,func2,func3]
for i in li:
i()
#这样就可以一个一个的去调用函数了
1.4函数名可以当做函数的参数
def func(x):
x()
print('in func') def func1():
print('in func1') func(func1)
#结果
in func1
in func
1.5函数名可以当做函数的返回值
def func(x): # x ---> func1
return x # func1 def func1():
print('in func1') ret = func(func1) # func1
ret()
#结果
in func1
2.闭包（重要）
定义：
- 内层函数对于外层函数（非全局）变量的引用
- 闭包值存在于内层函数内
- 函数都要逐层返回，最终返回最外层的函数
- （个人理解）在函数外部可以调用函数内部，同时可以使用内部的值
闭包的确定
#不是闭包
name = 'test'
def func1():
def inner():
print(name)
return inner() f = func1()
print(f.__closure__[0].cell_contents) #结果
AttributeError: 'NoneType' object has no attribute '__closure__'
#表示函数内没有闭包的参数 #是闭包
# 闭包
def func():
age =18
name ='test'
def inner():
print(age)
print(name)
return inner
f = func() # 获取闭包引用的外层变量
print(f.__closure__[0].cell_contents)
print(f.__closure__[1].cell_contents)
#结果
18
test
闭包的用法
需求，输入一个数，连续自加这个数五次，有可能会写成这样
def func(step):
sum = 1
sum += step
print(sum)
i =0
while i <5:
func(3)
i+=1
#结果
4
4
4
4
4
闭包：解释器执行程序时，如果遇到函数，随着函数的结束而关闭临时名称空间，但是！！！
如果遇到闭包，有一个机制：那么闭包的空间不会随着函数的结束而关闭。
重新写一下上面这个需求
def func(step):
sum1 = 1
def inner():
nonlocal sum1
sum1 += step
print(sum1)
return inner
i =0
f =func(3)
while i <5:
f()
i+=1
#结果
4
7
10
13
16
需要注意的是，如果将f =func(3)放入下面循环内部，就会发现打印的都是4，原因呢，就是生产了五个闭包，每个闭包执行了一次。
闭包的常用使用环境
- 装饰器
- 爬虫的一些使用环境（对一个网页重复抓取，之前抓取的内容已经放在内存中）
3.迭代器（重要）
3.1可迭代对象
常用可迭代对象为：str list tuple set range() 文件句柄
可迭代对象：内部含有__iter__方法的就是可迭代对象，遵循可迭代协议，可迭代对象不能直接取值
判断是否是可迭代对象
# 方法一：
s1 = 'barry'
# print('__iter__' in dir(s1))
# print('__iter__' in dir(range(10)))
3.2迭代器
迭代器：内部含有'__iter__'并且含有'__next__'方法的就是迭代器，遵循迭代器协议。
可迭代对象转化成迭代器
可迭代对象.__iter__() 或者 iter(可迭代对象)
s1 = 'abcd'
obj = iter(s1)
print(obj)
print(obj.__next__())
print(obj.__next__())
print(obj.__next__())
print(obj.__next__())
print(obj.__next__())
# 一个next 对应一个值，一一对应。
#结果
a
b
c
d
print(obj.__next__())
StopIteration
判断
一个对象是是迭代器
#方法一：判断一个对象内有没有指定的方法
li =[1,2,3,4]
obj = iter(li)
print('__iter__'in dir(obj) and '__next__'in dir(obj))
#结果
True
#方法二：引入其他模块，进行判断
from collections import Iterable
from collections import Iterator
li =[1,2,3,4]
obj = iter(li)
print(isinstance(obj,Iterable))#判断是否是可迭代对象
print(isinstance(obj,Iterator))#判断是否是迭代器
#结果
True
True
#这个也可以用于判断上面是否是可迭代对象
type() isinstance()区别？
type()只是判断该对象的数据类型
isinstance()不仅可以判断该对象的数据类型，而且可以判断其他很多
迭代器的作用:
1,节省内存.
2,惰性机制.
3, 一条路走到黑,不走回头路.
s2 = [1, 2, 3, 4, 5]
obj2 = iter(s2)
print(next(obj2))
print(next(obj2))
练习
# 练习
# 判断一个对象是否是可迭代对象，迭代器
# str list tuple set dict range() 文件句柄
# f = open('file',encoding='utf-8',mode='w')
# print(isinstance(f,Iterator)) # s2 = [1, 2, 3]
# # 将s2转化成迭代器 进行取值
# obj2 = iter(s2)
# # print(obj2.__next__())
# print(next(obj2)) #while循环模拟for循环机制