目的迴歸自我的蟒蛇

Question

我有一個問題「迴歸self'.`

class Fib: 
def __init__(self, max): 
    self.max = max 
def __iter__(self): 
    self.a = 0 
    self.b = 1 
    return self 
def __next__(self): 
    fib = self.a 
    if fib > self.max: 
     raise StopIteration 
    self.a, self.b = self.b, self.a + self.b 
    return fib 

我已經看到了這一問題return self problem，但我不明白什麼是利益」迴歸自我「

請我需要一個簡單的答案，因爲我會說一點英語

Answer 1

從返回self方法僅僅意味着你的方法返回一個對它被調用的實例對象的引用。有時候可以看到這種方法在面向對象的API中使用，這些API設計爲fluent interface，鼓勵method cascading。因此，例如，

>>> class Counter(object): 
...  def __init__(self, start=1): 
...   self.val = start 
...  def increment(self): 
...   self.val += 1 
...   return self 
...  def decrement(self): 
...   self.val -= 1 
...   return self 
... 
>>> c = Counter() 

現在我們可以使用方法級聯：

>>> c.increment().increment().decrement() 
<__main__.Counter object at 0x1020c1390> 

通知，decrement()上一次調用返回<__main__.Counter object at 0x1020c1390>，這是self。 現在：

>>> c.val 
2 
>>> 

注意，你不能做到這一點，如果你沒有返回self：

>>> class Counter(object): 
...  def __init__(self, start=1): 
...   self.val = start 
...  def increment(self): 
...   self.val += 1 
...   # implicitely return `None` 
...  def decrement(self): 
...   self.val -= 1 
...   # implicitely return `None` 
... 
>>> c = Counter() 
>>> c.increment().increment() 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
AttributeError: 'NoneType' object has no attribute 'increment' 
>>> c 
<__main__.Counter object at 0x1020c15f8> 
>>> c.val 
2 
>>> 

注意，不是每個人都的「方法級聯」設計的散熱風扇。 Python的內置插件不傾向於例如做到這一點，所以，list：

>>> x = list() 
>>> x.append(1).append(2) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
AttributeError: 'NoneType' object has no attribute 'append' 
>>> 

的一個地方，你做經常看到這是當你的類實現了iterator協議，在一個迭代器，其中iter通過返回self約定，雖然這是由the docs建議：

在看到迭代器協議背後的機制，很容易 添加迭代器行爲的類。定義一個__iter__()方法 ，該方法返回帶有__next__()方法的對象。如果類 定義__next__()，然後__iter__()可以只返回self：

class Reverse: 
    """Iterator for looping over a sequence backwards.""" 
    def __init__(self, data): 
     self.data = data 
     self.index = len(data) 

    def __iter__(self): 
     return self 

    def __next__(self): 
     if self.index == 0: 
      raise StopIteration 
     self.index = self.index - 1 
     return self.data[self.index] 

通知，這實際上使你的迭代器只對單次有用：

>>> x = [1, 2, 3, 4] 
>>> it = iter(x) 
>>> list(it) 
[1, 2, 3, 4] 
>>> list(it) 
[] 
>>> next(it) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
StopIteration 
>>> 

Answer 2

這是不必要的複雜代碼。很少關注它。地球上沒有理由以這種方式實施它。

話雖這麼說，他們做的是這樣的：

class Fib: 

    """Implements the Fibonacci sequence.""" 

    def __init__(self, max_): 
     self.max = max_ 

    def __iter__(self): 
     """Initializes and returns itself as an iterable.""" 

     self.a = 0 
     self.b = 1 
     return self 

    def __next__(self): 
     """What gets run on each execution of that iterable.""" 

     fib = self.a 
     if fib > self.max: 
      raise StopIteration 
     self.a, self.b = self.b, self.a + self.b # increment 
     return fib 

這一切更容易爲快遞：

def fib(max_): 
    a, b = 0, 1 
    while b <= max_: 
     out = a 
     a, b = b, a+b 
     yield out 

例子：

>>> fib_obj = Fib(20) 
>>> for n in fib_obj: 
...  print(n) 

>>> for n in Fib(20): 
...  print(n) 

>>> for n in fib(20): 
...  print(n) 
# all give.... 
0 
1 
1 
2 
3 
5 
8 
13