Python名称空间和作用域，闭包函数

抛头露面

Python名称空间和作用域，闭包函数

• 名称的查询顺序
  
• 名称空间的作用域
  
• global和nonlocal关键字的使用
  
• 函数对象（函数名）
  
• 函数的嵌套调用
  
• 函数的嵌套定义
  
• 闭包函数
  

名称空间

定义

1. # 什么是名称空间?
2.         名称空间即存放名字与对象映射/绑定关系的地方。
3.         就是存放变量名与变量值关系的地方

复制代码

名称空间的分类

1. 1.内置的名称空间
2.         内置:就在python解释器里面，可以直接使用
3.         """一般大多数都是在函数内部存在的都是局部的!"""
4.         def index():
5.             a=1
6.             b=2
7. 2.全局的名称空间
8.         全局：在py文件中顶格编写的变量名就是全局变量
9.                      name='jerry'
10.              def index():
11.                     pass
12.                
13.              if a:
14.                 pass
15.             
16.              while b:
17.                     pass
18.                
19.              for i in range(10):
20.                 pass
21.             
22. 全局变量：
23.         在函数外的变量就是全局变量
24. 局部变量：
25.         在函数内部的变量就是局部变量
26.    

复制代码

名称查询顺序

1. 既然有全局变量和局部变量那么就一定会有查询顺序
3. 名称空间的加载顺序是（在内置）：内置名称空间->全局名称空间->局部名称空间
4. 如果你在全局：全局--->内置
5. 局部变量在外部是不能被使用的
6. 在函数内部打印出来的结构都属于当前函数的局部名称空间
7. """局部名称空间的嵌套！"""
9. def f1():
10.     # x = 222
11.     def f2():
12.         print('f2')
13.         # x = 333
14.         def f3():
15.             print('f3')
16.             # x = 444
17.             def f4():
18.                 # x = 555
19.                 print(x)
20.             f4()
21.         f3()
22.     f2()
23. f1()

复制代码

名称空间的作用域

1. 域：范围
3. 作用域：变量的作用范围
5. 1. 内置名称空间
6.         # 在全局的任意位置都能够使用
7. 2. 全局名称空间
8.         # 在全局的任意位置任意时间都能够使用
9. 3. 局部名称空间
10.         # 一般情况只能够在局部使用
11.    
12. def index():
13.     x = 666
14.    

复制代码

global和nonlocal的使用

1. global
3. 如果你想在局部修改全局的变量：
4.                 1. 如果你修改的是不可变的类型，需要global关键字的声明
5.                 2. 如果你修改的是可变类型的，无需使用global关键字声明
6. # x = 10
8. # def index():
9. #     global x # 声明这个x用的是全局的x
10. #     x = 20  # 我想在局部修改全局的x的值
11. #     # print(x)
12. #
13. # index()
14. # print(x) # 10
17. name_list = ['kevin', 'jerry']
20. def func():
21.     name_list.append('tank')
24. func()
25. print(name_list) # ['kevin', 'jerry', 'tank']
27. nonlocal
28. 如果你想在内部的局部修改外部的局部：
29.                 1. 如果你修改的是不可变的类型，需要nonlocal关键字的声明
30.                 2. 如果你修改的是可变类型的，无需使用nonlocal关键字声明
31. nonlocal的使用：
32. # def outer():
33. #     x = 666
34. #     def inner():
35. #         nonlocal x
36. #         x = 999
37. #     inner()
38. #     print(x) # 此时的x是多少? 666
39. #
40. # outer()
42. def outer():
43.     name_list = ['a', 'b']
44.     def inner():
45.         name_list.append('c')
46.     inner()
47.     print(name_list) # 此时的x是多少? 666
49. outer()

复制代码

函数对象（函数名）

函数名可以当成变量赋值

1. ef index():
2.     print('index')
3.     return 123
5. # print(index())
6. '''函数名就是函数在内存中得地址'''
7. # print(index)  # <function index at 0x0000022FD03AD550>
9. a = index
10. # print(a) # <function index at 0x0000022D4E03D550>
11. res=a()  # index()
12. print(res)

复制代码

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

1. def index():
2.     print('index')
3.     return None
5. def func(a):
6.     # a：index
7.     print(a)
8.     res=a()  # index()
9.     print(res) # res的结果? None
11. # index:index函数所在的内存地址

复制代码

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

1. def index():
2.     print('index')
3.     return 'index2'
5. def func():
6.     print('func')
7.     # return index() # 'index'
8.     return index # 'index'
10. res = func()  #
11. print(res)
12. res1=res()  # index()
13. print(res1)

复制代码

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

1. def index():
2.    print('index')  
3. return Nonell = [11, 22, 33, index]
4. # ll = [11, 22, 33, index()]# print(ll[3])
5. res=ll[3]() # index()
6. print(res)

复制代码

函数的嵌套调用

1. 嵌套：函数套函数
2. # 案例：给你四个数，比较大小，返回最大的
3. # 两个数的比较大小，返回大的
5. def my_max(a, b):
6.     if a >b:
7.         return a
8.     return b
10. # res=my_max(1, 2)
11. # print(res)
13. ##
14. def many_max(a, b, c, d, e):
15.     '''四个数的比较大小其实还是要两两比较!'''
16.     res=my_max(a, b) # res得到a和b中得大的那个
17.     # 怎么样比较res和剩余的大小， 只需要拿res和c或者d中得一个进行比较
18.     res1=my_max(res, c) # res1:a,b,c中得最大的那个
19.     res2=my_max(res1, d)
20.     res3=my_max(res2, e)
21.     return res3
23. res=many_max(11, 12, 3, 24)
24. print(res)

复制代码

闭包函数

1. # 闭包函数还是函数，它是有函数一点一点演变过来的
3. 什么是闭包函数?
4.         闭：就是函数内部定义函数，至少要有2层函数
5.     包：内部的函数要使用外部函数名称空间中的名字
6.    
7. '''只有同时满足以上两个条件，才能称之为是闭包函数'''
9. def outer():
10.     x = 666
11.     def inner():
12.         print('hello', x)
13.     return inner
15. outer()
18. # 闭包函数的使用场景：
19. 闭包函数其实是第二种传参方式!
21. # 第一种传参方式
23. # def index(username):
24. #     print(username)
25. #
26. # index('jerry')
28. # 第二种传参方式
29. # 比较两个数的大小
30. # def my_max(a, b):
31. #     if a>b:
32. #         return a
33. #     return b
34. #
35. # my_max(1, 2)
38. # 让你用闭包函数实现比较2个数的大小:一次传值，多次使用
39. def outer(a, b):
40.     # a = 100
41.     # b = 200
43.     def my_max():
44.         if a > b:
45.             return a
46.         return b
48.     return my_max
51. res = outer(1, 10)  # my_max函数的内存地址
52. print(res()) # my_max()
53. print(res()) # my_max()
54. print(res()) # my_max()
55. print(res()) # my_max()
56. print(res()) # my_max()
57. print(res()) # my_max()
58. print(res()) # my_max()
59. print(res()) # my_max()
61. res1=outer(10, 20) # res1:my_max
62. print(res1())
63. print(res1())
64. print(res1())
65. print(res1())
66. print(res1())
67. print(res1())
68. print(res1())
69. print(res1())
70. print(res1())

复制代码

来源:https://www.cnblogs.com/zhangfanshixiaobai/p/17685546.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！