Saya awalnya salah kode program. Alih-alih mengembalikan angka Fibonacci antara rentang (mis. StartNumber 1, endNumber 20 seharusnya = hanya angka-angka di antara 1 & 20), saya telah menulis untuk program ini untuk menampilkan semua angka Fibonacci antara rentang (mis. StartNumber 1, endNumber 20 display = 20 angka Fibonacci Pertama). Saya pikir saya punya kode pasti. Saya juga tidak mengerti mengapa ini terjadi.

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))

Seseorang menunjukkan dalam Bagian II saya (yang ditutup karena duplikat - /programming/504193/how-to-write-the-fibonacci- berikutnyaence- in-python-part-ii ) bahwa saya harus melewati startNumber dan endNumber melalui generator menggunakan loop sementara. Dapatkah seseorang tolong tunjukkan saya arah bagaimana melakukan ini? Setiap bantuan dipersilahkan.

Saya seorang programmer belajar dan saya telah mengalami sedikit campur aduk. Saya diminta untuk menulis sebuah program yang akan menghitung dan menampilkan Urutan Fibonacci oleh pengguna memasukkan angka awal dan angka akhir (mis. StartNumber = 20 endNumber = 100 dan hanya akan menampilkan angka-angka di antara rentang itu). Triknya adalah menggunakannya secara inklusif (yang saya tidak tahu bagaimana melakukannya dengan Python? - Saya berasumsi ini berarti menggunakan rentang inklusif?).

Apa yang saya miliki sejauh ini bukan coding sebenarnya melainkan:

• Tulis rumus urutan Fib hingga tak terbatas
• Tampilan startNumber hingga endNumber hanya dari urutan Fib.

Saya tidak tahu harus mulai dari mana dan saya meminta ide atau wawasan tentang cara menulis ini. Saya juga telah mencoba untuk menulis urutan forum Fib tapi saya tersesat juga.

Ada banyak informasi tentang Urutan Fibonacci di wikipedia dan di wolfram . Lebih banyak dari yang Anda butuhkan. Bagaimanapun juga adalah hal yang baik untuk belajar bagaimana menggunakan sumber daya ini untuk menemukan (secepatnya jika mungkin) apa yang Anda butuhkan.

Tulis rumus urutan Fib hingga tak terbatas

Dalam matematika, itu diberikan dalam bentuk rekursif:

Dalam pemrograman, infinite tidak ada. Anda dapat menggunakan formulir rekursif menerjemahkan bentuk matematika langsung dalam bahasa Anda, misalnya dalam Python menjadi:

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

Cobalah dalam bahasa favorit Anda dan lihat bahwa formulir ini membutuhkan banyak waktu karena n semakin besar. Sebenarnya, ini adalah O (2 ⁿ ) pada waktunya.

Buka situs yang saya tautkan dengan Anda dan akan melihat ini (di wolfram ):

Yang ini cukup mudah diimplementasikan dan sangat, sangat cepat untuk dikomputasi, dengan Python:

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

Cara lain untuk melakukannya adalah mengikuti definisi (dari wikipedia ):

Angka pertama dari urutan adalah 0, angka kedua adalah 1, dan setiap angka berikutnya sama dengan jumlah dari dua angka sebelumnya dari urutan itu sendiri, menghasilkan urutan 0, 1, 1, 2, 3, 5, 8 , dll.

Jika bahasa Anda mendukung iterator, Anda dapat melakukan sesuatu seperti:

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

Tampilan startNumber hingga endNumber hanya dari urutan Fib.

Setelah Anda tahu cara menghasilkan Angka Fibonacci, Anda hanya perlu siklus melalui angka dan memeriksa apakah mereka memverifikasi kondisi yang diberikan.

Misalkan sekarang Anda menulis af (n) yang mengembalikan istilah ke-n dari Urutan Fibonacci (seperti yang dengan sqrt (5))

Dalam sebagian besar bahasa, Anda dapat melakukan sesuatu seperti:

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

Dalam python saya akan menggunakan formulir iterator dan pergi untuk:

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

Petunjuk saya adalah belajar membaca apa yang Anda butuhkan. Project Euler (google for it) akan melatih Anda untuk melakukannya: P Semoga beruntung dan bersenang-senang!

Generator Pythonic yang efisien dari deret Fibonacci

