日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

Python基礎globlal?nonlocal和閉包函數裝飾器語法糖_python

作者：Kkkkangsh ? 更新時間： 2022-12-06 編程語言

一、global與nonlocal

1、global

  • 在py文件中，一般無法調用函數體內變量名，而global可使函數體代碼內的變量名直接在函數體外部調用，條件是在需要調用的代碼體中使用global 調用需要的變量名

未使用global情況：

# 在外部綁定一個變量名
name = 'kangkng'
# 定義一個函數體代碼
def func():
    # 函數體內部重新綁定一個變量名
    name = 'zhangzhang'
# 調用函數func
func()
# 這時無法打印函數體內部的變量名
print(name)
------------------------------------------------------------------------ kangkang

使用global情況:

# 在函數體內部使用global時，可在外部直接調用函數內部變量名
name = 'kangkng'
# 定義一個函數體代碼
def func():
    # 使用global調用變量名
    global name
    # 函數體內部重新綁定一個變量名
    name = 'zhangzhang'
# 調用函數func
func()
# 外py中打印name
print(name)
------------------------------------------------------------------------
zhangzhang

2、nonlocal

  • 在函數嵌套使用時，通常在父代碼體中無法調用子代碼中變量名，

而nonlocal的作用是，可以在父代碼中直接調用子代碼中的變量名，條件是需要在子代碼中使用nonlocal 調用需要的變量名

未使用nonlocal情況：

# 定義一個函數體代碼
def outer():
    # 綁定一個變量名
    name = 'kangkang'
    # 代碼體內部再次定義一段函數體
    def subcoat():
        # 內層中綁定變量名
        name = 'zhangzhang'
    # 在函數外層打印變量名
    print(name)
# 調用外層函數體代碼
outer()
----------------------------------------------------------------------- 
kangkang

使用nonlocal情況：

# 在函數體內部使用global時，可在外部直接調用函數內部變量名
def outer():
    # 函數外層綁定一個變量名
    name = 'kangkang'
    # 代碼體內部再次定義一段函數體
    def subcoat():
        # 在函數體內層使用nonlocal，調用變量名
        nonlocal name
        # 內層中綁定變量名
        name = 'zhangzhang'
    # 調用內層函數
    subcoat()
    # 在函數外層打印變量名
    print(name)
# 調用外層函數體代碼
outer()   
----------------------------------------------------------------------
zhangzhang

二、函數名的多種用法

引言：

? 函數名就相當于變量名，只不過函數名綁定的是一段函數體代碼，在我們使用這個函數名加括號時就可以調用這段代碼體，具體由以下幾種用法：

1、當做變量名賦值

def func():
    print('我是func函數體代碼')
res = func
print(res())
------------------------------------------------------------------------
我是func函數體代碼
None

2、當作函數的參數

def func():
    print('我是func函數體代碼')
def func1(a):
    print('我是func1函數體代碼', a)
    a()
func1(func)
------------------------------------------------------------------------
我是func1函數體代碼 <function func at 0x000001D0C14D6310>
我是func函數體代碼

3、當作函數的返回值

def func():
    print('我是func函數體代碼')
def func1():
    print('我是func1函數體代碼')
    return func
res = func1()
print(res)
res()
------------------------------------------------------------------------
我是func1函數體代碼
<function func at 0x00000218F95B6310>
我是func函數體代碼

4、當作容器類型的數據

def spring():
    print('我是春季,生機盎然')
def summer():
    print('我是夏季，活力四射')
def autumn():
    print('我是秋季，翩翩起舞')
def winter():
    print('我是冬季，大雪紛飛')
while True:
    season_dict = { '1': spring,
               '2': summer,
               '3': autumn,
               '4': winter
                   }
    season_select = input('根據編號，選擇您喜歡的季節>>>:').strip()
    if season_select in season_dict:
        season_dict.get(season_select)()
    else:
        print('你選擇的編號不存在')
------------------------------------------------------------------------

