blocks|key|1688719|text|“‘self”只是对对象的引用。“'del+self”正在从kill函数的本地命名空间中删除“self”引用，而不是从实际对象中删除。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1688720|要亲自查看这一点，请看一下执行这两个函数时会发生什么：|1688721|>>>+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|code-block|syntax|javascript|1688722|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

'self' is only a reference to the object. 'del self' is deleting the 'self' reference from the local namespace of the kill function, instead of the actual object.

To see this for yourself, look at what happens when these two functions are executed:

<pre><code>&gt;&gt;&gt; class A():
... def kill_a(self):
... print self
... del self
... def kill_b(self):
... del self
... print self
... 
&gt;&gt;&gt; a = A()
&gt;&gt;&gt; b = A()
&gt;&gt;&gt; a.kill_a()
&lt;__main__.A instance at 0xb771250c&gt;
&gt;&gt;&gt; b.kill_b()
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
 File "&lt;stdin&gt;", line 7, in kill_b
UnboundLocalError: local variable 'self' referenced before assignment
</code></pre>

blocks|key|1688736|text|首先，您不需要使用del删除实例。一旦对象的最后一个引用消失，该对象将被垃圾回收。也许你应该告诉我们更多关于整个问题的信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1688737|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You don't need to use del to delete instances in the first place. Once the last reference to an object is gone, the object will be garbage collected. Maybe you should tell us more about the full problem.

blocks|key|1688966|text|实际上，你不应该需要删除对象来完成你想要做的事情。相反，您可以更改对象的状态。一个不需要编码的例子就是你的玩家与怪物战斗并杀死怪物。这个怪物的状态是战斗。怪物将获得战斗所需的所有方法。当怪物因生命降至0而死亡时，怪物状态将变为死亡，你的角色将自动停止攻击。这种方法与使用标志甚至关键字非常相似。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1688967|显然，在python中不需要删除类，因为当它们不再使用时，它们将被自动垃圾回收。|1688968|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Realistically you should not need to delete the object to do what you are trying to do. Instead you can change the state of the object. 
An example of how this works without getting into the coding would be your player fighting a monster and killing the monster. The state of this monster is fighting. The monster will be accessing all methods needed for fighting. When the monster dies because his health drops to 0, the monsters state will change to dead and your character will stop attacking automatically. This methodology is very similar to using flags or even keywords.

Also apparently in python deleting classes is not required since they will be garbage collected automatically when they are not used anymore.

blocks|key|1473888|text|我也在尝试同样的事情。我有一个RPG战斗系统，其中我的Death(self)函数必须杀死Fighter类的自己的对象。但这似乎是不可能的。也许我收集战斗中所有参与者的班级游戏应该从“虚构”地图中删除单位？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1473889|+++def+Death(self):
++++if+self.stats["HP"]+<=+0:
++++++++print("%25s+wounds+were+too+much...+Dead!"%25(self.player["Name"]))
++++++++del+self
++++else:
++++++++return+True

