Я спочатку неправильно кодував програму. Замість того, щоб повертати числа Фібоначчі між діапазоном (наприклад, startNumber 1, endNumber 20 повинен = лише ті числа між 1 і 20), я написав для програми, щоб відобразити всі числа Фібоначчі між діапазоном (наприклад, startNumber 1, endNumber 20 покази = Перші 20 чисел Фібоначчі). Я думав, що у мене є надійний код. Я також не бачу, чому це відбувається.

startNumber = int(raw_input("Enter the start number here "))
endNumber = int(raw_input("Enter the end number here "))

def fib(n):
    if n < 2:
        return n
    return fib(n-2) + fib(n-1)

print map(fib, range(startNumber, endNumber))

Хтось зазначив у моїй частині II (яка була закрита через те, що вона була дублікатом - /programming/504193/how-to-write-the-fibach-sequence-in-python-part-ii ), що я необхідно передати startNumber і endNumber через генератор, використовуючи цикл while. Чи може хтось, будь ласка, вказати мені в напрямку, як це зробити? Будь-яка допомога вітається.

Я програміст, що навчається, і я трохи зіткнувся. Мене просять написати програму, яка буде обчислювати та відображати послідовність Фібоначчі за введеним користувачем початковим номером та кінцевим номером (тобто. StartNumber = 20 endNumber = 100, і вона відображатиме лише числа між цим діапазоном). Трюк полягає в тому, щоб використовувати його інклюзивно (що я не знаю, як зробити в Python? - Я припускаю, що це означає використовувати інклюзивний діапазон?).

У мене поки що немає фактичного кодування, а скоріше:

• Напишіть формулу послідовності Fib до нескінченності
• Відобразити startNumber до endNumber лише з послідовності Fib.

Я поняття не маю, з чого почати, і я прошу ідеї чи розуміння, як це написати. Я також намагався написати форум форумів послідовностей Fib, але я також втрачаю на цьому.

Є багато відомостей про послідовність Фібоначчі у вікіпедії та вольфрамі . Набагато більше, ніж вам може знадобитися. У будь-якому випадку, це добре навчитися використовувати ці ресурси, щоб знайти (швидко, якщо можливо) те, що вам потрібно.

Напишіть формулу послідовності Fib до нескінченності

У математиці він подається в рекурсивній формі:

У програмуванні нескінченності не існує. Ви можете використовувати рекурсивну форму, що переводить математичну форму безпосередньо на вашу мову, наприклад, в Python це стає:

def F(n):
    if n == 0: return 0
    elif n == 1: return 1
    else: return F(n-1)+F(n-2)

Спробуйте це на своїй улюбленій мові і переконаєтесь, що ця форма вимагає багато часу, оскільки п росте більше. Насправді, це O (2 ⁿ ) у часі.

Заходьте на сайти, з якими я пов’язаний з вами, і побачите це (на wolfram ):

Цей досить простий у здійсненні і дуже, дуже швидкий для обчислення, на Python:

from math import sqrt
def F(n):
    return ((1+sqrt(5))**n-(1-sqrt(5))**n)/(2**n*sqrt(5))

Інший спосіб зробити це - слідуючи визначенню (з wikipedia ):

Перше число послідовності дорівнює 0, друге число дорівнює 1, і кожне наступне число дорівнює сумі попередніх двох чисел самої послідовності, виводячи послідовність 0, 1, 1, 2, 3, 5, 8 тощо.

Якщо ваша мова підтримує ітератори, ви можете зробити щось на кшталт:

def F():
    a,b = 0,1
    while True:
        yield a
        a, b = b, a + b

Відобразити startNumber до endNumber лише з послідовності Fib.

Як тільки ви дізнаєтеся, як генерувати числа Фібоначчі, вам просто доведеться пройти чисел і перевірити, чи вони перевіряють задані умови.

Припустимо, тепер ви написали af (n), який повертає n-й додаток послідовності Фібоначчі (як той, що має sqrt (5))

