1. 斐波那契数列的数学魅力与编程价值
斐波那契数列这个数学概念，最早出现在印度数学中，后来由意大利数学家斐波那契引入西方。这个数列看似简单，却蕴含着令人惊叹的数学规律和美学价值。数列的定义非常直观：第一个和第二个数字都是1，从第三个数字开始，每个数字都是前两个数字之和。用数学表达式表示就是：
F(1) = 1
F(2) = 1
F(n) = F(n-1) + F(n-2) (n ≥ 3)
这个简单的递归关系产生的数列是：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144...
斐波那契数列在自然界中随处可见——向日葵的种子排列、松果的鳞片分布、鹦鹉螺的螺旋生长，甚至银河系的旋臂结构，都遵循着斐波那契数列的规律。这种普遍性使得它成为连接数学与自然的桥梁。
在编程领域，斐波那契数列常被用作算法教学的经典案例，因为它可以展示多种编程范式和技巧。从最基础的递归实现，到更高效的迭代方法，再到利用Python的高级特性进行简洁表达，斐波那契数列为我们提供了一个绝佳的学习平台。
提示：斐波那契数列在实际应用中远不止于教学示例。在金融领域，它被用于技术分析；在计算机科学中，它与黄金分割比和动态规划算法密切相关。
2. Python实现斐波那契数列的多种方法
2.1 基础递归实现
最直观的实现方式是直接按照数学定义编写递归函数：
python复制def fib_recursive(n):
if n <= 2:
return 1
return fib_recursive(n-1) + fib_recursive(n-2)
这种方法虽然简洁，但效率极低。计算fib_recursive(40)可能需要几秒钟时间，因为存在大量的重复计算。时间复杂度是指数级的O(2^n)，空间复杂度是O(n)（由于递归调用栈）。
2.2 迭代优化版本
为了提高效率，我们可以改用迭代方法：
python复制def fib_iterative(n):
a, b = 1, 1
for _ in range(n-1):
a, b = b, a + b
return a
这个版本的时间复杂度降到了线性的O(n)，空间复杂度是常数O(1)，性能有了质的飞跃。对于n=100这样的大数，也能瞬间计算出结果。
2.3 使用生成器实现
Python的生成器非常适合用来生成无限序列：
python复制def fib_generator():
a, b = 1, 1
while True:
yield a
a, b = b, a + b
# 使用示例
fib = fib_generator()
print([next(fib) for _ in range(10)]) # 输出前10项
生成器版本的优势在于它是惰性求值的，可以按需生成数列，而不必预先计算所有项，这在处理大规模数列时特别有用。
2.4 一行代码的魔法实现
现在，让我们揭晓那个"一行代码"的神奇实现：
python复制fib = lambda n: reduce(lambda x, _: x + [x[-1] + x[-2]], range(n-2), [1, 1])
这行代码使用了Python的functools.reduce函数和lambda表达式，虽然极其简洁，但可读性较差。它实际上是通过累积计算来构建整个数列。
更Pythonic的一行实现是：
python复制fib = lambda n: [0,1][:n] if n <= 2 else (fib(n-1) + [fib(n-1)[-1] + fib(n-1)[-2]])
不过要注意，这些一行代码的实现更多是展示Python的表达能力，在实际项目中，我们更推荐使用清晰可读的迭代版本。
3. Python高级特性在数列生成中的应用
3.1 列表推导式的妙用
Python的列表推导式可以用来生成斐波那契数列：
python复制n = 10
fib = [1, 1]
[fib.append(fib[-1] + fib[-2]) for _ in range(n-2)]
print(fib)
虽然这种写法很简洁，但使用列表推导式只是为了副作用（修改fib列表）并不是最佳实践，因为它违背了列表推导式原本的设计目的。
3.2 使用装饰器缓存计算结果
对于递归实现，我们可以使用functools.lru_cache装饰器来缓存计算结果，大幅提升性能：
python复制from functools import lru_cache
@lru_cache(maxsize=None)
def fib_cached(n):
if n <= 2:
return 1
return fib_cached(n-1) + fib_cached(n-2)
这个装饰器会自动缓存函数的结果，避免重复计算。对于fib_cached(100)，不加装饰器可能需要数年才能计算完成，而加了装饰器后几乎是瞬间完成。
3.3 矩阵快速幂算法
对于需要计算极大斐波那契数（如第100万项）的场景，我们可以使用基于矩阵快速幂的O(log n)算法：
python复制def fib_matrix(n):
def 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_pow(mat, power):
result = [[1, 0], [0, 1]] # 单位矩阵
while power > 0:
if power % 2 == 1:
result = multiply(result, mat)
mat = multiply(mat, mat)
power //= 2
return result
if n == 0:
return 0
mat = [[1, 1], [1, 0]]
return matrix_pow(mat, n-1)[0][0]
这个算法利用了斐波那契数列的矩阵表示和快速幂运算，可以在对数时间内计算出结果，非常适合处理极大的n值。
4. 斐波那契数列的实用技巧与性能对比
4.1 各种实现方法的性能测试
让我们通过实际测试来比较不同实现方法的性能差异：
python复制import timeit
n = 35
def test_recursive():
fib_recursive(n)
def test_iterative():
fib_iterative(n)
def test_cached():
fib_cached(n)
print("递归版本:", timeit.timeit(test_recursive, number=1))
print("迭代版本:", timeit.timeit(test_iterative, number=1))
print("缓存递归:", timeit.timeit(test_cached, number=1))
在我的测试环境中（Python 3.9，i7-9700K），n=35时的结果：
- 递归版本: 约3.5秒
- 迭代版本: 约0.000005秒
- 缓存递归: 约0.0001秒
这个测试清晰地展示了不同算法的时间复杂度差异。对于更大的n值，递归版本会变得完全不实用。
4.2 内存使用优化
当需要存储整个斐波那契数列时，内存使用也是一个考虑因素。生成器版本在这方面有明显优势，因为它不需要一次性存储所有元素：
python复制def memory_efficient_fib(n):
a, b = 1, 1
for _ in range(n):
yield a
a, b = b, a + b
# 使用示例
for num in memory_efficient_fib(1000000):
process(num) # 处理每个数，而不需要存储整个数列
这种方法特别适合处理极大数列或流式处理场景。
4.3 大数处理与精度问题
斐波那契数列增长非常快，第100项已经是354224848179261915075。Python的整数类型可以自动处理大数，不会像其他语言那样溢出。但是，对于极大的数，计算时间会变长。
如果只需要近似值，可以使用基于黄金分割比的公式：
python复制def fib_golden(n):
phi = (1 + 5**0.5) / 2
return int(round(phi**n / 5**0.5))
这个公式利用了斐波那契数列与黄金分割比的关系，可以在O(1)时间内得到近似结果，但对于小的n值可能不够精确。
4.4 实际应用中的选择建议
根据不同的应用场景，我建议：
- 教学演示：使用基础递归版本展示算法思想
- 小规模计算：使用迭代版本，简单高效
- 大规模数列生成：使用生成器版本，节省内存
- 单次大数计算：使用矩阵快速幂算法
- 频繁重复计算：使用缓存装饰器优化递归
注意：虽然一行代码的实现很酷炫，但在实际项目中应优先考虑代码的可读性和可维护性。Python之禅告诉我们："可读性很重要"。
5. 斐波那契数列的扩展应用
5.1 生成斐波那契数列的前N项
在实际应用中，我们常常需要生成数列的前N项。以下是几种不同的实现方式：
python复制# 方法1：使用迭代
def first_n_fib(n):
a, b = 1, 1
result = []
for _ in range(n):
result.append(a)
a, b = b, a + b
return result
# 方法2：使用生成器
def first_n_fib_gen(n):
fib = fib_generator()
return [next(fib) for _ in range(n)]
# 方法3：使用递归（效率较低）
def first_n_fib_rec(n):
if n == 1:
return [1]
if n == 2:
return [1, 1]
prev = first_n_fib_rec(n-1)
return prev + [prev[-1] + prev[-2]]
5.2 检查一个数是否为斐波那契数
有时候我们需要判断一个给定的数是否属于斐波那契数列。一个高效的方法是：
python复制import math
def is_fibonacci(num):
# 一个数是斐波那契数当且仅当5*n^2+4或5*n^2-4是完全平方数
val = 5 * num * num
return math.isqrt(val + 4)**2 == val + 4 or math.isqrt(val - 4)**2 == val - 4
这个方法基于斐波那契数的数学性质，避免了生成整个数列，效率很高。
5.3 斐波那契数列的可视化
使用matplotlib可以直观地展示斐波那契数列的增长规律：
python复制import matplotlib.pyplot as plt
def plot_fibonacci(n):
fibs = first_n_fib(n)
plt.figure(figsize=(10, 6))
plt.plot(range(1, n+1), fibs, 'bo-')
plt.xlabel('Index')
plt.ylabel('Fibonacci Number')
plt.title(f'First {n} Fibonacci Numbers')
plt.grid(True)
plt.show()
plot_fibonacci(20)
这个可视化可以清楚地展示斐波那契数列的指数增长特性。
5.4 斐波那契数列在算法题中的应用
斐波那契数列经常出现在编程面试题中，常见的变体包括：
- 爬楼梯问题（每次可以爬1或2阶，问有多少种方法爬到第n阶）
- 瓷砖铺放问题（用1×1和2×1的瓷砖铺2×n的地板有多少种方法）
- 青蛙跳问题（青蛙每次可以跳1或2步，问跳到第n步有多少种跳法）
这些问题的解法本质上都是斐波那契数列的应用。例如，爬楼梯问题的解就是：
python复制def climb_stairs(n):
if n == 1:
return 1
a, b = 1, 2
for _ in range(n-2):
a, b = b, a + b
return b
6. Python环境配置与开发工具建议
6.1 Python版本选择
斐波那契数列的实现与Python版本关系不大，但建议使用Python 3.8+以获得最佳性能和新特性支持。可以使用以下命令检查Python版本：
bash复制python --version
6.2 开发环境配置
对于Python开发，推荐以下工具组合：
- 代码编辑器：VS Code + Python扩展
- IDE：PyCharm（专业版功能更强大）
- Jupyter Notebook（适合交互式探索）
在VS Code中配置Python环境的步骤：
- 安装Python扩展
- 创建或打开一个Python文件
- 选择Python解释器（Ctrl+Shift+P，然后输入"Python: Select Interpreter"）
- 安装必要的依赖（如matplotlib用于可视化）
6.3 性能分析工具
当优化斐波那契数列的实现时，可以使用Python内置的cProfile模块进行性能分析：
python复制import cProfile
cProfile.run('fib_iterative(100000)')
cProfile.run('fib_matrix(100000)')
这可以帮助我们识别性能瓶颈，比较不同算法的实际表现。
6.4 单元测试
为斐波那契函数编写单元测试是个好习惯：
python复制import unittest
class TestFibonacci(unittest.TestCase):
def test_fib(self):
self.assertEqual(fib_iterative(1), 1)
self.assertEqual(fib_iterative(2), 1)
self.assertEqual(fib_iterative(5), 5)
self.assertEqual(fib_iterative(10), 55)
def test_first_n(self):
self.assertEqual(first_n_fib(5), [1, 1, 2, 3, 5])
self.assertEqual(first_n_fib(7), [1, 1, 2, 3, 5, 8, 13])
if __name__ == '__main__':
unittest.main()
良好的测试可以确保我们的实现在各种边界条件下都能正确工作。
7. 从斐波那契数列看Python编程哲学
7.1 Python之禅的体现
斐波那契数列的各种实现方式很好地体现了Python之禅中的几条原则：
- "优美胜于丑陋"：一行代码的实现虽然简洁，但可读性可能不如清晰的迭代版本
- "明了胜于晦涩"：带有明确变量名的迭代版本比复杂的lambda表达式更易于理解
- "简洁胜于复杂"：Python的高级特性让我们可以用很少的代码表达复杂逻辑
- "可读性很重要"：这是选择实现方式时的首要考虑因素
7.2 不同编程范式的展示
斐波那契数列的实现可以展示多种编程范式：
- 命令式编程（迭代版本）
- 函数式编程（reduce/lambda版本）
- 面向对象编程（可以创建一个Fibonacci类）
- 生成器（惰性求值版本）
这种多样性正是Python作为多范式语言的强大之处。
7.3 性能与可读性的权衡
斐波那契数列的各种实现让我们不得不思考性能与可读性之间的权衡。在实际项目中，除非性能是关键瓶颈，否则通常应该优先考虑代码的可读性和可维护性。Python社区有句名言："过早优化是万恶之源"。
7.4 Python特性的实际应用
通过实现斐波那契数列，我们实际应用了Python的多个重要特性：
- 递归函数
- 迭代与生成器
- 装饰器（缓存）
- lambda表达式
- 列表推导式
- 高阶函数（reduce）
这些特性的熟练掌握是成为Python高手的关键。
8. 斐波那契数列的数学深度探索
8.1 通项公式推导
斐波那契数列的通项公式可以通过求解其特征方程得到。特征方程为：
x² = x + 1
解得两个特征根：
φ = (1 + √5)/2 ≈ 1.618（黄金分割比）
ψ = (1 - √5)/2 ≈ -0.618
因此通项公式为：
F(n) = (φⁿ - ψⁿ)/√5
这个公式虽然看起来复杂，但它让我们可以在O(1)时间内（理论上）计算斐波那契数，尽管在实际编程中由于浮点数精度问题，对于大的n值可能不够精确。
8.2 斐波那契数列与黄金分割
斐波那契数列与黄金分割比φ有密切关系。随着n增大，F(n+1)/F(n)趋近于φ。这个性质在艺术、建筑和自然界中都有体现，也是斐波那契数列美学价值的重要来源。
我们可以用Python验证这个性质：
python复制def golden_ratio_convergence(n):
fibs = first_n_fib(n)
ratios = [fibs[i+1]/fibs[i] for i in range(n-1)]
return ratios
ratios = golden_ratio_convergence(30)
print(ratios[-1]) # 将非常接近1.618033988749895
8.3 斐波那契数列的矩阵表示
斐波那契数列可以用矩阵乘法表示：
[ F(n+1) F(n) ] [ 1 1 ]^n
[ F(n) F(n-1) ] = [ 1 0 ]
这个表示方法导出了我们之前提到的矩阵快速幂算法，是高效计算大斐波那契数的基础。
8.4 斐波那契数列的扩展与变种
斐波那契数列有许多有趣的变种：
- 卢卡斯数列：L(1)=1, L(2)=3, L(n)=L(n-1)+L(n-2)
- 三项递推数列：T(n)=T(n-1)+T(n-2)+T(n-3)
- 随机斐波那契数列：随机选择F(n-1)或F(n-2)相加
这些变种保持了斐波那契数列的基本特性，同时引入了新的数学性质，可以用类似的Python技术来实现和研究。
9. 斐波那契数列在实际项目中的应用案例
9.1 算法交易中的斐波那契回撤
在金融技术分析中，斐波那契回撤是一种常用的工具，用于预测价格可能的支撑位和阻力位。我们可以用Python实现基本的斐波那契回撤计算：
python复制def fibonacci_retracement(high, low):
diff = high - low
return {
'0%': high,
'23.6%': high - 0.236 * diff,
'38.2%': high - 0.382 * diff,
'50%': high - 0.5 * diff,
'61.8%': high - 0.618 * diff,
'100%': low
}
这个函数计算了关键的斐波那契回撤位，交易员常用这些水平位来制定交易策略。
9.2 图形设计中的斐波那契螺旋
斐波那契螺旋是一种美学上令人愉悦的曲线，常用于Logo设计和艺术创作。我们可以用Python的turtle模块绘制斐波那契螺旋：
python复制import turtle
import math
def draw_fibonacci_spiral(n):
# 初始化turtle
t = turtle.Turtle()
t.speed('fastest')
# 生成斐波那契数列
fibs = first_n_fib(n)
# 绘制正方形和螺旋
for i in range(1, n):
t.color('black')
t.begin_fill()
for _ in range(4):
t.forward(fibs[i])
t.left(90)
t.end_fill()
t.color('red')
t.circle(fibs[i], 90)
turtle.done()
draw_fibonacci_spiral(10)
这个程序会绘制出由斐波那契正方形组成的经典螺旋图案。
9.3 性能测试框架中的斐波那契基准
斐波那契计算常被用作编程语言和计算机的性能基准测试。我们可以设计一个简单的基准测试框架：
python复制import time
def benchmark(fib_func, sizes):
results = {}
for n in sizes:
start = time.perf_counter()
fib_func(n)
duration = time.perf_counter() - start
results[n] = duration
return results
sizes = [10, 20, 30, 40]
print("迭代版本:", benchmark(fib_iterative, sizes))
print("递归版本:", benchmark(fib_recursive, sizes))
这个框架可以用来比较不同实现、不同语言或不同硬件上的性能差异。
9.4 教育软件中的斐波那契可视化
对于教学软件，我们可以创建一个交互式的斐波那契数列展示工具：
python复制import matplotlib.pyplot as plt
from matplotlib.widgets import Slider
def interactive_fibonacci():
fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.25)
ax_slider = plt.axes([0.2, 0.1, 0.6, 0.03])
slider = Slider(ax_slider, 'n', 1, 50, valinit=10, valstep=1)
def update(val):
n = int(slider.val)
fibs = first_n_fib(n)
ax.clear()
ax.bar(range(1, n+1), fibs)
ax.set_title(f'First {n} Fibonacci Numbers')
fig.canvas.draw_idle()
slider.on_changed(update)
update(10)
plt.show()
interactive_fibonacci()
这个工具允许用户通过滑块动态调整显示的斐波那契数列长度，非常适合教学演示。
10. 从斐波那契数列看Python的优化技巧
10.1 循环展开优化
对于特别注重性能的场景，我们可以使用循环展开技术来优化迭代版本的斐波那契计算：
python复制def fib_unrolled(n):
if n == 0:
return 0
a, b = 1, 1
for _ in range(n // 2 - 1):
a = a + b
b = a + b
return b if n % 2 == 0 else a
这个版本每次迭代计算两步，减少了循环次数和条件判断，在某些情况下可以提高性能。
10.2 使用NumPy进行向量化计算
如果需要计算大量斐波那契数，可以利用NumPy的向量化运算：
python复制import numpy as np
def fib_numpy(n):
sqrt5 = np.sqrt(5)
phi = (1 + sqrt5) / 2
return np.rint((phi**np.arange(1, n+1)) / sqrt5).astype(np.uint64)
这种方法利用了NumPy的广播机制，可以一次性计算出前n个斐波那契数，对于大规模计算非常高效。
10.3 Cython加速
对于性能关键的场景，可以使用Cython将Python代码编译为C扩展：
cython复制# fib_cython.pyx
def fib_cython(int n):
cdef int i
cdef long a = 1, b = 1
for i in range(n-1):
a, b = b, a + b
return a
编译后，这个版本的性能可以接近纯C代码，特别适合计算极大的斐波那契数。
10.4 多线程并行计算
虽然斐波那契数列本质上是顺序相关的，但我们可以设计并行算法来计算多个独立的斐波那契数：
python复制from concurrent.futures import ThreadPoolExecutor
def parallel_fib(numbers):
with ThreadPoolExecutor() as executor:
results = list(executor.map(fib_iterative, numbers))
return results
# 计算第10, 20, 30, 40项
print(parallel_fib([10, 20, 30, 40]))
这种方法适合需要批量计算多个不相关的斐波那契数的场景。
11. 斐波那契数列的边界情况与错误处理
11.1 输入验证
一个健壮的斐波那契函数应该处理各种边界情况和无效输入：
python复制def robust_fib(n):
if not isinstance(n, int):
raise TypeError("Input must be an integer")
if n < 0:
raise ValueError("Input must be non-negative")
if n == 0:
return 0
return fib_iterative(n)
这个版本添加了类型检查和范围验证，可以防止常见的错误输入。
11.2 大数处理与溢出
虽然Python的整数不会溢出，但对于极大的n值（如n=1e6），计算时间可能变得不可接受。我们可以添加警告：
python复制def fib_with_warning(n, max_n=100000):
if n > max_n:
import warnings
warnings.warn(f"Calculating Fibonacci({n}) may take a long time")
return fib_iterative(n)
11.3 记忆化装饰器的内存考虑
使用lru_cache装饰器时，对于极大的n值，缓存可能消耗大量内存。我们可以限制缓存大小：
python复制from functools import lru_cache
@lru_cache(maxsize=1000)
def fib_cached_limited(n):
if n <= 2:
return 1
return fib_cached_limited(n-1) + fib_cached_limited(n-2)
这样在计算非常大的斐波那契数列时，可以避免内存耗尽的问题。
11.4 浮点数精度的处理
当使用基于黄金分割比的近似公式时，需要注意浮点数精度问题：
python复制def accurate_fib_golden(n):
if n < 0:
raise ValueError("Input must be non-negative")
if n == 0:
return 0
sqrt5 = 5**0.5
phi = (1 + sqrt5) / 2
# 使用高精度计算避免浮点误差
return int(round((phi**n - (-phi)**(-n)) / sqrt5))
这个版本改进了数值稳定性，对于中等大小的n值（n<70）可以得到准确结果。
12. 斐波那契数列的趣味扩展
12.1 斐波那契诗歌
我们可以编写一个生成斐波那契诗歌的程序，每行的音节数遵循斐波那契数列：
python复制def fibonacci_poem(words):
syllables = []
for word in words:
syllables.append(count_syllables(word))
poem = []
a, b = 1, 1
for _ in range(10): # 生成10行
line = []
current_syllables = 0
target = a
while current_syllables < target and words:
word = words.pop(0)
line.append(word)
current_syllables += count_syllables(word)
poem.append(" ".join(line))
a, b = b, a + b
return "\n".join(poem)
def count_syllables(word):
# 简化的音节计数逻辑
vowels = "aeiouy"
count = 0
prev_char_was_vowel = False
for char in word.lower():
if char in vowels and not prev_char_was_vowel:
count += 1
prev_char_was_vowel = True
else:
prev_char_was_vowel = False
return max(1, count) # 每个单词至少一个音节
12.2 斐波那契时钟
创建一个用斐波那契数列表示时间的时钟：
python复制import time
from matplotlib import pyplot as plt
def fibonacci_clock():
plt.ion()
fig, ax = plt.subplots()
squares = [1, 1, 2, 3, 5]
while True:
current_time = time.localtime()
hours = current_time.tm_hour % 12
minutes = current_time.tm_min // 5 # 每5分钟一个单位
ax.clear()
colors = []
for i in range(5):
if i < hours:
colors.append('red')
elif i < hours + minutes:
colors.append('green')
else:
colors.append('white')
for i, (size, color) in enumerate(zip(squares, colors)):
ax.add_patch(plt.Rectangle((sum(squares[:i]), 0), size, size,
color=color, ec='black'))
ax.set_xlim(0, sum(squares))
ax.set_ylim(0, squares[-1])
ax.set_aspect('equal')
ax.axis('off')
plt.draw()
plt.pause(60) # 每分钟更新一次
fibonacci_clock()
这个创意时钟使用不同颜色的斐波那契方块来表示时间，红色方块表示小时，绿色方块表示5分钟的间隔。
12.3 斐波那契音乐
我们可以将斐波那契数列转换为音乐音符：
python复制import simpleaudio as sa
import numpy as np
def fibonacci_music(n_notes):
fibs = first_n_fib(n_notes)
max_fib = max(fibs)
# 将斐波那契数映射到音符频率
notes = []
for fib in fibs:
# 映射到A4(440Hz)附近的音符
freq = 440 * (2 ** ((fib % 12 - 9) / 12))
duration = 0.3 # 每个音符0.3秒
t = np.linspace(0, duration, int(44100 * duration), False)
note = np.sin(freq * t * 2 * np.pi)
notes.append(note)
audio = np.concatenate(notes)
audio *= 32767 / np.max(np.abs(audio))
audio = audio.astype(np.int16)
play_obj = sa.play_buffer(audio, 1, 2, 44100)
play_obj.wait_done()
fibonacci_music(15)
这个程序将斐波那契数列转换为一系列音符，创建出独特的数学音乐。
12.4 斐波那契艺术
使用斐波那契数列生成艺术图案：
python复制import turtle
def fibonacci_art(n):
fibs = first_n_fib(n)
max_fib = max(fibs)
t = turtle.Turtle()
t.speed('fastest')
screen = turtle.Screen()
screen.colormode(255)
for i, fib in enumerate(fibs):
# 根据斐波那契数设置颜色
r = int((i / n) * 255)
g = int((fib / max_fib) * 255)
b = 128
t.color(r, g, b)
# 绘制正方形
for _ in range(4):
t.forward(fib * 10)
t.left(90)
# 移动到下一个位置
t.penup()
t.forward(fib * 10 / 2)
t.left(90)
t.forward(fib * 10 / 2)
t.right(90)
t.pendown()
turtle.done()
fibonacci_art(10)
这个程序会生成一个彩色的斐波那契正方形图案，每个正方形的颜色和大小都由斐波那契数列决定。