Gerçekten python delanahtar kelimeye ihtiyacı olan herhangi bir neden düşünemiyorum (ve çoğu dilde benzer bir anahtar kelime yok gibi görünüyor). Örneğin, bir değişkeni silmek yerine, bir değişken atayabilir None. Ve bir sözlükten silerken, bir delyöntem eklenebilir.

Saklamak için herhangi bir sebep var mı delPython'da kalmanız , yoksa Python'un çöp öncesi toplama günlerinin bir kalıntısı mı?

İlk olarak, yerel değişkenlerin yanı sıra başka şeyler de yapabilirsiniz

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

Her ikisi de açıkça faydalı olmalıdır. İkincisi, delyerel bir değişken üzerinde kullanmak amacı daha net hale getirir. Karşılaştırmak:

del foo

için

foo = None

del fooNiyetin değişkeni kapsamdan çıkarmak olduğunu biliyorum . Bunu yaptığı belli değil foo = None. Birisi yeni atanmışsa foo = None, bunun ölü kod olduğunu düşünebilirim. Ama anında kodlayan birinin ne del fooyapmaya çalıştığını biliyorum.

Neyin bu kısmı delvar ( Python Dil Referansından ):

Bir adın silinmesi, o adın yerel veya genel ad alanından bağlanmasını kaldırır

NoneBir ada atamak , adın ad alanından bağlanmasını kaldırmaz.

(Sanırım bir ad bağlayıcısının kaldırılmasının gerçekten yararlı olup olmadığı konusunda bazı tartışmalar olabilir , ancak bu başka bir soru.)

delYararlı bulduğum bir yer , döngüler için yabancı değişkenleri temizlemektir:

for x in some_list:
  do(x)
del x

Şimdi for döngüsü dışında kullanırsanız x'in tanımsız olacağından emin olabilirsiniz.

Bir değişkeni silmek, Yok olarak ayarlamaktan farklı

Değişken adlarının silinmesi del, büyük olasılıkla nadiren kullanılan bir şeydir, ancak anahtar kelime olmadan önemsiz bir şekilde elde edilemeyen bir şeydir. Yazarak bir değişken adı oluşturabiliyorsanız a=1, a'yı silerek teorik olarak geri alabilirsiniz.

Silinen bir değişkene erişmeye çalışmak bir NameError değerini yükselteceğinden, bazı durumlarda hata ayıklamayı kolaylaştırabilir.

Sınıf örneği niteliklerini silebilirsiniz

Python şöyle bir şey yazmanıza izin verir:

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

Bir sınıf örneğine dinamik olarak öznitelikler eklemeyi seçerseniz, kesinlikle yazarak geri alabilmek istersiniz.

del a.a

Ne zaman kullanmanız gerektiğine dair belirli bir örnek delvar (başkaları olabilir, ancak bunu bir elden biliyorum)sys.exc_info()Bir istisnayı incelemek . Bu işlev bir tuple, yükseltilen istisna türü, ileti ve geri izleme döndürür.

İlk iki değer genellikle bir hatayı teşhis etmek ve üzerinde işlem yapmak için yeterlidir, ancak üçüncüsü istisnanın ortaya çıktığı durum ile istisnanın yakalandığı yer arasındaki tüm çağrı yığınını içerir. Özellikle,

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

geri izleme, tbçağrı yığınının yerlileriyle sonuçlanır ve çöp toplanamayan dairesel bir referans oluşturur. Bu nedenle, aşağıdakileri yapmak önemlidir:

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

dairesel referansı kırmak için. Aramak istediğiniz birçok durumda sys.exc_info(), metasınıf büyüsünde olduğu gibi, geri izleme yararlıdır, bu nedenle istisna işleyiciden çıkmadan önce temizlediğinizden emin olmanız gerekir. Geri izlemeye ihtiyacınız yoksa, hemen silmeniz veya yapmanız gerekenler:

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

Hepsini birlikte önlemek için.

Sadece başka bir düşünce.

Django gibi bir çerçevedeki http uygulamalarında hata ayıklarken, özellikle çok uzun bir liste olduğunda, daha önce kullanılan işe yaramaz ve berbat değişkenlerle dolu çağrı yığını, geliştiriciler için çok acı verici olabilir. bu nedenle, ad alanı kontrolü yararlı olabilir.

