Ada banyak informasi tentang Deret Fibonacci pada [wikipedia][1] dan di [wolfram][2]. Lebih banyak dari yang anda mungkin perlu. Pokoknya itu adalah hal yang baik untuk belajar bagaimana untuk menggunakan sumber daya ini untuk menemukan (dengan cepat jika mungkin) apa yang anda butuhkan.

Menulis Fib urutan susu formula yang tak terbatas

Dalam matematika,'s diberikan dalam bentuk rekursif:

![fibonacci dari wikipedia][3]

Dalam pemrograman, terbatas doesn't ada. Anda dapat menggunakan rekursif bentuk menerjemahkan matematika bentuk langsung dalam bahasa anda, misalnya di Python itu menjadi:

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

Coba saja di favorit anda bahasa dan lihat bahwa bentuk ini membutuhkan banyak waktu n akan lebih besar. Pada kenyataannya, ini adalah O(2n) dalam waktu.

Pergi pada situs saya dengan anda dan akan melihat ini (pada wolfram):

[![Fibonacci Persamaan][4]][4]

Yang satu ini cukup mudah untuk menerapkan dan sangat, sangat cepat untuk menghitung, dalam Python:

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

Sebuah cara lain untuk melakukan ini adalah sebagai berikut definisi (dari wikipedia):

angka pertama dari urutan 0, nomor kedua adalah 1, dan masing-masing nomor berikutnya adalah sama dengan jumlah dari sebelumnya dua angka 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 untuk endNumber hanya dari Fib urutan.

Setelah anda tahu bagaimana untuk menghasilkan angka-Angka Fibonacci anda hanya perlu untuk siklus melalui angka-angka dan memeriksa apakah mereka memverifikasi kondisi yang diberikan.

Misalkan sekarang anda menulis f(n) yang kembali istilah-n dari Deret Fibonacci (seperti satu dengan sqrt(5) )

Dalam kebanyakan bahasa, anda dapat melakukan sesuatu seperti:

def SubFib(startNumber, endNumber):
    n = 0
    cur = f(n)
    while cur 

Efisien Pythonic generator dari deret Fibonacci

Saya menemukan pertanyaan ini ketika mencoba untuk mendapatkan terpendek Pythonic generasi urutan ini (kemudian menyadari saya telah melihat yang serupa di Python Peningkatan Proposal), dan saya belum't melihat orang lain datang dengan solusi spesifik (meskipun atas jawabannya semakin dekat, tapi masih kurang elegan), jadi di sini adalah, dengan komentar-komentar yang menjelaskan iterasi pertama, karena saya berpikir bahwa mungkin 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, aku baru saja melihat mirip penerapan di Python dokumentasi pada modul, bahkan menggunakan variabel a dan b, yang sekarang saya ingat setelah melihat sebelum menulis jawaban ini. Tapi saya pikir jawaban ini menunjukkan penggunaan yang lebih baik dari itu.)

Didefinisikan secara rekursif pelaksanaan

The Online Encyclopedia of Integer Urutan mendefinisikan Urutan Fibonacci secara rekursif sebagai

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

Ringkas mendefinisikan hal ini secara rekursif dalam 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

Tapi ini tepat representasi matematika definisi ini sangat tidak efisien untuk angka-angka yang jauh lebih besar dari 30, karena setiap angka yang dihitung juga harus menghitung untuk setiap nomor di bawah ini. Anda dapat menunjukkan bagaimana lambat adalah dengan menggunakan kode berikut:

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

Memoized rekursi untuk efisiensi