三、閉包函數

1、什么是閉包函數

? 一個函數的返回值是另外一個函數，返回的函數調用父函數內部的變量，如果返回的函數在外部被執行，就產生了閉包

2、閉包函數需滿足的條件

滿足以下兩個條件的就是閉包函數：

條件一：定義在函數內部的函數

條件二：用到了外部函數空間名稱中的名子

3、閉包函數的作用

作用：使函數外部能夠調用函數內部放入屬性和方法

缺點：閉包操作導致整個函數的內部環境被長久保存，占用大量內存

4、閉包函數的實際應用

1.函數內部變量名在外部被訪問

def fun1():
    name = 'python'
    def inner():
        print(name)
    return inner
result = fun1()
result()
------------------------------------------------------------------------
python

2.函數體內部函數體代碼可以通過外部訪問

def fun2():
    def inner():
        print("執行了內部函數inner")
    def all():
        return inner
    return all
result = fun2()
result()()
------------------------------------------------------------------------
執行了內部函數inner

四、裝飾器

? 當我們需要將一段函數體代碼在不改變調用方式和源代碼的情況下，需要給這個段代碼添加新的功能時，這時候我們就需要給這段代碼安裝一個裝飾器，裝飾器是指將這段代碼封裝在閉包函數內，來達到既能滿足上述條件，又能增加新的功能的條件

概念

  • 在不修改被裝飾對象源代碼和調用方式的情況下給被裝飾的對象添加新的功能

本質

  • 并不是一門新的技術，而是由函數參數、名稱空間、函數名多種用法、閉包函數組合到一起的效果

口訣

  • 對修改封閉，對擴展開放

1、裝飾器推導流程

1、首先定義一段函數體代碼，當我們給這段函數傳入指定的參數時，他就會暫停一秒，然后運行，使它在運行結束后，能夠統計它的運行時間

import time
def index(a， b):
    time.sleep(1)
    print(index，a， b)

2、通常，我們只需要在這段代碼運行前打印一個時間戳，運行后再次打印一個時間戳，在這段代碼運行結束后通過前后時間的插值就能統計出這段代碼的運行時間，但這種辦法使用起來比較麻煩且只能使用一次

方法一：
    import time
    def index(a, b):
        start = time.time()
        time.sleep(1)
        print(index, a, b)
        end = time.time()
        print(end - start)
    index(1,2)
方式二：
    import time
    def index(a, b):
        time.sleep(1)
        print(index, a, b)
    start = time.time()
    index(1,2)
    end = time.time()
    print(end - start)

3、通過上述方法的方式二，我們可以得出將函數名包裹在統計時間功能代碼內，這樣在調用時相對便捷，進一步思考，若將這段代碼使用函數封包，那樣在調用時就可以更為便捷，在以后統計該代碼時，只需要調用封包這段代碼的函數名就可以直接統計這段代碼的運行時間

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
def time_():
    start = time.time()
    index()
    end = time.time()
    print(end - start)
time_()
------------------------------------------------------------------------
Traceback (most recent call last):
  File "D:/pytcharm項目文件路徑/38/11.py", line 297, in <module>
    time_()
  File "D:/pytcharm項目文件路徑/38/11.py", line 293, in time_
    index()
TypeError: index() missing 2 required positional arguments: 'a' and 'b'

4、雖然這種方式可以行得通，但只能針對沒有參數的函數體代碼，若這段代碼需要傳參者無法運行，并直接報錯。再次進一步思考，只需要將封包的這段函數設置為有參函數就可解決這個問題

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
def core(a,b):
    start = time.time()
    index(a, b)
    end = time.time()
    print(end - start)
core(1, 2)
------------------------------------------------------------------------
<function index at 0x000001F4A0026310> 1 2
1.0047826766967773

