摘要：外部作用域變量，常見于閉包函數(shù)，也就是嵌套函數(shù)中的上一層函數(shù)變量。其生命周期在整個(gè)閉包函數(shù)結(jié)束時(shí)會被釋放。該函數(shù)的返回值必須是內(nèi)嵌函數(shù)名閉包函數(shù)可以大幅提高代碼復(fù)用性，使得代碼性能大幅提高。

閱讀本文大約需要 7 分鐘。

LEGB 指的是 Python 中的變量作用域問題，其中

L：local 局部變量，僅存在函數(shù)內(nèi)部，其存儲位置位于棧中，其生命周期在函數(shù)結(jié)束時(shí)就會被釋放。

E：enclosing 外部作用域變量，常見于閉包函數(shù)，也就是嵌套函數(shù)中的上一層函數(shù)變量。其生命周期在整個(gè)閉包函數(shù)結(jié)束時(shí)會被釋放。

G：global 全局變量，作用于整個(gè)程序，其存儲位置位于全局?jǐn)?shù)據(jù)區(qū)中，其生命周期在程序銷毀時(shí)就被釋放。

B：builtins 內(nèi)建模塊變量，其存儲于內(nèi)置變量命名空間。

變量查找順序：

L-E-G-B

示例：

def func():
    a = b = 1
    def internal_func(c):
        if a+b == c:
            print("True")
        else:
            print("False")

test = func()
test(2)

# 結(jié)果為 True

閉包函數(shù)作為函數(shù)式編程中的一種，當(dāng)含有以下幾點(diǎn)時(shí)，便可稱它為一個(gè)閉包函數(shù)。

該函數(shù)是一個(gè)嵌套函數(shù)。

內(nèi)嵌函數(shù)必須引用外部函數(shù)的變量。

該函數(shù)的返回值必須是內(nèi)嵌函數(shù)名

閉包函數(shù)可以大幅提高代碼復(fù)用性，使得代碼性能大幅提高。

淺拷貝

copy 模塊下的 copy() 方法，實(shí)現(xiàn)一個(gè)對象的淺拷貝，list 下的分割也是一種淺拷貝，

示例：

import copy

a = [1, 2, [3, 4]]
b = copy.copy(a)

a == b
a is b

# 結(jié)果為 True，F(xiàn)alse

e = [1, 2, [3, 4]]
f = e[2]
h = e[2][:]

f == h
f is h

# 結(jié)果為 True，F(xiàn)alse

淺拷貝只會拷貝對象的第一層引用，如果是復(fù)合類型，如 list 里面嵌套 list，則當(dāng)內(nèi)嵌 list 發(fā)生變化時(shí)，經(jīng)過淺拷貝出來的對象，也會發(fā)生變化。

示例：

import copy

a = [1, 2, [3, 4]]
b = copy.copy(a)

a == b
a is b

# 結(jié)果為 True，F(xiàn)alse

c = copy.copy(a)

a[1] = 0

print(a)
print(c)

# 結(jié)果為 a = [1, 0, [3, 4]], c = [1, 2, [3, 4]]


a[2].append(5)

print(a)
print(c)

# 結(jié)果為 a = [1, 0, [3, 4, 5]], c = [1, 2, [3, 4, 5]]

深拷貝

深拷貝將拷貝對象里所有引用全部拷貝，生成一個(gè)全新的對象。

示例：

import copy

a = [1, 2, 3, 4]
b = copy.deepcopy(a)

a == b 
a is b

# 結(jié)果為 True，F(xiàn)alse

深、淺拷貝會根據(jù)拷貝對象的數(shù)據(jù)類型，決定是否開辟新的內(nèi)存空間來存放拷貝出來的新對象。

import copy

a = [1, 2, 3, 4] # list 可變類型
b = copy.copy(a)

a == b
a is b

# 結(jié)果為 True，F(xiàn)alse

c = (1, 2, 3, 4)  # tuple 不可變類型
d = copy.copy(c)
e = copy.deepcopy(c)

c == d
c is d
c is e

# 結(jié)果為 True，True, True

自己實(shí)現(xiàn)深拷貝

[深拷貝源碼分析]()，先占坑，還未寫。

Python 中通過將對象進(jìn)行 HASH 來判斷該對象是哪種類型，可 HASH 的為不可變類型，不可 HASH 的為可變類型。其中常見的幾種如下所示：

? 可變類型：List，dict，set

? 不可變類型：int，float，string，tuple，frorzenset

也可通過是否含有__hash__()方法，判斷該對象為何種類型，擁有該方法的為不可變類型，相反為可變類型。

首先通過類的魔法方法__new__()來創(chuàng)建一個(gè)實(shí)例，再通過魔法方法__init__()來對這個(gè)實(shí)例初始化，最終刪除一個(gè)實(shí)例時(shí)，Python 根據(jù)該實(shí)例的「引用計(jì)數(shù)」來判斷是否釋放該實(shí)例所占用的內(nèi)存，當(dāng)該實(shí)例的引用計(jì)數(shù)為 0 時(shí)，__del__()方法才會被調(diào)用，__del__()方法的不等同于del。

單例是指一個(gè)類的實(shí)例有且只有一個(gè)。一般在一個(gè)類只需要使用一次之后便不在使用時(shí)使用。

實(shí)現(xiàn)方式：

使用__new__()方法

class Singleton():
    is_instance = None

    def __new__(cls):
        if not cls.is_instance:
            cls.is_instance = super().__new__(cls)
            return cls.is_instance

        return cls.is_instance
        
s = Singleton()
g = Singleton()
print(s is g)

# 結(jié)果為 True

使用裝飾器

def Singleton01(cls):
    is_instance = {}
    def get_instance(*args, **kwargs):
        if not is_instance:
            is_instance[cls] = cls()
            return is_instance[cls]
        return is_instance[cls]
    return get_instance


@Singleton01
class Myclass():
    pass

s = Myclass()
g = Myclass()
print(s is g)

# 結(jié)果為 True

多線程下實(shí)現(xiàn)單例

class Singleton02():
    is_instance = None
    is_lock = threading.Lock()

    def __new__(cls):
        with cls.is_lock:
            if not cls.is_instance:
                cls.is_instance = super().__new__(cls)
                return cls.is_instance

            return cls.is_instance


s = Singleton()
g = Singleton()
print(s is g)

# 結(jié)果為 True

多線程優(yōu)化

class Singleton03():
    is_instance = None
    is_lock = threading.Lock()

    def __new__(cls):
        # 單例判斷提前,只在第一次判斷時(shí)加鎖，避免無意義的加鎖解鎖
        if not cls.is_instance:
            with cls.is_lock:
                cls.is_instance = super().__new__(cls)
                return cls.is_instance

        return cls.is_instance

s = Singleton03()
g = Singleton03()
print(s is g)

# 結(jié)果為 True

未寫完，下一次更新補(bǔ)上