Day11--Python--函数名,闭包,迭代器

通过 lst.__iter__()拿到lst.的迭代器

1.函数名第一类对象
    函数名就是变量名
    1.函数名可以像变量一样互相赋值.
    2.可以作为函数的参数,进行传递
    3.可以作为返回值返回
    4.可以作为集合的元素进行存储
-----------------------------------------------------
def 函数名(形参):
　　函数体

函数名(实参)   # ()表示调用    #实参必须和形参对得上



    函数名的内存地址:
    def func():
        print('呵呵')
    print(func)

    结果:
    <function func at 0x1101e4ea0>
-----------------------------------------------------
def func_1():
    print("这⾥是函数1")
    def func_2():
        print("这⾥是函数2")
        print("这⾥是函数1")
    return func_2

fn = func_1() # 执⾏函数1. 函数1返回的是函数2, 这时fn指向的就是上⾯函数2
fn()
-----------------------------------------------------
-----------------------------------------------------

2.闭包(函数的嵌套,返回函数名)
    闭包:内层函数对外层函数(非全局)的变量的引用
    用__closure__检测函数是否闭包 函数名.__closure__返回cell就是闭包,返回None就不是闭包

    作用:
        1.保护变量
        2.常驻内存
    基本写法:
        def outer():
            a = 10
            def inner():
                return a
            return inner

 -----------------.__closure__检测函数是否闭包------------------------------------
def func1():
    name = "alex"
    def func2():
        print(name) # 闭包
        func2()
    print(func2.__closure__) # (<cell at 0x10c2e20a8: str object at
0x10c3fc650>,)
func1()

 ----------------在函数外调用内部函数-----------------------------
 def outer():
    name = 'alex'
    def inner():    #内部函数
        print(name)
    return inner

 fn = outer() #访问外部函数,获取到内部函数的函数地址
 fn()  #访问内部函数
 -------------------多层嵌套--------------------------
 def func1():
    def func2():
        def func3():
            print('嘿嘿')
        return func3
    return func2

 func1()()()

 -----------------------------------------------------

3.迭代器
    1. Iterable: 可迭代对象. 内部包含__iter__() 函数
    2. Iterator: 迭代器. 内部包含__iter__()   和 __next__() 函数

    特点:
        1.节省内存
        2.惰性机制(只有执行__next__()才会取值)
        3.只能向前,不能反复

    dir()  查看数据可以执行的方法,查看内置属性
    isinstance()  判断XX对象是否是XXX类型
-------------------------dir()----------------------------
    print(dir(dict))
    print(dir(open('a.txt')))   #打印内容有 __iter__表示可迭代, 对象中有__iter__代表对象遵守可迭代协议
　　 print('__iter__' in dir(str))    #可迭代True,不可迭代False
----------------------isinstance()-------------------------------
    l = [1, 2, 3]
    l_iter = l.__iter__()          #__iter__()获取迭代器
    from collections import Iterable
    from collections import Iterator
    print(isinstance(l, Iterable))  # True
    print(isinstance(l, Iterator))  # False
    print(isinstance(l_iter, Iterable))  # True
    print(isinstance(l_iter, Iterator)) # True

----------------------------------------------------------------------------
# 迭代器给所有的数据类型提供了一种统一的遍历的方式(可迭代协议), Iterable, __iter__()
# lst = [1, 2, 3, 4, 5]
# # print("__iter__" in dir(lst))
# # print("__next__" in dir(lst))

-----------用迭代器中的__next__()获取迭代器中的元素------------------------------------------
s = '我爱健身'
c = s.__iter__()   #获取迭代器
print(c.__next__())  #使用迭代器进行迭代,获取第一个元素   我
print(c.__next__())  #爱
print(c.__next__())  #健
print(c.__next__())  #身
print(c.__next__())   #StopIteration

--------------※※使用while循环和迭代器模拟for循环※※重要,必须掌握---------------------------------------
# for i in [1, 2, 3]:
#    print(i)

lst = [1, 2, 3]
lst_iter = lst.__iter__()
while 1:
    try:
        i = lst__iter.__next__()
        print(i)
    except StopIteration:
        break

-----------------------------------------------------



    for循环内部用的是迭代器
    lst = [1, 2, 3]
    it = lst.__iter__()
    while1:
        try:
            it.__next__()
        except StopIteration:
            break

-------函数名可以当做函数的参数------------------------------------
    def func1():
        print("我是一个单纯的函数")

    def func2(abc): # abc接收到的是一个函数的内存地址
        abc()  # 执行func1, func1()
        print("我是func2", abc)

    # a = "苹果"

    func2(func1)
-----------------------------------------------------
# def panpan():
#     print("我是潘潘. 我喜欢 ")
#
# def xiaoping():
#     print("我是小萍萍. 我喜欢 ")
#
# def xiaohua():
#     print("我是小花花. 我喜欢 ")
#
# def daguanren():
#     print("大官人喜欢xxxx")
#
# def wangpo(nv, nan): # 核心业务逻辑
#     nv()
#     nan()
#
# wangpo(xiaohua, daguanren) # 王婆代理了大官人和潘潘

----------------------查找初始函数名 .__name__ -------------------------------
def chi():
    print("我是吃")

a = chi
haha = a
hehe = haha
bilibili= hehe

bilibili()
print(bilibili.__name__) # 函数名
-----------------------------------------------------
在外界访问内部函数,函数执行完毕后临时空间消失.在内部函数中访问外层函数
中的变量,那这个变量将不会消亡,将会常住内存中,供后面的的程序使用.
# 闭包的应用.保护变量, 常驻内存
from urllib.request import urlopen

def func():
    # 闭包. content会常驻内存
    content = urlopen("http://www.xiaohuar.com/").read()
    def inner():
        return content
    return inner

print("加载中...")
g = func() # 网络请求
print("加载完毕")
print(g())
print(g())
print(g())


-----------------------函数的注释------------------------------
def play(wanjv1, wanjv2, wanjv3):
    '''
        这是一个表示玩儿的函数,可以玩玩具1,玩具2,玩具3,返回心情
        :param wanjv1: 玩具1
        :param wanjv2: 玩具2
        :param wanjv3: 玩具3
        :return: 开心
    '''
    print("我要玩儿荡秋千")
    return "开心"


# play("独木桥", "独轮车", "独眼龙")
print(play.__doc__) #  document   查看注释
print(str.join.__doc__)
-----------------------------------------------------