Saya menemukan pertanyaan ini ketika mencoba untuk mendapatkan generasi Pythonic terpendek dari urutan ini (kemudian menyadari bahwa saya telah melihat yang serupa dalam Proposal Peningkatan Python ), dan saya belum melihat ada orang lain yang datang dengan solusi spesifik saya (walaupun jawaban teratas semakin dekat, tetapi masih kurang elegan), jadi ini dia, dengan komentar yang menggambarkan iterasi pertama, karena saya pikir itu dapat membantu pembaca memahami:

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)

dan penggunaan:

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

cetakan:

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

(Untuk tujuan atribusi, saya baru-baru ini memperhatikan implementasi yang serupa dalam dokumentasi Python pada modul, bahkan menggunakan variabel adan b, yang sekarang saya ingat pernah melihat sebelum menulis jawaban ini. Tapi saya pikir jawaban ini menunjukkan penggunaan bahasa yang lebih baik.)

Implementasi yang didefinisikan secara rekursif

The online Encyclopedia of Integer Urutan mendefinisikan Fibonacci Sequence rekursif sebagai

F (n) = F (n-1) + F (n-2) dengan F (0) = 0 dan F (1) = 1

Mendefinisikan secara ringkas ini secara Python dapat dilakukan sebagai berikut:

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

Tetapi representasi pasti dari definisi matematika ini sangat tidak efisien untuk angka-angka yang jauh lebih besar dari 30, karena setiap angka yang dihitung juga harus menghitung untuk setiap angka di bawahnya. Anda dapat menunjukkan seberapa lambatnya dengan menggunakan yang berikut:

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

Rekursi memo untuk efisiensi

Ini dapat di-memoise untuk meningkatkan kecepatan (contoh ini mengambil keuntungan dari fakta bahwa argumen kata kunci default adalah objek yang sama setiap kali fungsi dipanggil, tetapi biasanya Anda tidak akan menggunakan argumen default yang bisa berubah-ubah untuk alasan ini):

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

Anda akan menemukan versi memoized jauh lebih cepat, dan akan dengan cepat melebihi kedalaman rekursi maksimum Anda bahkan sebelum Anda berpikir untuk bangun untuk minum kopi. Anda dapat melihat seberapa cepat secara visual dengan melakukan ini:

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

(Sepertinya kita bisa melakukan yang di bawah ini, tetapi sebenarnya tidak membiarkan kita mengambil keuntungan dari cache, karena ia memanggil dirinya sendiri sebelum setdefault dipanggil.)

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

Generator yang didefinisikan secara rekursif:

Karena saya telah belajar Haskell, saya menemukan implementasi ini di Haskell:

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

Yang paling dekat saya pikir bisa saya dapatkan dengan Python saat ini adalah:

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

Ini menunjukkannya:

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

Namun, itu hanya bisa mencapai batas rekursi. Biasanya, 1000, sedangkan versi Haskell dapat mencapai 100-an juta, meskipun menggunakan semua 8 GB memori laptop saya untuk melakukannya:

> length $ take 100000000 fib 
100000000

Mengkonsumsi iterator untuk mendapatkan nomor fibonacci ke-n

Seorang komentator bertanya:

Pertanyaan untuk fungsi Fib () yang didasarkan pada iterator: bagaimana jika Anda ingin mendapatkan yang ke-n, misalnya nomor ke-10?

Dokumentasi itertools memiliki resep untuk ini:

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)

dan sekarang:

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

Mengapa tidak sekadar melakukan yang berikut?

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

Gagasan di balik deret Fibonacci ditunjukkan dalam kode Python berikut:

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

Ini berarti bahwa fib adalah fungsi yang dapat melakukan satu dari tiga hal. Ini mendefinisikan fib (1) == 1, fib (0) == 0, dan fib (n) menjadi:

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

Di mana n adalah integer yang berubah-ubah. Ini berarti bahwa fib (2) misalnya, memperluas ke aritmatika berikut:

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

Kita dapat menghitung fib (3) dengan cara yang sama dengan aritmatika yang ditunjukkan di bawah ini:

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

Yang penting untuk disadari di sini adalah bahwa fib (3) tidak dapat dihitung tanpa menghitung fib (2), yang dihitung dengan mengetahui definisi dari fib (1) dan fib (0). Memiliki panggilan fungsi itu sendiri seperti fungsi fibonacci tidak disebut rekursi, dan ini merupakan topik penting dalam pemrograman.

