Question

我从博客中提到了这个例子，但我不明白。

>>> class Udict:
    def __init__(self, dict=None):
        self.data = {}
        if dict is not None: self.update(dict)
    def update(self, dict=None):
        self.data.update(dict)
        print(self.data)

>>> d = {1:'one', 2:'two'}
>>> g = Udict(d)
{1: 'two', 2: 'two'}
>>> g.data
{1: 'two', 2: 'two'}
>>> c.Udict()
{}
>>> c.update({3: 'three'})
{3: 'three'}
>>>

我希望对obj.update（）函数进行递归调用，直到'RuntimeError：超出最大递归深度'

但不，update（）函数到达print(self.data)

self.data.update(dict)正在调用自己的方法update（），为什么它不像我期望的那样工作？

任何人都可以向我解释为什么调用函数本身不会进入无限循环？带有示例的博客没有解释它。

Answer 1

根本不是递归地调用自己。

它不会在更新中调用self.update：它会调用数据字典的更新方法，这完全不同。

Answer 2

当它调用self.data.update时，它不会输入相同的功能。它正在调用update的{{1}}函数，它只是一个字典。如果它调用类似self.data之类的东西，则会发生递归，也许这就是你在想什么。

Answer 3

这不会调用Udict.update，而是dict.update（不是递归）：

self.data.update(dict)

也许你误解了self.update(dict)。

顺便说一句，不要使用dict作为变量名。它影响内置函数dict。

Answer 4

self.data！= self.update

此处 self.data 是实例变量，它是字典对象。 Dictionary对象具有更新方法。因此，当您调用self.data.update（）时，它会调用字典中的方法：

>>> help(dict.update)
Help on method_descriptor:

update(...)
   D.update(E, **F) -> None.  Update D from dict/iterable E and F.
   If E has a .keys() method, does:     for k in E: D[k] = E[k]
   If E lacks .keys() method, does:     for (k, v) in E: D[k] = v
   In either case, this is followed by: for k in F: D[k] = F[k]
>>>

self.update是类Udict的实例方法：

所以让我们重新编写一下你的代码：

>>> class Udict:
...     def __init__(self):
...         self.data = dict()
...     def update(self, dic=None):
...         if dic:
...             self.data.update(dic)
...         return self.data
...
>>> d = {1:'one', 2:'two'}
>>> g = Udict()
>>> g.update(d)
{1: 'one', 2: 'two'}

为了更好的练习，请不要通过 init （）调用任何方法，请仅使用 init （）初始化属性，因此在您的情况下，您甚至可以从论证中初始化的词汇如下：

>>> class Udict:
...     def __init__(self, dic=None):
...         self.data = dict()
...         if dic:
                self.data.update(dic)

如果有帮助，请告诉我。

为什么调用自身的成员方法（递归）不会进入无限循环？

4 个答案: