Python理解力是什么？为什么要使用它们？

Python程序员小泉

已于 2024-01-05 18:56:27 修改

阅读量1.1k

点赞数 7

分类专栏： python 程序员 python是什么文章标签： python 开发语言后端 Python入门 Python爬虫

于 2022-02-07 10:34:07 首次发布

本文链接：https://blog.csdn.net/m0_59162248/article/details/122805254

版权

python 同时被 3 个专栏收录

753 篇文章 64 订阅

订阅专栏

程序员

216 篇文章 2 订阅

订阅专栏

python是什么

17 篇文章 0 订阅

订阅专栏

本文探讨了Python中的四种理解式：列表理解、字典理解、集合理解和生成器理解，强调了它们在提高代码可读性和效率方面的优势。列表理解是最常见的一种，可用于创建新序列。字典理解则用于根据迭代器创建键值对。集合理解与列表理解类似，但元素不重复。生成器理解则返回一个迭代器，允许逐步遍历结果。然而，过度使用或嵌套理解式可能降低代码可读性。正确使用理解式能够提升Python代码的简洁性和效率。

摘要由CSDN通过智能技术生成

作为语言中最具代表性的_Pythonic_语法之一，我相信每个人都听说过或已经使用过列表理解法。

但是你知道吗，在这门语言中还有三种类型的理解式？

在这篇文章中，我将讨论什么是_Python_中的理解式，以及为什么要使用它们。我还将讨论什么情况下使用理解式会对代码的可读性产生不利影响。

什么是 Python 中的理解力？

从本质上讲，_Python_中的理解力是一种语法，用于通过对另一个迭代对象进行操作来创建一个新的序列。

在_Python_中有四种类型的理解力。

列表理解
Dict 汇编
集合理解法
生成器理解

大多数初学者对理解力有一个常见的误解，那就是初始迭代对象需要和理解力的类型相同。然而，情况并非如此，例如，如果你正在使用一个_dict编译器_，那么初始迭代器也可以是一个列表。

名称中提到的类型是指从理解力中返回的序列的类型。

为什么要在 Python 中使用理解力？

我们在代码中使用理解力，因为使用它更具有_Python 的_特点，也更具有可读性。然而，在某些情况下使用它们时需要小心，因为有些时候它们会产生相反的效果。

列表理解

列表_理解是_Python 中最常见的理解类型，它遵循简单的语法。

# Not using conditional in list comprehension.
[<expression> for <variable> in <iterable>]

# Using standard condition in list comprehension.
[<expression> for <variable> in <iterable> if <condition>]

# Using if and else in a list comprehension.
[<expression>  if <condition> else <expression> for <variable> in <iterable>]

正如我们在这里看到的，条件是完全可选的，但是如果你使用它，取决于你是否使用_else_子句，它在_列表_理解中的位置将发生变化。

我们还可以看到，它们非常容易使用，在减少for循环的使用方面相当方便，使代码更加简洁。

掌握它的最好方法是自己玩玩它们，了解它们的限制。下面是一个真实的使用例子，给你一个概念。

original_list = ["hello", "and", "welcome", "to", "list", "comprehensions"]

# Not using conditional in list comprehension.
new_list = [item.capitalize() for item in original_list]
print(new_list)
# ['Hello', 'And', 'Welcome', 'To', 'List', 'Comprehensions']

# Using standard condition in list comprehension.
new_list = [item.capitalize() for item in original_list if item not in ["and", "to"]]
print(new_list)
# ['Hello', 'Welcome', 'List', 'Comprehensions']

# Using if and else in a list comprehension.
new_list = [item.capitalize() if item not in ["and", "to"] else item for item in original_list]
print(new_list)
# ['Hello', 'and', 'Welcome', 'to', 'List', 'Comprehensions']

Dict理解

正如我前面提到的，理解力名称中提到的_类型_是指它所创建的序列的类型，而不是理解力中使用的迭代器的类型。

head -n 10 us.txtThe syntax for a dictionary comprehension is:

new_dictionary = {<key>:<value> for <item> in <iterable> if <condition>}

再说一次，这里的条件是可选的。

你可以在许多不同的场景中使用它，例如，设想你希望能够根据员工在公司中的职位来比较所获得的工资，而你有一长串的字典，包含了每个员工的各种信息。

事实上，你也许可以用它来工作，但如果你只关心职位和工资，那么有很多信息是不需要的，因此我们可以用字典理解法来轻松地创建一个只包含我们想要的信息的新字典。

