ฉันไม่สามารถคิดด้วยเหตุผลใด ๆ ว่าทำไมไพ ธ อนต้องการ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

การลบตัวแปรแตกต่างจากการตั้งค่าเป็นไม่มี

การลบชื่อตัวแปรด้วยdelอาจเป็นสิ่งที่ไม่ค่อยได้ใช้ แต่เป็นสิ่งที่ไม่สามารถทำได้โดยไม่ต้องใช้คำสำคัญ หากคุณสามารถสร้างชื่อตัวแปรได้โดยการเขียนa=1มันเป็นเรื่องดีที่คุณสามารถเลิกทำสิ่งนี้ได้ในทางทฤษฎีโดยการลบ

มันสามารถทำให้การดีบักง่ายขึ้นในบางกรณีเนื่องจากการพยายามเข้าถึงตัวแปรที่ถูกลบจะเพิ่ม 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()ในการตรวจสอบข้อยกเว้น ฟังก์ชันนี้ส่งคืน tuple ชนิดของข้อยกเว้นที่เพิ่มขึ้นข้อความและการติดตามกลับ

โดยปกติค่าสองค่าแรกจะเพียงพอในการวิเคราะห์ข้อผิดพลาดและดำเนินการกับค่านั้น แต่ค่าที่สามจะมี call stack ทั้งหมดระหว่างที่มีการยกข้อยกเว้นและที่ที่มีการยกเว้น โดยเฉพาะถ้าคุณทำอะไรที่ชอบ

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

traceback tbสิ้นสุดลงในท้องถิ่นของ call stack สร้างการอ้างอิงแบบวงกลมที่ไม่สามารถรวบรวมขยะได้ ดังนั้นจึงเป็นสิ่งสำคัญที่จะทำ:

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

เพื่อทำลายการอ้างอิงแบบวงกลม ในหลาย ๆ กรณีที่คุณต้องการโทรsys.exc_info()เช่นเดียวกับ metaclass magic การสืบค้นกลับมีประโยชน์ดังนั้นคุณต้องตรวจสอบให้แน่ใจก่อนว่าคุณล้างมันก่อนที่จะออกจากตัวจัดการข้อยกเว้น หากคุณไม่ต้องการการสืบค้นกลับคุณควรลบทันทีหรือเพียงแค่ทำสิ่งต่อไปนี้

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

เพื่อหลีกเลี่ยงมันทั้งหมดเข้าด้วยกัน

อีกความคิดหนึ่ง

เมื่อทำการดีบั๊กแอพพลิเคชั่น http ในกรอบงานเช่น Django การเรียกสแต็คที่เต็มไปด้วยตัวแปรที่ไร้ประโยชน์และทำให้ยุ่งเหยิงก่อนหน้านี้ที่ใช้โดยเฉพาะอย่างยิ่งเมื่อมันเป็นรายการที่ยาวมาก ดังนั้น ณ จุดนี้การควบคุมเนมสเปซอาจมีประโยชน์

การใช้ "del" อย่างชัดเจนก็ดีกว่าการกำหนดตัวแปรให้กับ None หากคุณพยายามที่จะลบตัวแปรที่ไม่มีอยู่คุณจะได้รับข้อผิดพลาดรันไทม์ แต่ถ้าคุณพยายามตั้งค่าตัวแปรที่ไม่มีอยู่ Python จะตั้งค่าตัวแปรใหม่ให้ไม่มี None โดยไม่แจ้งให้ทราบ ต้องการลบในที่ที่มันอยู่ ดังนั้นเดลจะช่วยคุณจับข้อผิดพลาดก่อนหน้านี้

วิธีเพิ่มคะแนนสองสามข้อให้กับคำตอบด้านบน: del x