Hal ini dapat memoized untuk meningkatkan kecepatan (contoh ini mengambil keuntungan dari fakta bahwa kata kunci default argumen adalah objek yang sama setiap kali fungsi dipanggil, tapi biasanya anda tidak't menggunakan mutable default argumen 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'll menemukan memoized versi ini jauh lebih cepat, dan dengan cepat akan melebihi maksimum kedalaman rekursi sebelum anda bahkan dapat berpikir untuk bangun untuk minum kopi. Anda dapat melihat seberapa cepat hal ini secara visual dengan melakukan hal ini:

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

(Ini mungkin tampak seperti kita hanya bisa melakukan hal di bawah ini, tapi itu benar-benar doesn't mari kita mengambil keuntungan dari cache, karena itu menyebut dirinya sebelum setdefault disebut.)

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

Didefinisikan secara rekursif generator:

Seperti yang saya telah belajar Haskell, saya datang di ini implementasi di Haskell:

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

Terdekat saya pikir saya bisa mendapatkan ini di Python pada 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 menunjukkan hal itu:

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

Hal ini dapat hanya pergi ke rekursi batas, meskipun. Biasanya, 1000, sedangkan Haskell versi bisa naik ke 100 juta, meskipun ia menggunakan semua 8 GB laptop saya's memori untuk melakukannya:

> length $ take 100000000 fib 
100000000

Mengapa tidak hanya melakukan hal-hal berikut?

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

Ide di balik urutan Fibonacci ditunjukkan berikut ini kode Python:

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 salah satu dari tiga hal. Ini mendefinisikan fib(1) == 1, fib(0) == 0, dan fib(n) untuk menjadi:

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

Di mana n adalah sembarang bilangan bulat. Ini berarti bahwa fib(2) misalnya, memperluas keluar 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) dapat't dapat dihitung tanpa memperhitungkan fib(2), yang dihitung dengan mengetahui definisi dari fib(1) dan fib(0). Memiliki fungsi yang memanggil dirinya sendiri seperti fibonacci fungsi tidak disebut rekursi, dan's sebuah topik yang penting dalam pemrograman.

Ini terdengar seperti tugas pekerjaan rumah jadi saya'm tidak akan melakukan start/end bagian untuk anda. Python adalah sangat ekspresif bahasa untuk ini meskipun, jadi ini harus masuk akal jika anda memahami matematika, dan mudah-mudahan akan mengajarkan anda tentang rekursi. Good luck!

Edit: salah Satu potensi kritik dari kode saya adalah bahwa hal itu doesn't menggunakan super-berguna Python fungsi yield, yang membuat fib(n) fungsi yang jauh lebih pendek. Contoh saya adalah sedikit lebih umum meskipun, karena tidak banyak bahasa di luar Python benar-benar memiliki hasil.

Kompleksitas waktu :

Fitur caching mengurangi normal cara menghitung deret Fibonacci dari O(2^n) untuk O(n) dengan menghilangkan pengulangan secara rekursif pohon Fibonacci series :

![enter image description here][1]

Kode :

import sys

table = [0]*1000

def FastFib(n):
    if n

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

def fib(n):
    return pow(2 

Canonical kode Python untuk mencetak deret 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 pertama Fibonacci jumlah yang lebih besar dari 1000 digit":

a,b=1,1
i=1
while len(str(a))

Kita tahu bahwa

Dan yang ke-n kekuatan matrix memberikan kita:

Sehingga kita dapat melaksanakan fungsi yang hanya menghitung kekuatan matriks dengan n-th -1 kekuasaan.

seperti yang semua kita tahu kekuatan a^n adalah sama dengan

Sehingga pada akhir fibonacci fungsi akan menjadi O( n )... tidak ada yang benar-benar berbeda dari yang lebih mudah pelaksanaannya kalau bukan't untuk fakta bahwa kita juga tahu bahwa x^n * x^n = x^2n dan evaluasi x^n karena itu dapat dilakukan dengan kompleksitas O( log n )

Berikut adalah fibonacci implementasi menggunakan bahasa pemrograman yang 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 oìkekuatan Q dengan eksponen n-1 dan kemudian kita mengambil elemen m00 yang Fn+1 bahwa pada kekuatan eksponen n-1 adalah persis-n bilangan Fibonacci yang kita inginkan.

Setelah anda memiliki cepat fibonacci fungsi anda dapat beralih dari jumlah awal dan akhir nomor untuk mendapatkan bagian dari deret Fibonacci yang anda tertarik.

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

tentu saja terlebih dahulu melakukan beberapa cek di mulai dan akhir untuk memastikan mereka dapat membentuk kisaran yang valid.

Aku tahu pertanyaan berusia 8 tahun, tapi aku senang menjawab pula. :)

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

Deret Fibonacci adalah: 1, 1, 2, 3, 5, 8, ....

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

Favorit saya implementasi (yang paling sederhana dan belum mencapai kecepatan cahaya di bandingkan dengan implementasi lainnya) adalah:

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

Tes

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

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.

ada metode yang sangat mudah untuk menyadari itu!

anda dapat menjalankan kode ini online 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]

Menggunakan loop for dan cetak hanya hasil

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

Mencetak daftar yang berisi semua angka-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]

Cara lain untuk melakukan hal itu:

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 bilangan bulat untuk 'n' Peta dan mengurangi 2 dari tiga yang paling kuat fungsi pada python. Berikut ini peta ini digunakan hanya untuk iterate 'n-2' times. a[-2:] akan mendapatkan dua elemen dari sebuah array. a.append(x+y) akan menambah dua elemen dan akan menambahkan ke array

ini merupakan perbaikan untuk mathew henry's jawaban:

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 cetak b bukan c percetakan

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

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, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, 12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041, 1548008755920, 2504730781961, 4052739537881, 6557470319842, 10610209857723, 17167680177565, 27777890035288, 44945570212853]

jangka waktu: 0.04298138618469238

OK.. setelah lelah merujuk semua jawaban panjang, sekarang menemukan berikut jenis & manis, cukup lurus ke depan jalan untuk menerapkan Fibonacci di python. Anda dapat meningkatkan itu dengan cara yang anda inginkan dengan mendapatkan sebuah argumen atau mendapatkan input pengguna...atau mengubah batas-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 memiliki performa yang baik. Menemukan menjalankan analytics di bawah ini

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

Ini semua terlihat sedikit lebih rumit dari yang mereka butuhkan untuk menjadi. Kode saya ini 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

Rekursi menambah waktu. Untuk menghilangkan loop, pertama impor matematika. Kemudian menggunakan matematika.sqrt dan rasio emas di fungsi:

#!/usr/bin/env python3

import math

def fib(n):
    gr = (1 + math.sqrt(5)) / 2
    fib_first = (gr**n - (1 - gr)**n) / math.sqrt(5)
    return int(round(fib_first))

fib_final = fib(100)

print(fib_final)

ref: Angka Fibonacci dalam Python