Я не можу реально придумати будь-яку причину, чому python потребує delключового слова (і, здається, більшість мов не мають подібного ключового слова). Наприклад, замість видалення змінної можна було просто призначити Noneїї. І при видаленні зі словника delметод може бути доданий.

Чи є якась причина триматися delв пітоні, чи це пережиток днів попереднього збирання сміття Python?

По-перше, ви можете виділити інші речі, крім локальних змінних

del list_item[4]
del dictionary["alpha"]

І те й інше повинно бути корисним. По-друге, використання delлокальної змінної робить наміри зрозумілішими. Порівняйте:

del foo

до

foo = None

Я знаю, що у випадку, del fooщо наміром є видалення змінної з області застосування. Незрозуміло, що foo = Noneце робить. Якщо хтось щойно призначив, foo = Noneя можу подумати, що це мертвий код. Але я моментально знаю, що del fooнамагався зробити хтось, хто кодує .

Ось ця частина того, що delробить (із посилання на мову Python ):

Видалення імені видаляє прив'язку цього імені з локального чи глобального простору імен

Присвоєння Noneімені не видаляє прив'язку імені з простору імен.

(Я припускаю, що може виникнути дискусія щодо того, чи справді корисне видалення прив’язки імен , але це інше питання.)

Одне місце, яке я вважаю delкорисним, - це очищення сторонніх змінних для циклів:

for x in some_list:
  do(x)
del x

Тепер ви можете бути впевнені, що x буде невизначено, якщо використовувати його поза циклом for.

Видалення змінної відрізняється від встановлення значення None

Видалення імен змінних за допомогою del, ймовірно, використовується вкрай рідко, але це неможливо досягти тривіально без ключового слова. Якщо ви можете створити ім'я змінної, написавши a=1, добре, що ви можете теоретично скасувати це, видаливши a.

Це може полегшити налагодження в деяких випадках, оскільки спроба отримати доступ до видаленої змінної призведе до виникнення NameError.

Ви можете видалити атрибути екземплярів класу

Python дозволяє написати щось на кшталт:

class A(object):
    def set_a(self, a):
        self.a=a
a=A()
a.set_a(3)
if hasattr(a, "a"):
    print("Hallo")

Якщо ви вирішите динамічно додавати атрибути до екземпляра класу, ви, звичайно, хочете мати можливість скасувати його, написавши

del a.a

Існує конкретний приклад того, коли ви повинні використовувати del(можуть бути й інші, але я знаю про це одноосібно), коли ви використовуєте sys.exc_info()для перевірки винятку. Ця функція повертає кортеж, тип винятку, який було порушено, повідомлення та прослідкування.

Перших двох значень зазвичай достатньо для діагностування помилки та дії на ній, але третє містить весь стек викликів між тим, де був винятий виняток, і де вилучення винятку. Зокрема, якщо ви робите щось подібне

try:
    do_evil()
except:
    exc_type, exc_value, tb = sys.exc_info()
    if something(exc_value):
        raise

трекбек, tbопиняється у місцевих жителів стека викликів, створюючи циркулярну посилання, яку неможливо зібрати сміття. Таким чином, важливо зробити:

try:
    do_evil()
except:
    exc_type, exc_value, tb = sys.exc_info()
    del tb
    if something(exc_value):
        raise

щоб розбити кругову опору. У багатьох випадках, коли ви хочете зателефонувати sys.exc_info(), як, наприклад, з металевою магією, зворотний слід є корисним, тому вам потрібно переконатися, що ви очистите його, перш ніж ви зможете залишити обробник винятків. Якщо прослідкування вам не потрібне, його слід негайно видалити або просто зробити:

exc_type, exc_value = sys.exc_info()[:2]

Щоб уникнути цього всього разом.

Просто інше мислення.

Під час налагодження програм http у такій структурі, як Django, стек викликів, повний непотрібних та заплутаних змінних раніше використовуваних, особливо коли це дуже довгий список, може бути дуже болючим для розробників. тож у цей момент контроль простору імен може бути корисним.

Використання "del" явно також є кращою практикою, ніж присвоєння змінної None. Якщо ви спробуєте дельтувати змінну, яка не існує, ви отримаєте помилку під час виконання, але якщо ви спробуєте встановити змінну, яка не існує в None, Python беззвучно встановить нову змінну на None, залишивши змінну вам хотіли видалити, де це було. Тож дель допоможе вам зловити свої помилки раніше

