摘要：第一種情況打印結果為第二種打印結果為因為如果默認參數是一個可變的數據類型，那么他在內存中永遠是一個。

1.變量儲存在一個內存空間中
2.當程序運行的時候代碼從上到下依次執行，它會將變量與值的關系存儲在一個空間中，這個空間叫名稱空間,命名空間，全局名稱空間
3.當程序遇到函數時，它會將函數名存在內存中，函數體漠不關心
4.當程序執行的時候，內存會臨時開辟一個空間，存放函數體里的代碼(變量,代碼等）
5.函數外面訪問不到臨時空間的內容，隨著函數執行完畢，臨時名稱空間會被釋放掉,向這個臨時開辟的空間也叫臨時名稱空間，也叫局部名稱空間

python名稱空間分為三種：
1.內置名稱空間
2.全局名稱空間
3.局部名稱空間

按照作用域分為兩種：

全局作用域

1.內置名稱空間
2.全局名稱空間

局部作用域

1.局部名稱空間

加載順序
內置名稱空間---全局名稱空間(當程序執行時)---局部名稱空間(函數調用時)

取值順序
局部名稱空間(函數調用時)---全局名稱空間(當程序執行時)---內置名稱空間
注:取值順序是單向不可逆的

  1.取值又叫引用，局部名稱空間可以臨時像全局名稱空間引用，但是無法修改
  2.取值是從小到大取值LEGB
      - L=最里層的局部作用域
      - E=父親級別的局部作用域
      - G=全局作用域中的全局名稱空間
      - B=全局作用域中的內置名稱空間

內置函數globals和locals的方法：

globles

   globales返回一個字典，字典里的內容是全局名稱空間的內容

locals

   locals返回一個字典，當前位置的所有變量（看locals的位置是否在函數體里還是在全局里）

#1.
print(globals())
print(locals())
#打印結果：
{"__name__": "__main__", "__doc__": None, "__package__": None, "__loader__": <_frozen_importlib_external.SourceFileLoader object at 0x004DB4B0>, "__spec__": None, "__annotations__": {}, "__builtins__": , "__file__": "E:/python/day04/1.py", "__cached__": None}
{"__name__": "__main__", "__doc__": None, "__package__": None, "__loader__": <_frozen_importlib_external.SourceFileLoader object at 0x004DB4B0>, "__spec__": None, "__annotations__": {}, "__builtins__": , "__file__": "E:/python/day04/1.py", "__cached__": None}

#2.
def func():
    a = 12
    b = 20
    print(locals())
    print(globals())
func()
#打印結果：
{"b": 20, "a": 12}
{"__name__": "__main__", "__doc__": None, "__package__": None, "__loader__": <_frozen_importlib_external.SourceFileLoader object at 0x0044B4B0>, "__spec__": None, "__annotations__": {}, "__builtins__": , "__file__": "E:/python/day04/1.py", "__cached__": None, "func": }

關鍵字global和nonlocal的方法：

global
1.global可以引用全局變量，并且改變全局變量
2.在局部作用域聲明一個全局變量

nonlocal
1.不能操作全局變量
2.在局部作用域中，對父級作用域（或者更外層作用域非全局作用域）的變量進行引用和修改，并且引用的哪層，從那層及以下此變量全部發生改變。

注:對于可變的數據類型list，dict，set，不用引用global,nonlocal
注：如果默認參數是一個可變的數據類型，那么他在內存中永遠是一個。

#1.第一種情況:
def extendList(val,list=[]):
    list.append(val)
    return list
list1 = extendList(10)
print("list1=%s"%list1)  # [10,]
list2 = extendList(123,[])
print("list2=%s"%list2)  # [123,]
list3 = extendList("a")
print("list3=%s"%list3)  #[10,"a"]
打印結果為：
list1=[10]
list2=[123]
list3=[10, "a"]
#2.第二種：
def extendList(val,list=[]):
    list.append(val)
    return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList("a")
print("list1=%s"%list1)
print("list2=%s"%list2)
print("list3=%s"%list3)
打印結果為：
list1=[10, "a"]
list2=[123]
list3=[10, "a"]
因為：如果默認參數是一個可變的數據類型，那么他在內存中永遠是一個。

1.global實例：

def func():
    global a
    a = 3
func()
print(a)
#打印結果為：3
count = 1
def search():
    global count
    count = 2
search()
print(count)
#打印結果為2

2.nonloacl實例：

def add_b():
    b = 42
    def do_global():
        b = 10
        print(b)
        def dd_nonlocal():
            nonlocal b
            b = b + 20
            print(b)
        dd_nonlocal()  #30
        print(b) #30
    do_global()   #10
    print(b)
add_b()
#打印結果為：
10
30
30
42

函數的嵌套與調用：

#函數的嵌套
def max2(x,y):
    m  = x if x>y else y
    return m
def max4(a,b,c,d):
    res1 = max2(a,b)
    res2 = max2(res1,c)
    res3 = max2(res2,d)
    return res3
#函數的調用
max4(1,2,3,4)

函數名的本質
1.打印函數名

def func():
    print("in func")
f = func
print(f)
#打印結果為：
為一塊內存地址

2.函數名可以作為容器類數據的元素

def func1():
    print(111)
def func2():
    print(222)
def func3():
    print(333)
l1 = [func1, func2, func3]
for i in l1:
    i()
#打印結果為：
111
222
333

3.函數名可以作為函數的參數

def func1():
    print(111)
def func2(x):
    print(x)
    x()
    print(222)
func2(func1)
#打印結果為：

111
222

4.函數名可以作為函數的返回值

def func1():
    return 111
def func2(x):  # x = func1
    print(222)
    return x
ret = func2(func1)  # func1
print(ret())
print(ret)
#打印結果為：
222
111

總結：
函數名的應用,第一類對象

  - 函數名打印的出來的是個內存地址，加()號就可以運行
  - 函數名可以作為容器類型內的元素
  - 函數名可以作為傳遞的參數
  - 函數名可以作為函數的返回值，return把值給函數的執行者

閉包函數

  - 內層函數對外層函數非全局變量的引用，就叫做閉包
  - 判斷是否是閉包：__closure__
  - 如果python解釋器遇到了閉包，他有個機制，這個閉包不會隨著函數的結束而釋放
  - 裝飾器@語法糖，裝飾器放在需要裝飾的函數的上邊，利用的就是閉包函數

裝飾器：

#測試func1函數的執行時間
def timmer(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        ret = f(*args,**kwargs)
        end_time = time.time()
        print("此函數的執行效率%s" % (end_time - start_time))
        return ret
    return inner
@timmer
def func1():
    time.sleep(0.3)
    print("非常復雜......")
func1()
#格式為：
def wrapper(f):
    def inner(*args,**kwargs):
        """被裝飾函數執行之前的操作"""
        ret = f(*args,**kwargs)
        """被裝飾函數執行之后的操作"""
        return ret
    return inner
# 裝飾器 本質就是閉包
# 裝飾器根本作用：在不影響原函數執行的基礎上，增加一些額外的功能登錄認證，打印日志等等。

內褲可以用來遮羞，但是到了冬天它沒法為我們防風御寒，聰明的人們發明了長褲，有了長褲后寶寶再也不冷了，裝飾器就像我們這里說的長褲，在不影響內褲作用的前提下，給我們的身子提供了保暖的功效。