函数名的作用：函数也是第一类对象

函数名的作用：函数也是第一类对象

​ 1.函数名就是函数的内存地址

　　2.函数名可以作为变量

　　3.函数名可以作为函数的参数

　　4.函数名还可以当做函数的返回值

　　5.函数名可以作为容器类型的元素（列表中的一个元素）

globals（）　　　　locals（）

​ globals() #作用是 返回全局变量的一个字典

　　locals（） # 返回当前位置的局部变量的字典

def func1():
    a =1
    b = 2
    print(globals())
    print(locals())    #{'b': 2, 'a': 1}
func1()
#{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000026005C0D240>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'G:/骑士计划/2018-8-17/8-17草稿.py', '__cached__': None, 'lis': [1, 2, 3, 4], 'func1': <function func1 at 0x0000026005BB2EA0>}


#{'b': 2, 'a': 1}

闭包：即在函数内部，内层函数对外层函数的变量（非全局变量）的引用，并返回

判断这个函数是否形成了闭包，用 函数名.closure 来进行判断

def wraaper():
    name = 'alex'
    def inner():
        print(name)
    print(inner.__closure__)    #输出结果不是None，就说明形成了闭包
    inner()
    return inner
wraaper()
输出结果#(<cell at 0x00000254669A85B8: str object at 0x0000025466A39110>,)
alex

a = "alex"
def func1(b):
    # a = "alex"　　　　#即相当于在函数内部定义了一个变量a = "alex”
    def func2():
        print(b)
    print(func2.__closure__)
    func2()
func1(a)　　#运行时将外部的变量a加载到函数内
#输出结果为(<cell at 0x0000025E4A4285B8: str object at 0x0000025E4A4B9110>,)
alex#所以这种情况是一个闭包

闭包的作用：当程序运行时，遇到函数执行，他就会在内存中开辟一个空间，（局部名称空间），如果这个函数内部形成了闭包。那么他就不会随着函数的结束而消失。

可迭代对象　　迭代器

可迭代对象定义：对象内部含有__iter__方法的就是可迭代对象。（str，list,dict,tuple,tange()）

　　　　　　　　　　而当可迭代对象签订了可迭代协议就形成了迭代器

　　迭代器定义：内部含有__iter__和__next__的方法就是迭代器。即存在__next__的方法就是迭代器

可迭代对象与迭代器的区别：

1.可迭代对象不能直接取值，而迭代器可以直接取值

　　2.迭代器非常节省内存，

　　3.迭代器每次只能去一个值

　　4,迭代器是单向的，一直到底

判断一个对象是否是可迭代对象的方法：

1.判断__iter__是否在这个对象里

lis = [1,2,3]
print("__iter__" in dir(lis))    #返回结果为True则说明该对象是可迭代对象

dir（） 显示出你这个参数的所有方法，装在一个列表里

　　2.from collections import Iterable 在 文件（colletions） 导入 这个 可迭代的（Iterable）

　　　from collections import Iterator 在文件（colletions）导入 这个 迭代器（ Iterator）　　（自我理解，非专业术语）

from collections import Iterable
from collections import Iterator

print(isinstance('alex',Iterable))  # True 
print(isinstance('alex',Iterator))  # False    是否是迭代器
#isinstance() 判断类型，即“alex”是不是可迭代对象    （自我解释，非专业）

可迭代对象转换成迭代器的方法

1.lis.iter()

　　2.iter(lis)

# lis = [1, 2, 3]  # 可迭代对象
# # ite1 = lis.__iter__()  # 迭代器  <list_iterator object at 0x0000027A183BFFD0>
# ite1 = iter(lis)  # 迭代器  <list_iterator object at 0x0000027A183BFFD0>
# print(ite1)

迭代器取值：next（），或者 对象.next()

lis = [1,2,3]
l1 = lis.__iter__()
print(l1)
print(l1.__next__())    #1
print(next(l1))        #2

例题，用while循环模拟出for循环的过程（了解，）

# iter1 = s1.__iter__()
#
# while 1:
#     try:　　
#         print(iter1.__next__())
#     except StopIteration:　#　StopIteration报错原因
#         break　　#遇到抱歉就结束循环先了解。

装饰器语法糖

# def create_people():
# 	print('女娲真厉害，抓把捏一下吹口气，就成了人!!')

def a(func):
	def b():
		print('加点水')
		func()
	return b
# ret=a(create_people) #内层的b函数
# ret()

# create_people=a(create_people) #内层的b函数，引用了func,func-->create_people
# create_people()  #相当于调用了内层函数b
@a
def create_people():
	print('女娲真厉害，抓把捏一下吹口气，就成了人!!')

create_people()

@a #相当于把被装饰的函数当成参数传给a,然后把返回值再赋值给被装饰的函数名
def create_pig():
	print('女娲真厉害，抓把捏猪')

create_pig()

@a
def create_dog():
	print('捏个狗')
create_dog()