认知: 随着年龄阅历的变化而变化。
01 去年内容回顾
*args **kwargs: 万能参数，动态参数
* 魔性用法：
函数的定义时，* ** 聚合。
函数的执行时，* ** 打散。
形参顺序：
位置参数，*args，默认参数，**kwargs
名称空间：
临时名称空间：
内置名称空间:
作用域：
全局作用域：内置名称空间，全局名称空间。
局部作用域：临时名称空间（局部名称空间）。
加载顺序： 内置名称空间 全局名称空间 临时名称空间
取值顺序：就近原则，LEGB。
内置函数：
globals(): 返回一个字典：全局作用域的内容。
locals() : 返回一个字典：当前作用域的内容。
关键字：
global：
1，在局部作用域可以声明一个全局变量。
2，在局部作用域可以对全局变量进行修改。
nonlocal：
1，不能对全局变量进行修改。
2，子级对父级函数的变量的修改。
02 作业讲解
03 函数名的运用
04 闭包
05 迭代器
#03 函数名的运用
#1 函数名是一个特殊的变量
# def func():
# print(666)
# print(func)
#2 函数名可以当做变量赋值
# f1 = 2
# f2 = f1
# f3 = f2
# print(f3)
# def func():
# print(333)
# func1 = func
# f2 = func1
# f3 = f2
# print(f3)
# f3()
#3 函数名可以当做容器类数据类型的元素
# def func1():
# print('in func1')
#
# def func2():
# print('in func2')
#
# def func3():
# print('in func3')
#
# l1 = [func1,func2,func3]
# for i in l1:
# i()
#4 函数名可以当做函数的参数
# def func(x):
# print(x)
# x()
# print('in func')
#
# def func1():
# print('in func1')
#
# func(func1)
#5 函数名可以当做函数的返回值
# def func(x):
# return x
#
# def func1():
# print('in func1')
#
# func(func1)()
#函数名也成为第一类对象
#04 闭包
#闭包:
#1,内层函数对外层函数(非全局)变量的引用
#2,闭包只存在于内层函数中
#3,函数都要逐层返回,最终返回给最外层的函数
# 坑:引用也是闭包
# n = 'mo'
# def func(n):###n引用,相当于在里面执行 n = 'mo'
#不是闭包例子:
# name = 'alex'
# def func():
# def inner():
# print(name)
# return inner
# f = func()
# print(f.__closure__[0].cell_contents) #??? /\
#闭包
# def func():
# name = 'alex'
# age = 12
# def inner():
# print(age)
# print(name)
# return inner
# f = func()
#获取闭包引用的外层变量
# print(f.__closure__[0].cell_contents)
# print(f.__closure__[0].cell_contents)
# def func(n):
# def inner():
# print(n)
# return inner
# name = '太白'
# f = func(name)
# print(f.__closure__[0].cell_contents) #??? /\ f = func(name)
# def func(n):
# n = name
# def inner():
# print(n)
# return inner
# name = '太白'
# f = func(name)
# print(f.__closure__[0].cell_contents)
#闭包有什么用???
# def func(step):
# num = 1
# num += step
# print(num)
# j = 0
# while j < 5:
# func(3)
# j +=1 ##每次结果一样
#闭包:解释器执行程序时,如果遇到函数,随着函数的结束而关闭临时命名空间,但是!!!
#如果遇到闭包,有一个机制:那么闭包的空间不会随着函数的结束而关闭
# def wrapper(step): ###执行过程???
# num = 1
# def inner():
# nonlocal num
# num += step
# print(num)
# return inner
# f = wrapper(3)
# j = 0
# while j < 5:
# j += 1
# f() #等同于inner()
#闭包的应用:
#1 装饰器
#2 爬虫
#05 迭代器
#iterable:可迭代对象:
#str list tuple set dic range() 文件句柄
# for i in 'abcd':
# print(i)
# for i in 123:
# print(i)#报错:TypeError: 'int' object is not iterable
#可迭代对象:内部含有__iter__方法的就是可迭代对象,遵循可迭代协议
s1 = 'barry'
# l1 = [1,2,3]
# print(dir(s1))#列出s1包含的所有方法
#判断一个对象是否是可迭代对象,迭代器
#方法一:
# print('__iter__' in dir(s1))
# print('__iter__' in dir(range(10)))
#可迭代对象不能直接取值
#迭代器:内部含有'__iter__'并且含有'__next__'方法的就是迭代器,遵循迭代器协议
#可迭代对象转化成迭代器:
# 可迭代对象.__iter__()或者iter(可迭代对象)
# obj = s1.__iter__()
# s1 = 'abcd'
# obj = iter(s1)
# print(obj)
# print(obj.__next__())
# print(obj.__next__())
# print(obj.__next__())
#逐个取出迭代器里的元素,一个next对应一个值,一一对应
# print(dir(obj))
# print('__iter__' in dir(obj) and '__next__' in dir(obj))
#方法二:
# from collections import Iterable
# from collections import Iterator
# s1 = 'abcd'
# obj = iter(s1)
# print(isinstance(obj,Iterable))
# print(isinstance(obj,Iterator))
# type()与isinstance()的区别:
#type()只是判断该对象的数据类型
#isinstance()不仅可以判断该对象的数据类型,而且可以判断其他很多
from collections import Iterable
from collections import Iterator
# s1 = 'abcd'
# print(isinstance(s1,str))
# print(type(s1))
# 迭代器的作用:
# 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 循环机制
# l1 = [i for i in range(20)]
# s1 = 'fsdhjkafjdsfalkdjsflksd;f'
# obj = iter(s1)
# while 1:
# try:
# print(next(obj))
# except StopIteration:
# break