首页 > 代码库 > 11、函数对象、函数的嵌套、名称空间与作用域

11、函数对象、函数的嵌套、名称空间与作用域

2024-09-29 06:40:02   218人阅读

一、函数对象

　　函数对象，函数是第一类对象，即函数可以当做数据传递

　　具体特点：

　　　　1、可以被引用；　　

1 def foo():
2     print(‘from foo‘)
3 
4 func=foo
5 
6 print(foo)
7 print(func)
8 func()

　　　　2、可以当作参数传递

1 def foo():
2     print(‘from foo‘)
3 
4 def bar(func):
5     print(func)
6     func()
7 
8 bar(foo)

　　　　3、返回值可以是函数

 1 def foo():
 2     print(‘from foo‘)
 3 
 4 def bar(func):
 5     return func
 6 
 7 f=bar(foo)
 8 
 9 print(f)
10 
11 f()

　　　　4、可以当作容器类型的元素

1 def foo():
2     print(‘from foo‘)
3 dic={‘func‘:foo}
4 
5 print(dic[‘func‘])
6 
7 dic[‘func‘]()

具体应用场景：

 1 def select(sql):
 2     print(‘========>select‘)
 3 
 4 def insert(sql):
 5     print(‘========>add‘)
 6 
 7 def delete(sql):
 8     print(‘=======>delete‘)
 9 
10 def update(sql):
11     print(‘-=---->update‘)
12 
13 
14 func_dic={
15     ‘select‘:select,
16     ‘update‘:update,
17     ‘insert‘:insert,
18     ‘delete‘:delete
19 }
20 
21 def main():
22     while True:
23         sql = input(‘>>: ‘).strip()
24         if not sql:continue
25         l = sql.split()
26         cmd=l[0]
27         if cmd in func_dic:
28             func_dic[cmd](l)
29 
30 main()
31 # def main():
32 #     sql = input(‘>>: ‘)
33 #     l = sql.split()
34 #     print(l)
35 #     if l[0] == ‘select‘:
36 #         select(l)
37 #     elif l[0] == ‘insert‘:
38 #         insert(l)
39 #     elif l[0] == ‘delete‘:
40 #         delete(l)
41 #     elif l[0] == ‘update‘:
42 #         update(l)

二、函数的嵌套

　　1、函数的嵌套调用

 1 def max2(x,y):
 2     return x if x > y else y
 3 
 4 
 5 def max4(a,b,c,d):
 6     res1=max2(a,b)
 7     res2=max2(res1,c)
 8     res3=max2(res2,d)
 9     return res3
10 
11 print(max4(10,99,31,22))

　　2、函数的嵌套定义

1 def f1():
2 
3     def f2():
4         print(‘from f2‘)
5         def f3():
6             print(‘from f3‘)
7         f3()
8     f2()
9 f1()

 

三、名称空间与作用域

名称空间：存放名字的地方，三种名称空间

　　1、定义名字的方法

1 import time
2 
3 name=‘egon‘
4 
5 def func():
6     pass
7 
8 class Foo:
9     pass

　　2、三种名称空间

　　1）内置名称空间:随着python解释器的启动而产生
 1 print(sum)
 2 print(max)
 3 print(min)
 4 
 5 
 6 print(max([1,2,3]))
 7 
 8 import builtins
 9 for i in dir(builtins):
10     print(i)

　　2）全局名称空间：文件的执行会产生全局名称空间，指的是文件级别定义的名字都会放入改空间

 1 x=1
 2 if x ==1 :
 3     y=2
 4 import time
 5 
 6 name=‘egon‘
 7 
 8 def func():
 9     pass
10 
11 class Foo:
12     pass
13 
14 #====================
15 
16 x=1
17 
18 
19 def func():
20     money=2000
21     x=2
22     print(‘func‘)
23 print(x)
24 print(func)
25 func()
26 print(money)
27 
28 func()
29 print(x)
3）局部名称空间:调用函数时会产生局部名称空间，只在函数调用时临时绑定，调用结束解绑定
1 x=10000
2 def func():
3     x=1
4     def f1():
5         pass

ps:

作用域：
    1. 全局作用域：内置名称空间，全局名层空间
    2. 局部作用：局部名称空间

3、名字的查找顺序：局部名称空间---》全局名层空间---》内置名称空间

 1 x=1
 2 def func():
 3     # x=2
 4     # print(x)
 5     # sum=123123
 6     print(sum)
 7 func()
 8 
 9 
10 
11 def func():
12     x=2
13 
14 func()
15 
16 print(x)
查看全局作用域内的名字：gloabls()
查看局局作用域内的名字：locals()
1 x=1000
2 def func():
3     x=2
4 
5 print(globals())
6 
7 print(locals())
8 print(globals() is locals())
1 x=1000
2 def func(y):
3     x=2
4     print(locals())
5     print(globals())
6 
7 func(1)
#全局作用域：全局有效，在任何位置都能被访问到，除非del删掉，否则会一直存活到文件执行完毕

#局部作用域的名字：局部有效，只能在局部范围调用，只在函数调用时才有效，调用结束就失效
 1 x=1
 2 
 3 def f1():
 4     print(x)
 5 
 6 def foo():
 7     print(x)
 8 
 9 def f(x):
10     # x=4
11     def f2():
12         # x=3
13         def f3():
14             # x=2
15             print(x)
16 
17         f3()
18     f2()
19 
20 f(4)

 

11、函数对象、函数的嵌套、名称空间与作用域


联系
我们