Щоб додати кілька пунктів до вищезазначених відповідей: del x

Визначення xвказує r -> o(посилання, що rвказує на об'єкт o), але замість цього del xзмінюється . Це операція над посиланням (вказівником) на об'єкт, а не об'єктом, пов'язаним з . Тут розрізняють і є ключовим.roxro

• Це видаляє його з locals().
• Видаляє його, globals()якщо він xналежить.
• Видаляє його з кадру стека (фізично видаляє з нього посилання, але сам об'єкт знаходиться в пулі об'єктів, а не в кадрі стека).
• Вилучає його з поточної області. Дуже корисно обмежити діапазон визначення локальної змінної, що в іншому випадку може спричинити проблеми.
• Йдеться скоріше про оголошення імені, а не про визначення змісту.
• Це впливає на те, де xналежить, а не там, де xвказує. Єдина фізична зміна пам’яті - це. Наприклад, якщо xє у словнику чи списку, він (як довідник) видаляється звідти (і не обов'язково з об’єднаного пулу). У цьому прикладі словник, якому він належить, є фреймом стека ( locals()), який перекривається globals().

Примушуйте закривати файл після використання numpy.load:

Можливість використання ніші, але я вважаю це корисним при використанні numpy.load читанні файлу. Раз у раз я оновлював би файл і мені потрібно було скопіювати файл з тим самим іменем у каталог.

Я раніше delвипускав файл і дозволяв мені копіювати новий файл.

Примітка. Я хочу уникати withконтекстного менеджера, оскільки я грав із сюжетами в командному рядку і не хотів сильно натискати вкладку!

Дивіться це питання.

delчасто бачимо у __init__.pyфайлах. Будь-яка глобальна змінна, яка визначена у __init__.pyфайлі, автоматично "експортується" (вона буде включена в a from module import *). Одним із способів уникнути цього є визначення__all__ , але це може стати безладним, і не всі використовують його.

Наприклад, якщо у вас був код у __init__.pyподібному

import sys
if sys.version_info < (3,):
    print("Python 2 not supported")

Тоді ваш модуль експортував би sysім'я. Натомість слід писати

import sys
if sys.version_info < (3,):
    print("Python 2 not supported")

del sys

Як приклад того, для чого delможна використовувати, я вважаю корисним i такі ситуації:

def f(a, b, c=3):
    return '{} {} {}'.format(a, b, c)

def g(**kwargs):
    if 'c' in kwargs and kwargs['c'] is None:
        del kwargs['c']

    return f(**kwargs)

# g(a=1, b=2, c=None) === '1 2 3'
# g(a=1, b=2) === '1 2 3'
# g(a=1, b=2, c=4) === '1 2 4'

Ці дві функції можуть бути в різних пакетів / модулів і програмісту не потрібно знати , що значення аргументу по замовчуванням cвf насправді є. Таким чином, використовуючи kwargs у поєднанні з del, ви можете сказати "Я хочу значення за замовчуванням на c", встановивши його "None" (або в цьому випадку також залишити його).

Ви можете зробити те ж саме з чимось на зразок:

def g(a, b, c=None):
    kwargs = {'a': a,
              'b': b}
    if c is not None:
        kwargs['c'] = c

    return f(**kwargs)

Однак я вважаю попередній приклад більш сухим та елегантним.

Коли дель корисний у python?

Ви можете використовувати його для видалення одного елемента масиву замість синтаксису зрізів x[i:i+1]=[]. Це може бути корисно, якщо ви, наприклад, перебуваєте в ньому os.walkі хочете видалити елемент в каталозі. Я б не вважав ключовим словом корисним для цього, оскільки можна просто зробити [].remove(index)метод ( .removeметод насправді пошук і видалення-перший-екземпляр вартості).

Я виявив delсебе корисним для управління псевдоручною пам'яттю під час обробки великих даних за допомогою Numpy. Наприклад:

for image_name in large_image_set:
    large_image = io.imread(image_name)
    height, width, depth = large_image.shape
    large_mask = np.all(large_image == <some_condition>)
    # Clear memory, make space
    del large_image; gc.collect()

    large_processed_image = np.zeros((height, width, depth))
    large_processed_image[large_mask] = (new_value)
    io.imsave("processed_image.png", large_processed_image)

    # Clear memory, make space
    del large_mask, large_processed_image; gc.collect()

Це може бути різницею між приведенням сценарію до шліфувальної зупинки, оскільки система обмінюється, як зненацька, коли Python GC не може йти в ногу, і він ідеально гладкий нижче вільного порогу пам'яті, що залишає достатньо місця для використання машини для перегляду. і код, поки він працює.

Я думаю, що одна з причин того, що дель має власний синтаксис, полягає в тому, що замінити його функцією може бути важко в певних випадках, враховуючи, що вона працює на прив'язці або змінній, а не на значення, на яке посилається. Таким чином, якщо для створення версії del слід створити контекст, потрібно було б передати його. Del foo повинен стати глобальними (). Remove ('foo') або localals (). Remove ('foo'), який стає брудним і менш читабельний. І все-таки я кажу, що позбавлення від дель буде добре, враховуючи його, здавалося б, рідкісне використання. Але видалення мовних особливостей / недоліків може бути болісним. Можливо, python 4 видалить його :)

Я хотів би детальніше розглянути прийняту відповідь, щоб виділити нюанс між встановленням змінної та Noneпорівнянням з її видаленням del:

Дано змінну foo = 'bar'і таке визначення функції:

def test_var(var):
    if var:
        print('variable tested true')
    else:
        print('variable tested false')

Як тільки спочатку оголосили, test_var(foo)врожайність, variable tested trueяк очікувалося.

Тепер спробуйте:

foo = None
test_var(foo)

яка врожайність variable tested false.

Порівнюйте цю поведінку з:

del foo
test_var(foo)

який зараз піднімає NameError: name 'foo' is not defined.

Ще одне використання ніші: У pyroot з ROOT5 або ROOT6 "del" може бути корисним для видалення об'єкта python, який посилався на вже не існуючий об'єкт C ++. Це дозволяє динамічному пошуку pyroot знайти ідентично названий об'єкт C ++ і прив'язати його до імені python. Тож у вас може бути такий сценарій, як:

import ROOT as R
input_file = R.TFile('inputs/___my_file_name___.root')
tree = input_file.Get('r')
tree.Draw('hy>>hh(10,0,5)')
R.gPad.Close()
R.hy # shows that hy is still available. It can even be redrawn at this stage.
tree.Draw('hy>>hh(3,0,3)') # overwrites the C++ object in ROOT's namespace
R.hy # shows that R.hy is None, since the C++ object it pointed to is gone
del R.hy
R.hy # now finds the new C++ object

Будемо сподіватися, що ця ніша буде закрита керованим управлінням об'єктом ROOT7.

Команда "del" дуже корисна для контролю даних у масиві, наприклад:

elements = ["A", "B", "C", "D"]
# Remove first element.
del elements[:1]
print(elements)

Вихід:

['B', 'C', 'D']

Одного разу мені довелося користуватися:

del serial
serial = None

тому що використовуючи лише:

serial = None

не випустив послідовний порт досить швидко, щоб негайно відкрити його знову. З цього уроку я дізнався, що delнасправді означало: "ЗАРАЗ зараз! І чекай, поки це зроблено", і це дійсно корисно у багатьох ситуаціях. Звичайно, у вас може бути system.gc.del_this_and_wait_balbalbalba(obj).

del є еквівалентом "unset" у багатьох мовах і як перехресна точка, що переходить з іншої мови на python. var до "" або жодна дійсно не видаляє var із області застосування. Це просто спорожняє її значення, ім'я самого var все ще зберігатиметься в пам'яті ... чому?!? у скрипті, що інтенсивно працює на пам’яті .. зберігання сміття за його просто ні ні, і все одно ... кожна мова там має якусь форму функції "unset / delete" var функції ... чому не python?

Кожен об'єкт в python має ідентифікатор, Type, посилання, пов'язаний з ним, коли ми використовуємо del, кількість посилань зменшується, коли кількість відліку стає нульовою, це потенційний кандидат для збирання сміття. Це відрізняє del, порівняно з встановленням ідентифікатора на None. У подальшому випадку це просто означає, що об'єкт просто залишається диким (поки ми не вийдемо за межі, і в цьому випадку кількість знижується), а тепер просто ідентифікатор вказує на якийсь інший об'єкт (місце пам'яті).