1.函數對象：函數是第一類對象
特點
　　1：可以被引用

1 def func():
2     pass
3 f =func
4 print(f is func)

　　2：可以當做參數傳給其它函數

1 def foo():
2     print(‘from foo‘)
3 def bar(func):
4     print(‘func‘)
5     func()
6 bar(foo)  #foo就相當於func

　　3：可以當做函數的返回值

1 def foo():
2     print(‘foo‘)
3 def ddd(func):
 
4     print(func)
5     return func
6 ddd(foo)()

　　4：可以當做容器類型的一個元素

 1 def get():
 2     print(‘get‘)
 3 def put():
 4     print(‘put‘)
 5 def auth():
 6     print(‘auth‘)
 7 func_dic={
 8     ‘get‘:get,
 9     ‘put‘:put,
10     ‘auth‘:auth
11 }
12 # print(func_dic)
13 def main():
14     while
 
 True:
15         cmd = input(‘>>:‘).strip()
16         if not cmd :continue
17         if cmd in func_dic:
18             func_dic[cmd]()
19 if __name__ == ‘__main__‘:
20     main()

2.函數嵌套調用（可以吧大的問題分成一個個小的問題，然後調用，縮減代碼）

 1 def my_max2(x,y):
 2     ‘‘‘兩個數比較大小‘‘‘
 3     return x if
 
 x>y else y
 4 print(‘最大的數是：%s‘%my_max2(1,2))
 5 def my_max4(a,b,c,d):
 6     ‘‘‘四個數比較大小‘‘‘
 7     res1 = my_max2(a,b)
 8     res2 = my_max2(res1,c)
 9     res3 = my_max2(res2,d)
10     return res3
11 print(‘最大的數是：%s‘%my_max4(5,8,1,4))

3.函數嵌套定義

1 def f1():
2     x=1
3     def f1():
4         def f3():
5             pass
6 f1()

4.名稱空間：指的是內存級別隔離的空間（存放名字與值綁定關系的地方）
分類：
　　內置名稱空間：會隨著python解釋器的運行而產生，如果解釋器關閉則回收，存放python解釋器自帶的名字
　　全局名稱空間：執行python文件時產生，文件執行結束後回收，存放的文件級別的名字
　　局部名稱空間：只有在調用函數時才會臨時產生，在函數調用結束後就回收了，存放的函數內部定義的名字
三類名稱空間的加載順序：內置名稱空間-->全局名稱空間-->局部名稱空間
查找名字的順序：
　　在局部調用：局部命名空間--->全局命名空間--->內置命名空間
　　站在全局範圍找：全局----內置----局部
5.作用域：就是作用範圍
　　全局作用域：全局命名空間和內置命名空間（文件執行的時候生效，在文件執行結束後就失效了）
　　　　　　　　全局存活，全局有效
　　局部作用域：局部命名空間(只在函數調用時生效，函數調用結束後失效)
　　　　　　　　臨時存活，局部有效
強調：作用域關系在函數定義階段就已經固定了，與調用位置無關

 1 x = 1
 2 def f1():
 3     x=2
 4     def f2():
 5         # x=3
 6         print(‘f2‘,x)
 7     return f2
 8 f = f1()
 9 
10 def bar():
11     x = ‘bar‘  #x輸出的還會上面函數裏面的，如果x=3註釋了，就輸出2，
12     # 它不會輸出bar,因為在函數定義階段就已經固定了
13     f()
14 bar()

6.global與nonlocal
global:將局部變量強制轉換成全局變量（一般不到迫不得已不要這樣強轉）

1 x=1
2 def func():
3     # global x
4     x=2
5     print(globals())  # 查看全局
6     print(locals())  # 查看局部
7 func()
8 print(x)  #打印的是全局變量1，如果加上global就成2了

nonlocal:讓內部函數中的變量在上一層函數中生效，外部必須有

 1 x=5
 2 def o():
 3     x = 1
 4     def f1():
 5         # x= 2
 6         def f2():
 7             nonlocal x  #修改本層函數外的變量,如果本層函數外
 8             # 沒有，就去找上一層的，但是不會去修改全局的
 9             x = 100
10         f2()
11         print(x)
12     f1()
13 o()
14 print(x)

7.閉包函數：定義在函數內部的函數，包含對外部作用域而非全局作用於的名字的引用，該函數就是閉包函數

 1 x = 1
 2 def f1():
 3     y =2222
 4     def f2():
 5         print(y)
 6     return f2
 7 f =f1()
 8 print(f)
 9 print(f.__closure__)  #判斷是不是閉包函數
10 print(f.__closure__[0].cell_contents)  #輸出2222 #查看閉包的內容

1 from urllib.request import urlopen
2 def index(url):
3     def inner():
4         return urlopen(url).read()
5     return inner
6 baidu = index(‘http://www.baidu.com‘)
7 print(baidu())
8 print(baidu())
9 print(baidu())

1 from urllib.request import urlopen
2 def index(url):
3     return urlopen(url).read()
4 print(index(‘http://www.baidu.com‘))
5 print(index(‘http://www.baidu.com‘))
6 print(index(‘http://www.baidu.com‘))
7 print(index(‘http://www.baidu.com‘))

函數嵌套復習