Wie ist die Struktur von Python-Listenverständnissen und Generatorausdrücken?

Listenverständnisse und Generatorausdrücke

Generatorausdrücke sind eine übersichtliche Möglichkeit, Container zu generieren. Am häufigsten hört man Listenverständnis, aber es gibt auch Setverständnisse und Wörterbuchverständnisse. Der Unterschied in der Terminologie ist jedoch etwas wichtig: Wenn Sie tatsächlich eine Liste erstellen, handelt es sich lediglich um ein Listenverständnis.

Generatorausdrücke werden in Klammern ( ) eingeschlossen, während ( )，而列表解析用方括号括起来[ ]。集合解析用花括号括起来{ }。除了这些差异之外，所有三种情况的语法都是相同的！

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

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

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

生成器表达式的结构

生成器表达式（或列表/集合户外组）有点像一个被翻转的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)

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

(Zur Wörterbuchanalyse gehört noch mehr, worauf wir später noch eingehen werden.) 🎜

Generatorausdrücke vs. 🎜Generatoren 🎜Wir werden Erfahren Sie mehr darüber in den folgenden Abschnitten. Im Moment genügt es uns, einfach die offizielle Definition des Generatorausdrucks zu verwenden: 🎜

Generator expression – gibt den Ausdruck des Iterators zurück. 🎜

Struktur des Generatorausdrucks 🎜

Generatorausdruck (oder Liste/Set-Außengruppe) ist so etwas wie eine for-Schleife, die umgedreht wird. 🎜

Als einfaches Beispiel sehen wir uns ein Beispiel aus dem vorherigen Artikel an, in dem wir eine Liste von Fahrenheit-Temperaturen in Celsius umgewandelt haben. Ich würde es leicht anpassen, damit die Zahlen in einer anderen Liste gespeichert und nicht direkt gedruckt werden. 🎜

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

Ob Sie es glauben oder nicht, das Listenverständnis reduziert das gesamte Programm auf drei Zeilen! Vereinfachen wir es Schritt für Schritt, damit Sie verstehen, was ich meine. 🎜

Ersetzen wir zunächst die for-Schleife durch ein Listenverständnis... 🎜

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

Die wichtige Codezeile ist temps_c = [f_to_c(temp) für temp in temps_f] Dies verhält sich sehr ähnlich wie map(). tempFür jedes Element temps_f in der Liste wenden wir die Funktion f_to_c() an. 🎜

Wenn ich nun die Funktion f_to_c() an anderer Stelle benötige, höre ich einfach hier auf. Wenn dies jedoch der einzige Ort wäre, an dem ich eine Umrechnungslogik von Fahrenheit in Celsius benötige, könnte ich die Funktion überhaupt nicht verwenden und den Logikcode direkt in die Analyse verschieben: 🎜

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

Ich folgte Was hast du gesagt? Drei Zeilen! Sind es nicht nur drei Codezeilen? 🎜

Basierend auf den Daten, die ich habe, kann ich noch weiter reduzieren. Schauen wir uns das anhand eines anderen Beispiels an. 🎜

Stellen Sie sich vor, Sie haben ein Programm, das eine Reihe von durch Leerzeichen getrennten Ganzzahlen in einer Zeile empfängt, z. B. 5 4 1 9 5 7 5. Sie möchten die Summe aller dieser ganzen Zahlen ermitteln. (Der Einfachheit halber gehen wir davon aus, dass bei Ihnen keine Gefahr von Tippfehlern besteht.) 🎜

Beginnen wir damit, es auf offensichtliche Weise zu schreiben, 🎜ohne 🎜Listenverständnisse. 🎜

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

Natürlich, oder? Wir erhalten die Benutzereingabe als Zeichenfolge und teilen die Liste dann in Leerzeichen auf, um die einzelnen Zahlen zu erhalten. Wir erstellen eine Variable, um die Summe zu speichern, verwenden dann eine Schleife, um jeden Wert zu durchlaufen, ihn in eine Ganzzahl umzuwandeln und ihn zur Summe zu addieren. Nachdem wir nun die Codelogik haben, vereinfachen und optimieren wir sie. 🎜

Lassen Sie uns hier zunächst einige offensichtliche Codes vereinfachen. Wir haben alle diese Konzepte bereits behandelt. Sehen Sie also nach, ob Sie erkennen können, wo ich mich verbessert habe. 🎜

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

Einfacher geht es nicht, wenn wir nicht Listenverständnis verwenden, also fangen wir jetzt an! 🎜

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

Der Generatorausdruck hier ist (int(v) für v in Werten). v entspricht jedem Wert in der Liste values, den wir in eine Ganzzahl umwandeln ( int(v)). 🎜

Beachten Sie, wie ich die Funktion sum() verwende und den Generatorausdruck direkt an sie übergebe. Da der Ausdruck direkt als einziges Argument übergeben wird, benötige ich keine zusätzlichen Klammern darum. 🎜

Wenn ich jetzt keine anderen Listen values benötige, kann ich diese Logik tatsächlich direkt in den Generatorausdruck verschieben! 🎜

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)

Einfach kinderleicht, oder? 🎜

Analyse verschachtelter Listen

Wenn wir stattdessen die Nummer jeder eingegebenen Zahl haben möchten 🎜Was über die Summe der Quadrate? 🎜Eigentlich gibt es zwei Möglichkeiten, dies zu tun. So geht's ganz einfach: 🎜

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

Das funktioniert, aber irgendwie fühlt es sich einfach nicht richtig an, oder? Wir müssen 🎜 zweimal 🎜v in eine ganze Zahl umwandeln. 🎜

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

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.它们很难调试

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

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

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

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

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

Das obige ist der detaillierte Inhalt vonWie ist die Struktur von Python-Listenverständnissen und Generatorausdrücken?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!