def+Damage(self,+enemy):
++++todamage+=+self.stats["ATK"]+%2B+randint(1,6)
++++todamage+-=+enemy.stats["DEF"]
++++if+todamage+>=0:
++++++++enemy.stats["HP"]+-=+todamage
++++++++print("%25s+took+%25d+damage+from+your+attack!"%25(enemy.player["Name"],+todamage))
++++++++enemy.Death()
++++++++return+True
++++else:
++++++++print("Ineffective...")
++++++++return+True
def+Attack(self,+enemy):
++++tohit+=+self.stats["DEX"]+%2B+randint(1,6)
++++if+tohit+>+enemy.stats["EVA"]:
++++++++print("You+landed+a+successful+attack+on+%25s+"%25(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.%25d,+%25r"%25(i,+enemylist[i]))
++++print("It`s+your+turn,+%25s.+Take+action!"%25(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()|code-block|syntax|javascript|1473890|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I am trying the same thing. I have a RPG battle system in which my Death(self) function has to kill the own object of the Fighter class. But it appeared it`s not possible. Maybe my class Game in which I collect all participants in the combat should delete units form the "fictional" map???

<pre><code> def Death(self):
 if self.stats["HP"] &lt;= 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 &gt;=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 &gt; 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&gt;")
 if choice == 'a'or choice == 'A':
 who = int(input("Who? "))
 self.Attack(enemylist[who])
 return True
 else:
 return self.Action()
</code></pre>

blocks|key|1688783|text|事实上，Python通过引用计数进行垃圾收集。一旦对某个对象的最后一个引用超出作用域，它就会被删除。在您的示例中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1688784|a+=+A()
a.kill()|code-block|syntax|javascript|1688785|我不相信有任何方法可以让变量'a‘隐式地将自身设置为None。|1688786|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Indeed, Python does garbage collection through reference counting. As soon as the last reference to an object falls out of scope, it is deleted. In your example:

<pre><code>a = A()
a.kill()
</code></pre>

I don't believe there's any way for variable 'a' to implicitly set itself to None.

blocks|key|1474093|text|如果您使用对对象的单个引用，则对象可以通过将外部引用重置为自身来终止自身，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1474094|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()|code-block|syntax|javascript|1474095|当然，您可以通过从对象外部(而不是对象状态)检查对象的存在来进行逻辑控制，例如：|1474096|if+object_exists:
+++use_existing_obj()
else:+
+++obj+=+Obj()|1474097|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you're using a single reference to the object, then the object can kill itself by resetting that outside reference to itself, as in:

<pre><code>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()
</code></pre>

You can of course do the logic control by checking for the object existence from outside the object (rather than object state), as for instance in:

<pre><code>if object_exists:
 use_existing_obj()
else: 
 obj = Obj()
</code></pre>

blocks|key|1689340|text|这是我过去做过的事情。创建一个对象列表，然后可以使用list.remove()方法删除对象本身。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1689341|bullet_list+=+[]

class+Bullet:
++++def+kill_self(self):
++++++++bullet_list.remove(self)

bullet_list+%2B=+[Bullet()]|code-block|syntax|javascript|1689342|entityMap^0|Q|D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

This is something I have done in the past.
Create a list of objects, and you can then have objects delete themselves with the <code>list.remove()</code> method.

<pre><code>bullet_list = []

class Bullet:
 def kill_self(self):
 bullet_list.remove(self)

bullet_list += [Bullet()]
</code></pre>

blocks|key|1473834|text|我很好奇你为什么要做这样的事。很有可能，您应该让垃圾收集来完成它的工作。在python中，垃圾收集是非常确定的。因此，您不必像在其他语言中那样担心仅仅将对象留在内存中(这并不是说refcounting没有缺点)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1473835|不过，您应该考虑的一件事是对以后可能删除的任何对象或资源进行包装。|1473836|class+foo(object):
++++def+__init__(self):
++++++++self.some_big_object+=+some_resource

++++def+killBigObject(self):
++++++++del+some_big_object|code-block|syntax|javascript|1473837|为响应Null's+addendum|offset|length|1473838|不幸的是，我不相信有一种方法可以用你想做的方式去做你想做的事情。以下是您可能希望考虑的一种方式：|1473839|>>>+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
+{}|1473840|这有点乱，但这应该会给你一个想法。从本质上讲，我不认为将一个物品在游戏中的存在与它是否被分配到内存中捆绑在一起是一个好主意。这是因为该物品被垃圾收集的条件可能与游戏中该物品的条件不同。这样的话，你就不用那么担心了。|1473841|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/293431/python-object-deleting-itself#293497^0|0|0|0|3|F|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@$K|14|L|15|1|16]]|A|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

I'm curious as to why you would want to do such a thing. Chances are, you should just let garbage collection do its job. In python, garbage collection is pretty deterministic. So you don't really have to worry as much about just leaving objects laying around in memory like you would in other languages (not to say that refcounting doesn't have disadvantages).

Although one thing that you should consider is a wrapper around any objects or resources you may get rid of later.

<pre><code>class foo(object):
 def __init__(self):
 self.some_big_object = some_resource

 def killBigObject(self):
 del some_big_object
</code></pre>

In response to <a href="https://stackoverflow.com/questions/293431/python-object-deleting-itself#293497">Null's addendum</a>:

Unfortunately, I don't believe there's a way to do what you want to do the way you want to do it. Here's one way that you may wish to consider:

<pre><code>&gt;&gt;&gt; class manager(object):
... def __init__(self):
... self.lookup = {}
... def addItem(self, name, item):
... self.lookup[name] = item
... item.setLookup(self.lookup)
&gt;&gt;&gt; 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]
&gt;&gt;&gt; man = manager()
&gt;&gt;&gt; item = Item("foo")
&gt;&gt;&gt; man.addItem("foo", item)
&gt;&gt;&gt; man.lookup
 {'foo': &lt;__main__.Item object at 0x81b50&gt;}
&gt;&gt;&gt; item.deleteSelf()
&gt;&gt;&gt; man.lookup
 {}
</code></pre>

It's a little bit messy, but that should give you the idea. Essentially, I don't think that tying an item's existence in the game to whether or not it's allocated in memory is a good idea. This is because the conditions for the item to be garbage collected are probably going to be different than what the conditions are for the item in the game. This way, you don't have to worry so much about that.

blocks|key|1689165|text|你可以做的就是把这个名字带到课堂上，然后做一个字典：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1689166|class+A:
++def+__init__(self,+name):
++++self.name=name
++def+kill(self)
++++del+dict[self.name]

dict={}
dict["a"]=A("a")
dict["a"].kill()|code-block|syntax|javascript|1689167|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

what you could do is take the name with you in the class and make a dictionairy:

<pre><code>class A:
 def __init__(self, name):
 self.name=name
 def kill(self)
 del dict[self.name]

dict={}
dict["a"]=A("a")
dict["a"].kill()
</code></pre>

blocks|key|1474262|text|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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1474263|这段代码可以工作吗？|unstyled|1474264|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>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)
</code></pre>

May this code work ?

blocks|key|1689381|text|一种替代工具：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1689382|class+A:

++++def+__init__(self):
++++++++self.a+=+123

++++def+kill(self):
++++++++from+itertools+import+chain
++++++++for+attr_name+in+chain(dir(self.__class__),+dir(self)):
++++++++++++if+attr_name.startswith('__'):
++++++++++++++++continue
++++++++++++attr+=+getattr(self,+attr_name)
++++++++++++if+callable(attr):
++++++++++++++++setattr(self,+attr_name,+lambda+*args,+**kwargs:+print('NoneType'))
++++++++++++else:
++++++++++++++++setattr(self,+attr_name,+None)
++++++++a.__str__+=+lambda:+''
++++++++a.__repr__+=+lambda:+''|code-block|syntax|javascript|1689383|a+=+A()
print(a.a)
a.kill()

print(a.a)
a.kill()

a+=+A()
print(a.a)|1689384|将输出：|1689385|123
None
NoneType
123|1689386|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

A replacement implement:
<pre><code>class A:

 def __init__(self):
 self.a = 123

 def kill(self):
 from itertools import chain
 for attr_name in chain(dir(self.__class__), dir(self)):
 if attr_name.startswith('__'):
 continue
 attr = getattr(self, attr_name)
 if callable(attr):
 setattr(self, attr_name, lambda *args, **kwargs: print('NoneType'))
 else:
 setattr(self, attr_name, None)
 a.__str__ = lambda: ''
 a.__repr__ = lambda: ''
</code></pre>
<pre><code>a = A()
print(a.a)
a.kill()

print(a.a)
a.kill()

a = A()
print(a.a)
</code></pre>
will outputs:
<pre><code>123
None
NoneType
123
</code></pre>

Why won't this work? I'm trying to make an instance of a class delete itself.

<pre><code>&gt;&gt;&gt; class A():
 def kill(self):
 del self


&gt;&gt;&gt; a = A()
&gt;&gt;&gt; a.kill()
&gt;&gt;&gt; a
&lt;__main__.A instance at 0x01F23170&gt;
</code></pre>

Python object deleting itself

Python

为什么这个不起作用？我正在尝试创建一个类的实例delete本身。>>> class A(): def kill(self): del self>>> a = A()>>> a.kill()>>> a<__main__.A instance at 0x01F23170>

问Python对象删除自身
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python对象删除自身EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python对象删除自身
EN