一.名称空间
1.什么是名称空间
就是存放变量名和变量值关系的地方
2.名称空间的分类
- 内置名称空间：Python解释器中本身就存在的，可以直接拿来使用，例如len···
- 全局名称空间：在Python文件中，顶格编写的变量名都是全局的空间名称（在函数外部存在的变量都是全局变量）
- 局部变量名称：一般大多数都是在函数内部存在的都是局部的（在函数内部存在的变量都是局部变量）
'''全局空间名称：'''
name='jerry'
def index():
pass
if a:
pass
while b:
pass
for i in range(10):
pass
'''局部空间名称'''
def index():
a=1
b=2
...3.名字的查找顺序
只有有了全局的名称空间和局部的名称空间就会存在名字的查找顺序
- 如果当前在局部：
局部 -------> 全局 ---------> 内置 - 如果当前在全局：
全局 --------> 内置
局部变量在外部是不能使用的
'''局部空间名称的嵌套'''
def f1():
# x = 222
def f2():
print('f2')
# x = 333
def f3():
print('f3')
# x = 444
def f4():
# x = 555
print(x)
f4()
f3()
f2()
f1()4.名称空间的作用域
域：范围
作用域：变量的作用范围
- 内置空间名称：在全局的任意位置都能够使用
- 全局名称空间：在全局的任意位置任意时间都能够使用
- 局部名称空间：一般情况只能够在局部使用
5.global和nonlocal使用
global：
# 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：
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关键字声明
"""二.函数
1.函数对象（函数名）
什么是函数对象：函数对象就是函数名字
2.函数对象的使用
方法一：函数名当作变量赋值
方法二：函数名当成函数的实参
方法三：函数名当成函数的返回值
方法四：函数名当成容器类型的元素
'''方法一'''
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)
'''方法二'''
def index():
print('index')
return None
def func(a):
# a：index
print(a)
res=a() # index()
print(res) # res的结果? None
# index:index函数所在的内存地址
func(index)
'''方法三'''
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)
'''方法四'''
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)3.函数的嵌套调用
# 案例：给你四个数，比较大小，返回最大的
# 两个数的比较大小，返回大的
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.闭包函数
什么是闭包函数：
闭：闭就是函数内部定义函数，至少要有两层函数
包：包就是内部的函数要使用外部函数名称空间中的名字
只有同时满足这两个条件才能是闭包函数
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())
