Python 的del語句將允許您從不同的命名空間中刪除名稱和引用。它還允許您從列表中刪除不需要的項目以及從字典中刪除鍵。如果您想學習如何del在 Python 代碼中使用，那么本教程適合您。該del語句使您能夠更好地管理代碼中的內存資源，使您的程序更加高效。
在本教程中，您將學習如何：
為了充分利用本教程，您應該熟悉 Python 的內置數據類型，特別是列表和字典。您還應該了解Python 中的類和面向對象編程的基礎知識。
Python 的語句允許您從給定的命名空間del或容器類型中刪除對對象的引用。它執行與賦值語句相反的操作。這是一種取消賦值語句，允許您取消一個或多個名稱與其引用對象的綁定。
這是 Python 的一個自然特性。如果可以通過寫入來創建變量variable=value，那么您必須可以選擇通過刪除來撤消此操作variable。這就是del現場出現的地方。
該del語句在不同的編碼情況下可以派上用場，例如：
當然，這個清單并不完整。您可能會找到適合此語句的其他一些用例。在本教程中，您將了解該del語句的工作原理以及如何在代碼中使用它。首先，您將首先學習delPython 的一般語法。
Python del語句由del 關鍵字和后跟一系列以逗號分隔的引用組成。
del以下是Python 中該語句的一般語法：
del reference_1[, reference_2, ..., reference_n]
該del語句允許您從給定名稱空間中刪除一個或多個引用。它還允許您從可變容器類型（例如列表和字典）中刪除數據。
您經常會將此語句與單個參數一起使用。但是，它還支持一系列用逗號分隔的參數。
在上面的構造中，reference_*表示可以保存對存儲在內存中的具體對象的引用的任何類型的標識符。在實踐中，這些參考可以包括：
您可以使用這些引用中的任何一個作為 的參數del。如果您使用逗號分隔的一系列參數，請記住del從左到右按順序對每個參數進行操作。當您從列表中刪除項目時，這種行為可能存在風險，您將在本教程后面了解到。
del下面是一個使用刪除變量的簡單示例：
>>>
>>> greeting="Hi, Pythonista!"
>>> greeting
'Hi, Pythonista!'
>>> del greeting
>>> greeting
Traceback (most recent call last):
...
NameError: name 'greeting' is not defined
運行該del語句后，該變量greeting將不再可用。如果您嘗試訪問greeting，則會得到 a ，NameError因為該變量不再存在。
刪除像變量這樣的引用持有者是del. 該語句不會刪除對象。在下一節中，您將更深入地了解運行語句的實際和直接效果del。
正如您所了解的，Python 的del語句會刪除命名空間或數據容器中的引用。它不會移除具體物體。例如，您不能使用以下方法刪除內置類型的文字del：
>>>
>>> del 314
File "<input>", line 1
del 314
^^
SyntaxError: cannot delete literal
>>> del "Hello, World!"
File "<input>", line 1
del "Hello, World!"
^^^^^^^^^^^^^^^
SyntaxError: cannot delete literal
在這些示例中，請注意，您不能del直接在對象上使用該語句。正如您已經了解到的，您必須將其與變量、名稱和其他標識符一起使用：
>>>
>>> number=314
>>> del number
但是，del像本示例中那樣運行并不意味著您要從314內存中刪除該數字。number它僅從當前名稱空間或范圍中刪除該名稱。
當您將標識符（如變量、類、函數或方法名稱）作為參數傳遞給 時del，該語句會解除該標識符與引用對象的綁定，并從其包含的命名空間中刪除該標識符。但是，引用的對象可能不會立即從計算機內存中刪除。
同樣，當您使用列表索引、切片或字典鍵作為 的參數時del，您將從包含的數據結構中刪除對目標項、切片或鍵的引用。這可能并不意味著立即從計算機內存中刪除引用的對象。
簡而言之，del不會從內存中刪除對象并釋放已用空間。它僅刪除對對象的引用。這種行為可能會引發一個問題。如果del不從內存中刪除對象，那么如何del在代碼執行期間釋放內存資源呢？
要回答這個問題，您需要了解 Python 如何管理從內存中刪除對象。在下面的部分中，您將了解 Python 的垃圾收集系統以及它與del釋放程序中的內存有何關系。
Python 有一個垃圾收集系統，負責從內存中刪除未使用的對象并釋放資源以供以后使用。在Python的CPython實現中，引用計數是觸發垃圾收集的主要指標。
本質上，Python 會跟蹤在任何給定時間有多少標識符保存對每個對象的引用。指向給定對象的標識符的數量稱為該對象的引用計數。
如果至少有一個對某一對象的活動引用，那么該對象仍可供您訪問，并占用計算機上的內存。如果您使用del刪除此單個引用，則該對象已準備好進行垃圾收集，這將刪除該對象并釋放內存。
另一方面，如果您有多個對某個對象的活動引用，并且您用來del刪除其中一些引用，但不是全部，則垃圾收集系統將無法刪除該對象并釋放內存。
簡而言之，del刪除引用，而垃圾收集則刪除對象并釋放內存。根據這種行為，您可以得出結論，del只有在刪除對對象的最后一個引用（這為垃圾收集做好準備）時，才允許您減少代碼的內存消耗。
需要注意的是，在刪除對象的最后一個引用后，Python 的垃圾收集系統不會立即釋放該對象使用的內存，從而將引用計數降至零。相反，Python 的垃圾收集器會定期掃描內存中未引用的對象并釋放它們。
當對象的引用計數達到零時，垃圾收集器可能會繼續從內存中刪除該對象。這時候，.__del__()特殊的方法就發揮作用了。
.__del__()當給定對象即將被銷毀時，Python 會自動調用。此調用允許對象釋放外部資源并清理自身。需要注意的是，該del語句不會觸發該.__del__()方法。
您不需要.__del__()經常在自己的類中實現該方法。正確使用.__del__()是相當棘手的。如果您需要在某個類中編寫此方法，請確保仔細閱讀其文檔頁面。
分配None給引用是一種經常與使用del語句進行比較的操作。但此操作不會像del那樣刪除引用。它僅重新分配引用以指向None：
>>>
>>> number=314
>>> number
314
>>> number=None
>>> print(number)
None
重新分配變量number指向None使對象的引用計數314降至零。因此，Python 可以對對象進行垃圾回收，釋放相應的內存。但是，此賦值不會像語句那樣從當前作用域中刪除變量名稱del。
因為None它是 Python 中內置的單例對象，所以此分配不會分配或使用新內存，而是使變量保持活動狀態并在當前作用域中可用。
None當您想要防止NameError嘗試刪除當前命名空間中不存在的名稱或引用持有者時發生的異常時，該方法可能很有用。在這種情況下，Python 將默默地創建一個新變量并None為其指定初始值。
從給定范圍中刪除名稱是del您將在本教程中了解的第一個用例。給定名稱或標識符的范圍是您可以明確訪問該名稱的程序區域。
在 Python 中，您最多會發現四個作用域：
該del語句可以從其中一些范圍中刪除名稱。正如您在前面的示例中所看到的，您可以使用del從全局范圍中刪除一個或多個變量：
>>>
>>> color="blue"
>>> fruit="apple"
>>> pet="dog"
>>> del color
>>> color
Traceback (most recent call last):
...
NameError: name 'color' is not defined
>>> del fruit, pet
>>> fruit
Traceback (most recent call last):
...
NameError: name 'fruit' is not defined
>>> pet
Traceback (most recent call last):
...
NameError: name 'pet' is not defined
在此示例中，您創建三個全局變量。然后，您使用該del語句將這些變量從全局范圍（它們所在的位置）中刪除。請記住，這del具有取消賦值語句的效果。
del您還可以使用相同的方式從自定義函數中的本地范圍和封閉范圍中刪除名稱。但是，您無法從內置范圍中刪除名稱：
>>>
>>> del list
Traceback (most recent call last):
...
NameError: name 'list' is not defined
>>> list()
[]
>>> del dict
Traceback (most recent call last):
...
NameError: name 'dict' is not defined
>>> dict()
{}
>>> del max
Traceback (most recent call last):
...
NameError: name 'max' is not defined
>>> max([3, 2, 5])
5
如果您嘗試使用語句刪除任何內置名稱del，那么您會得到一個NameError. 該錯誤消息可能看起來令人困惑，因為您可以訪問所有這些名稱，就好像它們位于全局范圍內一樣。但是，這些名稱位于內置范圍內，無法直接使用del.
即使您無法刪除內置名稱，您也可以隨時在代碼中覆蓋或隱藏它們。Python 有許多內置名稱。其中一些可能適合您在某些情況下的命名需求。例如，當您開始使用 Python 時，列表可能是您首先了解的內置數據類型之一。
假設您正在學習列表并運行以下代碼：
>>>
>>> list=[1, 2, 3, 4]
>>> list
[1, 2, 3, 4]
在此示例中，您使用了包含一些數字的對象list的名稱list。正如您在此代碼片段中所做的那樣，重新分配內置名稱會隱藏該名稱后面的原始對象，從而阻止您在代碼中使用它：
>>>
>>> list(range(10))
Traceback (most recent call last):
...
TypeError: 'list' object is not callable
現在調用list()失敗，因為您已經覆蓋了之前代碼中的名稱。解決此問題的快速方法是使用以下del語句刪除假內置名稱并恢復原始名稱：
>>>
>>> del list # Remove the redefined name
>>> list() # Now the original name is available again
[]
如果您不小心在交互式會話中重新分配了內置名稱，則可以運行快速del name語句從作用域中刪除重新定義，并在工作作用域中恢復原始內置名稱。
從列表或字典等可變集合中刪除項目可以說是 Python 語句最常見的用例del。盡管這些內置數據類型提供了可用于按索引或鍵刪除項目的方法，但del可能會產生略有不同的結果或適用于不同的場景。
您還可以使用該del語句一次性從列表中刪除多個項目。為此，您可以使用切片語法。對于這個特定的用例，您將找不到執行該任務的方法。所以，del這是你要走的路。
在以下部分中，您將了解如何使用del從現有列表中刪除項目。您還將學習如何使用從字典中刪除鍵值對del。有了這些技能，您將能夠通過讓 Python 的垃圾收集系統釋放列表和字典不再需要的內存資源來提高代碼效率。
您已經了解了列表索引語法a_list[index]允許您訪問列表中的各個項目。此語法提供了一個標識符，該標識符保存對目標索引處的項目的引用。
如果需要從現有列表中刪除項目，則可以將該del語句與索引運算符一起使用。一般語法是：
該語句將刪除位于indexin定義的位置的項目a_list。這是一個示例，以便您可以在實踐中體驗其工作原理：
>>>
>>> computer_parts=[
... "CPU",
... "motherboard",
... "case",
... "monitor",
... "keyboard",
... "mouse"
... ]
>>> del computer_parts[3]
>>> computer_parts
['CPU', 'motherboard', 'case', 'keyboard', 'mouse']
>>> del computer_parts[-1]
>>> computer_parts
['CPU', 'motherboard', 'case', 'keyboard']
在此代碼片段中，您創建一個包含一些計算機部件的列表。然后您使用del刪除"monitor"索引處的項目3。最后，使用負索引刪除列表中的最后一項-1。
使用擴展語法del從列表中刪除多個項目時要小心。您最終可能會刪除錯誤的項目，甚至得到一個IndexError.
例如，假設您需要刪除數值數據樣本中包含的項目None，以便可以在某些計算中使用該數據。那么你可能會想到使用下面的del語句：
>>>
>>> sample=[3, None, 2, 4, None, 5, 2]
>>> del sample[1], sample[4]
>>> sample
[3, 2, 4, None, 2]
剛剛發生了什么？您沒有刪除第二個None，而是刪除了數字5。問題是del從左到右按順序對其參數進行操作。在此示例中，del首先從 中刪除第二項sample。5然后它從修改后的列表中刪除第四項。為了獲得所需的結果，您需要考慮目標列表在每次刪除后都會發生變化。
一種可能的解決方法是從右到左刪除項目：
>>>
>>> sample=[3, None, 2, 4, None, 5, 2]
>>> del sample[4], sample[1]
>>> sample
[3, 2, 4, 5, 2]
在此示例中，您已按相反順序刪除了項目，從最大索引開始一直到最小索引。此技術允許您使用單個del語句安全地從列表中刪除多個項目。
當您使用列表索引作為 的參數時del，Python 會回退到調用.__delitem__()特殊方法，該方法負責實際的刪除。下面是一個說明此行為的示例：
>>>
>>> class List(list):
... def __delitem__(self, index):
... print(
... f"Running .__delitem__() to delete {self[index]}"
... )
... super().__delitem__(index)
...
>>> sample=List([3, None, 2, 4, None, 5, 2])
>>> del sample[1]
Running .__delitem__() to delete None
>>> del sample[3]
Running .__delitem__() to delete None
在此示例中，您對內置list類進行子類化并重寫其.__delitem__()方法。在方法內部，您打印一條消息以表明該方法被自動調用。然后您可以使用調用父類中super()的原始實現。.__delitem__()list
說到方法，Python 列表有.remove()和.pop()方法，它們分別允許您按值或索引刪除項目：
>>>
>>> pets=["dog", "cat", "fish", "bird", "hamster"]
>>> pets.remove("fish") # Equivalent to del pets[2]
>>> pets
['dog', 'cat', 'bird', 'hamster']
>>> pets.pop(3)
'hamster'
>>> pets.pop()
'bird'
>>> pets
['dog', 'cat']
在對 的調用中，您從列表中.remove()刪除該項目。該方法調用相當于運行。"fish"petsdel pets[2]
使用delvs.remove()將取決于您想要做什么。如果想要根據項目的索引刪除項目，而不知道其內容，那么這del是解決方案，因為它對項目索引進行操作。另一方面，如果您想刪除內容已知的列表項，則.remove()可以更具可讀性和明確性。它將清楚地表明您想要刪除該特定值。
然后您可以使用.pop()刪除索引處的項目3。除了刪除目標項目外，.pop()還將其返回。這就是你出現'hamster'在屏幕上的原因。最后，.pop()不帶目標索引的調用將從目標列表中刪除并返回最終項目。
使用delvs.pop()更取決于您的具體需求。在這種情況下，兩個選項都使用項目索引。其顯著特征是返回值。如果你不關心返回值，那么就選擇del. 如果您需要返回值進行進一步計算，則必須使用.pop().
從現有列表中刪除一部分項目是該del語句的另一個日常用例。您找不到任何list執行類似任務的方法，因此del可能是您的選擇。要從列表中刪除切片，需要使用以下語法：
>>>
>>> del a_list[start:stop:step]
切片語法最多接受三個以冒號分隔的參數：start、stop和step。它們定義開始切片的索引、切片必須停止檢索值的索引以及值之間的步長。這三個參數通常稱為偏移量。
以下是使用上述構造從列表中刪除切片的一些示例：
>>>
>>> digits=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del digits[3:6]
>>> digits
[0, 1, 2, 6, 7, 8, 9]
>>> del digits[:3]
>>> digits
[6, 7, 8, 9]
>>> del digits[2:]
>>> digits
[6, 7]
在第一個示例中，您將索引中的所有項目刪除3到6。請注意，切片間隔在偏移處打開stop，這意味著索引處的項目6不包含在刪除中。換句話說，切片操作在到達偏移量時停止stop，而不包括該偏移量處的項目。
在第二個示例中，您沒有使用偏移值start，這意味著您希望從列表中的第一項開始刪除。stop最后，在第三個示例中沒有使用偏移量。2這意味著您想要刪除列表末尾的所有項目。
您還可以使用step偏移量來定義切片期間要跳過的項目數。考慮以下示例：
>>>
>>> numbers=[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del numbers[::2]
>>> numbers
[2, 4, 6, 8]
在此示例中，您使用stepof2來刪除 中的所有其他項目numbers。這是一個巧妙的技巧，可以從列表中刪除奇數。
您可以使用slice對象而不是切片運算符來從列表中刪除項目：
>>>
>>> numbers=[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> every_other=slice(0, None, 2)
>>> del numbers[every_other]
>>> numbers
[2, 4, 6, 8]
在此示例中，您使用內置slice()類創建切片對象。類構造函數采用三個參數start、stop和step。它們與切片運算符中的等效偏移量具有相同的含義。
這個特定的切片對象檢索從0列表開始到末尾的項目，您可以通過將stop參數設置為 來完成此操作None。該step參數的值為2。該切片將從目標列表中刪除所有其他項目。
有趣的是，從現有列表中刪除項目切片與將空列表分配給同一切片具有相同的效果：
>>>
>>> digits=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> digits[3:6]=[]
>>> digits
[0, 1, 2, 6, 7, 8, 9]
>>> digits[:3]=[]
>>> digits
[6, 7, 8, 9]
>>> digits[2:]=[]
>>> digits
[6, 7]
將空列表分配給給定切片與使用del語句刪除目標切片具有相同的效果。此示例相當于本節開頭的第一個版本。
從列表中刪除不必要的項目可能會節省程序的一些內存。您通常不會保留對列表項的附加引用，因此，如果您從列表中刪除多個項目，則存儲在這些項目中的對象將可用于垃圾回收，這可能會導致釋放一些內存。
從字典中刪除鍵值對是del. 為此，您需要指定要刪除的鍵作為 的參數del。這是一般語法：
此語句key從包含的字典 中刪除 及其關聯值a_dict。要查看此構造的實際效果，請繼續運行以下示例：
>>>
>>> vegetable_prices={
... "carrots": 0.99,
... "spinach": 1.50,
... "onions": 0.50,
... "cucumbers": 0.75,
... "peppers": 1.25,
... }
>>> del vegetable_prices["spinach"]
>>> del vegetable_prices["onions"], vegetable_prices["cucumbers"]
>>> vegetable_prices
{'carrots': 0.99, 'peppers': 1.25}
您可以在此處從字典中del刪除"spinach"、"onions"和鍵。對于字典，使用擴展語法刪除一行中的多個鍵是完全安全的，因為鍵是唯一的。"cucumbers"vegetable_pricesdel
您還可以使用一些方法從字典中刪除鍵。例如，您可以使用.pop()和.popitem()方法：
>>>
>>> school_supplies={
... "pencil": 0.99,
... "pen": 1.49,
... "notebook": 2.99,
... "highlighter": 0.79,
... "ruler": 1.29,
... }
>>> school_supplies.pop("notebook")
2.99
>>> school_supplies.popitem()
('ruler', 1.29)
>>> school_supplies.popitem()
('highlighter', 0.79)
>>> school_supplies
{'pencil': 0.99, 'pen': 1.49}
在第一個示例中，您使用從字典中.pop()刪除"notebook"鍵及其關聯值。您必須使用現有密鑰作為參數進行調用。在第二個示例中，您調用從 中刪除最近添加的項目。2.99school_supplies.pop().popitem()school_supplies
盡管這些方法從現有字典中刪除鍵，但它們的工作方式與del. 除了刪除目標鍵之外，.pop()還返回與該鍵關聯的值。類似地，.popitem()刪除鍵并以元組形式返回相應的鍵值對。該del語句不返回刪除的值。
當您用于從字典中刪除鍵時， Python 會自動調用.__delitem__() 特殊方法。del下面是一個說明此行為的示例：
>>>
>>> class Dict(dict):
... def __delitem__(self, key) -> None:
... print(f"Running .__delitem__() to delete {(key, self[key])}")
... super().__delitem__(key)
...
>>> ordinals=Dict(
... {"First": "I", "Second": "II", "Third": "III", "Fourth": "IV"}
... )
>>> del ordinals["Second"]
Running .__delitem__() to delete ('Second', 'II')
>>> del ordinals["Fourth"]
Running .__delitem__() to delete ('Fourth', 'IV')
在此示例中，您重寫了從內置類繼承的類.__delitem__()中的方法。使用鍵 作為參數運行該語句會觸發您的自定義實現，該實現會打印一條消息，提供有關已刪除項目的信息。DictdictdelDict.__delitem__()
要了解有關如何在 Python 中安全地子類化內置dict類型的更多信息，請查看自定義 Python 字典：繼承dict自與UserDict.
有時，您可能需要在外部列表、元組和字典中嵌套可變類型，例如列表和字典。創建這些嵌套結構之一后，您可以使用這些項目的索引或鍵來訪問不同嵌套級別上的各個項目。最左邊的索引或鍵將檢索外部序列或字典，而最右邊的索引將檢索嵌套最深的對象。
訪問嵌套項目的可能性允許您使用del以下語法刪除它們：
# Syntax for sequences
del sequence[outer_index][nested_index_1]...[nested_index_n]
# Syntax for dictionaries
del dictionary[outer_key][nested_key_1]...[nested_key_n]
# Syntax for combined structures
del sequence_of_dicts[sequence_index][dict_key]
del dict_of_lists[dict_key][list_index]
要訪問和刪除嵌套可變集合中的對象，必須使用索引運算符，從左到右提供適當的索引。計算一下您需要遍歷多少層嵌套才能到達目標項目。這就是您必須提供的索引數量。
以下是如何從列表列表中刪除嵌套項目的示例：
>>>
>>> matrix=[
... [1, 2, 3],
... [4, 5, 6],
... [7, 8, 9]
... ]
>>> target_row=0
>>> target_col=2
>>> del matrix[target_row][target_col]
>>> matrix
[
[1, 2],
[4, 5, 6],
[7, 8, 9]
]
>>> target_row=1
>>> del matrix[target_row][target_col]
>>> matrix
[
[1, 2],
[4, 5],
[7, 8, 9]
]
>>> target_row=2
>>> del matrix[target_row][target_col]
>>> matrix
[
[1, 2],
[4, 5],
[7, 8]
]
在此示例中，您曾經del刪除matrix列表中的嵌套項目。具體來說，您已從每個矩陣行中刪除了最后一個值。使用索引的描述性名稱可以提高代碼的可讀性，使其更容易推理。
如您所見，target_row表示 中嵌套列表的索引matrix，而target_col表示嵌套列表中目標項的索引。這就是訪問嵌套項目的方式。
盡管 Python元組是不允許直接刪除的不可變數據類型，但它們可以存儲列表、字典和其他允許刪除的可變類型。因此，您還可以del在元組中使用嵌套的可變對象。
為了說明此行為，假設您正在使用RGB 顏色模型中的顏色。為了表示每種顏色，您可以使用元組，因為顏色應該是恒定的。您決定通過提供大寫名稱和 RGB 值列表來創建顏色對象：
>>>
>>> red=("RED", [255, 0, 0])
>>> blue=("BLUE", [0, 0, 255])
這些顏色看起來很棒。它們有一個名稱和一個 RBG 值列表。您無法刪除這些元組中的第一級項目，因為元組是不可變的。但是，您可以從包含 RGB 值的嵌套列表中刪除項目：
>>>
>>> del red[1][0]
>>> red
('RED', [0, 0])
當元組的所有項都是不可變的時，元組也是完全不可變的。如果元組中的一項或多項是可變的，那么您可以使用嵌套索引從其中刪除值，就像在上面的示例中所做的那樣。
Python 中的另一個常見做法是將列表嵌套在字典中。當您使用JSON文件時，這種類型的構造經常出現，它為交換信息提供了清晰易讀的格式。
考慮以下按類別存儲產品的字典示例：
>>>
>>> products={
... "fruits": ["apple", "banana", "orange"],
... "veggies": ["tomato", "avocado", "pepper"]
... }
>>> del products["fruits"][1]
>>> products
{
'fruits': ['apple', 'orange'],
'veggies': ['tomato', 'avocado', 'pepper']
}
>>> del products["veggies"][0]
>>> products
{
'fruits': ['apple', 'orange'],
'veggies': ['avocado', 'pepper']
}
要從字典的內部列表中刪除項目product，首先使用字典鍵，然后使用嵌套列表中目標項目的索引。
您可以在 Python 字典的值中存儲任何數據類型的對象。您可以存儲字符串、元組、列表、其他字典、類、函數，甚至用戶定義的對象。如果給定值中的對象是可變的，那么您可以使用 從中刪除項目del。
這是另一個例子。這次，您有一個字典列表。每個嵌套字典包含另一個字典：
>>>
>>> prices=[
... {"fruits": {"apple": 1.2, "banana": 1.3, "orange": 1.5}},
... {"veggies": {"tomato": 2.1, "avocado": 3.2, "pepper": 1.8}},
... ]
>>> del prices[0]["fruits"]["banana"]
>>> prices
[
{'fruits': {'apple': 1.2, 'orange': 1.5}},
{'veggies': {'tomato': 2.1, 'avocado': 3.2, 'pepper': 1.8}}
]
>>> del prices[0]["fruits"]
>>> prices
[{}, {'veggies': {'tomato': 2.1, 'avocado': 3.2, 'pepper': 1.8}}]
要從最深層嵌套的字典中刪除項目，您需要使用包含列表的索引，然后是第二層字典的鍵，最后是要刪除的項目的鍵。請注意，您可以使用其他索引鍵組合來刪除其他項目，具體取決于它們的嵌套級別。
當涉及到用戶定義的類時，您可以使用該語句刪除類和實例屬性del。您還可以使用del從類中刪除方法。刪除類和實例的成員可能很少有用，但在 Python 中是可能的。
刪除類成員的一般語法del如下：
del a_class.class_attribute
del a_class.method
del an_instance.instance_attribute
要將目標成員作為參數傳遞給del，您需要在類或其實例之一上使用點表示法，具體取決于您需要刪除的成員類型。在以下部分中，您將編寫示例來說明這一切在實踐中是如何工作的。
為了說明del刪除類成員的語法是如何工作的，請繼續SampleClass在 Python 交互式REPL中編寫以下類：
>>>
>>> class SampleClass:
... class_attribute=0
... def __init__(self, arg):
... self.instance_attribute=arg
... def method(self):
... print(self.instance_attribute)
...
>>> SampleClass.__dict__
mappingproxy({
'__module__': '__main__',
'class_attribute': 0,
'__init__': <function SampleClass.__init__ at 0x105534360>,
'method': <function SampleClass.method at 0x104bcf240>,
...
})
>>> sample_instance=SampleClass("Value")
>>> sample_instance.__dict__
{'instance_attribute': 'Value'}
在此代碼段中，您將創建一個具有類屬性、實例屬性和方法的示例類。突出顯示的行顯示了這些成員如何存在于類和實例.__dict__屬性中，它們分別存儲類和實例屬性。
現在繼續運行以下語句來刪除此類及其對象的成員：
>>>
>>> # Delete members through the instance
>>> del sample_instance.instance_attribute
>>> del sample_instance.class_attribute
Traceback (most recent call last):
...
AttributeError: 'SampleClass' object has no attribute 'class_attribute'
>>> del sample_instance.method
Traceback (most recent call last):
...
AttributeError: 'SampleClass' object has no attribute 'method'
>>> sample_instance.__dict__
{}
>>> # Delete members through the class
>>> del SampleClass.class_attribute
>>> del SampleClass.method
>>> SampleClass.__dict__
mappingproxy({
'__module__': '__main__',
'__init__': <function SampleClass.__init__ at 0x105534360>,
...
})
使用給定類的實例，您只能刪除實例屬性。如果您嘗試刪除類屬性和方法，則會出現異常AttributeError。您只能通過類本身刪除類屬性和方法，正如您在最后兩個示例中可以確認的那樣。
什么時候del刪除實例屬性有用？當您需要通過為 Python 的垃圾收集系統準備臨時實例屬性來減少對象的內存占用時，這可能會釋放計算機上寶貴的內存資源。
例如，假設您想編寫一個Factorial類來表示數字的階乘。類構造函數必須采用數字作為參數，并創建一個具有兩個只讀屬性.number和 的實例.factorial。
該類應該使用緩存作為優化，以避免任何不必要的中間計算重復。它還應該具有內存效率，并在計算階乘后刪除緩存。
這是您的班級的可能實現Factorial：
1# factorial.py
2
3class Factorial:
4 def __init__(self, number):
5 self._number=number
6 self._cache={0: 1, 1: 1}
7 self._factorial=self._calculate_factorial(number)
8 del self._cache
9
10 def _calculate_factorial(self, number):
11 if number in self._cache:
12 return self._cache[number]
13 current_factorial=number * self._calculate_factorial(number - 1)
14 self._cache[number]=current_factorial
15 return current_factorial
16
17 @property
18 def number(self):
19 return self._number
20
21 @property
22 def factorial(self):
23 return self._factorial
24
25 def __str__(self) -> str:
26 return f"{self._number}!={self._factorial}"
27
28 def __repr__(self):
29 return f"{type(self).__name__}({self._number})"
哇！這段代碼中發生了很多事情。以下是最相關行的細分：
以下是您的班級在實踐中的運作方式：
>>>
>>> from factorial import Factorial
>>> for i in range(5):
... print(Factorial(i))
...
0!=1
1!=1
2!=2
3!=6
4!=24
>>> factorial_5=Factorial(5)
>>> factorial_5
Factorial(5)
>>> factorial_5.number
5
>>> factorial_5.factorial
120
>>> print(factorial_5)
5!=120
>>> factorial_5.factorial=720
Traceback (most recent call last):
...
AttributeError: property 'factorial' of 'Factorial' object has no setter
>>> factorial_5._cache
Traceback (most recent call last):
...
AttributeError: 'Factorial' object has no attribute '_cache'
在第一個示例中，您運行一個for循環來創建 的五個實例Factorial并將它們打印到屏幕上。請注意該方法如何.__str__()通過使用數學階乘表示法打印實例來工作。
Factorial然后您創建另一個with實例5作為輸入數字。請注意如何訪問.number和.factorial屬性，但無法重新分配它們，因為它們是只讀的。最后，如果您嘗試訪問非公共._cache屬性，那么您會得到一個，AttributeError因為您已經在方法中刪除了該屬性.__init__()。
在階乘計算后刪除._cache屬性可以使實例Factorial節省內存。為了說明這一點，請繼續通過安裝來添加Pympler庫。該庫將允許您測量實例的內存占用量。pymplerpipFactorial
然后執行以下代碼：
>>>
>>> from pympler import asizeof
>>> asizeof.asizeof(Factorial(100))
600
在這里，您使用該asizeof()函數來計算實例的組合大小（以字節為單位）Factorial。正如您所看到的，該特定實例Factorial占用了計算機內存中的 600 字節。
現在回到您的factorial.py文件并注釋掉第 8 行，其中包含del刪除._cache. 完成此更改后，繼續再次運行上述函數調用：
>>>
>>> asizeof.asizeof(Factorial(100))
14216
現在，您的實例的大小Factorial比以前大了 23 倍多。這就是實例完成后刪除與保留不必要的緩存數據的影響。
在 Python 中，您可以以防止刪除實例屬性的方式編寫類。您會發現很多技術可以做到這一點。在本節中，您將了解其中兩種技術：
首先，您將首先使用.__delattr__()自定義實現覆蓋特殊方法。在幕后，當您使用給定的實例屬性作為del語句的參數時，Python 會自動調用此方法。
作為如何創建一個阻止您刪除其實例屬性的類的示例，請考慮以下玩具類：
# non_deletable.py
class NonDeletable:
def __init__(self, value):
self.value=value
def __delattr__(self, name):
raise AttributeError(
f"{type(self).__name__} object doesn't support attribute deletion"
)
在此類中，您將重寫.__delattr__()特殊方法。每當用戶嘗試使用語句AttributeError刪除任何屬性（例如 , ）時，您的實現都會引發異常。.valuedel
以下是您的班級在實踐中的行為示例：
>>>
>>> one=NonDeletable(1)
>>> one.value
1
>>> del one.value
Traceback (most recent call last):
...
AttributeError: NonDeletable object doesn't support attribute deletion
每當您嘗試刪除 的.value任何實例的屬性時NonDeletable，您都會收到AttributeError來自 的自定義實現的異常.__delattr__()。此技術為需要防止實例屬性刪除的情況提供了快速解決方案。
另一種防止實例屬性刪除的常見、快速技術是將目標屬性轉換為屬性并提供合適的刪除器方法。例如，假設您想要編寫一個Person類來防止用戶刪除其.name屬性：
# person.py
class Person:
def __init__(self, name):
self.name=name
@property
def name(self):
return self._name
@name.setter
def name(self, value):
self._name=str(value).upper()
@name.deleter
def name(self):
raise AttributeError("can't delete attribute 'name'")
在此示例中，Person有一個.name通過屬性實現的屬性。該屬性有一個 getter 方法，該方法返回 的值._name，這是存儲數據的常規屬性。
setter 方法獲取屬性的新值，將其轉換為字符串，然后將其轉換為大寫字母。
最后，刪除器方法會發出一個AttributeError信號，表明該屬性不可刪除。當您在語句中使用.name屬性作為參數時，Python 會自動調用此方法del：
>>>
>>> from person import Person
>>> jane=Person("Jane")
>>> jane.name
'JANE'
>>> jane.name="Jane Doe"
>>> jane.name
'JANE DOE'
>>> del jane.name
Traceback (most recent call last):
...
AttributeError: can't delete attribute 'name'
您的Person課程按預期進行。您可以訪問其.name屬性并使用新值更新它，同時每次都將輸入值大寫。.name類定義末尾的屬性的刪除器方法可確保您的用戶無法刪除該屬性。
您已經了解了 Python 語句的del工作原理以及如何使用它來刪除代碼中的名稱和引用。您現在知道如何從不同的命名空間中刪除變量、從列表中刪除項目、從字典中刪除鍵以及從自定義對象和類中刪除成員。您還了解了del當您需要釋放內存以使代碼更高效、更輕量時如何為您提供幫助。
在本教程中，您學習了如何：
現在您已經了解了有關 Pythondel語句的很多知識，您可以通過刪除對不需要的對象的引用來編寫內存高效的代碼，從而為垃圾收集系統準備這些對象。
Windows 10 version 22H2 (updated Jan 2024) 中文版、英文版下載
Windows 10 22H2 企業版 arm64 x64
請訪問原文鏈接：https://sysin.org/blog/windows-10/，查看最新版。原創作品，轉載請保留出處。
作者主頁：sysin.org
Windows 10 laptop
Windows 10, version 22H2, all editions
發布日期: 2022/10/18
版本: Windows 10，版本 22H2
2022/10/19
從 Windows 10 版本 21H2 開始，Windows 10 版本的功能更新在每個日歷年的下半年發布到正式發布頻道。自發布之日起 18 個月或 30 個月內，將向其提供每月質量更新，具體取決于生命周期策略。
我們建議立即開始將每個正式發布頻道版本定向部署到已選擇進行早期采用的設備 (sysin)，并自行升級到完全部署。通過此操作，能夠盡快獲得對新功能、體驗和集成安全性的訪問權限。
有關服務時間線的信息，請參閱 Windows 生命周期常見問題解答。
備注
正式發布頻道替換了之前的“半年度頻道”，后者曾是 Windows 10 服務的主要和推薦頻道。
Windows 發布運行狀況中心不斷發展變化。參加我們的簡短調查 ，讓我們了解我們可以如何改進。
對應于服務選項的 Windows 10 當前版本
所有的日期都按照 ISO 8601 格式列出：YYYY-MM-DD)
版本服務選項上市日期最后修訂日期最新版本服務終止：家庭版、專業版、專業教育版和專業工作站版服務終止：企業版、教育版和 IoT 企業版 22H2正式發布頻道2022-10-182022-10-1819045.21302024-05-142025-05-13 21H2正式發布頻道2021-11-162022-10-1719044.21322023-06-132024-06-11 21H1半年頻道2021-05-182022-10-1719043.21322022-12-132022-12-13 20H2半年頻道2020-10-202022-10-1719042.2132服務終止2023-05-09
版本服務選項上市日期最后修訂日期最新版本主要支持結束日期外延支持結束日期 21H2長期服務頻道 (LTSC)2021-11-162022-10-1719044.21322027-01-122032-01-13 （僅限 IoT 企業版）1 1809長期服務頻道 (LTSC)2018-11-132022-10-1717763.35342024-01-092029-01-09 1607長期服務分支 (LTSB)2016-08-022022-10-1814393.5429服務終止2026-10-13 1507 (RTM)長期服務分支 (LTSB)2015-07-292022-10-1810240.19509服務終止2025-10-14
備注
1 Windows 10 企業版 LTSC 2021 版（版本 21H2）不具有擴展支持。服務將于 2027 年 1 月 12 日終止。2032 年 1 月 13 日之前，將僅向 Windows 10 IoT 企業版 LTSC 2021（版本 21H2）提供支持 (sysin)。
Windows 10 發行歷史記錄
在 Windows 10 更新歷史記錄上了解有關 Windows 10 更新內容的更多信息。
**Version 22H2 (OS build 19045)**：
To update devices running Windows 10, version 20H2 or 21H2 to version 22H2, you can speed up the update process using an?enablement package.
服務選項上市日期內部版本知識庫文章 正式發布頻道2022-10-1819045.2130
語言：簡體中文、繁體中文、English
**Windows 10 Enterprise (教育版、企業版、專業版、專業教育版、專業工作站版) Arm64, 64-bit (released Oct 2022)**： 百度網盤鏈接：https://pan.baidu.com/s/1flnvy6jhyj9HaBwgAfxNMA?pwd=40zg
Windows 10, version 22H2 (released Oct 2022) Arm64 Chinese Simplified 5074 MB ISO SHA256：2B52E357307E79E33733C9563B1ED325458ACE163E8FD0106EA11001E4BE430D Windows 10, version 22H2 (released Oct 2022) 64-bit Chinese Simplified 5677 MB ISO SHA256：44F6E097C3244BC99DB4D9C9592C04E1F2EF31898E68EEF526106B97282D30FB
Windows 10, version 22H2 (released Oct 2022) Arm64 Chinese Traditional 5062 MB ISO SHA256：6343E3E52529D2F51A9376B270C1840313FFBF7C8FB603C42C95D2904AC42A5B Windows 10, version 22H2 (released Oct 2022) 64-bit Chinese Traditional 5668 MB ISO SHA256：91C5B86E6FF0D0D9F3C29E26EB60C10CA379638AE3082C456154D8AB23334414
Windows 10, version 22H2 (released Oct 2022) Arm64 English 4838 MB ISO SHA256：F074B6577E8D078A23860153A9E35875F24CBC5DFFBFB77BA858251C50DC0607 Windows 10, version 22H2 (released Oct 2022) 64-bit English 5691 MB ISO SHA256：18A84E0DA1043D7C1D3CF46EE127E8F637D425AD57E115EE862AF203FA4932A8
Windows 10 MUI 多國語言包：
訪問此網站可獲取有關在 Windows 10 映像中添加語言的更多信息
Windows 10, version 2004 or newer Language Packs (released May 2020 32/64 bit/ARM64 5675 MB ISO SHA256SUM: 201269A05A09DBA91D47923C733D43F38F38EBF33DE2FD0750887D2763886743
百度網盤鏈接：https://pan.baidu.com/s/1S-vqkvdMvdf7kZ7WVEKi1A?pwd=miet
**Windows 10 Enterprise (教育版、企業版、專業版、專業教育版、專業工作站版) Arm64, 64-bit (updated Jan 2024)**： 百度網盤鏈接：https://sysin.org/blog/windows-10/
以上皆為官方原版。
更多：
虛機模板下載：