python实现斐波那契数列

1.递归方式
写法最简洁，但是效率最低，会出现大量的重复计算，时间复杂度O（1.618^n）,而且最深度1000

def Fib_sequence(num):
    if num == 1 or num == 2:
        return 1
    else:
        return Fib_sequence(num-2)+Fib_sequence(num-1)


user_input = input('请输入一个数字')
print('根据递归方式生成的结果为', Fib_sequence(int(user_input)))

2.for循环
迭代主要思想为: 循环代码中参与运算的变量同时是保存结果的变量,最常见的迭代为遍历列表
递推法，就是递增法，时间复杂度是 O(n)，呈线性增长，如果数据量巨大，速度会越拖越慢

def Fib_sequence2(num):
    a, b = 0, 1
    for i in range(num-1):
        a, b = b, a+b
    return b

user_input2 = input('请输入一个数字')
print('根据for循环后生成的结果为', Fib_sequence2(int(user_input2)))

#while循环

def Fib_sequence3(num):
    a, b, i = 0, 1, 0
    while(i < num-1):
        a, b = b, a+b
        i += 1
    return b

user_input3 = input('请输入一个数字')
print('根据while循环后生成的结果为', Fib_sequence3(int(user_input3)))

3.生成器

def generator_fib(num):
    a, b = 0, 1
    while num > 0:
        a, b = b, a + b
        num -= 1
        yield a

def generator_(f):
    while True:
        try:
            x = next(f)
        except StopIteration as e:
            print('生成器最后的返回值是：', x)
            break

f = generator_fib(8)
generator_(f)

user_input4 = input('请输入一个数字')
print(generator_fib(int(user_input4)))

4.矩阵
因为幂运算可以使用二分加速，所以矩阵法的时间复杂度为 O(log n)
用科学计算包numpy来实现矩阵法 O(log n)

1 numpy

import numpy
def fib_matrix(n):
    res = pow((numpy.matrix([[1, 1], [1, 0]])), n) * numpy.matrix([[1], [0]])
    return res[0][0]
for i in range(10):
    print(int(fib_matrix(i)), end=' ')

#2 使用矩阵计算斐波那契数列

def Fibonacci_Matrix_tool(n):
    Matrix = numpy.matrix("1 1;1 0")
    # 返回是matrix类型
    return pow(Matrix, n)  # pow函数速度快于 使用双星好 **

def Fibonacci_Matrix(n):
    result_list = []
    for i in range(0, n):
        result_list.append(numpy.array(Fibonacci_Matrix_tool(i))[0][0])
    return result_list

#调用

Fibonacci_Matrix(10)