У більшості мов ви можете зробити щось на кшталт:

def SubFib(startNumber, endNumber):
    n = 0
    cur = f(n)
    while cur <= endNumber:
        if startNumber <= cur:
            print cur
        n += 1
        cur = f(n)

У python я б використовував форму ітератора та йшов:

def SubFib(startNumber, endNumber):
    for cur in F():
        if cur > endNumber: return
        if cur >= startNumber:
            yield cur

for i in SubFib(10, 200):
    print i

Мій натяк - навчитися читати те, що потрібно. Проект Euler (Google для нього) навчить вас це робити: P Удачі та веселощів!

Ефективний пітонічний генератор послідовності Фібоначчі

Я знайшов це питання під час спроби отримати найкоротшу пітонічну генерацію цієї послідовності (пізніше зрозумівши, що я бачив подібне у пропозиції щодо розширення Python ), і я не помітив, щоб хто-небудь інший придумував моє конкретне рішення (хоча верхня відповідь наближається, але все ж менш елегантно), тож ось це, з коментарями, що описують першу ітерацію, тому що я думаю, що це може допомогти читачам зрозуміти:

def fib():
    a, b = 0, 1
    while True:            # First iteration:
        yield a            # yield 0 to start with and then
        a, b = b, a + b    # a will now be 1, and b will also be 1, (0 + 1)

та використання:

for index, fibonacci_number in zip(range(10), fib()):
     print('{i:3}: {f:3}'.format(i=index, f=fibonacci_number))

відбитки:

  0:   0
  1:   1
  2:   1
  3:   2
  4:   3
  5:   5
  6:   8
  7:  13
  8:  21
  9:  34
 10:  55

(Для цілей атрибуції я нещодавно помітив подібну реалізацію в документації Python на модулях, навіть використовуючи змінні aі b, яку я зараз пам’ятаю, бачив перед тим, як писати цю відповідь. Але я думаю, що ця відповідь демонструє краще використання мови.)

Рекурсивно визначена реалізація

Інтернет Енциклопедія цілочислових послідовностей визначає послідовність Фібоначчі рекурсивно

F (n) = F (n-1) + F (n-2) при F (0) = 0 і F (1) = 1

Точно визначити це рекурсивно в Python можна так:

def rec_fib(n):
    '''inefficient recursive function as defined, returns Fibonacci number'''
    if n > 1:
        return rec_fib(n-1) + rec_fib(n-2)
    return n

Але таке точне подання математичного визначення є неймовірно неефективним для чисел, значно більших за 30, оскільки кожне число, що обчислюється, також повинно обчислювати кожне число, що знаходиться під ним. Ви можете продемонструвати, наскільки це повільно, скориставшись наступним:

for i in range(40):
    print(i, rec_fib(i))

Запам'ятована рекурсія для ефективності

Його можна запам'ятати, щоб підвищити швидкість (цей приклад використовує той факт, що аргумент ключового слова за замовчуванням - це той самий об'єкт щоразу, коли функція викликається, але зазвичай ви не використовуєте змінний аргумент за замовчуванням саме з цієї причини):

def mem_fib(n, _cache={}):
    '''efficiently memoized recursive function, returns a Fibonacci number'''
    if n in _cache:
        return _cache[n]
    elif n > 1:
        return _cache.setdefault(n, mem_fib(n-1) + mem_fib(n-2))
    return n

Ви дізнаєтеся, що запам'ятована версія набагато швидша, і швидко перевищить вашу максимальну глибину рекурсії, перш ніж ви навіть можете думати встати на каву. Ви можете бачити, наскільки швидше це візуально, виконуючи це:

for i in range(40):
    print(i, mem_fib(i))

(Може здатися, що ми можемо просто виконати наведене нижче, але насправді це не дозволяє нам скористатися кешем, оскільки він викликає себе перед тим, як викликати setdefault.)

