"""
题目：斐波那契数列。
程序分析：斐波那契数列（Fibonacci sequence），又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……。
这里所有的斐波那契数列都是以0开头来算
"""
import functools
def answer1():
"""
输出100000以内斐波那契数列
:return:
"""
print("\n输出一", end=":")
a = 0
print(a, end=",")
b = 1
print(b, end=",")
c = a + b
while c < 100000:
print(c, end=",")
a = b
b = c
c = a + b
answer1()
def answer2():
"""
参考答案用到了多变量赋值
:return:
"""
print("\n输出二", end=":")
a, b = 0, 1
print(a, end=",")
while b < 100000:
print(b, end=",")
a, b = b, a + b
answer2()
def answer3(n, m):
"""
利用递归来实现
:param n:
:return:
"""
if n == 0:
print("\n输出三", end=":")
print(n, end=",")
if m < 100000:
print(m, end=",")
n, m = m, n + m
answer3(n, m)
else:
return
answer3(0, 1)
def answer4():
"""
利用代数公式计算，公式可参考example006_FormulaDerivation文件：
F(n)=（√5/5)*{[(1+√5)/2]^n - [(1-√5)/2]^n}。
:return:
"""
print("\n输出四", end=":")
i = 0
n = 0
while n < 100000:
print(int(n), end=",")
i += 1
n = (5 ** 0.5 / 5) * (((1 + 5 ** 0.5) / 2) ** i - ((1 - 5 ** 0.5) / 2) ** i)
answer4()
def answer5(n):
"""
根据输入整数n,获取前n个斐波那契数
:param n:
:return:
"""
print("\n输出五", end=":")
a = 0
print(a, end=",")
b = 1
for i in range(1, n):
print(b, end=",")
a, b = b, a + b
answer5(26)
def answer6(n):
"""
利用另一种递归来计算，注意与answer3(n, m)区分
其中用到了内嵌函数
:param n:
:return:
"""
print("\n输出六", end=":")
def getOne(index):
if index == 1:
return 0
if index == 2:
return 1
num = getOne(index - 2) + getOne(index - 1)
return num
for i in range(1, n+1):
print(getOne(i), end=",")
answer6(26)
def answer7(n):
"""
利用数组来计算
:param n:
:return:
"""
print("\n输出七", end=":")
num = [0, 1]
for i in range(2, n):
num.append(num[-1] + num[-2])
print(num)
answer7(26)
def answer8(n):
"""
利用公司算前n个
:param n:
:return:
"""
print("输出八", end=":")
for i in range(0, n):
num = (5 ** 0.5 / 5) * (((1 + 5 ** 0.5) / 2) ** i - ((1 - 5 ** 0.5) / 2) ** i)
print(int(num), end=",")
answer8(26)
def answer9(n):
"""
多变量赋值，获取前n个斐波那契数列
:param n:
:return:
"""
print("\n输出九", end=":")
a, b = 0, 1
while n:
print(a, end=",")
a, b, n = b, a + b, n - 1
answer9(26)
@functools.lru_cache(None)
def answer10(n):
"""
在 Python 的 3.2 版本中，引入了一个非常优雅的缓存机器，即 functool 模块中的 lru_cache 装饰器。如果要在 python2 中使用 lru_cahce 需要安装 functools32。lru_cache 原型如下：
@functools.lru_cache(maxsize=None, typed=False)
使用functools模块的lur_cache装饰器，可以缓存最多 maxsize 个此函数的调用结果，从而提高程序执行的效率，特别适合于耗时的函数。参数maxsize为最多缓存的次数，如果为None，则无限制，设置为2n时，性能最佳；如果 typed=True（注意，在 functools32 中没有此参数），则不同参数类型的调用将分别缓存，例如 f(3) 和 f(3.0)。
被 lru_cache 装饰的函数会有 cache_clear 和 cache_info 两个方法，分别用于清除缓存和查看缓存信息。
这里用一个简单的示例演示 lru_cache 效果：
from functools import lru_cache
@lru_cache(None)
def add(x, y):
print("calculating: %s + %s" % (x, y))
return x + y
print(add(1, 2))
print(add(1, 2))
print(add(2, 3))
输出结果：
calculating: 1 + 2
3
3
calculating: 2 + 3
5
从结果可以看出，当第二次调用 add(1, 2) 时，并没有真正执行函数体，而是直接返回缓存的结果。
有一个用 C 实现的，更快的，同时兼容 Python2 和 Python3 的第三方模块 fastcache 能够实现同样的功能。
:param n:
:return:
"""
if n == 1:
print("\n输出十", end=":")
assert n >= 1
m = 0 if n == 1 else answer10(1)+1 if n == 2 else answer10(n - 2) + answer10(n - 1)
print(m, end=",")
return m
answer10(26)
def answer11(n):
"""
reduce练习
:return:
"""
print("\n输出十一", end=":")
num = [0, 1]
for i in range(2, n):
num.append(functools.reduce(lambda x, y: x + y, num[-1: -3: -1]))
print(num)
answer11(26)
def answer12(n):
"""
练习sum 和列表切片
:param n:
:return:
"""
print("输出十二", end=":")
num = [0, 1]
for i in range(2, n):
num.append(sum(num[i-2: i]))
print(num)
answer12(26)
class Fibs:
"""
练习类，创建一个迭代器
"""
def __init__(self, n):
self.a = 0
self.b = 1
self.n = n
self.i = 1
print("输出十三", end=":")
def __iter__(self):
return self
def __next__(self):
if self.i > self.n:
raise StopIteration
print(self.a, end=",")
self.a, self.b = self.b, self.a + self.b
self.i += 1
f = Fibs(26)
for i in f:
pass