函数的嵌套调用闭包函数，函数对象

函数嵌套：
函数嵌套：
嵌套指的是，一个物体包含另一个物体，函数嵌套就是一个函数包含另一个函数
按照函数的两个阶段
嵌套调用
指的是在函数的执行过程中调用了另一个函数，其好处可以简化外层大函数的代码，使得结构更清晰
可以将一个大的复杂的功能拆成多个简单的小功能

嵌套调用的好处：

def max（a,b）:
if a>b:
return a
return b
print(max(100,200))
嵌套调用：

def max_3(a,b,c):
temp=max(a,b)
m=max(temp,c)
return m
print(max_3(100,200,300))

def func1():
print('func1 run !')
def func2():
print('func2 run !')
func1()
func2()
嵌套定义
值得是在函数的函数体中定义了另一个函数体称作为函数的嵌套定义
特点：
需要注意的是，内部定义的函数只能在内部使用，外部无法直接访问，
唯一的使用场景是闭包函数，除此之外不要这么写

def outer():
print('outer run')
def inner():
print('inner run')
inner()
outer()
名称空间：
存储名字的内存区域
名称空间的分类：
x=10
内置名称空间：存的是解释器自带的名称print len ...
顺着解释器的启动二生效，随着解释器关闭而失效

在任何位置都能访问到

全局名称空间：
只要是顶着最左边写的没有任何缩进的，就在全局名称空间中
程序运行的过程中，在所有位置都能访问到一直有效，随着文件的结束而失效
需要注意的是在 if 中，如果if是顶着最左边的没有缩进的，if里面的名字也是全局变量
同样的 while，for，with，都是如此
if 1==1：
age=18 全局变量
print(age)

局部名称空间
存的是函数内部定义的名字，
特点：仅在函数调用中零时有效
生命周期：随着函数的调用而生效，随着函数的调用结束而失效
名字查找顺序：
局部》--全局>>--内置
名称空间的加载顺序
内置》-全局》》--局部

作用域：
作用区域，作用范围，有效范围
简单的说就是名字的有效范围
存储名字的有三个范围
内置名称空间
全局名称空间

局部名称空间：
由于内置名称空间的名字与全局名称空间的名字，可以在任何位置来访问
所以他们两可以划分到同一个范围内，称作全局作用域

局部名称空间的名字，只能在当前的函数中访问，所以他划到了单独的一个范围中
这个范围称之为局部作用的范围即局部作用域
global（全局）与 nonlocal （不使用本地）关键字
global 当需要在函数内部修改全局名字值得时候需要使用global
注意，必须在使用这个名字之前声明写（global）
a=100
def func():
global a
a=1# 改写法，既有修改a的值得意思，也有定义变量的意思默认在函数中都是定义新的变量
func()
print(a)
应用场景
is_login = False
# def login(name,pwd):
# global is_login
# if name == "cgon" and pwd == "8848":
# print("登录成功!")
# is_login = True
#
# login("cgon","8848")
# print(is_login)

nonlocal
当需要在内层函数中修改外层函数中的名字，就是需要nonlocal
会一层一层的往外找，直到找到了找到位置，但是只能在函数中找，不能找全局

a=0
def f1():
# a = 1
# def f2():
# def f3():
# nonlocal a
# a = 3
# f3()
# print("f2 中的a", a)
# f2()
# print("f1 中的a",a)
# f1()
# print("全局的a",a)
#

函数对象
目的是为了让你知道函数都可以怎么使用
面向对象经典语录：
万物皆对象
函数是第一类对象
1、能够被调用，
2、可以当做容器类型的元素
3、可以当做函数的参数
4、可以当做函数的返回值
函数名除了可以调用之外与一个变量名，没有什么区别，函数名怎么用变量名怎么用

闭包函数;
闭包：一个函数将另一个函数关闭在内部，反着来说一个函数被另一个函数包裹
闭包函数也是一种函数
特点：
1、该函数是定义在另一个函数中的
2、该函数包含了对外层函数中名字的引用，无论在任何位置使用这个函数，其都包含了外部名字的引用
满足以上两条，就称之为闭包函数
需要注意的是：名字所在的作用域在函数定义阶段就已经固定了，与调用位置无关
现阶段可以将闭包函数理解为另一种为函数传值的方式
之前只能通过参数给函数传值
现在可以通过闭包的方式

  def counter():
            n=0
            def incr():
                nonlocal n
                x=n
                n+=1
                return x
            return incr

        c=counter()
        print(c())
        print(c())
        print(c())
        print(c.__closure__[0].cell_contents) #查看闭包的元素

def func1():
def func2():
pritn('func2,run')
func2()

func1()

由于名称空间与作用域的特点，内层定义的对象只能在函数内使用
而函数对象可以将一个函数作为返回值，使得内部函数也可以被外界使用

outer():
name = "扎尔伯克"
def inner():
print("name :",name)
# inner()
return inner

inner = outer()
name = "比尔盖茨"
inner()

闭包函数的应用：
"""

"""
import requests

def get_page(url):
res = requests.get(url)
return res.text

def load(url):# url = https://www.qq.com
# 把URL函数包给get_page函数
def get_page():
res = requests.get(url)
return res.text
return get_page

qq = load("https://www.qq.com") # 拿到get_page的同时也拿到了包裹的url参数
res = qq()
print(res)
print("==========================================================")
res2 = qq()
print(res2)

# qq = get_page("https://www.qq.com")

函数的嵌套调用 闭包函数，函数对象

函数的嵌套调用闭包函数，函数对象