def mem_fib(n, _cache={}):
    '''don't do this'''
    if n > 1:  
        return _cache.setdefault(n, mem_fib(n-1) + mem_fib(n-2))
    return n

Рекурсивно визначений генератор:

Коли я вивчав Haskell, я натрапив на цю реалізацію в Haskell:

fib@(0:tfib) = 0:1: zipWith (+) fib tfib

Найближчим, на який я думаю, що я можу дійти до цього на Python, є:

from itertools import tee

def fib():
    yield 0
    yield 1
    # tee required, else with two fib()'s algorithm becomes quadratic
    f, tf = tee(fib()) 
    next(tf)
    for a, b in zip(f, tf):
        yield a + b

Це демонструє це:

[f for _, f in zip(range(999), fib())]

Однак він може піднятися лише до межі рекурсії. Зазвичай 1000, тоді як версія Haskell може досягати 100 мільйонів, хоча для цього використовується 8 Гб пам'яті мого ноутбука:

> length $ take 100000000 fib 
100000000

Споживаючи ітератор, щоб отримати номер n-го значення

Коментолог запитує:

Питання для функції Fib (), заснованої на ітераторі: що робити, якщо ви хочете отримати n-й, наприклад, 10-й номер фіб?

Документація itertools має такий рецепт:

from itertools import islice

def nth(iterable, n, default=None):
    "Returns the nth item or a default value"
    return next(islice(iterable, n, None), default)

а зараз:

>>> nth(fib(), 10)
55

Чому б просто не зробити наступне?

x = [1,1]
for i in range(2, 10):  
    x.append(x[-1] + x[-2]) 
print(', '.join(str(y) for y in x))

Ідея послідовності Фібоначчі показана в наступному коді Python:

def fib(n):
   if n == 1:
      return 1
   elif n == 0:   
      return 0            
   else:                      
      return fib(n-1) + fib(n-2)         

Це означає, що fib - це функція, яка може виконувати одну з трьох речей. Він визначає fib (1) == 1, fib (0) == 0, а fib (n) буде:

fib (n-1) + fib (n-2)

Де n - довільне ціле число. Це означає, що fib (2), наприклад, розширюється до наступної арифметики:

fib(2) = fib(1) + fib(0)
fib(1) = 1
fib(0) = 0
# Therefore by substitution:
fib(2) = 1 + 0
fib(2) = 1

Ми можемо обчислити fib (3) аналогічно арифметиці, показаній нижче:

fib(3) = fib(2) + fib(1)
fib(2) = fib(1) + fib(0)
fib(2) = 1
fib(1) = 1
fib(0) = 0
# Therefore by substitution:
fib(3) = 1 + 1 + 0

Тут важливо усвідомити, що fib (3) не можна обчислити без обчислення fib (2), що обчислюється знанням визначень fib (1) та fib (0). Сам виклик функції, як функція напруженості, називається рекурсією, і це важлива тема програмування.

Це звучить як домашнє завдання, тому я не збираюся робити для вас початок / кінець. Python - це надзвичайно виразна мова для цього, тому це має мати сенс, якщо ви розумієте математику, і, сподіваємось, навчите вас про рекурсію. Удачі!

Редагувати: Однією з потенційних критик мого коду є те, що він не використовує надзвичайно зручний вихід функції Python, завдяки чому функція fib (n) значно скорочується. Мій приклад є трохи більш загальним, оскільки не так багато мов поза Python насправді мають вихід.

Часова складність:

Функція кешування зменшує звичайний спосіб обчислення рядів Фібоначчі від O (2 ^ n) до O (n) , виключаючи повтори в дереві рекурсивного ряду Фібоначчі:

Код:

import sys

table = [0]*1000

def FastFib(n):
    if n<=1:
        return n
    else:
        if(table[n-1]==0):
            table[n-1] = FastFib(n-1)
        if(table[n-2]==0):
            table[n-2] = FastFib(n-2)
        table[n] = table[n-1] + table[n-2]
        return table[n]

