Python 목록 이해 및 생성기 표현식의 구조는 무엇입니까?

List comprehension 및 Generator 표현식

Generator 표현식은 컨테이너를 생성하는 간결한 방법입니다. 가장 일반적으로 list comprehension을 듣게 되지만 set comprehension과 dictionary comprehension도 있습니다. 용어의 차이는 다소 중요합니다. 실제로 목록을 만드는 경우 이는 단지 목록 이해에 불과합니다.

생성기 표현식은 괄호 ( )로 묶이고 ( )，而列表解析用方括号括起来[ ]。集合解析用花括号括起来{ }。除了这些差异之外，所有三种情况的语法都是相同的！

（字典解析还有更多内容，我们稍后会讨论。）

生成器表达式与生成器有关，我们将在后面的部分深入探讨。现在，我们只要使用生成器表达式的官方定义就足够了：

生成器表达式 - 返回迭代器的表达式。

生成器表达式的结构

生成器表达式（或列表/集合户外组）有点像一个被翻转的for循环。

举一个简单的例子，让我们回顾上一篇文章中的一个例子，我们将华氏温度列表转换为摄氏温度。我会稍微调整一下，所以数字将存储在另一个列表中，而不是直接打印。

temps_f = [67.0, 72.5, 71.3, 78.4, 62.1, 80.6]
temps_c = []

def f_to_c(temp):
    return round((temp - 32) / 1.8, 1)

for c in map(f_to_c, temps_f):
    temps_c.append(c)

print(temps_c)

信不信由你，列表解析将使整个程序减少到三行！我们一次简化为一部分，好让你可以理解我的意思。

让我们从用列表解析替换 for 循环开始......

temps_f = [67.0, 72.5, 71.3, 78.4, 62.1, 80.6]

def f_to_c(temp):
    return round((temp - 32) / 1.8, 1)

temps_c = [f_to_c(temp) for temp in temps_f]

print(temps_c)

重要的代码行是temps_c = [f_to_c(temp) for temp in temps_f]. 这表现得非常像map()。temp对于列表中的每个元素temps_f，我们应用该函数f_to_c()。

现在，如果我在其他地方需要f_to_c()函数，我就停在这里结束了。但是，如果这是我需要华氏到摄氏度转换逻辑的唯一地方，我可以完全不使用该函数，并将逻辑代码直接移动到解析中：

temps_f = [67.0, 72.5, 71.3, 78.4, 62.1, 80.6]
temps_c = [round((temp-32) / 1.8, 1) for temp in temps_f]
print(temps_c)

我跟你说了什么？三行！是不是只有三行代码！

根据我获得的数据，我甚至可以进一步减少。让我们用另一个例子来看看这个。

想象一下，你有一个程序在一行上接收一堆整数，用空格分隔，例如5 4 1 9 5 7 5。 你想找到所有这些整数的总和。（为简单起见，假设你没有输入错误的风险。）

让我们先以一种显而易见的方式编写它，而无需列表解析。

user_input = input()
values = user_input.split(' ')

total = 0

for v in values:
    n = int(v)
    total += n

print(total)

很明显，对吧？我们将用户输入作为字符串获取，然后将该字符串以空格拆分列表以获取各个数字。我们创建一个变量来存储总数，然后使用循环遍历每个值，将其转换为整数，然后将其添加到总数中。现在我们有了代码逻辑，让我们对其进行简化和优化。

让我们首先在这里简化一些显而易见的代码。我们之前已经介绍了所有这些概念，所以看看你是否能发现我改进的地方。

values = input().split(' ')
total = 0

for v in values:
    total += int(v)

print(total)

除非我们使用列表解析，否则我们不能比这更简单，所以现在就开始吧！

values = input().split(' ')
total = sum(int(v) for v in values)
print(total)

这里的生成器表达式是(int(v) for v in values)。v对应列表中的每个值values，我们将其转换为整数 ( int(v))。

请注意我是如何使用该sum()函数的，将生成器表达式直接传递给它。由于表达式直接作为唯一参数传递，因此我不需要在它周围加上额外的括号。

现在，如果我不需要values其他任何列表，我实际上可以将该逻辑直接移动到生成器表达式中！

total = sum(int(v) for v in input().split(' '))
print(total)

像做馅饼一样容易，对吧？

嵌套列表解析

如果相反，我们想要输入的每个数字的平方和呢？事实上，有两种方法可以做到这一点。简单做法是这样：

total = sum(int(v)**int(v) for v in input().split(' '))
print(total)

这行得通，但不知何故，它只是感觉不对，不是吗？我们要转换两次vlist comprehensions

