精华内容
下载资源
问答
  • 列表推导式能做什么
    万次阅读 多人点赞
    2021-03-03 21:50:58

    橡皮擦,一个逗趣的互联网高级网虫,新的系列,让我们一起 Be More Pythonic

    四、列表推导式与字典推导式

    在 Python 中推导式是一种非常 Pythonic 的知识,本篇博客将为你详细解答列表推导式与字典推导式相关的技术知识。

    4.1 列表推导式

    列表推导式可以利用列表,元组,字典,集合等数据类型,快速的生成一个特定需要的列表。
    语法格式如下:

    [表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]]
    

    if 条件表达式 非必选,学完列表推导式之后,你可以发现它就是 for 循环的一个变种语句,例如咱们现有一个需求是将一个列表中的所有元素都变成原值的 2 倍。

    for 循环写法

    my_list = 
    更多相关内容
  • Python小技巧之列表推导式到匿名函数 最近又看了一遍python的基础知识,所谓温故而知新,哈哈哈,所以在这里写下自己的一些见解,我觉得在实战过程中还是非常有用的一些小技巧,也分享给大家,如果写的不好,请大家...
  • 列表推导式、元组推导式、字典推导式、集合推导式列表推导式元组推导式字典推导式集合推导式 推导式(又称解析器),是 Python 独有的一种特性。 使用推导式可以快速生成列表、元组、字典以及集合类型的数据,因此...

    列表推导式、元组推导式、字典推导式、集合推导式

    推导式(又称解析器),是 Python 独有的一种特性。

    使用推导式可以快速生成列表、元组、字典以及集合类型的数据,因此推导式又可细分为列表推导式、元组推导式、字典推导式以及集合推导式。

    列表推导式

    列表推导式可以利用 range 区间、元组、列表、字典和集合等数据类型,快速生成一个满足指定需求的列表。

    列表推导式的语法格式如下:

    [表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]
    

    此格式中,[if 条件表达式] 不是必须的,可以使用,也可以省略。

    通过列表推导式的语法格式,明显会感觉到它和 for 循环存在某些关联。

    其实,除去 [if 条件表达式] 部分,其余各部分的含义以及执行顺序和 for 循环是完全一样的(表达式其实就是 for 循环中的循环体),即它的执行顺序如下所示:

    for 迭代变量 in 可迭代对象
        表达式
    

    可以这样认为,它只是对 for 循环语句的格式做了一下简单的变形,并用 [] 括起来而已,只不过最大的不同之处在于,列表推导式最终会将循环过程中,计算表达式得到的一系列值组成一个列表

    a_range = range(10)
    # 对a_range执行for表达式
    a_list = [x * x for x in a_range]
    # a_list集合包含10个元素
    print(a_list)
    
    输出结果:
    [0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64, 81]
    

    上面代码的第 3 行会对 a_range 执行迭代,由于 a_range 相当于包含 10 个元素,因此程序生成的 a_list 同样包含 10 个元素,且每个元素都是 a_range 中每个元素的平方(由表达式 x * x 控制)。

    不仅如此,我们还可以在列表推导式中添加 if 条件语句,这样列表推导式将只迭代那些符合条件的元素。例如:

    b_list = [x * x for x in a_range if x % 2 == 0]
    # a_list集合包含5个元素
    print(b_list)
    
    输出结果:
    [0 ,4 , 16, 36, 64]
    

    这里给列表推导式增加了 if 条件语句,这会导致推导式只处理 range 区间的偶数,因此程序生成的 b_list 只包含 5 个元素。

    另外,以上所看到的列表推导式都只有一个循环,实际上它可使用多个循环,就像嵌套循环一样。例如如下代码:

    d_list = [(x, y) for x in range(5) for y in range(4)]
    # d_list列表包含20个元素
    print(d_list)
    

    上面代码中,x 是遍历 range(5) 的迭代变量(计数器),因此该 x 可迭代 5 次;y 是遍历 range(4) 的计数器,因此该 y 可迭代 4 次。因此,该(x,y)表达式一共会迭代 20 次。上面的 for 表达式相当于如下嵌套循环:

    dd_list = []
    for x in range(5):
        for y in range(4):
            dd_list.append((x, y))
    
    输出结果:
    [(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3)]
    

    当然,也支持类似于三层嵌套的 for 表达式,例如如下代码:

    e_list = [[x, y, z] for x in range(5) for y in range(4) for z in range(6)]
    # e_list列表包含120个元素
    print(e_list)
    

    对于包含多个循环的 for 表达式,同样可指定 if 条件。

    假如我们有一个需求:

    • 程序要将两个列表中的数值按“能否整除”的关系配对在一起。

    • 比如 src_a 列表中包含 30,src_b 列表中包含 5,其中 30 可以整除 5,那么就将 30 和 5 配对在一起。对于上面的需求使用 for 表达式来实现非常简单,例如如下代码:

    src_a = [30, 12, 66, 34, 39, 78, 36, 57, 121]
    src_b = [3, 5, 7, 11]
    # 只要x能整除y,就将它们配对在一起
    result = [(x, y) for x in src_a for y in src_b if x % y == 0]
    print(result)
    
    输出结果:
    [(30, 3), (30, 5), (12, 3), (66, 3), (66, 11), (39, 3), (78, 3), (36, 3), (57, 3), (121, 11)]
    

    元组推导式

    元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型,快速生成一个满足指定需求的元组。

    元组推导式的语法格式如下:

    (表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] )
    

    其中,用 [] 括起来的部分,可以使用,也可以省略。

    通过和列表推导式做对比,你会发现,除了元组推导式是用 () 圆括号将各部分括起来,而列表推导式用的是 [],其它完全相同。不仅如此,元组推导式和列表推导式的用法也完全相同。

    例如,我们可以使用下面的代码生成一个包含数字 1~9 的元组:

    a = (x for x in range(1,10))
    print(a)
    
    输出结果:
    <generator object <genexpr> at 0x000001C6E5F97748>
    

    从上面的执行结果可以看出,使用元组推导式生成的结果并不是一个元组,而是一个生成器对象,这一点和列表推导式是不同的。

    如果我们想要使用元组推导式获得新元组或新元组中的元素,有以下三种方式:

    1. 使用 tuple() 函数,可以直接将生成器对象转换成元组,例如:
    a = (x for x in range(1,10))
    print(tuple(a))
    
    运行结果为:
    (1, 2, 3, 4, 5, 6, 7, 8, 9)
    
    1. 直接使用 for 循环遍历生成器对象,可以获得各个元素,例如:
    a = (x for x in range(1,10))
    for i in a:
        print(i,end=' ')
    print(tuple(a))
    
    输出结果:
    1 2 3 4 5 6 7 8 9 ()
    
    1. 使用 __next__() 方法遍历生成器对象,也可以获得各个元素,例如:
    a = (x for x in range(3))
    print(a.__next__())
    print(a.__next__())
    print(a.__next__())
    a = tuple(a)
    print("转换后的元组:",a)
    
    输出结果:
    0
    1
    2
    转换后的元组: ()
    

    注意,无论是使用 for 循环遍历生成器对象,还是使用 __next__() 方法遍历生成器对象,遍历后原生成器对象将不复存在,这就是遍历后转换原生成器对象却得到空元组的原因

    字典推导式

    Python 中,使用字典推导式可以借助列表、元组、字典、集合以及 range 区间,快速生成符合需求的字典。

    字典推导式的语法格式如下:

    {表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}
    

    可以看到,和其它推导式的语法格式相比,唯一不同在于,字典推导式用的是大括号{}

    listdemo = ['Jack','Tom']
    #将列表中各字符串值为键,各字符串的长度为值,组成键值对
    newdict = {key:len(key) for key in listdemo}
    print(newdict)
    
    输出结果:
    {'Jack': 4, 'Tom': 3}
    

    交换现有字典中各键值对的键和值。

    olddict={'Jack': 4, 'Tom': 3}
    newdict = {v: k for k, v in olddict.items()}
    print(newdict)
    
    输出结果:
    {4: 'Jack', 3: 'Tom'}
    

    使用 if 表达式筛选符合条件的键值对。

    olddict={'Jack': 4, 'Tom': 3}
    newdict = {v: k for k, v in olddict.items() if v>3}
    print(newdict)
    
    输出结果:
    {4: 'Jack'}
    

    集合推导式

    集合推导式的语法格式和字典推导式完全相同,如下所示:

    { 表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] }
    

    集合推导式和字典推导式的格式完全相同,那么给定一个类似的推导式,如何判断是哪种推导式呢?

    最简单直接的方式,就是根据表达式进行判断,如果表达式以键值对(key:value)的形式,则证明此推导式是字典推导式;反之,则是集合推导式。

    setnew = {i**2 for i in range(3)}
    print(setnew)
    
    输出结果:
    {0, 1, 4}
    

    既然生成的是集合,那么其保存的元素必须是唯一的。

    tupledemo = (1,1,2,3,4,5,6,6)
    setnew = {x**2 for x in tupledemo if x%2==0}
    print(setnew)
    
    输出结果:
    {16, 4, 36}
    
    dictdemo = {'1':1,'2':2,'3':3}
    setnew = {x for x in dictdemo.keys()}
    print(setnew)
    
    输出结果:
    {'2', '1', '3'}
    
    展开全文
  • 什么时候在Python中使用列表推导式

    千次阅读 多人点赞 2020-05-18 17:30:40
    这篇文章将带你了解Python列表的全部功能以及如何优雅的使用它们。还将了解使用它们所带来的权衡,以便确定何时其他方法更佳

    前言

      我们都知道Python语言好、功能恐怖如斯!它允许我们编写优雅到几乎与普通英语一样易读的代码而闻名。该语言最独特的功能之一就是列表功能,它可以在一行代码中创建强大的功能。但是,很多Python开发者都在努力充分利用Python中列表的更高级功能。一些程序员甚至使用它们太多,可能导致代码效率降低且更难阅读

    这篇文章将带我们了解Python列表的全部功能以及如何优雅的使用它们。还将了解使用它们所带来的权衡,以便确定何时其他方法更佳

    1. 如何在Python中创建列表

      可以使用几种不同的方法在Python中创建列表。为了更好地理解在Python中使用列表的权衡,让我们首先看看如何使用这些方法创建列表

    1.1 使用for循环

      循环的最常见类型for循环,可以使用for循环在三个步骤中创建元素列表:

    • 实例化一个空列表
    • 循环遍历元素的可迭代范围
    • 将每个元素追加到列表的末尾
    >>> test = []
    >>> for i in range(10):
    ...     test.append(i * i)
    >>> test
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    

    在这里,实例化一个空列表test。然后,使用for循环来遍历range(10)。最后,将每个数字本身相乘,然后将结果追加到列表的末尾

    1.2 使用map()函数

      map()提供了一种基于函数式编程的替代方法。传入一个函数和一个可迭代map()的对象,并将创建一个对象。该对象包含通过提供的功能运行每个可迭代元素所获得的输出

    txns = [1, 2, 3, 4, 5]
    tax_rate = .05
    def get_price_with_tax(txn):
        return txn * (1 + TAX_RATE)
    final_prices = map(get_price_with_tax, txns)
    list(final_prices)
    #[1.05, 2.1, 3.1500000000000004, 4.2, 5.25]
    

    以上代码有一个txns和一个get_price_with_tax()。将这两个参数都传递给map(),并将结果对象存储在中final_prices。使用list将对象转换为列表list()

    1.3 使用列表推导式

    使用列表推导式这种优雅的方法,可以for只用一行代码就可以重写第一个示例中的循环:

    >>> test = [i * i for i in range(10)]
    >>> test
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    

    我们不再需要创建一个空列表然后再将每个元素添加进去,只需按照以下格式同时定义列表及其内容即可:

    new_list = [expression for member in iterable]
    

    Python中的每个列表理解都包含三个元素:
      1. expression是成员本身,对方法的调用或返回值的任何其他有效表达式。在上面的示例中,表达式i * i是成员值的平方
      2. member是列表中可迭代的对象或值。在上面的示例中,成员值为i
      3. erable是一个列表,集合,序列,生成器或可以一次返回其元素的任何其他对象。在上面的示例中,iterable为range(10)

    1.4 使用列表推导式的好处

    在Python中使用列表推导式的一个主要好处是它可以在许多不同情况下使用。除了标准列表创建之外,列表推导式还可用于映射和过滤。不必为每种情况使用不同的方法

    列表推导式也比循环更具声明性,这意味着它们更易于阅读和理解。循环要求集中精力创建列表。必须手动创建一个空列表,在元素上循环、追加

    2. 如何增强理解力

    2.1 使用条件逻辑

      尽管列表推导式的公式是准确的,但它也有些不完整。对理解公式的更完整的描述增加了对可选条件的支持。向列表推导式内添加条件逻辑的最常见方法是在表达式的末尾添加条件:

    new_list = [expression for member in iterable (if conditional)]
    

    条件可以帮助它们允许列表推导过滤掉不需要的值,这通常需要调用filter()

    
    >>> test = 'hello world'
    >>> result = [i for i in test if i in 'roe']
    >>> result
    ['e', 'o', 'o', 'r']
    

    条件可以测试任何有效的表达式。如果需要更复杂的过滤器,可以将条件逻辑移至到单独的函数

    条件语句放在语句的末尾可以完成简单的过滤,但如果要更改成员值而不是将其过滤掉该怎么办?在这种情况下,将条件放在表达式的开头很有用,看下它的表达式:

    new_list = [expression (if conditional) for member in iterable]
    

    这个公式可以使用条件逻辑从多个可能的输出选项中进行筛选

    >>> test = [1, -1.02, 3, 4, 5, -1.16]
    >>> result = [i if i > 0 else 0 for i in test]
    >>> result
    [1, 0, 3, 4, 5, 0]
    

    表达式i包含一个条件语句if i > 0 else 0。这告诉Python来输出的值i,如果该数字为正数,但要改变i到0如果数字为负

    2.2 使用集合跟字典

      尽管Python中的列表推导式是一种常用工具,但也可以创建集合和字典。区别在于,集合可确保输出不包含重复项。可以使用花括号而不是方括号来创建集合:

    >>> test = "Hello world"
    >>> result = {i for i in test if i in 'roe'}
    >>> result
    {'e', 'o', 'o', 'r'}
    

    字典类似,但另外需要定义一个键:

    >>> test = {i: i * i for i in range(10)}
    >>> test
    {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
    

    要创建test字典,可以在表达式中使用花括号({})以及键值对(i: i * i)

    2.3 使用Walrus运算符

    Python3.8引入赋值表达式,也称为walrus运算符,举个示例

    假设我们需要向API发出多个请求,这些请求将返回年龄数据。我只想返回年龄大于50的结果。假设每个请求将返回不同的数据。在这种情况下,无法使用Python中的列表理解来解决这个问题。该公式expression for member in iterable (if conditional)无法为条件式提供将数据分配给表达式可以访问的变量的方法

    但是,Walrus解决了这个问题。它可以在运行表达式的同时将输出值分配给变量。以下示例显示了如何使用此方法get_age_data()来生成年龄数据:

    >>> import random
    >>> def get_weather_data():
    ...     return random.randrange(30, 60)
    >>> age_temps = [temp for _ in range(20) if (temp := get_age_data()) >= 50]
    >>> age_temps
    [51, 55, 57, 59, 50...]
    

    在Python中,通常不需要在列表理解内使用赋值表达式,但是在必要时,它是很有用的

    3. 何时不使用Python中的列表推导式

      列表推导式很有用,可以帮助我们编写易于阅读和调试的优美代码,但并不是在所有情况下都可以选择它。因为可能使我们的代码运行速度更慢或消耗更多的内存。如果代码性能较差或难以阅读的话,最好选择一个替代方案

    3.1 选择大型数据集的生成器

      Python中的列表推导式通过将整个输出列表加载到内存中来工作。对于小型甚至中型列表,通常都可以。如果要对前一千个整数的平方求和,则列表理解将很好地解决此问题:

    >>> sum([i * i for i in range(1000)])
    332833500
    

      但是,如果想对十亿的整数平方求和呢?如果在计算机上尝试过此操作,则可能会注意到计算机无响应。这是因为Python试图创建一个具有十亿个整数的列表,该列表消耗的内存比计算机所需的更多。计算机可能没有生成庞大列表并将其存储在内存中所需的资源。如果仍然尝试这样做,计算机可能会变慢甚至崩溃

      如果要用一个生成器来求和前十亿平方,那么程序可能会运行一段时间,但不会导致计算机死机。下面的示例使用一个生成器

    >>> sum(i * i for i in range(1000000000))
    333333332833333333500000000
    

    可以说这是一个生成器,因为表达式没有被方括号或花括号包围。生成器可以用括号括起来

    上面的示例仍然需要大量工作,但是它懒惰地执行操作。由于延迟计算,因此仅在明确要求时才计算值。生成器生成一个值(例如100 * 100)后,它可以将该值加到运行总和中,然后丢弃该值并生成下一个值(101 * 101)。当求和函数要求下一个值时,循环重新开始。此过程使内存占用量较小

    map() 也懒惰的工作,这意味着如果在这种情况下选择使用内存,内存将不是问题:

    >>> sum(map(lambda i: i*i, range(1000000000)))
    333333332833333333500000000
    

    是否选择生成器表达式或取决于map()

    3.2 配置文件以优化性能

      那么,到底哪种方法更快?应该使用列表推导式还是其他方法?与其坚持在所有情况下都适用的单一规则,不如看看在特定情况下效果是否更有用

    如果在性能很重要的情况下,通常最好是分析不同的方法并检查数据。timeit是一个有用的库,用于计算要花多长时间运行代码块。可以用timeit来比较map()、for循环和列表推导式的运行时间:

    >>> import random
    >>> import timeit
    >>> tax_rate = .05
    >>> txns = [random.randrange(100) for _ in range(100000)]
    >>> def get_price(txn):
    ...     return txn * (1 + tax_rate)
    ...
    >>> def get_prices_with_map():
    ...     return list(map(get_price, txns))
    ...
    >>> def get_prices_with_comprehension():
    ...     return [get_price(txn) for txn in txns]
    ...
    >>> def get_prices_with_loop():
    ...     prices = []
    ...     for txn in txns:
    ...         prices.append(get_price(txn))
    ...     return prices
    ...
    >>> timeit.timeit(get_prices_with_map, number=100)
    2.0554370979998566
    >>> timeit.timeit(get_prices_with_comprehension, number=100)
    2.3982384680002724
    >>> timeit.timeit(get_prices_with_loop, number=100)
    3.0531821520007725
    

    以上代码定义了三种方法,每种方法都使用不同的方法来创建列表。然后,告诉timeit每个功能运行100次。timeit返回运行这100次执行所花费的总时间。

    我们可以通过测试结果发现,最大的区别在于基于循环的方法和map(),循环执行时间延长了50%。这是否重要取决于应用程序需求

    4. 结论

    通过以上示例,我们知道了如何在Python中使用列表推导式来完成复杂的任务,而又不会使我们的代码过于复杂

    我们可以:

    • map()通过声明式列表简化循环和调用
    • 使用条件逻辑增强理解能力
    • 使用条件逻辑增强理解能力
    • 确定什么时候代码清晰或性能要求使用替代方法

    当必须选择列表创建方法时,大家可以尝试多种实现方式,并考虑在特定情况下最容易阅读和理解的内容。如果性能很重要,那么可以使用性能分析工具测试一下去分析数据,不要凭直觉跟预感去猜测
    在这里插入图片描述

    5. 致谢

      好了,到这里又到了跟大家说再见的时候了。我只是一个会写爬虫的段子手而已,一个希望有朝一日能够实现财富自由,能够早日荣归故里的游子罢了。希望我的文章能带给您知识,带给您帮助,带给您欢笑!同时也谢谢您能抽出宝贵的时间阅读,创作不易,如果您喜欢的话,点个赞再走吧。您的支持是我创作的动力,希望今后能带给大家更多优质的文章!

    展开全文
  • 列表推导式并不是什么特别的技术,它只是一种创建列表的简洁方法,目的是为了让大家写程序时更方便更快捷,写出更简洁的代码初识列表现在请创建一个list,元素为1到9的整数,先用普通方法lst = []for i in range...

    列表推导式并不是什么特别的技术,它只是一种创建列表的简洁方法,目的是为了让大家写程序时更方便更快捷,写出更简洁的代码

    初识列表

    现在请创建一个list,元素为1到9的整数,先用普通方法做

    lst = []

    for i in range(10):

    lst.append(i)

    用了3行代码完成了这个功能,现在用列表推导式来做

    lst = [i for i in range(10)]

    仅仅是一行代码哦,一行代码就能解决的问题,就没必要用三行代码去做

    创建一个列表,元素为10以内的偶数,方法1

    lst = [i for i in range(2,10,2)]

    方法2

    lst = [i for i in range(2,10) if i%2 == 0]

    小做总结

    讲到这里,我必须稍微的做一个总结了,for语句前面的表达式,经过计算,最终留在新建的list列表中,for循环是一个不断取值的过程,而满足if语句的元素才有资格参与for语句前面的表达式计算。

    我这样讲,可能你还是不能够理解,换一个新的例子,创建一个列表,元素为10以内偶数的平方

    lst = [i*i for i in range(2,10) if i%2 == 0]

    程序解读

    * for 语句前面的表达式是i*i

    * i 的值从2变化到9,但不是每一个i的值都会参加i*i的计算,i的值必须满足if条件语句才行

    配合函数

    for语句前面的表达式在某些情况下,仍然不能够满足实际需要,比如下面的要求,创建一个list,元素为10以内的偶数的平方,如果元素的个位数是6,则该元素的值转为字符串。

    根据要求,新创建的列表内容应当为[4, '16', '36', 64],你现在知道for语句前面的内容是表达式,更进一步,他们是lambda表达式,关于这个概念,我后续会介绍,想要用lambda表达式来完成这个功能,是比较困难的,这种情况下,可以配合函数来做,代码如下

    def func(i):

    res = i * i

    if res % 10 == 6:

    return str(res)

    return res

    lst = [func(i) for i in range(2,10) if i % 2 == 0]

    print lst

    列表推导式更快

    列表推导式不仅仅是让程序更简洁,其速度也比普通方法快,下面是一段测试比较代码

    #coding=utf-8

    import time

    #装饰器函数

    def timefunc(func):

    def newfunc(*args,**kwargs):

    t1 = time.time()

    lst = func(*args,**kwargs)

    t2 = time.time()

    diff = t2 - t1

    print u'{func}用时{diff}'.format(diff=diff,

    func=func.func_name)

    return lst

    return newfunc

    @timefunc

    def func1(count):

    lst = []

    for i in range(count):

    lst.append(i)

    return lst

    @timefunc

    def func2(count):

    lst = [i for i in range(count)]

    return lst

    count = 1000000

    func1(count)

    func2(count)

    这段代码里用到了装饰器,后续我也会讲,程序运行的结果如下:

    func1用时0.144474029541

    func2用时0.0513877868652

    可以明显的看到,使用列表推导式,创建相同内容的列表,要比普通方法快接近3倍的速度

    列表推导式总结优点

    1. 简洁

    2. 高效

    缺点

    如果使用不当,会造成阅读困难。

    写出别人难以理解的代码是非常容易的,如果再用心些,写出一份几天后自己都看不懂的代码也不是什么难事,真正难的是写出别人看得懂的代码,列表推导式虽然简洁,但一味的简洁,在推导式里写上一堆的代码,就造成理解困难,比如下面的题目:

    a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    将这个嵌套列表转成一维列表,转换后,列表内容为

    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    如果用列表推导式,则可以这样写

    a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    b = [j for i in a for j in i]

    print(b)

    上面的代码我已经不想去解释了,如果是用普通方法,则可以这样写

    a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    b = []

    for i in a:

    for j in i:

    b.append(j)

    print b

    这两份代码,你更喜欢用哪一个呢?成长离不开与优秀的同伴共同交流,如果你需要好的学习环境,好的学习资源,这里欢迎每一位热爱Python的小伙伴,Python学习圈

    展开全文
  • 【技能树共建】Python 列表推导式

    万次阅读 多人点赞 2022-04-21 17:46:56
    nn_list = [i*2 for i in my_list if i>1] print(nn_list) 优化两层 for 循环 这些都是一般技能,列表推导式能支持两层 for 循环,例如下述代码: nn_list = [(x,y) for x in range(3) for y in range(3) ] print...
  • python列表推导式与生成器表达式
  • 刚开始的时候,我并没有接触到推导式这个东西,于是乎,每次在进行这种输入的时候,都会用到之前知晓的这个代码list(map(int,input().split())),来使输入内容变成一个元素是数字的列表,因为直接用input()...
  • 列表推导式并不是什么特别的技术,它只是一种创建列表的简洁方法,目的是为了让大家写程序时更方便更快捷,写出更简洁的代码初识列表现在请创建一个list,元素为1到9的整数,先用普通方法lst = []for i in range...
  • 列表常用函数及列表推导式 列表相关函数有很多,我在这只分享一下常用的几个函数。 常用函数 min、max — 求最小/最大值 用法:max(序列) / min(序列); 使用时,序列中元素类型一致。且具有可比性。 numbers = ...
  • 我非常喜爱列表推导式,为此我写过一篇关于它们的文章,过一次针对它们的演讲,还在 PyCon 2018 上办过一个三小时推导式教程。我喜爱推导式,但是我发现一旦一个新的 Python 使用者开始真正使用推导式,他们会在...
  • Example-1 三位数组合题目:有四个数字:1、2、3、4,组成多少个互不相同且无重复数字的三位数?各是多少?思路最简单的方法,就是穷举法了,分别求出在百位、十位、个位上的数字,然后剔除出现重复数字的组合,...
  • 本篇博客主要为 https://bbs.csdn.net/skill/python 频道练习题模块补充题目,暂定每天提供5道测试题,后面可能会更多哦~。 本篇博客针对【进阶语法】【 列表推导式】进行出题。
  • 详解Python列表推导式

    千次阅读 2021-07-13 16:52:54
    列表推导式可以使用非常简洁的方式对列表或其他可迭代对象的元素进行遍历和过滤,快速生成满足特定需求的列表,代码具有非常强的可读性,是Python程序开发时应用最多的技术之一。Python的内...
  • 上一节我们结束了有关python的方法相关内容这一节我们先来学习python的列表推导式之前跟大家说过range方法的使用,在这里我就不过多的解释了,如忘记了,请翻阅之前的介绍列表推导式,是Python内置的一种极其强大...
  • 列表推导式 # 列表推导式就是使用一个简单的方法创建一个列表 # 列表里元素的类型是根据for前面的数据类型而定的 a = [m for m in range(31)] print(a)# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16...
  • 文章目录列表推导式(语法糖)使用方法使用方式推广生成器使用方法 列表推导式(语法糖) 初看列表推导式可能会一头雾水,对词语法的可读性表示质疑,一旦理解语法糖后,你就会感觉出他那简短语句中的魅力。 使用...
  • 周末花了点时间把自己一直不会用的列表推导式和生成器表达式好好看了下,整理一篇笔记,部分代码是参考了《流畅的Python》中的示例。在搞明白这俩货之前,如果需要从两个数据源取出数据耦合起来,我大概率会把代码写...
  • 列表推导式 和 字典推导式在python中常用,但是有时候经常混淆,语法上也略有区别,随手写下,给自己个记录 列表推导式 a = [0,1,2,3,4,5,6,7,8,9] b = [i+100 if i > 5 else 0 for i in a ] print('b : ',b...
  • 栏目介绍Python列表推导式的使用。相关免费学习推荐:Python 列表推导式并不是给初学者用的,因为它非常反直觉,甚至对于有其他编程语言背景的人也是如此。我们接触到 List 的使用时,学习的内容都是零散的。所以...
  • Python笔记002-列表推导式 以下是我学习《流畅的Python》后的个人笔记,现在拿出来和大家共享,希望帮到各位Python学习者。 首次发表于: 微信公众号:科技老丁哥,ID: TechDing,敬请关注。 本篇主要知识点: ...
  • 【摘要】列表解析式(List comprehension)或者称为列表推导式,是 Python列表推导式最基本的概念。它可以基于现有的列表一些操作,从而快速创建新列表。因此写列表推导式是非常爽的一件事,有了这种方法,小编建议...
  • Python中关于列表推导式(与循环和条件判断结合时)常会出现的问题 话不多说,上代码: N=int(input()) numlist=[1/i if i%2==1 for i in range(1,2*N) ] S=sum(numlist) print("sum = {:.6f}".format(S)) 报错...
  • 列表解析式(List comprehension)或者称为列表推导式,是 Python 中非常强大和优雅的方法。它可以基于现有的列表一些操作,从而快速创建新列表。在我们第一次见到列表推导式时,可能会感觉这种方法非常炫酷,因此...
  • 以下内容转载自必会的List Comprehension (列表推导式),原作者为CodingFish。 强大的List Comprehension (列表推导式或者列表解析式)是Python中必须知道的概念。然而对于初学者来说是最具挑战性的。掌握这个...
  • 那么,什么时候最适合用列表推导式呢? 其实是 当你需要使用 for 循环来生成一个新列表 。举个例子,你通常会这样: squared = [] for x in range(10):  squared.append(x**2) 这时候,采用列表推导式最...
  • 推导式创建序列列表推导式字典推导式推导式代码普通代码集合推导式生成器推导式(生成元组)嵌套推导式1 列表套列表2 一个列表套两个 for 循环2.1 有点像 `product` 函数 的感觉2.2 在列表推导式中 序列解包3 批量...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,167
精华内容 9,266
关键字:

列表推导式能做什么