Açıkça "del" kullanmak, None değişkenine atamaktan daha iyi bir uygulamadır. Var olmayan bir değişkeni silmeye çalışırsanız, bir çalışma zamanı hatası alırsınız, ancak Yok'ta olmayan bir değişkeni ayarlamaya çalışırsanız, Python sessiz bir şekilde yeni değişkeni Yok olarak bırakır ve olduğu yerde silinmesini istedi. Yani del hatalarınızı daha erken yakalamanıza yardımcı olacak

Yukarıdaki cevaplara birkaç puan eklemek için: del x

Tanımı xgösterir r -> o(referans rbir nesneye işaret o), fakat del xdeğiştirir ryerine o. İlişkilendirilmiş nesne yerine nesneye başvuru (işaretçi) üzerinde yapılan bir işlemdir x. Burada rve arasında ayrım yapmak önemlidir o.

• Onu kaldırır locals() .
• Onu kaldırır globals()eğerx orada aittir.
• Yığın çerçevesinden kaldırır (başvuruyu fiziksel olarak ondan kaldırır, ancak nesnenin kendisi yığın çerçevesinde değil, nesne havuzunda bulunur).
• Geçerli kapsamdan kaldırır. Aksi takdirde sorunlara neden olabilecek bir yerel değişkenin tanım aralığını sınırlamak çok yararlıdır.
• Daha çok içerik tanımından ziyade adın beyanı ile ilgilidir.
• Nereye xait olduğunu etkiler , nereye xişaret ettiğini etkilemez . Hafızadaki tek fiziksel değişiklik şudur. Örneğin xbir sözlükte veya listede varsa, (başvuru olarak) oradan kaldırılır (ve nesne havuzundan olması gerekmez). Bu örnekte, ait olduğu sözlük locals()çakışan yığın karesidir ( ) globals().

Numpy.load kullandıktan sonra dosyayı kapatmaya zorlayın:

Belki bir niş kullanımı ama kullanırken yararlı buldum numpy.load bir dosyayı okumak için . Arada sırada dosyayı güncellerdim ve aynı ada sahip bir dosyayı dizine kopyalamam gerekir.

Kullandığım deldosyayı serbest bırakmak için ve bana yeni dosyasında kopyalamak için izin verir.

Not Ben withkomut satırında araziler ile uğraşırken ve sekme çok basmak istemiyordu bağlam yöneticisi kaçınmak istiyorum!

Bu soruya bakın .

delgenellikle __init__.pydosyalarda görülür . Bir __init__.pydosyada tanımlanan herhangi bir global değişken otomatik olarak "dışa aktarılır" (a içine dahil edilir from module import *). Bundan kaçınmanın bir yolu,__all__ , ancak bu dağınık olabilir ve herkes bunu kullanmaz.

Örneğin, eğer kod vardı __init__.pygibi

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

Ardından modülünüz sysadı dışa aktarır. Bunun yerine yazmalısın

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

del sys

Ne deliçin kullanılabilir bir örnek olarak , ben yararlı bu gibi durumlarda böyle buluyorum:

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'

Bu iki işlev farklı paketlerde / modüllerde olabilir ve programcının hangi varsayılan değer bağımsız değişkeninde olduğunu bilmesine gerek yoktur c.f aslında var. Yani kwargs komutunu del ile birlikte kullanarak None olarak ayarlayarak "c'de varsayılan değeri istiyorum" diyebilirsiniz (veya bu durumda da bırakın).

Aynı şeyi aşağıdaki gibi bir şeyle de yapabilirsiniz:

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

    return f(**kwargs)

Ancak önceki örneği daha kuru ve zarif buluyorum.

Del python'da ne zaman yararlıdır?

Bunu, dilim sözdizimi yerine bir dizinin tek bir öğesini kaldırmak için kullanabilirsiniz x[i:i+1]=[]. Örneğin os.walk, dizindeyseniz ve dizindeki bir öğeyi silmek istiyorsanız bu yararlı olabilir . Ben sadece bir [].remove(index)yöntem ( .removeyöntem aslında arama-ve-değeri-ilk-örneği-kaldır) yapabilirsiniz, çünkü bu bir anahtar kelime olsa yararlı olmaz .

