《Python》 函数嵌套、闭包和迭代器

一、函数的嵌套：

　　　1、函数的嵌套调用

def max2(x,y):
    m  = x if x>y else y
    return m

def max4(a,b,c,d):
    res1 = max2(a,b)
    res2 = max2(res1,c)
    res3 = max2(res2,d)
    return res3

# max4(23,-7,31,11)

函数的嵌套调用

函数的嵌套调用

　　　2、函数的嵌套定义

函数的嵌套定义

　　　3、函数的作用域链：小范围作用域可以使用大范围的变量，但是反之不行，他是单向的。

def f1():
    a = 1
    def f2():
        def f3():
            print(a)
        f3()
    f2()

f1()
################
def f1():
    a = 1
    def f2():
        a = 2
    f2()
    print('a in f1 : ',a)

f1()

作用域链应用举例

作用域链应用举例

二、 函数名的本质

　　　1、函数名就是函数的地址

　　　　print(func)

　　　2、函数名可以作为变量

 　　　　def func1():
     　　　　print(666)
 　　　　f1 = func1
 　　　　f2 = f1
 　　　　f2()

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

　　　　def func():
  　　　　  print(666)
　　　　def func1():
　　　　    func()
　　　　def func2(x):
　　　　    x()  
　　　　func2(func1)

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

　　　　def wraaper():
   　　　　 def inner():
　　　　        print('inner   ')
　　　　    return inner
　　　　ret = wraaper()  # inner
　　　　ret() # inner()

　　　5、函数名可以作为容器类类型的元素

　　　　def func1():
 　　　　   print('in func1')

　　　　def func2():
　　　　    print('in func2')

　　　　def func3():
　　　　    print('in func3')

　　　　def func4():
　　　　    print('in func4')
　　　　l1 = [func1,func2,func3,func4]
　　　　for i in l1:
　　　　    i()

　　　向上面的函数名这种，第一类对象　　　　　

　　　　第一类对象（first-class object）指
　　　　　　1.可在运行期创建
　　　　　　2.可用作函数参数或返回值
　　　　　　3.可存入变量的实体。

　　　globals()   和 locals()

　　　　globals()：返回全局变量的一个字典

　　　　locals()：返回当前位置的局部变量的字典

三、闭包

　　　内层函数对外层函数的变量(非全局变量)的引用，并返回，就这样形成了闭包。

　　　　def wrapper():

　　　　　　name='alex'

　　　　　　def inner():

　　　　　　　　print(name)

　　　　　　inner()

　　　　　　return inner

　　　　wrapper()

　　　闭包的作用：

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

#输出的__closure__有cell元素 ：是闭包函数
def func():
    name = 'eva'
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f = func()
f()

#输出的__closure__为None ：不是闭包函数
name = 'egon'
def func2():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f2 = func2()
f2()

判断闭包函数的方法__closure__

def wrapper():
    money = 1000
    def func():
        name = 'eva'
        def inner():
            print(name,money)
        return inner
    return func

f = wrapper()
i = f()
i()

闭包嵌套

闭包嵌套

from urllib.request import urlopen

def index():
    url = "http://www.xiaohua100.cn/index.html"
    def get():
        return urlopen(url).read()
    return get

xiaohua = index()
content = xiaohua()
print(content)

闭包函数获取网络应用

闭包函数获取网络应用

四、迭代器

　　　　1、可迭代对象：str,list,dict,tuple,set,range()

　　　　2、对象内部含有__iter__方法就是可迭代对象

　　　　3、可迭代对象满足可迭代协议

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

　　　　　第一种方法：print ('__iter__' in  dir (s1))

　　　　　第二种方法：from collcetions import iterable可迭代对象/Iterator迭代器

　　　　　　　print(isinstanse)('alex',Iterable)

　　　　　　　print(isinstanse)('alex',Iterator)

　　　迭代器：对象内部含有__iter__方法且含有__next__方法就是迭代器

　　　可迭代对象vs迭代器

　　　　　可迭代对象不能取值，迭代器是可以取值的，但是可迭代对象可以转化成迭代器

　　　　　　　　lis=[1,2,3]

　　　　　　　　itrl=lis.__iter__()

　　　　　　　　print(itrl.__next__())

　　　　　迭代器如何取值：__next__一次取一个值

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

　　　　(1)可迭代对象不能取值，迭代器可以

　　　　(2)迭代器非常节省内存

　　　　(3)迭代器每次只会取一个值

　　　　(4)迭代器是单向的，不回头

　　　for 循环：

　　　　将可迭代对象转化成迭代器

　　　　调用__next__方法取值

　　　　利用异常处理停止报错

　　　　s1 = 'kfdsjl'

　　　　iter1 = s1.__iter__()

　　　　while 1:
  　　　　  try:
 　　　　      print(iter1.__next__())
　　　　    except StopIteration:
    　　　　   break