ความหมายของการxบ่งชี้r -> o(อ้างอิงrที่ชี้ไปยังวัตถุo) แต่del xการเปลี่ยนแปลงมากกว่าr oมันเป็นงานในการอ้างอิง (ชี้) xที่จะคัดค้านมากกว่าวัตถุที่เกี่ยวข้องกับ แยกความแตกต่างระหว่างrและoเป็นกุญแจสำคัญที่นี่

• 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สามารถใช้สำหรับฉันพบว่ามีประโยชน์ฉันสถานการณ์เช่นนี้:

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" โดยการตั้งค่าเป็นไม่มี (หรือในกรณีนี้ก็ปล่อยไว้)

คุณสามารถทำสิ่งเดียวกันกับสิ่งที่ชอบ:

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

    return f(**kwargs)

อย่างไรก็ตามฉันพบตัวอย่างก่อนหน้านี้แห้งมากขึ้นและสง่างาม

เมื่อใดที่ del มีประโยชน์ใน 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 จะต้องกลายเป็น globals (). ลบ ('foo') หรือคนในท้องถิ่น (). ลบ ('foo') ซึ่งทำให้ยุ่งเหยิง และอ่านได้น้อยลง ถึงกระนั้นฉันก็บอกว่าการกำจัดเดลจะดีเพราะมันใช้ยาก แต่การลบคุณสมบัติภาษา / ข้อบกพร่องอาจเจ็บปวดได้ บางทีหลาม 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" อาจมีประโยชน์ในการลบวัตถุหลามที่อ้างถึงวัตถุ C ++ ที่ไม่มีอยู่แล้ว สิ่งนี้ยอมให้การค้นหา pyroot แบบไดนามิกค้นหาวัตถุ C ++ ที่มีชื่อเหมือนกันและผูกเข้ากับชื่อไพ ธ อน ดังนั้นคุณสามารถมีสถานการณ์เช่น:

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มีความหมายจริง ๆ : "GC นี่เดี๋ยวนี้! และรอจนกว่ามันจะเสร็จสิ้น" และนั่นมีประโยชน์จริง ๆ ในหลาย ๆ สถานการณ์ system.gc.del_this_and_wait_balbalbalba(obj)แน่นอนคุณอาจจะมี

เดลเทียบเท่ากับ "unset" ในหลายภาษาและเป็นจุดอ้างอิงไขว้ย้ายจากภาษาอื่นเป็นไพ ธ อน .. ผู้คนมักจะมองหาคำสั่งที่ทำสิ่งเดียวกันกับที่พวกเขาเคยทำในภาษาแรก ... var ถึง "" หรือไม่มีใครไม่ลบ var ออกจากขอบเขตจริงๆ .. แต่เพียงล้างค่าของชื่อ var ตัวเองจะยังคงถูกเก็บไว้ในหน่วยความจำ ... ทำไม?!? ในสคริปต์ที่ใช้หน่วยความจำมาก .. ทิ้งขยะไว้ข้างหลังมันไม่มีอะไรเลย ... ทุกภาษามีฟังก์ชั่น var "unset / delete" รูปแบบบางอย่าง .. ทำไมไม่ใช้หลาม?

ทุกออบเจ็กต์ในไพ ธ อนมีตัวระบุ, ประเภท, จำนวนการอ้างอิงที่สัมพันธ์กันเมื่อเราใช้ del จำนวนการอ้างอิงจะลดลงเมื่อจำนวนการอ้างอิงกลายเป็นศูนย์มันเป็นตัวเลือกที่เป็นไปได้สำหรับการรวบรวมขยะ สิ่งนี้จะแตกต่างเดลเมื่อเปรียบเทียบกับการตั้งค่าตัวระบุเป็นไม่มี ในกรณีต่อมามันก็หมายความว่าวัตถุเพิ่งจะออกจากป่า (จนกว่าเราจะออกนอกขอบเขตในกรณีที่การนับจะลดลง) และเพียงตอนนี้ตัวบ่งชี้ชี้ไปที่วัตถุอื่น ๆ (ตำแหน่งหน่วยความจำ)