Returning a Fibonacci list

Question

def fib_m_through_n(m, n):
    """(number, number) -> list

    A function which returns a list containing the mth through the nth
    fibonacci numbers.

    SHOULD BE MODIFIED IN THE FUTURE so it will remember values already computed,
    so when it is called again it reuses that information
    """
    fib_list = [0, 1, 1]
    a, b, c = 1, 1, 0  #why can I do three variable assignments here...
    count = 0
    while count <= n:
        c = a + b; a = b; b = c #...but not here?
        fib_list.append(c)
        count += 1
    print(fib_list[m : n])

fib_m_through_n(0, 17)

I have a few questions about this:

The first is general: are there any clear pythonic violations here, any obvious improvements to style?

The second is included in some of the comments. Why can I get away with assigning three variables in one line here: a, b, c = 1, 1, 0

but not here: c = a + b; a = b; b = c

If I try to do this: c, a, b = a + b, b, c

Then I get an incorrect output.

After analyzing the mistake and trying to imagine how things look from the function's POV, it still seems to me like doing three variable assignments in a row should work, assuming that when the function runs it just reads this line from left to right.

Finally, as noted in the section just after the docstring, I want to turn this into a generator. I have read about generators and understand them a bit, but I don't know how to implement one here.

Answer 1

Of course not.

If you do c, a, b = a + b, b, c, this is what you get

a, b, c = a0, b0, c0
c, a, b = a + b, b, c 
## c become a0 + b0
## a becomes b0
## b becomes c0

I'm pretty sure this is not your intention.

In tuple assignment, the right tuple is evaluated first and then assigned to the left tuple. I'm guessing you thought it's done in order. Sorry, but no.

You can instead eliminate the variable c and do this

a, b = a0, b0
a, b = b, a + b
## a becomes b0
## b becomes a0 + b0

UPDATE

This is what is done by the machine, imagine the left values as an array of variables waiting to be assigned values that are on the left. Like this

[c, a, b] = [a + b, b, c] 

Imagine the right values as an array of expression waiting to be evaluated. The right one gets evaluated first, then one by one the left variables takes the right values. No assignment is done until the left expressions are evaluated.

Answer 2

Rather than looping with while and a count variable, it is more pythonic to write for _ in range(n + 1). Also worth commenting that you are storing the same values in two places - in fib_list and in a, b, c.

fibonacci = [0, 1]
for _ in range(n + 1):
    fibonacci.append(fibonacci[-2] + fibonacci[-1])
print (fibonacci[m:n])

To convert this into a generator is fairly straightforward:

def fibonacci(m, n):
   a, b = 0, 1
   for _ in xrange(m):
       a, b = b, a + b
   for _ in xrange(n - m):
       yield a
       a, b = b, a + b
print (list(fibonacci(0, 17)))

If, as you say in your docstring, you want to hold values that have already been calculated, then making a generator does not particularly help you; instead you need to make a class in which you can store the values. In this case it will be handy to overload the slice operators so you can treat Fibonacci objects as if they were lists.

class Fibonacci:
    def __init__(self):
        self.sequence = [0, 1]
    def __getitem__(self, key):
        if isinstance(key, int):
            stop = key + 1
        elif isinstance(key, slice):
            stop = key.stop
        while len(self.sequence) < stop:
            self.sequence.append(self.sequence[-2] + self.sequence[-1])
        return self.sequence[key]
f = Fibonacci()
print f[7:17]