为什么这不起作用？我正试图让一个类的实例删除自己。
>>> class A():
def kill(self):
del self
>>> a = A()
>>> a.kill()
>>> a
<__main__.A instance at 0x01F23170>
'self'只是对象的引用。 'del self'正在从kill函数的本地命名空间中删除'self'引用，而不是实际的对象。
要自己查看，请查看执行这两个函数时会发生什么：
>>> class A():
... def kill_a(self):
... print self
... del self
... def kill_b(self):
... del self
... print self
...
>>> a = A()
>>> b = A()
>>> a.kill_a()
<__main__.A instance at 0xb771250c>
>>> b.kill_b()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 7, in kill_b
UnboundLocalError: local variable 'self' referenced before assignment
我很好奇你为什么要做这样的事情。有可能，你应该让垃圾收集完成它的工作。在python中，垃圾收集非常具有确定性。所以你不必担心像在其他语言中那样只留下存储在内存中的对象（并不是说引用计数没有缺点）。
虽然你应该考虑的一件事是围绕任何对象或资源的包装，你可能会在以后摆脱它。
class foo(object):
def __init__(self):
self.some_big_object = some_resource
def killBigObject(self):
del some_big_object
不幸的是，我不相信有办法以你想要的方式做你想做的事。这是您可能希望考虑的一种方式：
>>> class manager(object):
... def __init__(self):
... self.lookup = {}
... def addItem(self, name, item):
... self.lookup[name] = item
... item.setLookup(self.lookup)
>>> class Item(object):
... def __init__(self, name):
... self.name = name
... def setLookup(self, lookup):
... self.lookup = lookup
... def deleteSelf(self):
... del self.lookup[self.name]
>>> man = manager()
>>> item = Item("foo")
>>> man.addItem("foo", item)
>>> man.lookup
{'foo': <__main__.Item object at 0x81b50>}
>>> item.deleteSelf()
>>> man.lookup
{}
它有点乱，但这应该给你的想法。从本质上讲，我不认为将一个项目在游戏中的存在与它在内存中的分配是一个好主意。这是因为物品被垃圾收集的条件可能与游戏中物品的条件不同。这样，你就不用太担心了。
你能做的就是在课堂上随身携带这个名字并制作一个词典：
class A:
def __init__(self, name):
self.name=name
def kill(self)
del dict[self.name]
dict={}
dict["a"]=A("a")
dict["a"].kill()
class A:
def __init__(self, function):
self.function = function
def kill(self):
self.function(self)
def delete(object): #We are no longer in A object
del object
a = A(delete)
print(a)
a.kill()
print(a)
愿这段代码有效吗？
这是我过去做过的事情。创建一个对象列表，然后可以使用list.remove()方法删除对象。
bullet_list = []
class Bullet:
def kill_self(self):
bullet_list.remove(self)
bullet_list += [Bullet()]
您不需要首先使用del来删除实例。一旦对象的最后一次引用消失，该对象将被垃圾收集。也许你应该告诉我们更多有关完整问题的信息。
在这个特定的上下文中，您的示例没有多大意义。
当一个人拿起物品时，该物品保留个人存在。它并没有消失，因为它被拾起了。它仍然存在，但它（a）与存在位于同一位置，并且（b）不再有资格被接收。虽然它有状态变化，但它仍然存在。
存在和物品之间存在双向关联。存在集合中的物品。该物品与存在相关联。
当物品被存在拾取时，必须发生两件事。
set项目中添加项目。例如，你的bag属性可能是这样的set。 [一个list是一个糟糕的选择 - 袋子里的物品有什么用？]在任何情况下都不需要删除任何Python对象。如果一件物品被“摧毁”，那么它就不在一个存在的包里。它不在某个地方。
player.bag.remove(cat)
是不是需要让猫从袋子里出来。由于cat不会在其他任何地方使用，因此它将作为“已使用”的内存存在而不存在，因为程序中的任何内容都无法访问它。当一些量子事件发生并且内存引用被垃圾收集时，它将从内存中悄然消失。
另一方面，
here.add( cat )
player.bag.remove(cat)
将猫放在当前位置。猫继续存在，不会被垃圾熄灭。
我想我终于明白了！ 注意：您不应该在普通代码中使用它，但它是可能的。这仅仅是一种好奇心，请参阅此问题的实际解决方案的其他答案。
# NOTE: This is Python 3 code, it should work with python 2, but I haven't tested it.
import weakref
class InsaneClass(object):
_alive = []
def __new__(cls):
self = super().__new__(cls)
InsaneClass._alive.append(self)
return weakref.proxy(self)
def commit_suicide(self):
self._alive.remove(self)
instance = InsaneClass()
instance.commit_suicide()
print(instance)
# Raises Error: ReferenceError: weakly-referenced object no longer exists
在__new__方法中创建对象时，实例将替换为弱引用代理，并且唯一的强引用将保留在_alive类属性中。
弱引用是一个引用，当垃圾收集器收集对象时，它不计入引用。考虑这个例子：
>>> class Test(): pass
>>> a = Test()
>>> b = Test()
>>> c = a
>>> d = weakref.proxy(b)
>>> d
<weakproxy at 0x10671ae58 to Test at 0x10670f4e0>
# The weak reference points to the Test() object
>>> del a
>>> c
<__main__.Test object at 0x10670f390> # c still exists
>>> del b
>>> d
<weakproxy at 0x10671ab38 to NoneType at 0x1002050d0>
# d is now only a weak-reference to None. The Test() instance was garbage-collected
因此，对实例的唯一强引用存储在_alive类属性中。当commit_suicide（）方法删除引用时，实例被垃圾收集。
实际上，您不应该删除该对象来执行您要执行的操作。相反，您可以更改对象的状态。一个如何在不进入编码的情况下工作的例子就是你的玩家与怪物战斗并杀死怪物。这个怪物的状态是战斗。怪物将访问战斗所需的所有方法。当怪物因为生命值降至0而死亡时，怪物状态将变为死亡，你的角色将自动停止攻击。此方法与使用标志甚至关键字非常相似。
显然在python中删除类不是必需的，因为它们将在不再使用时自动被垃圾收集。
我无法告诉你如何使用类来实现这一点，但函数可以自行删除。
def kill_self(exit_msg = 'killed'):
global kill_self
del kill_self
return exit_msg
并看到输出：
>>> kill_self
<function kill_self at 0x02A2C780>
>>> kill_self()
'killed'
>>> kill_self
Traceback (most recent call last):
File "<pyshell#28>", line 1, in <module>
kill_self
NameError: name 'kill_self' is not defined
我不认为删除类的单个实例而不知道它的名称是可能的。
注意：如果为该函数指定另一个名称，另一个名称仍将引用旧名称，但一旦您尝试运行它将导致错误：
>>> x = kill_self
>>> kill_self()
>>> kill_self
NameError: name 'kill_self' is not defined
>>> x
<function kill_self at 0x...>
>>> x()
NameError: global name 'kill_self' is not defined
我正在尝试同样的事情。我有一个RPG战斗系统，其中我的死亡（自我）功能必须杀死战斗机类的自己的对象。但它似乎不可能。也许我收集战斗中所有参与者的班级游戏应该从“虚构”地图中删除单位？
def Death(self):
if self.stats["HP"] <= 0:
print("%s wounds were too much... Dead!"%(self.player["Name"]))
del self
else:
return True
def Damage(self, enemy):
todamage = self.stats["ATK"] + randint(1,6)
todamage -= enemy.stats["DEF"]
if todamage >=0:
enemy.stats["HP"] -= todamage
print("%s took %d damage from your attack!"%(enemy.player["Name"], todamage))
enemy.Death()
return True
else:
print("Ineffective...")
return True
def Attack(self, enemy):
tohit = self.stats["DEX"] + randint(1,6)
if tohit > enemy.stats["EVA"]:
print("You landed a successful attack on %s "%(enemy.player["Name"]))
self.Damage(enemy)
return True
else:
print("Miss!")
return True
def Action(self, enemylist):
for i in range(0, len(enemylist)):
print("No.%d, %r"%(i, enemylist[i]))
print("It`s your turn, %s. Take action!"%(self.player["Name"]))
choice = input("\n(A)ttack\n(D)efend\n(S)kill\n(I)tem\n(H)elp\n>")
if choice == 'a'or choice == 'A':
who = int(input("Who? "))
self.Attack(enemylist[who])
return True
else:
return self.Action()
实际上，Python通过引用计数进行垃圾收集。一旦对象的最后一次引用超出范围，它就会被删除。在你的例子中：
a = A()
a.kill()
我不相信变量'a'有任何方法可以隐式地将自己设置为None。
如果您使用对该对象的单个引用，则该对象可以通过重置对其自身的外部引用来自行终止，如：
class Zero:
pOne = None
class One:
pTwo = None
def process(self):
self.pTwo = Two()
self.pTwo.dothing()
self.pTwo.kill()
# now this fails:
self.pTwo.dothing()
class Two:
def dothing(self):
print "two says: doing something"
def kill(self):
Zero.pOne.pTwo = None
def main():
Zero.pOne = One() # just a global
Zero.pOne.process()
if __name__=="__main__":
main()
您当然可以通过从对象外部（而不是对象状态）检查对象是否存在来执行逻辑控制，例如：
if object_exists:
use_existing_obj()
else:
obj = Obj()