Bulduğum delNumpy büyük veri işlerken yarı manuel bellek yönetimi için yararlı olduğu. Örneğin:

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()

Bu, bir komut dosyasını taşlama durmasına getirme arasındaki fark olabilir, çünkü Python GC devam edemediğinde deli gibi takas eder ve makineyi taramak için bol miktarda boş alan bırakan gevşek bir bellek eşiğinin altında mükemmel bir şekilde çalışır. ve kod çalışırken.

Del'in kendi sözdizimine sahip olmasının nedenlerinden biri, bir işlevle değiştirmenin, başvurduğu değer değil, bağlanma veya değişken üzerinde çalıştığı göz önüne alındığında bazı durumlarda zor olabileceğini düşünüyorum. Bu nedenle del'in bir işlev sürümü yaratılacaksa, bir bağlamın geçmesi gerekirdi. Del foo'nun global () olması gerekir. Remove ('foo') veya locals (). Remove ('foo') ve daha az okunabilir. Yine de del gibi kurtulmak görünüşte nadir kullanımı göz önüne alındığında iyi olacağını söylüyorum. Ancak dil özelliklerini / kusurlarını kaldırmak acı verici olabilir. Belki python 4 kaldıracak :)

Bir değişkenin Nonekaldırılması ile bir değişkenin ayarlanması arasındaki nüansı vurgulamak için kabul edilen cevabı detaylandırmak istiyorum del:

Değişken foo = 'bar've aşağıdaki işlev tanımı verildiğinde :

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

Başlangıçta beyan edildikten sonra, beklendiği gibi test_var(foo)sonuç verir variable tested true.

Şimdi dene:

foo = None
test_var(foo)

hangi verir variable tested false.

Bu davranışı aşağıdakilerle karşılaştırın:

del foo
test_var(foo)

şimdi yükseliyor NameError: name 'foo' is not defined.

Yine başka bir niş kullanımı: ROOT5 veya ROOT6 ile pirootta, "del" artık mevcut olmayan bir C ++ nesnesine atıfta bulunan bir python nesnesini kaldırmak için yararlı olabilir. Bu, pirootun dinamik aramasının, aynı adlı bir C ++ nesnesini bulmasını ve onu python adına bağlamasını sağlar. Böylece aşağıdaki gibi bir senaryo olabilir:

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

Umarım, bu niş ROOT7'nin akılcı nesne yönetimi ile kapatılacaktır.

"Del" komutu, bir dizideki verileri kontrol etmek için çok kullanışlıdır, örneğin:

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

Çıktı:

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

Bir kez kullanmak zorunda kaldım:

del serial
serial = None

çünkü sadece:

serial = None

Seri bağlantı noktasını hemen tekrar açmak için yeterince hızlı bırakmadı. Bu dersten öğrendiğimi delgerçekten anlamıştım: "ŞİMDİ GC! Ve bitene kadar bekleyin" ve bu birçok durumda gerçekten yararlıdır. Tabii ki, bir olabilir system.gc.del_this_and_wait_balbalbalba(obj).

del, birçok dilde "unset" e eşdeğerdir ve başka bir dilden python'a geçiş yapan bir çapraz referans noktasıdır .. insanlar ilk dillerinde yaptıklarıyla aynı şeyleri yapan komutları arama eğilimindedirler ... bir var "" veya hiçbiri gerçekten var kapsamı kaldırmaz .. sadece değerini boşaltır var kendisi adını hala bellekte saklanır ... neden?!? bellek yoğun bir senaryoda .. onun arkasında sadece bir hayır tutmak çöp kutusu ve her neyse ... orada her dilde bir "unset / delete" var işlevi bir form var .. neden python?

Python'daki her nesnenin bir tanımlayıcısı, Türü, onunla ilişkili referans sayısı vardır, del'i kullandığımızda referans sayısı azalır, referans sayısı sıfır olduğunda, çöp toplanması için potansiyel bir adaydır. Bu, tanımlayıcıyı Yok olarak ayarlamakla karşılaştırıldığında del'i ayırır. Daha sonra, bu sadece nesnenin vahşi kaldığı anlamına gelir (biz kapsam dışında kalana kadar sayım azaltılır) ve şimdi tanımlayıcı başka bir nesneye (bellek konumu) işaret eder.