def main():
    print('Enter a number : ')
    num = int(sys.stdin.readline())
    print(FastFib(num))

if __name__=='__main__':
    main()

Це досить ефективно, використовуючи O (log n) основні арифметичні операції.

def fib(n):
    return pow(2 << n, n + 1, (4 << 2*n) - (2 << n) - 1) % (2 << n)

У цьому використовується основна арифметична операція O (1), але розмір проміжних результатів великий і тому зовсім не ефективний.

def fib(n):
    return (4 << n*(3+n)) // ((4 << 2*n) - (2 << n) - 1) & ((2 << n) - 1)

Цей обчислює X ^ n у поліноміальному кільці Z [X] / (X ^ 2 - X - 1), використовуючи експоненцію шляхом квадратування. Результатом цього обчислення є многочлен Fib (n) X + Fib (n-1), з якого можна прочитати n-е число Фібоначчі.

Знову ж таки, це використовує арифметичні операції O (log n) і є дуже ефективним.

def mul(a, b):
        return a[0]*b[1]+a[1]*b[0]+a[0]*b[0], a[0]*b[0]+a[1]*b[1]

def fib(n):
        x, r = (1, 0), (0, 1)
        while n:
                if n & 1: r = mul(r, x)
                x = mul(x, x)
                n >>= 1
        return r[0]

Канонічний код Python для друку послідовності Фібоначчі:

a,b=1,1
while True:
  print a,
  a,b=b,a+b       # Could also use b=a+b;a=b-a

Для проблеми "Друк першого числа Фібоначчі довше 1000 цифр":

a,b=1,1
i=1
while len(str(a))<=1000:
  i=i+1
  a,b=b,a+b

print i,len(str(a)),a

Ми це знаємо

І що N-а сила цієї матриці дає нам:

Таким чином, ми можемо реалізувати функцію, яка просто обчислює потужність цієї матриці до n-го -1 потужності.

як нам відомо, що сила a ^ n дорівнює

Отже, наприкінці функцією напруження буде O (n) ... насправді нічого більш простого, ніж простіша реалізація, якби не те, що ми також це знаємо, x^n * x^n = x^2nі тому оцінювання x^nможе бути здійснено зі складністю O (log n )

Ось моя мовна реалізація за допомогою швидкої мови програмування:

struct Mat {
    var m00: Int
    var m01: Int
    var m10: Int
    var m11: Int
}

func pow(m: Mat, n: Int) -> Mat {
    guard n > 1 else { return m }
    let temp = pow(m: m, n: n/2)

    var result = matMultiply(a: temp, b: temp)
    if n%2 != 0 {
        result = matMultiply(a: result, b: Mat(m00: 1, m01: 1, m10: 1, m11: 0))
    }
    return result
}

func matMultiply(a: Mat, b: Mat) -> Mat {
    let m00 = a.m00 * b.m00 + a.m01 * b.m10
    let m01 = a.m00 * b.m01 + a.m01 * b.m11
    let m10 = a.m10 * b.m00 + a.m11 * b.m10
    let m11 = a.m10 * b.m01 + a.m11 * b.m11

    return Mat(m00: m00, m01: m01, m10: m10, m11: m11)
}

func fibonacciFast(n: Int) -> Int {

    guard n > 0 else { return 0 }
    let m = Mat(m00: 1, m01: 1, m10: 1, m11: 0)

    return pow(m: m, n: n-1).m00
}

Це має складність O (log n). Ми обчислюємо o 'потужність Q з експонентом n-1, а потім беремо елемент m00, який є Fn + 1, що в показника потужності n-1 - це саме п яте число, яке ми бажали.

Після того, як у вас буде функція швидкої напруги, ви можете перейти від стартового номера та номера кінця, щоб отримати частину послідовності, яка вас цікавить.

let sequence = (start...end).map(fibonacciFast)

звичайно спочатку проведіть деяку перевірку на початку та в кінці, щоб переконатися, що вони можуть сформувати дійсний діапазон.