5、由上推導可看出，雖然此功能可以更為便捷的統計代碼執行時間，但若是源代碼的參數需要修改則封包它的參數也需要修改，這時我們可聯想到將參數修改為可變長參數，就不會出現這個問題

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
def core(*args,**kwargs):
    start = time.time()
    index(*args, **kwargs)
    end = time.time()
    print(end - start)
core(1,2)
------------------------------------------------------------------------
<function index at 0x000002ECDD4E6310> 1 2
1.004744529724121

6、這樣無論源代碼參數如何修改，我們都可以進行傳參，雖然這個問題解決了，但考慮使用的廣泛性，若有其他函數體也需要用到這個功能時，還需要重新修改封包內代碼，這時，我們可以使用閉包的方式來滿足這個條件

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
def func(x, y, z):
    time.sleep(2)
    print(func, x, y, z)
def outer(index):
    def core(*args, **kwargs):
        start = time.time()
        index(*args, **kwargs)
        end = time.time()
        print(end - start)
    return core
res = outer(func)
res(1, 2, 3)
------------------------------------------------------------------------
<function func at 0x0000018C23686670> 1 2 3
2.00856614112854

7、通過將源代碼函數名放至閉包函數參數內，就可以達到可以調動任何函數體代碼都可以執行此功能的方法，但并未滿足閉包函數的條件，源代碼的調用方式改變了，這時我們可以通過將原函數體代碼賦值的方式來達到調用方式和源代碼都未改變的情況下來增加此功能

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
def func(x, y, z):
    time.sleep(2)
    print(func, x, y, z)
def outer(index):
    def core(*args, **kwargs):
        start = time.time()
        index(*args, **kwargs)
        end = time.time()
        print(end - start)
    return core
index = outer(index)
index(1,2)
func = outer(func)
func(1, 2, 3)
------------------------------------------------------------------------
<function outer.<locals>.core at 0x0000026C17F58280> 1 2
1.004807710647583
<function outer.<locals>.core at 0x0000026C17F58940> 1 2 3
2.0077626705169678

8、雖然上述推導過程都已滿足裝飾器條件，但是考慮到源代碼有返回值的情況，我們沒有并沒有獲取，這時在進一步推導，可在裝飾器函數內部調用源代碼函數名的位置設置一個變量名用于接收返回值，傳給裝飾器底層return用于接收即可解決這個問題

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
    return 'index'
def func(x, y, z):
    time.sleep(2)
    print(func, x, y, z)
    return 'func'
def outer(index):
    def core(*args, **kwargs):
        start = time.time()
        res = index(*args, **kwargs)
        end = time.time()
        print(end - start)
        return res
    return core
index = outer(index)
res = index(1,2)
print(res)
func = outer(func)
res = func(1, 2, 3)
print(res)
------------------------------------------------------------------------
<function outer.<locals>.core at 0x0000020C50A78280> 1 2
1.0050580501556396
index
<function outer.<locals>.core at 0x0000020C50A78940> 1 2 3
2.0094454288482666
func

2、裝飾器語法糖

什么是裝飾器語法糖

當我們使用裝飾器調用被裝飾的函數體代碼時，總是需要在調用前通過賦值的方式來調用，這樣的方式相對比較麻煩，這時我們就可以用到裝飾器語法糖來節省時間和代碼

語法糖的使用方法和條件

用法：在源代碼函數體上方使用@加裝飾器函數名

條件：源代碼需在裝飾器下方

具體用法

import time
def outer(index):
    def core(*args, **kwargs):
        start = time.time()
        res = index(*args, **kwargs)
        end = time.time()
        print(end - start)
        return res
    return core
@outer
def index(a, b):
    time.sleep(1)
    print(index, a, b)
    return 'index'
index(1,2)

3、裝飾器模板

def outer(func):
    def inner(*args, **kwargs):
        # 執行被裝飾對象之前可以做的額外操作
        res = func(*args, **kwargs)
        # 執行被裝飾對象之后可以做的額外操作
        return res
    return inner

原文鏈接：https://www.cnblogs.com/kangssssh/p/16782101.html

欄目分類
最近更新