employee_list = [
    {
        'name': 'Peter',
        'surname': 'Pan',
        'position': 'Full-stack Developer',
        'salary': 60000
    },
    {
        'name': 'Molly',
        'surname': 'Weasley',
        'position': 'Front-End Developer',
        'salary': 50000
    },
    {
        'name': 'Harry',
        'surname': 'Potter',
        'position': 'Data Scientist',
        'salary': 55000
    },
    {
        'name': 'Hermione',
        'surname': 'Granger',
        'position': 'Data Engineer',
        'salary': 50000
    },
    {
        'name': 'Ronald',
        'surname': 'Weasley',
        'position': 'Junior Developer',
        'salary': 40000
    }
]

# Dict Comprehension without condition.

position_dict = {position['position']: position['salary'] for position in employee_list}
print(position_dict)
# {'Full-stack Developer': 60000, 'Front-End Developer': 50000, 'Data Scientist': 55000, 'Data Engineer': 50000, 'Junior Developer': 40000}

# Dict Comprehension with condition.

position_dict = {position['position']: position['salary'] for position in employee_list if "Developer" in position['position']}
print(position_dict)
# {'Full-stack Developer': 60000, 'Front-End Developer': 50000, 'Junior Developer': 40000}

正如你在上面所看到的，我们可以用一个字典的理解力在一行中非常容易和干净地实现这个目标*。*

集合理解

_集合_理解的功能与_列表_理解类似，只是它具有集合的所有优点，即集合中的项目不能重复，而且数值不按顺序排列。

除了使用大括号而不是方括号外，它还使用了与_列表_理解类似的语法。

# Not using conditional in set comprehension.
{<expression> for <variable> in <iterable>}

# Using standard condition in set comprehension.
{<expression> for <variable> in <iterable> if <condition>}

# Using if and else in a set comprehension.
{<expression>  if <condition> else <expression> for <variable> in <iterable>}

在有些时候，这可能是有用的，但是你必须记住要小心，因为如果需要对结果进行排序的话，集合的有利方面可能会导致问题，如下所示。


original_list = ["hello", "and", "welcome", "to", "set", "comprehensions", "set", "comprehensions"]

# Not using conditional in set comprehension.
new_set = {item.capitalize() for item in original_list}
print(new_set)
# {'To', 'Hello', 'Set', 'And', 'Welcome', 'Comprehensions'}

# Using standard condition in set comprehension.
new_set = {item.capitalize() for item in original_list if item not in ["and", "to"]}
print(new_set)
# {'Set', 'Comprehensions', 'Hello', 'Welcome'}

# Using if and else in a set comprehension.
new_set = {item.capitalize() if item not in ["and", "to"] else item for item in original_list}
print(new_set)
# {'Hello', 'Set', 'and', 'to', 'Welcome', 'Comprehensions'}

生成器理解法

生成器_理解是我们在_Python 中最不为人所知的理解类型。

_生成器_是一个返回对象（迭代器）的函数，我们可以逐个迭代，它是Python中一种独特的语法，通常由一个带有yield关键字的函数生成。

生成器的语法和其他所有的语法一样简单。

# Not using conditional in generator comprehension.
(<expression> for <variable> in <iterable>)

# Using standard condition in generator comprehension.
(<expression> for <variable> in <iterable> if <condition>)

# Using if and else in a generator comprehension.
(<expression>  if <condition> else <expression> for <variable> in <iterable>)

使用生成器的好处是，我们可以通过使用内置的函数**next()**来一步步地对它进行迭代。

generator = (i*2 if i%2 else i**2 for i in range(0,10))
for _ in range(10):
    print(next(generator), end=' ')
    
# 0 2 4 6 16 10 36 14 64 18

什么时候不应该使用编译器？

在阅读了这里的所有内容之后，似乎不需要考虑总是使用理解式，对吗？

其实不然。

python中的理解式可以用上述所有的方式来创建可读的代码，但是当我们使用_嵌套_的理解式时，我们需要小心，因为它可能导致代码的可读性变差。

嵌套式理解力

_嵌套_式理解是一个术语，我们用来指在其他理解中进行的理解。

虽然这是一个非常强大的功能，但它也会在可读性方面产生相反的效果。

例如，下面的两个脚本都创建了下面的金字塔。

# method 1

for row in range(0, number_of_rows):
    for _ in range(0, row + 1):
        print("#", end='')
    print("\n")    
    
# Method 2

print('\n'.join([''.join(['#' for _ in range(1, row + 1)]) for row in range(0, number_of_rows)]))