Я знаю, що це питання 8 років, але мені було весело відповісти. :)

Послідовність Фібоначчі: 1, 1, 2, 3, 5, 8, ....

Тобто f(1) = 1, f(2) = 1, f(3) = 2, ..., f(n) = f(n-1) + f(n-2).

Моя улюблена реалізація (найпростіша і все ж досягає швидкості світла порівняно з іншими реалізаціями):

def fibonacci(n):
    a, b = 0, 1
    for _ in range(1, n):
        a, b = b, a + b
    return b

Тест

>>> [fibonacci(i) for i in range(1, 10)]
[1, 1, 2, 3, 5, 8, 13, 21, 34]

Хронометраж

>>> %%time
>>> fibonacci(100**3)
CPU times: user 9.65 s, sys: 9.44 ms, total: 9.66 s
Wall time: 9.66 s

Редагувати: приклад візуалізації для цих реалізацій.

використовувати рекурсію:

def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)
x=input('which fibonnaci do you want?')
print fib(x)

Ще один спосіб зробити це:

a,n=[0,1],10
map(lambda i: reduce(lambda x,y: a.append(x+y),a[-2:]),range(n-2))

Присвоєння списку 'a', призначення цілого числа 'n' Map і зменшення - це 2 з трьох найпотужніших функцій python. Тут карта використовується просто для повторення "n-2" разів. a [-2:] отримає два останні елементи масиву. a.append (x + y) додасть два останні елементи та додасть до масиву

Всі вони виглядають трохи складніше, ніж потрібно. Мій код дуже простий і швидкий:

def fibonacci(x):

    List = []
    f = 1
    List.append(f)
    List.append(f) #because the fibonacci sequence has two 1's at first
    while f<=x:
        f = List[-1] + List[-2]   #says that f = the sum of the last two f's in the series
        List.append(f)
    else:
        List.remove(List[-1])  #because the code lists the fibonacci number one past x. Not necessary, but defines the code better
        for i in range(0, len(List)):
        print List[i]  #prints it in series form instead of list form. Also not necessary

Гаразд .. після того, як втомився згадувати всі тривалі відповіді, тепер знайдіть поданий нижче сорт & солодкий, досить прямий шлях для впровадження Фібоначчі в пітон. Ви можете покращити його так, як вам захочеться, отримавши аргумент або отримавши введення користувача… або змінивши обмеження на 10000. По мірі необхідності ……

def fibonacci():
    start = 0 
    i = 1 
    lt = []
    lt.append(start)
    while start < 10000:
        start += i
        lt.append(start)
        i = sum(lt[-2:])
        lt.append(i)
    print "The Fibonaccii series: ", lt

Такий підхід також працює добре. Знайдіть аналітику запуску нижче

In [10]: %timeit fibonacci
10000000 loops, best of 3: 26.3 ns per loop

це поліпшення відповіді Меттью Генрі:

def fib(n):
    a = 0
    b = 1
    for i in range(1,n+1):
            c = a + b
            print b
            a = b
            b = c

код повинен друкувати b, а не друкувати c

вихід: 1,1,2,3,5 ....

Використання для циклу та друку тільки результату

def fib(n:'upto n number')->int:
    if n==0:
        return 0
    elif n==1:
        return 1
    a=0
    b=1
    for i in range(0,n-1):
        b=a+b
        a=b-a
    return b

Результат

>>>fib(50)
12586269025
>>>>
>>> fib(100)
354224848179261915075
>>> 

Роздрукуйте, що listмістить усі числа

def fib(n:'upto n number')->int:
    l=[0,1]
    if n==0:
        return l[0]
    elif n==1:
        return l
    a=0
    b=1
    for i in range(0,n-1):
        b=a+b
        a=b-a
        l.append(b)
    return l

Результат

>>> fib(10)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

import time
start_time = time.time()



#recursive solution
def fib(x, y, upperLimit):
    return [x] + fib(y, (x+y), upperLimit) if x < upperLimit else [x]

