【附源码】Python ：斐波那契数列（10种方法计算第n项）

爱吃饭团的饭桶

于 2024-09-09 21:31:59 发布

阅读量1.2k

点赞数 16

分类专栏： Python 文章标签： python 算法人工智能

本文链接：https://blog.csdn.net/weixin_72553621/article/details/142069363

版权

Python 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

系列文章目录

Python 算法学习：斐波那契数列（10种方法计算第n项）

文章目录

系列文章目录
一、算法需求
二、方法+源码
总结

一、算法需求

采用多种方法，来计算斐波那契数列的第n项。

二、方法+源码

方法1：递归

递归是最直观的方法，但效率较低，因为它会重复计算很多子问题。

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

# 测试递归方法
print(fibonacci_recursive(10))  # 输出斐波那契数列的第10项

方法2：迭代

迭代方法比递归更高效，因为它避免了重复计算。

def fibonacci_iterative(n):
    if n <= 0:
        return 0
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

# 测试迭代方法
print(fibonacci_iterative(10))  # 输出斐波那契数列的第10项

方法3：动态规划

动态规划方法通过存储已经计算过的值来避免重复计算，这种方法比递归更高效。

def fibonacci_dp(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    memo[n] = fibonacci_dp(n-1, memo) + fibonacci_dp(n-2, memo)
    return memo[n]

# 测试动态规划方法
print(fibonacci_dp(10))  # 输出斐波那契数列的第10项

方法4：生成器

使用Python的生成器可以创建一个斐波那契数列生成器，每次调用时返回下一个斐波那契数。

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

# 使用生成器
gen = fibonacci_generator()
for _ in range(11):
    print(next(gen))  # 输出斐波那契数列的前11项

方法5：矩阵快速幂

斐波那契数列可以通过矩阵乘法来表示，其中每个斐波那契数可以看作是矩阵的幂次方的结果。这种方法利用了矩阵的快速幂算法。
在这个实现中：
matrix_multiply 函数用于计算两个矩阵的乘积。
matrix_power 函数用于计算矩阵的幂次方，这是快速幂算法的核心。
fibonacci_matrix 函数使用上述两个函数来计算斐波那契数列的第n项。
这种方法利用了斐波那契数列与矩阵乘法之间的关系，通过快速幂算法高效地计算出结果。这种方法特别适合计算非常大的斐波那契数，因为它的时间复杂度远低于递归和迭代方法。

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

def matrix_power(matrix, n):
    if n == 1:
        return matrix
    if n % 2 == 0:
        half_power = matrix_power(matrix, n // 2)
        return matrix_multiply(half_power, half_power)
    else:
        return matrix_multiply(matrix, matrix_power(matrix, n - 1))

def fibonacci_matrix(n):
    if n <= 0:
        return 0
    base_matrix = [[1, 1],
                   [1, 0]]
    result_matrix = matrix_power(base_matrix, n - 1)
    return result_matrix[0][0]

# 测试矩阵快速幂方法
print(fibonacci_matrix(10))  # 输出斐波那契数列的第10项

方法6：闭包

使用闭包来存储计算斐波那契数列所需的状态（即前两个数），从而避免重复计算。
在这个实现中：
fibonacci_closure 函数定义了一个内部函数 fib，它使用 nonlocal 关键字来修改外部函数中的变量 a 和 b。
fib 函数递归地计算斐波那契数列的第n项，同时更新 a 和 b 的值。
当 fibonacci_closure 被调用时，它返回 fib 函数，这个函数现在关联了 a 和 b 的初始值。
这种方法的优点是它利用了闭包的特性来存储状态，避免了全局变量的使用，并且可以重复调用而不需要重新初始化状态。这在某些情况下可以提高代码的封装性和可读性。不过，对于斐波那契数列的计算，这种方法的性能并不比迭代或动态规划方法更优，但它展示了Python闭包的有趣用法。

def fibonacci_closure():
    a, b = 0, 1
    def fib(n):
        nonlocal a, b
        if n == 0:
            return a
        elif n == 1:
            return b
        else:
            a, b = b, a + b
            return fib(n - 1)
    return fib

# 创建一个斐波那契闭包函数
fib = fibonacci_closure()

# 测试闭包方法
print(fib(10))  # 输出斐波那契数列的第10项

方法7：公式法（Binet’s Formula）

Binet公式可以直接计算斐波那契数列的第n项，但因为涉及到无理数的计算，当n较大时会有精度问题。

import math

def fibonacci_binet(n):
    phi = (1 + math.sqrt(5)) / 2  # 黄金分割比
    psi = (1 - math.sqrt(5)) / 2
    return round((phi**n - psi**n) / math.sqrt(5))

# 测试公式法
print(fibonacci_binet(10))  # 输出斐波那契数列的第10项

方法8：利用Python的内置函数

Python的functools模块提供了一个lru_cache装饰器，可以缓存函数的最近调用结果，从而优化递归函数的性能。

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci_cached(n):
    if n < 2:
        return n
    return fibonacci_cached(n-1) + fibonacci_cached(n-2)

# 测试缓存优化的递归方法
print(fibonacci_cached(10))  # 输出斐波那契数列的第10项

方法9：基于生成器的迭代

使用Python的生成器，可以创建一个迭代器，每次迭代返回斐波那契数列的下一个值。

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

# 测试生成器迭代方法
for value in fibonacci_generator(10):
    print(value, end=' ')  # 输出斐波那契数列的前10项

方法10：列表推导式

使用Python的列表推导式来计算斐波那契数列的第n项的方法。这种方法利用了列表推导式的强大功能，可以快速生成斐波那契数列的前n项，然后直接返回第n项。
在这个实现中：
我们首先检查n是否小于或等于1，如果是，直接返回斐波那契数列的第0项或第1项。
对于n > 1的情况，我们使用列表推导式来生成斐波那契数列的前n项。
列表推导式中的enumerate([0, 1] + [0] * (n-1))用于生成一个初始列表，其中包含两个初始斐波那契数和足够多的0，以确保列表长度至少为n。
对于列表中的每个索引i，如果i < 2，直接使用初始值0或1。否则，使用递归调用fibonacci_list_comprehension(i-1) + fibonacci_list_comprehension(i-2)来计算斐波那契数。
最后，返回列表的第n项。
这种方法虽然简洁，但由于它在列表推导式中使用了递归调用，可能会导致性能问题，尤其是在计算较大的n值时。因此，它更适合于教学和理解斐波那契数列的生成过程，而不是用于实际的大规模计算。

def fibonacci_list_comprehension(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return [x if i < 2 else (fibonacci_list_comprehension(i-1) + fibonacci_list_comprehension(i-2)) 
                for i, x in enumerate([0, 1] + [0] * (n-1))][n]

# 测试列表推导式方法
print(fibonacci_list_comprehension(10))  # 输出斐波那契数列的第10项

总结

1. 递归方法：

直接使用递归定义来计算斐波那契数。
简单直观，但效率低，因为存在大量重复计算。

2. 迭代方法：

使用循环迭代计算斐波那契数，避免了递归的重复计算。
效率较高，适用于计算较大数值。

3. 动态规划：

通过存储已计算的结果来避免重复计算，通常用于递归函数的优化。
减少了计算次数，提高了效率。

4. 矩阵快速幂：

利用斐波那契数列与矩阵乘法的关系，通过快速幂算法高效计算。
时间复杂度为O(log n)，适合计算大数。

5. 闭包：

使用闭包来存储计算状态，避免全局变量。
封装性好，但性能并不比迭代或动态规划更优。

6. Binet公式：

直接使用数学公式计算斐波那契数，涉及无理数运算。
计算快速，但可能存在精度问题。

7. 内置函数优化：

使用Python的functools.lru_cache装饰器优化递归函数。
缓存递归调用结果，提高性能。

8. 基于生成器的迭代：

使用Python的生成器逐项生成斐波那契数列。
适合逐项处理的场景，内存效率高。

9. 列表推导式：

使用列表推导式快速生成斐波那契数列。
代码简洁，但可能因递归调用而导致性能问题。

总而言之，每种方法都有其适用场景和优缺点。递归和迭代是最基础的方法，而动态规划和矩阵快速幂提供了更高效的计算方式。闭包和列表推导式展示了Python语言特性的应用，而Binet公式则提供了一种数学上的解决方案。内置函数优化是一种实用的技巧，可以显著提高递归函数的性能。基于生成器的方法则适用于需要逐个处理斐波那契数的场景。