精华内容
下载资源
问答
  • 列表推导式提供了一个更简单的创建列表的方法。常见的用法是把某种操作应用于序列或可迭代对象的每个元素上,然后使用其结果来创建列表,或者通过满足某些特定条件元素来创建子序列。 例如,假设我们想创建一个平方...

    列表推导式提供了一个更简单的创建列表的方法。常见的用法是把某种操作应用于序列或可迭代对象的每个元素上,然后使用其结果来创建列表,或者通过满足某些特定条件元素来创建子序列。

    例如,假设我们想创建一个平方列表,像这样

    >>> squares = []
    >>> for x in range(10):
    ...     squares.append(x**2)
    ...
    >>> squares
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

     

     
       

    注意这里创建(或被重写)的名为 x 的变量在for循环后仍然存在。我们可以计算平方列表的值而不会产生任何副作用

    squares = list(map(lambda x: x**2, range(10)))

     

    或者,等价于

    squares = [x**2 for x in range(10)]

     

    上面这种写法更加简洁易读。

    Python列表推导式的结构是由一对方括号所包含的以下内容:一个表达式,后面跟一个 for 子句,然后是零个或多个 for或 if 子句。 其结果将是一个新列表,由对表达式依据后面的 for 和 if 子句的内容进行求值计算而得出。 举例来说,以下列表推导式会将两个列表中不相等的元素组合起来:

    >>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
    [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
     
       

    而它等价于

    >>> combs = []
    >>> for x in [1,2,3]:
    ...     for y in [3,1,4]:
    ...         if x != y:
    ...             combs.append((x, y))
    ...
    >>> combs
    [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
     
       

    注意在上面两个代码片段中, for 和 if 的顺序是相同的。

    如果表达式是一个Python元组(例如上面的 (x, y)),那么就必须加上括号

    >>>
    >>> vec = [-4, -2, 0, 2, 4]
    >>> # create a new list with the values doubled
    >>> [x*2 for x in vec]
    [-8, -4, 0, 4, 8]
    >>> # filter the list to exclude negative numbers
    >>> [x for x in vec if x >= 0]
    [0, 2, 4]
    >>> # apply a function to all the elements
    >>> [abs(x) for x in vec]
    [4, 2, 0, 2, 4]
    >>> # call a method on each element
    >>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
    >>> [weapon.strip() for weapon in freshfruit]
    ['banana', 'loganberry', 'passion fruit']
    >>> # create a list of 2-tuples like (number, square)
    >>> [(x, x**2) for x in range(6)]
    [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
    >>> # the tuple must be parenthesized, otherwise an error is raised
    >>> [x, x**2 for x in range(6)]
      File "<stdin>", line 1, in <module>
        [x, x**2 for x in range(6)]
                   ^
    SyntaxError: invalid syntax
    >>> # flatten a list using a listcomp with two 'for'
    >>> vec = [[1,2,3], [4,5,6], [7,8,9]]
    >>> [num for elem in vec for num in elem]
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

     

    列表推导式可以使用复杂的表达式和嵌套函数

    >>> from math import pi
    >>> [str(round(pi, i)) for i in range(1, 6)]
    ['3.1', '3.14', '3.142', '3.1416', '3.14159']
     
       

    嵌套的列表推导式

    列表推导式中的初始表达式可以是任何表达式,包括另一个列表推导式。

    考虑下面这个 3x4的矩阵,它由3个长度为4的列表组成


    >>> matrix = [
    ...     [1, 2, 3, 4],
    ...     [5, 6, 7, 8],
    ...     [9, 10, 11, 12],
    ... ]

     

    下面的列表推导式将交换其行和列

    >>> [[row[i] for row in matrix] for i in range(4)]
    [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
     
       

    如上节所示,嵌套的列表推导式是基于跟随其后的 for 进行求值的,所以这个例子等价于:

    >>> transposed = []
    >>> for i in range(4):
    ...     transposed.append([row[i] for row in matrix])
    ...
    >>> transposed
    [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
     
       

    反过来说,也等价于

    >>> transposed = []
    >>> for i in range(4):
    ...     # the following 3 lines implement the nested listcomp
    ...     transposed_row = []
    ...     for row in matrix:
    ...         transposed_row.append(row[i])
    ...     transposed.append(transposed_row)
    ...
    >>> transposed
    [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
     
       

    实际应用中,你应该会更喜欢使用内置函数去组成复杂的流程语句。 zip() 函数将会很好地处理这种情况

    >>> list(zip(*matrix))
    [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
     
       

     

    转载于:https://www.cnblogs.com/yuanrenxue/p/10709398.html

    展开全文
  • Python列表推导式

    万次阅读 多人点赞 2019-05-18 00:51:24
    Python列表推导式 列表推导式是Python构建列表(list)的一种快捷方式,可以使用简洁的代码就创建出一个列表. 一、range()函数 python的range()函数可用来创建一个整数列表,一般用在 for 循环中. range()语法:...

    Python列表推导式

    列表推导式是Python构建列表(list)的一种快捷方式,可以使用简洁的代码就创建出一个列表.

    一、range()函数

    python的range()函数可用来创建一个整数列表,一般用在 for 循环中.

    range()语法:range(start, stop[, step])

    start: 计数从start开始,默认是从0开始(闭区间),如:range(5)等价于range(0,5).

    stop: 计数到stop结束,但不包括stop(开区间).如:range(0,5)是[0, 1, 2, 3, 4],不包含5.

    step:步长,相邻两个值的差值,默认为1.如:range(0,5)相当于range(0, 5, 1).

    为什么要在列表推导式前讲range(),因为列表推导式是通过一个可迭代对象来生成列表的,range()可以说是列表推导式中最常用的可迭代对象了.对列表推导式来说,range()是其中的精髓之一.没有range(),列表推导式的可读性和简洁性将会大打折扣.

    二、列表推导式

    列表推导式(list comprehension)是指循环创建列表.

    for循环有非常广的应用场景,也可以用来创建一个列表,而列表推导式就相当于for循环创建列表的简化版.

    # for循环
    list_a = list()
    for a in range(5):
        list_a.append(a)
    print(list_a)
    # 列表推导式
    list_b = [b for b in range(5)]
    print(list_b)

    上面分别是用for循环和列表推导式创建列表的代码,list_a和list_b的结果是一样的,都是[0, 1, 2, 3, 4].

    下面来看复杂点的列表推导式:

    # in后面跟其他可迭代对象,如字符串
    list_c = [7 * c for c in "python"]
    print(list_c)
    
    # 带if条件语句的列表推导式
    list_d = [d for d in range(6) if d % 2 != 0]
    print(list_d)
    
    # 多个for循环
    list_e = [(e, f * f) for e in range(3) for f in range(5, 15, 5)]
    print(list_e)
    
    # 嵌套列表推导式,多个并列条件
    list_g = [[x for x in range(g - 3, g)] for g in range(22) if g % 3 == 0 and g != 0]
    print(list_g)

    运行结果:

    ['ppppppp', 'yyyyyyy', 'ttttttt', 'hhhhhhh', 'ooooooo', 'nnnnnnn']
    [1, 3, 5]
    [(0, 25), (0, 100), (1, 25), (1, 100), (2, 25), (2, 100)]
    [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13, 14], [15, 16, 17], [18, 19, 20]]

    代码解释:

    1.列表推导式会遍历后面的可迭代对象,然后按照for前的表达式进行运算,生成最终的列表.

    2.如果有if条件语句,for遍历后紧跟着进行条件判断.

    3.如果有多个for循环,则最终的数据数量为多个for循环的笛卡尔积.

    4.可以进行嵌套的列表推导,与嵌套for循环的原理相同.

    三、代码可读性

    对于不熟悉列表推导式的人来说,可以使用for循环来实现相同的功能,但是需要好几行代码,而列表推导式只需要一行代码.

    很多人会说代码简洁了但可读性降低了,其实不然,当我们对列表推导式熟悉(自己写几次就熟悉了),代码的功能一眼就能轻松地看出来,但是for循环代码基本不可能一眼看完.尤其当创建列表的for循环嵌套在业务逻辑的其他for循环里时,恰恰是使用列表推导式的可读性最高.

    同时,在Python3中列表推导式有自己的局部作用域,就像函数似的.表达式内部的变量和赋值只在局部起作用,表达式的上下文里的同名变量还可以被正常引用,局部变量并不会影响到它们.

    也就是说,列表推导不会有变量泄漏的问题,在列表推导中的赋值操作不可能会影响到列表推导上下文中的同名变量.

    当然,也不是所有场景都推荐使用列表推导式.比如说:如果列表推导的代码超过了两行,就要考虑改成用for循环了.超过了两行的列表推导式就真的没有可读性了.通常的原则是,只用列表推导来创建新的列表,并且尽量保持简短.

    四、字典推导式

    自Python2.7以来,列表推导概念就移植到了字典上,从而有了字典推导(后面还会看到集合推导).

    如果列表推导的概念已经为你所熟知,接受字典推导并不难.直接看代码吧:

    # 因为key是唯一的,所以最后value都是1
    dict_a = {key: value for key in 'python' for value in range(2)}
    print(dict_a)
    
    # 可以根据键来构造值
    dict_b = {key: key * key for key in range(6)}
    print(dict_b)
    
    # 遍历一个有键值关系的可迭代对象
    list_phone = [('HUAWEI', '华为'), ('MI', '小米'), ('OPPO', 'OPPO'), ('VIVO', 'VIVO')]
    dict_c = {key: value for key, value in list_phone}
    print(dict_c)

    运行结果:

    {'p': 1, 'y': 1, 't': 1, 'h': 1, 'o': 1, 'n': 1}
    {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
    {'HUAWEI': '华为', 'MI': '小米', 'OPPO': 'OPPO', 'VIVO': 'VIVO'}

    五、集合推导式

    Python2.7不仅带来了字典推导式,还带来了集合推导式.

    同样的,我们直接看代码,这样可以直观的看到集合推导式.

    # 遍历一个可迭代对象生成集合
    set_a = {value for value in '有人云淡风轻,有人负重前行'}
    print(set_a)
    

    运行结果:

    {'负', '有', '人', '轻', '前', '云', '重', ',', '淡', '风', '行'}

    集合是无序且不重复的,所以会自动去掉重复的元素,并且每次运行显示的顺序不一样.

    从上面的代码中可以总结:

    集合推导式就是将列表推导式的[]换成{},字典推导式就是推导出两个值并构建成键值对的样子.

    另外,不管是字典推导式还是集合推导式,后面都可以像列表推导式一样接if条件语句,嵌套循环等,具体可以根据您自己的需求来使用.


    关注工重号可以领资料和学习交流。

     

    展开全文
  • 嵌套列表推导式注意: 字典和集合推导是最近才加入到Python的(Python 2.7 和Python 3.1以上版). 下面简要介绍下: 第一:列表推导式  列表推导式也叫列表解析式。 功能:是提供一种方便的列表创建方法,只用一条...

    推导式是Python中很强大的、很受欢迎的特性,具有语言简洁,简化代码,速度快等优点。推导式包括:
    1.列表推导式
    2.字典推导式
    3.集合推导式
    4.嵌套列表推导式
    注意: 字典和集合推导是最近才加入到Python的(Python 2.7 和Python 3.1以上版). 下面简要介绍下:

     

    第一:列表推导式

      列表推导式也叫列表解析式。
      功能:是提供一种方便的列表创建方法,只用一条简洁的表达式即可对得到的元素进行转换变形,所以,列表解析式返回的是一个列表
      格式:用中括号括起来,中间用for语句,后面跟if语句用作判读,满足条件的传到for语句前面用作构建先的列表

      其基本格式如下:

        [expr for value in collection ifcondition]
    

      过滤条件可有可无,取决于实际应用,只留下表达式;相当于下面这段for循环:   

      result = []  
      for value in collection:  
          if condition:  
              result.append(expression)  
    

      例1:  过滤掉长度小于3的字符串列表,并将剩下的转换成大写字母   

      >>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']  
      >>> [name.upper() for name in names if len(name)>3]  
      ['ALICE', 'JERRY', 'WENDY', 'SMITH']  
    

      例2:  求(x,y)其中x是0-5之间的偶数,y是0-5之间的奇数组成的元祖列表

      >>> [(x,y) for x in range(5) if x%2==0 for y in range(5) if y %2==1]  
      [(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]
    

      例3:  求M中3,6,9组成的列表

      >>> M = [[1,2,3],
      ...      [4,5,6],
      ...      [7,8,9]]
      >>> M  
      [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  
      >>> [row[2] for row in M]  
      [3, 6, 9] 
    
      #或者用下面的方式  
      >>> [M[row][2] for row in (0,1,2)]  
      [3, 6, 9]  
    

      例4:  求M中斜线1,5,9组成的列表 

      >>> M  
      [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  
      >>> [M[i][i] for i in range(len(M))]  
      [1, 5, 9]  

      例5:  求M,N中矩阵和元素的乘积

      >>> M = [[1,2,3],  
      ...      [4,5,6],  
      ...      [7,8,9]]  
      >>> N = [[2,2,2],  
      ...      [3,3,3],  
      ...      [4,4,4]]  
        >>> [M[row][col]*N[row][col] for row in range(3) for col in range(3)]  
      [2, 4, 6, 12, 15, 18, 28, 32, 36]  
      >>> [[M[row][col]*N[row][col] for col in range(3)] for row in range(3)]  
      [[2, 4, 6], [12, 15, 18], [28, 32, 36]]  
      >>> [[M[row][col]*N[row][col] for row in range(3)] for col in range(3)]  
      [[2, 12, 28], [4, 15, 32], [6, 18, 36]]  

      例5:  讲字典中age键,按照条件赋新值

      

      >>> bob  
      {'pay': 3000, 'job': 'dev', 'age': 42, 'name': 'Bob Smith'}  
      >>> sue  
      {'pay': 4000, 'job': 'hdw', 'age': 45, 'name': 'Sue Jones'}  
      >>> people = [bob, sue]  
      >>> [rec['age']+100 if rec['age'] >= 45 else rec['age'] for rec in people]  # 注意for位置  
      [42, 145]  

     

    第二:字典推导式

      字典和集合推导式是该思想的延续,语法差不多,只不过产生的是集合和字典而已。其基本格式如下:

        { key_expr: value_expr for value in collection if condition }

      例1:  用字典推导式以字符串以及其长度建字典

      >>> strings = ['import','is','with','if','file','exception']  
      >>> D = {key: val for val,key in enumerate(strings)}   
      >>> D  
      {'exception': 5, 'is': 1, 'file': 4, 'import': 0, 'with': 2, 'if': 3}  
    

      例2:  大小写key合并

        mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
        mcase_frequency = {
            k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0)
            for k in mcase.keys()
            if k.lower() in ['a','b']
        }
        print mcase_frequency
        #  Output: {'a': 17, 'b': 34}
    

      例3.快速更换key和value

      mcase = {'a': 10, 'b': 34}
      mcase_frequency = {v: k for k, v in mcase.items()}
      print mcase_frequency
      #  Output: {10: 'a', 34: 'b'}

     

     

    第三:集合推导式

      集合推导式跟列表推导式非常相似,唯一区别在于用{}代替[]。其基本格式如下:

      { expr for value in collection if condition }
    

      例1:  用集合推导建字符串长度的集合

      >>> strings = ['a','is','with','if','file','exception']  
      >>> {len(s) for s in strings}    #有长度相同的会只留一个,这在实际上也非常有用  
      set([1, 2, 4, 9])  
    

    第四:嵌套列表推导式

      嵌套列表是指列表中嵌套列表,比如说: 
      >>> L = [[1,2,3],  
               [4,5,6],  
               [7,8,9]]  
    

       例1: 一个由男人列表和女人列表组成的嵌套列表,取出姓名中带有两个以上字母e的姓名,组成列表

          names = [['Tom','Billy','Jefferson','Andrew','Wesley','Steven','Joe'],  
                   ['Alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva']]  
    

      用for循环实现:

      tmp = []  
      for lst in names:  
          for name in lst:  
              if name.count('e') >= 2:  
                  tmp.append(name)  
      
      print tmp  
      #输出结果  
      >>>   
      ['Jefferson', 'Wesley', 'Steven', 'Jennifer']  
    

      用嵌套列表实现:

      >>> names = [['Tom','Billy','Jefferson','Andrew','Wesley','Steven','Joe'],  
               ['Alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva']]   
      >>> [name for lst in names for name in lst if name.count('e')>=2]  #注意遍历顺序,这是实现的关键  
      ['Jefferson', 'Wesley', 'Steven', 'Jennifer']  
    

      

    本文链接:http://www.cnblogs.com/xuchunlin/p/6059707.html  

    转载于:https://www.cnblogs.com/xuchunlin/p/6059707.html

    展开全文
  • Python中使用列表推导式循环嵌套形式,也是有利于大大简化语言,非常简洁就实现循环嵌套。 这些Python专有的表达式,我们称之为Python语句,很Python. # Python 专用的列表表达式-循环嵌套形式 [expression for i ...

    在Python中使用列表推导式循环嵌套形式,也是有利于大大简化语言,非常简洁就实现循环嵌套。
    这些Python专有的表达式,我们称之为Python语句,很Python.

    # Python 专用的列表表达式-循环嵌套形式
    [expression for i in list1 for j in list2]
    # 完全等价于如下for循环嵌套形式
    for i in list1:
    	for j in list2:
    	expression
    

    我们先看普通的for循环嵌套程序实例:
    将两个字符串的字符相加,形成新的列表。

    new_list = 
    展开全文
  • 列表推导式 所谓列表推导式,就是将一个可迭代的列表遍历,将每次遍历的元素拿出来进行一些操作,并用一个【】括起来,组成一个新的列表 语法 [expression for i in item if condition] expression 就是对每一个...
  • 直接看代码: Microsoft Windows [版本 10.0.18363.1198] ...Python 3.7.4 (tags/v3.7.4:e09359112e, Jul 8 2019, 20:34:20) [MSC v.1916 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "lice
  • Python官网列表推导式部分 列表推导式提供了一种创建list的简便方法。应用程序创建列表时,列表中的元素来源于其他序列、可迭代对象或创建的一个满足一定条件的序列。 基本格式: ​[表达式 for 变量 in 列表] 或者...
  • Python中的嵌套列表推导式

    千次阅读 2017-12-25 15:58:44
    python列表推导式处理嵌套列表
  • Python 列表推导式

    2020-09-08 14:36:39
    print("Python 列表推导式") # 普通的应用程式通过将一些操作应用于序列的每个成员并通过返回的元素创建列表,或者通过满足特定条件的元素创建子序列。 x = 0 # squares = list(map(lambda x: x ** 2, range(10)...
  • python 列表推导式

    2018-03-06 14:39:20
    python列表推导式 &gt;&gt;&gt; aList = [x*x for x in range(10)] 相当于: &gt;&gt;&gt; aList = [] &gt;&gt;&gt;for x in range(10): ... aList.append(x*x) 下面...
  • 1、列表推导式 列表推导式列表推导式提供了一种简洁的方法创建列表 优势:代码更加简洁、更加清晰、更加易读 注意:当写出来的代码变得复杂,那就别使用列表推导式来了。 1.1、如果不用列表推导式,怎么从列表...
  • python列表推导式

    2021-04-29 20:09:15
    python列表推导式 响应数据的文本格式很多是列表嵌套字典的格式,如何获取类似结构中的数据并且存成一个新的列表 可以参考~ 列表套字典的数据获取 #获取list1中name、age的value值并且存起来 list=[{'name':yang,'...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,823
精华内容 2,729
关键字:

python列表推导式嵌套

python 订阅