#To test :

print(fib(0,1,40000000000000))
print("run time: " + str(time.time() - start_time))

Результати

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368 , 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 43349377777, 69349, 7349, 69349, 69349, 69349, 69349, 69349, 69349, 69349, 69349, 69349, 69349, 69349, 69349, 69349, 69349, 693, 69349, 693, 69349, 694, 694, 693, 694, 694, 695, 693, 693, 693, 693, 694, 693, 693, 694, 693, 695, 750,,,,, , 12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041, 1548008755920, 2504730781961, 405275955755, 275, 275,,

час роботи: 0,04298138618469238

Є дуже простий метод зрозуміти це!

ви можете запускати цей код в Інтернеті вільно за допомогою http://www.learnpython.org/

# Set the variable brian on line 3!

def fib(n):
"""This is documentation string for function. It'll be available by fib.__doc__()
Return a list containing the Fibonacci series up to n."""
result = []
a = 0
b = 1
while a < n:
    result.append(a)  # 0 1 1 2 3 5  8  (13) break
    tmp_var = b       # 1 1 2 3 5 8  13
    b = a + b         # 1 2 3 5 8 13 21
    a = tmp_var       # 1 1 2 3 5 8  13
    # print(a)
return result

print(fib(10))
# result should be this: [0, 1, 1, 2, 3, 5, 8]

Зробити це можна наступним чином.

n = 0

цифри = [0]

для i в діапазоні (0,11):
    друкувати n,
    numbers.append (n)
    prev = числа [-2]
    якщо n == 0:
        n = 1
    ще:
        n = n + prev

Для розваги, в Python 3.8+ ви можете використовувати вираз призначення (він же оператор моржів) у розумінні списку, наприклад:

>>> a, b = 0, 1
>>> [a, b] + [b := a + (a := b) for _ in range(8)]  # first 10 Fibonacci numbers
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Вираз присвоєння дозволяє призначити значення змінній і повернути її в тому ж виразі. Тому вираз

b := a + (a := b)

еквівалентно виконанню

a, b = b, a + b

і повертає значення b.

Через 15 хвилин підручник, який я використовував під час вивчення Python, він попросив читача написати програму, яка обчислила б послідовність Фібоначчі з 3-х вхідних чисел (перше число Фібоначчі, друге число та число, на якому зупиняти послідовність). Навчальний посібник охоплював лише змінні, якщо / thens, і цикли до цього моменту. Функцій поки немає. Я придумав такий код:

sum = 0
endingnumber = 1                

print "\n.:Fibonacci sequence:.\n"

firstnumber = input("Enter the first number: ")
secondnumber = input("Enter the second number: ")
endingnumber = input("Enter the number to stop at: ")

if secondnumber < firstnumber:

    print "\nSecond number must be bigger than the first number!!!\n"

else:

while sum <= endingnumber:

    print firstnumber

    if secondnumber > endingnumber:

        break

    else:

        print secondnumber
        sum = firstnumber + secondnumber
        firstnumber = sum
        secondnumber = secondnumber + sum

Як бачите, це дійсно неефективно, але це НЕ працює.

def fib():
    a,b = 1,1
    num=eval(input("Please input what Fib number you want to be calculated: "))
    num_int=int(num-2)
    for i in range (num_int):
        a,b=b,a+b
    print(b)

Щойно переживаючи http://projecteuler.net/problem=2, це було моїм захопленням

# Even Fibonacci numbers
# Problem 2

def get_fibonacci(size):
    numbers = [1,2]
    while size > len(numbers):
        next_fibonacci = numbers[-1]+numbers[-2]
        numbers.append(next_fibonacci)

    print numbers

get_fibonacci(20)

def fib(x, y, n):
    if n < 1: 
        return x, y, n
    else: 
        return fib(y, x + y, n - 1)

print fib(0, 1, 4)
(3, 5, 0)