은 대괄호 [ ]로 묶습니다. 🎜파싱 설정🎜중괄호 { }로 묶입니다. 이러한 차이점을 제외하면 세 가지 경우 모두 구문이 동일합니다! 🎜

(사전 구문 분석에는 더 많은 내용이 있으며 이에 대해서는 나중에 논의하겠습니다.) 🎜

생성기 표현식과 🎜Generator 🎜우리는 다음 섹션에서 이에 대해 자세히 살펴보세요. 지금은 생성기 표현식의 공식 정의를 사용하는 것으로 충분합니다. 🎜

생성기 표현식 - 반복기의 표현식을 반환합니다. 🎜

생성기 표현식의 구조 🎜

생성기 표현식(또는 목록/설정 야외 그룹)은 다음과 같습니다. 뒤집힌 for 루프와 비슷합니다. 🎜

간단한 예로 화씨 온도 목록을 섭씨로 변환한 이전 기사의 예를 검토해 보겠습니다. 숫자가 직접 인쇄되지 않고 다른 목록에 저장되도록 약간 조정하겠습니다. 🎜

total = sum(n**2 for n in [int(v) for v in input().split(' ')])

믿거나 말거나, 목록 이해는 전체 프로그램을 세 줄로 줄입니다! 무슨 뜻인지 이해할 수 있도록 한 번에 한 부분씩 단순화해 보겠습니다. 🎜

for 루프를 목록 이해로 바꾸는 것부터 시작하겠습니다... 🎜

the_list = [int(v) for v in input().split(' ')]
total = sum(n**2 for n in the_list)
print(total)

중요한 코드 줄은 입니다. temps_c = [temps_f의 임시에 대한 f_to_c(temp)] 이는 map()과 매우 유사하게 동작합니다. temp목록의 각 요소 temps_f에 대해 f_to_c() 함수를 적용합니다. 🎜

이제 f_to_c() 함수가 다른 곳에서 필요하면 여기서 멈추면 됩니다. 그러나 이것이 화씨에서 섭씨로의 변환 논리가 필요한 유일한 장소라면 함수를 전혀 사용할 수 없었고 논리 코드를 구문 분석으로 직접 이동할 수 없었습니다. 🎜

the_list = [int(v) for v in input().split(' ')]
total = sum(n**2 for n in the_list if n%2==0)
print(total)

나는 따랐습니다. 뭐라고 하셨나요? 세 줄! 코드가 세줄밖에 없나요? 🎜

내가 가지고 있는 데이터를 바탕으로 더 줄일 수 있어요. 다른 예를 통해 이를 살펴보겠습니다. 🎜

5 4 1 9 5 7 5와 같이 공백으로 구분된 한 줄의 정수 묶음을 받는 프로그램이 있다고 상상해 보세요. 이 모든 정수의 합을 구하고 싶습니다. (단순화를 위해 입력 오류의 위험이 없다고 가정합니다.) 🎜

목록 이해 없이 🎜명확한 방식으로 작성하는 것부터 시작하겠습니다. 🎜

output = []
for n in the_list:
    if n%2==0:
        output.append(n**2)

당연하죠? 사용자 입력을 문자열로 얻은 다음 목록을 공백으로 분할하여 개별 숫자를 얻습니다. 합계를 저장하는 변수를 만든 다음 루프를 사용하여 각 값을 살펴보고 정수로 변환한 다음 합계에 추가합니다. 이제 코드 로직이 있으므로 이를 단순화하고 최적화해 보겠습니다. 🎜

먼저 여기서 몇 가지 명백한 코드를 단순화해 보겠습니다. 우리는 이전에 이러한 개념을 모두 다루었으므로 내가 개선한 부분을 발견할 수 있는지 확인하십시오. 🎜

n**2
for n in the_list:
    if n%2==0:

리스트 컴프리헨션을 사용하지 않는 이상 이보다 더 간단할 수 없으니 지금 시작해 보세요! 🎜

n**2 for n in the_list if n%2==0

여기서 생성기 표현식은 (값의 v에 대한 int(v))입니다. v는 값 목록의 각 값에 해당하며 이를 정수( int(v))로 변환합니다. 🎜

sum() 함수를 사용하여 생성기 표현식을 직접 전달하는 방법을 참고하세요. 표현식이 유일한 인수로 직접 전달되므로 주위에 추가 괄호가 필요하지 않습니다. 🎜

이제 다른 목록이 값 필요하지 않으면 실제로 해당 논리를 생성기 표현식으로 직접 이동할 수 있습니다! 🎜

