函数名的运用,装饰器语法糖的运用

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

　　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　　#遇到抱歉就结束循环
先了解。

 装饰器语法糖

至关于