名称空间与函数基础知识

一、名称空间

       1.1 什么是名称空间？

              答：就是存放变量名与变量值关系的地方。

       1.2 名称空间的分类

                1.内置的名称空间

                    定义：Python解释器中本身就存在的，可以直接使用的。（如len）

                2. 全局的名称空间

                    定义： 在py文件中，顶格编写的变量名等都是全局的名称空间。

               3.  局部名称空间

                    一般大多数都是在函数内部存在的都是局部的！

             每日小知识：名称空间的加载顺序是：内置名称空间->全局名称空间->局部名称。

        1.3 名字的查找顺序

             查找顺序为：局部名称空间->全局名称空间->内置名称空间。

           结论：

                 1. 如果你在局部
                       局部  >>>   全局   >>> 内置
        
                 2. 如果你在全局
                      全局  >>>  内置

                    注：局部变量在外部是不能使用的！

          1.4  名称空间的作用域

                    域：范围   作用域：变量的作用范围

                     1. 内置名称空间
                            在全局的任意位置都能够使用
                     2. 全局名称空间
                            在全局的任意位置任意时间都能够使用
                     3. 局部名称空间
                             一般情况只能够在局部使用

           1.5 global和nonlocal的使用

                   代码展示：

# x = 10

# def index():
#     global x # 声明这个x用的是全局的x
#     x = 20  # 我想在局部修改全局的x的值
#     # print(x)
#
# index()
# print(x) # 10


name_list = ['kevin', 'jerry']


def func():
    name_list.append('tank')


func()
print(name_list) # ['kevin', 'jerry', 'tank']


"""
	如果你想在局部修改全局的变量：
		1. 如果你修改的是不可变的类型，需要global关键字的声明
		2. 如果你修改的是可变类型的，无需使用global关键字声明
"""

nonlocal的使用：
# def outer():
#     x = 666
#     def inner():
#         nonlocal x
#         x = 999
#     inner()
#     print(x) # 此时的x是多少? 666
#
# outer()

def outer():
    name_list = ['a', 'b']
    def inner():
        name_list.append('c')
    inner()
    print(name_list) # 此时的x是多少? 666

outer()

"""
	如果你想在内部的局部修改外部的局部：
		1. 如果你修改的是不可变的类型，需要nonlocal关键字的声明
		2. 如果你修改的是可变类型的，无需使用nonlocal关键字声明
"""

 二、函数对象（函数名）

             定义：函数对象就是函数的名字。有四种玩法‘

           2.1 函数名可以当成变量赋值

            如图所示：

ef index():
    print('index')
    return 123

# print(index())
'''函数名就是函数在内存中得地址'''
# print(index)  # 

a = index
# print(a) # 
res=a()  # index()
print(res)

         2.2 函数名可以的当成函数的实参

             如图所示：

def index():
    print('index')
    return None

def func(a):
    # a：index
    print(a)
    res=a()  # index()
    print(res) # res的结果? None

# index:index函数所在的内存地址
func(index)

         2.3 函数名可以当成函数的返回值

               如图所示：

def index():
    print('index')
    return 'index2'

def func():
    print('func')
    # return index() # 'index'
    return index # 'index'

res = func()  #
print(res)
res1=res()  # index()
print(res1)

             2.4 函数名可以当成容器类型的元素

                如图所示：

def index():
    print('index')
    return None

ll = [11, 22, 33, index]
# ll = [11, 22, 33, index()]
# print(ll[3])

res=ll[3]() # index()
print(res)

三、函数的嵌套调用

         定义：函数套函数

        代码展示：

# 案例：给你四个数，比较大小，返回最大的
# 两个数的比较大小，返回大的

def my_max(a, b):
    if a >b:
        return a
    return b

# res=my_max(1, 2)
# print(res)

##
def many_max(a, b, c, d, e):
    '''四个数的比较大小其实还是要两两比较!'''
    res=my_max(a, b) # res得到a和b中得大的那个
    # 怎么样比较res和剩余的大小， 只需要拿res和c或者d中得一个进行比较
    res1=my_max(res, c) # res1:a,b,c中得最大的那个
    res2=my_max(res1, d)
    res3=my_max(res2, e)
    return res3

res=many_max(11, 12, 3, 24)
print(res)

四、闭包函数

        4.1 什么是闭包函数？

            闭：就是函数内部定义函数，至少要有2层函数.
            包：内部的函数要使用外部函数名称空间中的名字.
        注：只有同时满足以上两个条件，才能称之为是闭包函数

          代码展示：

def outer():
    x = 666
    def inner():
        print('hello', x)
    return inner

outer()

       4.2 闭包函数的使用场景

      1.

 def index(username):
    print(username)
 index('jerry')

      2. 

 比较两个数的大小
 def my_max(a, b):
     if a>b:
         return a
     return b

 my_max(1, 2)