学习Python的第9天

1.名称空间与作用域

1.1名称空间

定义：存放变量名和变量值关系的地方

1.1.1名称空间的分类

1.内置的名称空间

在Python解释器中本来就存在的可以直接使用的。

2.全局的名称空间了

在Python中顶格编写的变量名等，都是全局变量

name='jerry'
             def index():
                    pass
                
             if a:
                pass
            
             while b:
                    pass
                
             for i in range(10):
                pass

一般在函数外部存在的变量都是全局变量

3.局部名称空间

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

ef index():
            a=1
            b=2

一般在局内存在的变量都是局部变量

1.2名字查找的顺序

定义：只要有了全局的名称空间和局部的名称空间就会存在名字的查找顺序。

总结：

1.如果你在局部

局部——全局——内置

2.如果你在全局

全局——内置

局部变量在外部是无法使用的

# 在函数内部打印出来的结构都输属于当前函数的局部名称空间
    print(locals()) # {'a': 1, 'name': 'kevin'}
	print(globals()) # 只要是存在于globals这个大字典中得都属于全局的

1.3名称空间的作用域

域：范围

作用域：变量的作用范围

1.内置名称空间

在全局中使用，是Python中自带的。

2.全局名称空间

在全局的任意时间任意位置都能使用

3.局部名称空间

一般情况只能在局内使用

1.4global和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关键字声明

​
 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.函数的对象与闭包

2.1函数对象（函数名）

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

1.

函数名可以当成变量赋值
 用法法一：
def index():
    print('index')
    return 123

 print(index())
'''函数名就是函数在内存中得地址'''
 print(index)  # <function index at 0x0000022FD03AD550>

a = index
 print(a) # <function index at 0x0000022D4E03D550>
res=a()  # index()
print(res)

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)

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)

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)

2.2函数的嵌套调用

定义：函数套函数

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

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)

2.3闭包函数

定义：闭包函数还是函数是函数演变过来的，

闭：就是函数内部的定义函数，至少要有两成函数

包：内部的函数要使用外部的函数名称中空间的名字

他俩合起来就是闭包函数

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

outer()


# 闭包函数的使用场景：
闭包函数其实是第二种传参方式!

# 第一种传参方式

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

# 第二种传参方式
# 比较两个数的大小
# def my_max(a, b):
#     if a>b:
#         return a
#     return b
#
# my_max(1, 2)


# 让你用闭包函数实现比较2个数的大小:一次传值，多次使用
def outer(a, b):
    # a = 100
    # b = 200

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

    return my_max


res = outer(1, 10)  # my_max函数的内存地址
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()

res1=outer(10, 20) # res1:my_max
print(res1())
print(res1())
print(res1())
print(res1())
print(res1())
print(res1())
print(res1())
print(res1())
print(res1())