Ini terdengar seperti tugas pekerjaan rumah jadi saya tidak akan melakukan bagian awal / akhir untuk Anda. Python adalah bahasa yang sangat ekspresif untuk ini, jadi ini masuk akal jika Anda memahami matematika, dan mudah-mudahan akan mengajarkan Anda tentang rekursi. Semoga berhasil!

Sunting: Salah satu kritik potensial terhadap kode saya adalah bahwa ia tidak menggunakan fungsi Python yang sangat berguna, yang membuat fungsi fib (n) jauh lebih pendek. Contoh saya sedikit lebih umum, karena tidak banyak bahasa di luar Python yang benar-benar menghasilkan.

Kompleksitas waktu:

Fitur caching mengurangi cara normal menghitung seri Fibonacci dari O (2 ^ n) menjadi O (n) dengan menghilangkan pengulangan di pohon rekursif seri Fibonacci:

Kode:

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()

Ini cukup efisien, menggunakan operasi aritmatika dasar O (log n).

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

Yang ini menggunakan O (1) operasi aritmatika dasar, tetapi ukuran hasil antara besar dan sama sekali tidak efisien.

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

Yang ini menghitung X ^ n dalam cincin polinomial Z [X] / (X ^ 2 - X - 1) menggunakan eksponensial dengan mengkuadratkan. Hasil perhitungan itu adalah Fib polinomial (n) X + Fib (n-1), dari mana angka Fibonacci n dapat dibaca.

Sekali lagi, ini menggunakan operasi hitung O (log n) dan sangat efisien.

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]

Kode Python Canonical untuk mencetak urutan Fibonacci:

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

Untuk masalah "Cetak angka Fibonacci pertama yang lebih besar dari 1000 digit":

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

Kami tahu itu

Dan bahwa kekuatan ke-n dari matriks itu memberi kita:

Jadi kita bisa mengimplementasikan fungsi yang hanya menghitung kekuatan matriks itu ke kekuatan n-th -1.

karena yang kita tahu kekuatan a sama dengan

Jadi pada akhirnya fungsi fibonacci akan menjadi O (n) ... tidak ada yang benar-benar berbeda dari implementasi yang lebih mudah jika bukan karena fakta bahwa kita juga tahu itu x^n * x^n = x^2ndan evaluasi x^nkarenanya dapat dilakukan dengan kompleksitas O (log n )

Berikut ini adalah implementasi fibonacci saya menggunakan bahasa pemrograman cepat:

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
}

Ini memiliki kompleksitas O (log n). Kami menghitung kekuatan Q dengan eksponen n-1 dan kemudian kami mengambil elemen m00 yaitu Fn + 1 yang pada eksponen daya n-1 persis angka Fibonacci ke-n yang kami inginkan.

Setelah Anda memiliki fungsi fibonacci cepat, Anda dapat beralih dari nomor awal dan nomor akhir untuk mendapatkan bagian dari deret Fibonacci yang Anda minati.

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

tentu saja pertama kali melakukan beberapa pemeriksaan pada awal dan akhir untuk memastikan mereka dapat membentuk rentang yang valid.

Saya tahu pertanyaannya adalah 8 tahun, tetapi saya tetap senang menjawab. :)

Fibonacci urutan: 1, 1, 2, 3, 5, 8, ....

Artinya f(1) = 1, f(2) = 1, f(3) = 2, ..., f(n) = f(n-1) + f(n-2).

Implementasi favorit saya (paling sederhana namun mencapai kecepatan rendah dibandingkan dengan implementasi lainnya) adalah ini:

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

Uji

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

Pengaturan waktu

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

Edit: contoh visualisasi untuk implementasi ini.

gunakan rekursi:

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)

Cara lain untuk melakukannya:

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

Menetapkan daftar ke 'a', menetapkan integer ke 'n' Map dan mengurangi adalah 2 dari tiga fungsi paling kuat dalam python. Di sini peta digunakan hanya untuk mengulangi 'n-2' kali. a [-2:] akan mendapatkan dua elemen terakhir dari sebuah array. a.append (x + y) akan menambahkan dua elemen terakhir dan akan menambahkan ke array

Ini semua terlihat sedikit lebih rumit dari yang seharusnya. Kode saya sangat sederhana dan cepat:

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

Oke .. setelah bosan merujuk semua jawaban yang panjang, sekarang temukan cara di bawah ini & manis, cara yang sangat mudah untuk menerapkan Fibonacci dalam python. Anda dapat meningkatkannya dengan cara yang Anda inginkan dengan mendapatkan argumen atau mendapatkan input pengguna ... atau mengubah batas dari 10000. Seperti yang Anda butuhkan ……

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