#
def fib(x, y, n):
    if n > 1:
        for item in fib(y, x + y, n - 1):
            yield item
    yield x, y, n

f = fib(0, 1, 12)
f.next()
(89, 144, 1)
f.next()[0]
55

Можливо, це допоможе

def fibo(n):
    result = []
    a, b = 0, 1
    while b < n:
            result.append(b)
            a, b = b, b + a
    return result

ґрунтуючись на класичній послідовності фільонок і просто заради однолінійки

якщо вам просто потрібен номер індексу, ви можете використовувати зменшення (навіть якщо зменшити це не найкраще для цього, це може бути хорошою вправою)

def fibonacci(index):
    return reduce(lambda r,v: r.append(r[-1]+r[-2]) or (r.pop(0) and 0) or r , xrange(index), [0, 1])[1]

і щоб отримати повний масив, просто видаліть або (r.pop (0) і 0)

reduce(lambda r,v: r.append(r[-1]+r[-2]) or r , xrange(last_index), [0, 1])

Як щодо цього? Я думаю, це не настільки фантастично, як інші пропозиції, тому що він вимагає початкової специфікації попереднього результату для отримання очікуваного результату, але я вважаю, що це дуже читабельний варіант, тобто все, що він робить, це забезпечити результат та попередній результат для рекурсія.

#count the number of recursions
num_rec = 0

def fibonacci(num, prev, num_rec, cycles):

    num_rec = num_rec + 1

    if num == 0 and prev == 0:
        result  = 0;
        num = 1;
    else:
        result = num + prev

    print(result)

    if num_rec == cycles:
        print("done")
    else:
        fibonacci(result, num, num_rec, cycles)

#Run the fibonacci function 10 times
fibonacci(0, 0, num_rec, 10)

Ось результат:

0
1
1
2
3
5
8
13
21
34
done

В основному перекладено з Рубі:

def fib(n):
    a = 0
    b = 1
    for i in range(1,n+1):
            c = a + b
            print c
            a = b
            b = c

...

def fib(lowerbound, upperbound):
    x = 0
    y = 1
    while x <= upperbound:
        if (x >= lowerbound):
            yield x
        x, y = y, x + y

startNumber = 10
endNumber = 100
for fib_sequence in fib(startNumber, endNumber):
    print "And the next number is... %d!" % fib_sequence

Більш детальне пояснення того, як Memoization працює для послідовності Фібоначчі.

# Fibonacci sequence Memoization

fib_cache = {0:0, 1:1}

def fibonacci(n):
    if n < 0:
        return -1
    if fib_cache.has_key(n):
        print "Fibonacci sequence for %d = %d cached" % (n, fib_cache[n])
        return fib_cache[n]
    else:
        fib_cache[n] = fibonacci(n - 1) + fibonacci(n - 2)
    return fib_cache[n]

if __name__ == "__main__":
    print fibonacci(6)
    print fib_cache
    # fibonacci(7) reuses fibonacci(6) and fibonacci(5)
    print fibonacci(7)
    print fib_cache

Я намагався уникати рекурсивної функції для вирішення цієї проблеми, тому застосував ітеративний підхід. Я спочатку виконував запам’ятовувану рекурсивну функцію, але продовжував вражати максимальну рекурсивну глибину. У мене також були суворі цілі пам’яті, тому ви побачите, як я зберігаю масив настільки маленьким, наскільки я можу під час циклічного циклу, зберігаючи лише 2-3 значення в масиві в будь-який час.

def fib(n):
    fibs = [1, 1] # my starting array
    for f in range(2, n):
        fibs.append(fibs[-1] + fibs[-2]) # appending the new fib number
        del fibs[0] # removing the oldest number
    return fibs[-1] # returning the newest fib

print(fib(6000000))

Отримання 6-мільйонного числа зайнятих на моїй машині займає близько 282 секунд, тоді як поле 600k займає лише 2,8 секунди. Мені не вдалося отримати такі великі цифри з рекурсивною функцією, навіть запам'ятовувану.