num_a = [1, 2, 3, 4, 5]
num_b = [6, 7, 8, 9, 10]
output = []

for a in num_a:
    for b in num_b:
        output.append(a*b)

파이처럼 쉽죠? 🎜

중첩 목록 구문 분석

대신에 입력된 각 숫자의 숫자를 원하는 경우 🎜What 제곱합에 대해서요? 🎜실제로는 두 가지 방법이 있습니다. 간단히 수행하는 방법은 다음과 같습니다. 🎜

a*b
for a in num_a:
    for b in num_b:

이 방법은 효과가 있지만 어쩐지 옳지 않은 것 같죠? 🎜 두 번 🎜v을 정수로 변환해야 합니다. 🎜

我们可以通过将列表解析嵌套到我们的生成器表达式中来解决这个问题！

total = sum(n**2 for n in [int(v) for v in input().split(' ')])

列表解析和生成器表达式从内部到外部进行解析。最里面的表达式 ,int(v) for v in input().split(' ')首先运行，并且封闭的方括号[ ]将其转换为列表（可迭代）。

接下来，n**2 for n in [LIST]运行外部表达式，[LIST]就是我们刚才生成的列表。

这种嵌套不是很容易理解，也不直观。尽量少用它。当我需要嵌套时，我将每个列表理解写在单独的行上并将其存储...

the_list = [int(v) for v in input().split(' ')]
total = sum(n**2 for n in the_list)
print(total)

...测试一下，然后通过复制和粘贴开始嵌套。

生成器表达式中的条件

如果我们只想要列表中奇数的总和怎么办？生成器表达式和列表解析也可以做到这一点。

我们将在此示例中使用嵌套，但我们将首先从非嵌套版本开始，为了使新逻辑更易于查看。

the_list = [int(v) for v in input().split(' ')]
total = sum(n**2 for n in the_list if n%2==0)
print(total)

新部分在第二行。在生成器表达式的末尾，我添加了if n%2==0. 你可能认识模运算符 ( %)，它为我们提供了除法的余数。任何偶数都可以被2整除，这意味着它没有余数。因此，n%2==0仅适用于偶数。

将条件放在语句之后而不是之前，感觉有点奇怪。理解它的最简单方法是和没有生成器表达式的相同代码逻辑做对比......

output = []
for n in the_list:
    if n%2==0:
        output.append(n**2)

基本上，要将其转换为生成器表达式，你只需知道append()，从这儿开始......

n**2
for n in the_list:
    if n%2==0:

然后从for和if语句中删除冒号 ( :)、换行符缩进...

n**2 for n in the_list if n%2==0

多个迭代对象

我们还可以使用生成器表达式和列表解析一次循环遍历多个可迭代对象，其方式与嵌套循环相同。

考虑以下逻辑：

num_a = [1, 2, 3, 4, 5]
num_b = [6, 7, 8, 9, 10]
output = []

for a in num_a:
    for b in num_b:
        output.append(a*b)

我们也可以按照我刚才给出的相同步骤将其转换为列表解析！我们把append()的参数放在前面...

a*b
for a in num_a:
    for b in num_b:

...然后我们将其余部分折叠成一行，删除冒号。

a*b for a in num_a for b in num_b

最后，将其包裹在方括号中，并将其复制给变量output输出。

output = [a*b for a in num_a for b in num_b]

集合解析

正如我在文章开头提到的，就像你可以使用包含在方括号[ ]中的生成器表达式来创建列表一样，你也可以使用花括号{ }来创建集合。

例如，让我们生成通过100 除以小于 100 的奇数得到的所有余数组成的集合。通过使用集合，我们确保没有重复项，使结果更容易理解。

odd_remainders = {100%n for n in range(1,100,2)}
print(odd_remainders)

运行该代码给我们...

{0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 25, 26, 27, 29, 30, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49}

这里真的没有什么特别的地方。集合解析的工作方式与列表解析相同，只是创建了不同的容器。

字典解析

字典解析遵循与其他形式的生成器表达式几乎相同的结构，但有一个区别：冒号。

如果你还记得，当你创建集合或字典时，你使用花括号{ }。唯一的区别是，在字典中，你使用冒号:来分隔键值对，这是在集合中不会执行的操作。同样的原则在这里也适用。

例如，如果我们想创建一个字典，将 1 到 100 之间的整数存储为键，并将该数字的平方作为值...

squares = {n : n**2 for n in range(1,101)}
print(squares)

这就是字典解析！除了冒号之外:，其他所有内容都与任何其他生成器表达式相同。

风险

