列表理解Python

Question

以下 Common Lisp 代码在 python 中的等效列表理解是什么：

(loop for x = input then (if (evenp x)
                             (/ x 2)
                             (+1 (* 3 x)))
      collect x
      until (= x 1))

Answer 1

列表理解用于获取现有序列并对其执行某些功能和/或过滤，从而生成一个新列表。 因此，在这种情况下，列表理解是不合适的，因为您没有起始序列。 一个 while 循环的例子：

numbers = []
x=input()
while x != 1:
  numbers.append(x)
  if x % 2 == 0: x /= 2
  else: x = 3 * x + 1

Answer 2

我相信你正在写冰雹序列，尽管我可能是错的，因为我不流利的 Lisp。

据我所知，您不能仅在列表理解中执行此操作，因为每个元素都依赖于最后一个元素。

我会如何做这当然

def hailstone(n):
    yield n
    while n!=1
        if n%2 == 0: # even
            n = n / 2
        else: # odd
            n = 3 * n + 1
        yield n

list = [ x for x in hailstone(input) ]

，输入将保存您的输入是什么。

我的冰雹函数可能会更简洁。 我的目标是清晰。

Answer 3

Python 没有内置这种控制结构，但您可以将其概括为如下函数：

def unfold(evolve, initial, until):
    state = initial
    yield state
    while not until(state):
        state = evolve(state)
        yield state

在这之后，您的表达式可以写为：

def is_even(n): return not n % 2
unfold(lambda x: x/2 if is_even(x) else 3*x + 1,
       initial=input, until=lambda x: x == 1)

但 Pythonic 的方法是使用生成器函数：

def produce(x):
    yield x
    while x != 1:
        x = x / 2 if is_even(x) else 3*x + 1
        yield x

Answer 4

劳伦斯提到的黑客行为：

你可以用一个列表理解来完成它，它最终会变成可怕的Python。 无法读取的Python。 可怕的蟒蛇。 我仅出于好奇而提出以下内容，而不是作为实际答案。 不要在您真正想要使用的代码中执行此操作，除非您想体验 python 的内部工作原理。

因此，有 3 种方法：

---

帮助列表 1

1：使用帮助列表，答案最终出现在帮助列表中。 这会将值附加到正在迭代的列表中，直到达到要停止的值。

A = [10]
print [None if A[-1] == 1
    else A.append(A[-1]/2) if (A[-1]%2==0) 
    else A.append(3*A[-1]+1) 
        for i in A]
print A

result:

[None, None, None, None, None, None, None]
[10, 5, 16, 8, 4, 2, 1]

---

Helping List 2

2：使用帮助列表，但结果是列表理解的输出。 这主要依赖于 list.append(...) 返回 None、not None 评估为 True 和 <出于算术目的，code>True 被视为 1。 叹。

A=[10]
print [A[0]*(not A.append(A[0])) if len(A) == 1 
    else 1 if A[-1] == 2 else (A[-1]/2)*(not A.append(A[-1]/2)) if (A[-1]%2==0) 
    else (3*A[-1]+1)*(not A.append(3*A[-1]+1)) 
        for i in A]

结果：

[10, 5, 16, 8, 4, 2, 1]

---

从 3 中引用列表推导式

：不使用帮助列表，而是在构建列表推导式时重新引用它。 这有点脆弱，可能不适用于所有环境。 如果它不起作用，请尝试单独运行代码：

from itertools import chain, takewhile
initialValue = 10
print [i if len(locals()['_[1]']) == 0
    else (locals()['_[1]'][-1]/2) if (locals()['_[1]'][-1]%2==0)
    else (3*locals()['_[1]'][-1]+1) 
        for i in takewhile(lambda x:x>1, chain([initialValue],locals()['_[1]']))]

结果：

[10, 5, 16, 8, 4, 2, 1]

---

所以，现在忘记您读过这篇文章。 这是一条漆黑、漆黑、肮脏的巨蟒。 邪恶的蟒蛇。 我们都知道蟒蛇并不邪恶。 Python 可爱又美好。 所以你不可能读过这篇文章，因为这种东西不可能存在。 好好。

Answer 5

正如 Kiv 所说，列表理解需要一个已知的序列来迭代。

话虽如此，如果您有一个序列并且专注于使用列表理解，您的解决方案可能会包含如下内容：

[not (x % 2) and (x / 2) or (3 * x + 1) for x in sequence]

Mike Cooper 的答案是一个更好的解决方案，因为它都保留了 x != 1终止，并且这一行读起来不清晰。

Answer 6

1

我发现了一个真正奇妙的证明，这个边距太窄而无法容纳。 ——费马

不过，严肃地说，我不相信你可以用 Python 列表推导式来做到这一点。 它们与地图和过滤器具有基本相同的功能，因此您无法在不诉诸黑客手段的情况下突破或查看以前的值。