Pendekatan ini juga berkinerja baik. Temukan analitik yang dijalankan di bawah ini

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

ini merupakan peningkatan untuk jawaban hewry:

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

kode harus dicetak b bukan cetak c

output: 1,1,2,3,5 ....

Menggunakan untuk loop dan mencetak hasilnya saja

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

Hasil

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

Cetak yang listberisi semua angka

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

Hasil

>>> 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))

Hasil

[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 ,,,,,,,,,,,,,,,,,,,,,,,,,, ,_7121_112112190112112121212,1212,1212,123127 besar, peningkatan daya,,,,,,,,,,,,, peningkatan,,,,,,,,,,,,,, Pen lanjut, Pen. , 12586269025, 20361.0121.0121.312.161.161.161.161.161.161 .112.161 daya.25, saat ini adalah anggota baru:

jangka waktu: 0,04298138618469238

ada metode yang sangat mudah untuk disadari!

Anda dapat menjalankan kode ini secara online secara bebas dengan menggunakan 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]

Itu bisa dilakukan dengan cara berikut.

n = 0

angka = [0]

untuk saya dalam kisaran (0,11):
    cetak n,
    numbers.append (n)
    prev = angka [-2]
    jika n == 0:
        n = 1
    lain:
        n = n + prev

Hanya untuk bersenang-senang, dalam Python 3.8+ Anda dapat menggunakan ekspresi penugasan (alias operator walrus) dalam pemahaman daftar, misalnya:

>>> 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]

Ekspresi penugasan memungkinkan Anda untuk menetapkan nilai ke variabel dan mengembalikannya dalam ekspresi yang sama. Karena itu, ungkapan

b := a + (a := b)

setara dengan mengeksekusi

a, b = b, a + b

dan mengembalikan nilai b.

15 menit tutorial yang saya gunakan ketika belajar Python, ia meminta pembaca untuk menulis sebuah program yang akan menghitung urutan Fibonacci dari 3 angka input (angka Fibonacci pertama, angka kedua, dan angka untuk menghentikan urutan). Tutorial hanya membahas variabel, jika / kemudian, dan loop sampai ke titik itu. Belum ada fungsi. Saya datang dengan kode berikut:

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

Seperti yang Anda lihat, ini benar-benar tidak efisien, tetapi TIDAK BAIK.

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)

Hanya melalui http://projecteuler.net/problem=2 ini adalah pendapat saya

# 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

Mungkin ini akan membantu

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

berdasarkan urutan fibonacci klasik dan hanya demi satu-liners

jika Anda hanya membutuhkan jumlah indeks, Anda dapat menggunakan pengurangan (bahkan jika pengurangan itu tidak cocok untuk ini, ini bisa menjadi latihan yang baik)

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]

dan untuk mendapatkan array lengkap cukup hapus atau (r.pop (0) dan 0)

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

Bagaimana dengan yang ini? Saya kira itu tidak semewah saran lainnya karena menuntut spesifikasi awal dari hasil sebelumnya untuk menghasilkan output yang diharapkan, tetapi saya merasa adalah pilihan yang sangat mudah dibaca, yaitu, semua yang dilakukannya adalah memberikan hasil dan hasil sebelumnya untuk rekursi.

#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)

Inilah hasilnya:

0
1
1
2
3
5
8
13
21
34
done

Diterjemahkan pada dasarnya dari Ruby:

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

Penjelasan lebih rinci tentang cara Memoisasi bekerja untuk urutan Fibonacci.

# 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

Saya mencoba menghindari fungsi rekursif untuk menyelesaikan masalah ini, jadi saya mengambil pendekatan berulang. Saya awalnya melakukan fungsi rekursif memoised tetapi terus memukul kedalaman rekursif max. Saya juga memiliki tujuan memori yang ketat sehingga Anda akan melihat saya menjaga array sekecil yang saya bisa selama proses perulangan hanya menjaga 2-3 nilai dalam array setiap saat.

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))

Mendapatkan 6 juta nomor fibonacci membutuhkan sekitar 282 detik di mesin saya sedangkan 600k fibonacci hanya membutuhkan 2,8 detik. Saya tidak dapat memperoleh angka fibonacci sebesar itu dengan fungsi rekursif, bahkan nomor memo.