如何使用列表推导创建斐波那契数列？

Question

我是 python 新手，我想知道是否可以使用 python 的列表理解功能生成斐波那契数列。我不知道列表推导是如何实现的。 我尝试了以下方法（目的是生成前五个斐波那契数）：

series=[]
series.append(1)
series.append(1)
series += [series[k-1]+series[k-2] for k in range(2,5)]

这段代码抛出错误：IndexError: list index out of range。

让我知道是否甚至可以使用列表推导生成这样的系列。

Answer 1

你不能那样做：列表推导首先被求值，然后该列表被添加到series。所以基本上它就像你会写的那样：

series=[]
series.append(1)
series.append(1)
temp = [series[k-1]+series[k-2] for k in range(2,5)]
series += temp

不过，您可以通过使用 list comprehension 作为一种强制副作用 来解决这个问题，例如：

series=[]
series.append(1)
series.append(1)
[series.append(series[k-1]+series[k-2]) for k in range(2,5)]

请注意，我们这里不要将结果添加到系列中。列表推导仅用于在 series 上调用 .append。然而，有些人认为具有副作用的列表推导很容易出错：它的声明性不是很强，如果不仔细处理，往往会引入错误。

Answer 2

以 Willem van Onsem 所说的话为基础：

如您所知，计算斐波那契数列第 n 项的传统方法是将 n-1 和 n-2 项相加。列表推导旨在创建一个在推导期间没有副作用的列表（除了创建单个列表）。在计算序列期间存储序列的最后 2 项是一种副作用，因此列表推导本身不适合该任务。

解决这个问题的一种安全方法是创建一个闭包生成器（本质上是一个具有一些相关私有状态的生成器），它可以传递给列表推导式，这样列表推导式就不必担心存储内容的细节：

def fib_generator(n):

    def fib_n_generator():
        last = 1
        curr = 1

        if n == 0:
            return

        yield last
        if n == 1:
            return

        yield curr
        if n == 2:
            return

        ii = 2
        while ii < n:
            next = curr + last
            yield next
            last = curr
            curr = next
            ii += 1

    return fib_n_generator()

fib = [xx for xx in fib_generator(10)]
print(fib)

Answer 3

如果您知道需要多少个系列术语，那么您可以紧凑地编写代码，而无需像这样的列表理解。

def Fibonacci(n):
    f0, f1 = 1, 1
    for _ in range(n):
        yield f0
        f0, f1 = f1, f0+f1

fibs = list(Fibonacci(10))
print (fibs)

如果你想要一些不定数量的术语，那么你可以使用这个，它非常相似。

def Fibonacci():
    f0, f1 = 1, 1
    while True:
        yield f0
        f0, f1 = f1, f0+f1

fibs = []
for f in Fibonacci():
    fibs.append(f)
    if f>100:
        break
print (fibs)

当您需要一个可能无限的项目集合时，您或许应该考虑使用带有一个或多个 yield 语句的 function 或生成器表达式。我希望能够使用生成器表达式制作斐波那契数，但显然不能。

Answer 4

我们可以使用它与黄金比例的关系将它写成一个干净的 Python 列表理解（或生成器）：

>>> series = [int((((1 + 5**0.5) / 2)**n - ((1 - 5**0.5) / 2)**n) / 5**0.5) for n in range(1, 21)]
>>> series
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
>>> 

或者更好一点：

>>> square_root_of_five = 5**0.5
>>> Phi = (1 + square_root_of_five) / 2
>>> phi = (1 - square_root_of_five) / 2
>>> 
>>> series = [int((Phi**n - phi**n) / square_root_of_five) for n in range(1, 21)]
>>> series
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

Answer 5

使用列表理解：

n = int(input())
fibonacci_list = [0,1]
[fibonacci_list.append(fibonacci_list[k-1]+fibonacci_list[k-2]) for k in range(2,n)]

if n<=0:
   print('+ve numbers only')
elif n == 1:
   fibonacci_list = [fibonacci_list[0]]
   print(fibonacci_list)
else:
   print(fibonacci_list)

也许这是解决这个问题的可行方案……

Answer 6

使用赋值表达式（python >= 3.8）：

s = [0, 1]
s += [(s := [s[1], s[0] + s[1]]) and s[1] for k in range(10)]

print (s)
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Answer 7

斐波那契数列的列表理解，基于显式公式1：

[int((0.5+5**0.5/2)**n/5**0.5+0.5) for n in range(21)]

Answer 8

这是一个单行列表理解解决方案，它避免了嵌套 ternary operators 和 walrus operator 的单独初始化步骤（因此需要 Python 3.8），并且还避免了 explicit form 可以给出的快速发生的溢出问题你（带有**n 组件）：

[
    0 if not i else
        (x := [0, 1]) and 1 if i == 1 else
            not x.append(x[-2] + x[-1]) and x[-1]
    for i in range(10)
]

给予：

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

这比 explicit form 生成最多 N 的所有值要快。但是，如果您不想要所有值，那么显式形式可能会快得多，但它确实会遭受溢出一些 N 在 1000 到 2000 之间：

n = 2000
int((((1 + 5**0.5) / 2)**n - ((1 - 5**0.5) / 2)**n) / 5**0.5)

给我：

OverflowError: (34, 'Numerical result out of range')

而“添加最后两个值”的方法可以为较大的 N 生成更高的值。在我的机器上，我可以继续运行直到内存不足之前的 300000 到 400000 之间的某个 N。

感谢乔纳森·格雷戈里（Jonathan Gregory）带领我走上这条路。

Answer 9

来自 Christian Mayer 的 Python One-Liners。

n = 10
x = [0,1]
fibs = x[0:2] + [x.append(x[-1] + x[-2]) or x[-1] for i in range(n-2)]
print(fibs)
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

答案是您可以在没有赋值运算符的情况下使用列表推导来做到这一点（即使在 Python 2 中也可以使用）。

Answer 10

我是这样做的：

def Phi(number:int):
n = [1,1]
[n.append(n[i-2]+n[i-1])for i in range(2,number)]
return n