对所有情况都使用列表解析或生成器表达式可能非常诱人。它们相当容易上瘾，部分原因是写出来时看起来非常高端优雅。强大的单行代码让程序员非常兴奋——我们真的很喜欢优雅地地处理我们的代码。

但是，我必须提醒你不要过分追求优雅。记住The Zend Of Python，这里有一些与此主题相关的部分：

美丽总比丑陋好。
...
简单胜于复杂。
复杂胜于复杂。
平面优于嵌套。
稀疏比密集好。
可读性很重要。
...

列表解析可能很优雅，但如果使用不当，它们也可能成为密集的、垃圾的逻辑片段。

1.代码变得难以阅读

我从互联网上的一项调查中借用了这个例子

primary = [ c for m in status['members'] if m['stateStr'] == 'PRIMARY' for c in rs_config['members'] if m['name'] == c['host'] ]
secondary = [ c for m in status['members'] if m['stateStr'] == 'SECONDARY' for c in rs_config['members'] if m['name'] == c['host'] ]
hidden = [ m for m in rs_config['members'] if m['hidden'] ]

你能说出这段代码的意思？如果你阅读一会，你可能可以，但你为什么要阅读？代码一清二楚。（在调查中，这被评为最不可读的示例。）当然，你可以添加注释来解释正在执行的逻辑 - 事实上，他们在原始示例中做了 - 但任何时候你需要注释来解释代码正在做什么，这几乎可以肯定太复杂了。

列表解析和生成器表达式固然很强大，但如果大量使用会像刚刚那样变得难以阅读。

不一定非得像刚刚那样做。只需将列表理解拆分为多行，你就可以重新获得很多可读性，其结构与传统循环类似。

primary = [
    c
    for m in status['members']
        if m['stateStr'] == 'PRIMARY'
    for c in rs_config['members']
        if m['name'] == c['host']
    ]

secondary = [
    c
    for m in status['members']
        if m['stateStr'] == 'SECONDARY'
    for c in rs_config['members']
        if m['name'] == c['host']
    ]

hidden = [
    m
    for m in rs_config['members']
        if m['hidden']
    ]

请注意，这并不能完全证明上述说法是正确的。我仍然会使用传统的循环而不是前面的示例，只是因为它们更易于阅读和维护。

如果你仍然不相信这是 Python 的一个容易被滥用的特性？我的有一个朋友分享他遇到的这个真实案例。我们根本不知道它做了什么。

cropids = [self.roidb[inds[i]]['chip_order'][
               self.crop_idx[inds[i]] % len(self.roidb[inds[i]]['chip_order'])] for i in
           range(cur_from, cur_to)]

光是看着，我的可能都会有点烦躁了。

2.它们不会替换循环

看看以下情况。（此代码是虚构的，仅供参考。）

some_list = getTheDataFromWhereever()
[API.download().process(foo) for foo in some_list]

对于未经训练的人来说，这看起来没啥问题，但请注意请仔细看砍......数据<strong>some_list</strong>正在被直接修改（变异），但结果没有被存储。这是列表解析甚至生成器表达式被滥用来代替循环的情况。它使阅读变得困难，更不用说调试了。

无论你想使用生成器表达式来变得优雅，这都是你应该坚持使用循环的一种情况：

some_list = getTheDataFromWhereever()
for foo in some_list:
    API.download().process(foo)

3.它们很难调试

想一想列表解析的本质：你将所有内容打包成一个巨大的语句。这样做的好处是你消除了一堆中间步骤。缺点也是……你消除了一堆中间步骤。

考虑调试一个典型的循环。你可以单步执行它，一次迭代，使用调试器随时观察每个变量的状态。你还可以使用错误处理来处理异常的边缘情况。

相比之下，这些都不适用于生成器表达式或列表解析。一切要么有效，要么无效！你可以尝试解析错误和输出以找出你做错了什么，但我可以向你保证，这是一种令人困惑的体验。

你可以通过避免在你的第一个代码版本中使用列表解析来避免这种疯狂！使用传统的循环和迭代器工具以显而易见的方式编写逻辑。一旦你知道它有效，那么并且只有在那时你才应该将逻辑折叠到生成器表达式中，并且只有在你可以这样做而不避免错误处理的情况下。

这听起来像是很多额外的工作，但我在平常的代码编写中中遵循了这个确切的模式。我对生成器表达式的理解通常是我对抗经验不足的竞争对手的主要优势，但我总是先编写标准循环：我不能把浪费时间在调试生成器表达式中错误逻辑上。

위 내용은 Python 목록 이해 및 생성기 표현식의 구조는 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!