精华内容
下载资源
问答
  • sentences=[y for x in sentences for y in x] 之前没看到过,一头雾水,经过查资料后发现是这样去理解的: def f(z): for y in z: for x in y: yield x 英文描述:[item for sublist in list for item i...

    看代码时偶然看到的一个写法:

    sentences=[y for x in sentences for y in x]

    之前没看到过,一头雾水,经过查资料后发现是这样去理解的:

    def f(z):
        for y in z:
            for x in y:
               yield x

    英文描述:[item for sublist in list for item in sublist]

    也就是:子列表中项目的子列表项目

     效果展示:

    > # 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]

    作用:将列表展平

    当然还有更高级的用法:

     [(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)]

    最后附上python3官方文档连接:https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions

    展开全文
  • https://www.pythoncentral.io/how-to-use-pythons-xrange-and-range/ xrange() 函数用法与 range 完全相同,所不同的是生成的不是一个数组,而是一个生成器。 ... ...
    
    

    xrange() 函数用法与 range 完全相同,所不同的是生成的不是一个数组,而是一个生成器。
    http://www.runoob.com/python/python-func-xrange.html

    展开全文
  • 语法分解:[程序最终执行的语句(变量x) for 变量x in range(n) 条件语句(if)或for 变量x in range(n)]  执行顺序:1.先执行中间的for语句  2.再执行最后面的条件语句或者嵌套for语句中的for  3.最后执行程序...
    语法分解:[程序最终执行的语句(变量x)  for 变量x in range(n) 条件语句(if)或for 变量x in range(n)]
           执行顺序:1.先执行中间的for语句
                2.再执行最后面的条件语句或者嵌套for语句中的for
                3.最后执行程序最终要达到目的的语句
    ------------------------------------------------------------------------------------- 等价于:
    for 变量x in range(n): if 条件 : 程序最终执行的语句

     

    列表推导是一种从其他列表创建列表的方式,类似于数学中的集合推导列表推导的工作原理非常简单,有点类似于for循环。

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

    这个列表由range(10)内每个值的平方组成,非常简单吧?如果只想打印那些能被3整除的平方值,该如何办呢?可使用求模运算符:如果y能被3整除,y % 3将返回0(请注意,仅当x能被3整除时,x*x才能被3整除)。为实现这种功能,可在列表推导中添加一条if语句。

    >>> [x*x for x in range(10) if x % 3 == 0]
    [0, 9, 36, 81]
    '''
      语法分解:[程序最终执行的语句(变量x) for 变量x in range(n) 条件语句(if)或for 变量x in range(n)]
           执行顺序:1.先执行中间的for语句
                2.再执行最后面的条件语句或者嵌套for语句中的for
                3.最后执行程序最终要达到目的的语句
    '''

    还可添加更多的for部分。

    >>> [(x, y) for x in range(3) for y in range(3)]
    [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

    按照上面程序的执行步骤我们可以改写验证:

    >>> for x in range(3):
    ...            for y in range(3):
    ...                    (x,y)
    ...
    (0,0)
    (0,1)
    (0,2)
    (1,0)
    (1,1)
    (1,2)
    (2,0)
    (2,1)
    (2,2)

    很明显咱们的验证是对的。它们最原始的样子应该是这个样子的,它们会返回一组组元组数据,它们输出的时候是零散的,所以我们要把它们收集起来,我们可以把它们装入列表。操作方法可以是直接在列表[]里面写这个代码,还有一种便是使用list()创建一个列表。如下:

    >>> list_number = list((x,y) for x in range(3) for y in range(3))
    >>> list_number
    [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

     

    转载于:https://www.cnblogs.com/iBoundary/p/11241045.html

    展开全文
  • 用python写杨辉三角时有一句代码是L=[L[X]+L[X+1]for x in range(len(L)-1)] 我想知道当len(L)=1时 x值为多少
  • 除了像上面介绍的 [x ** 2 for x in L] 这种基本语法之外,列表推导式还有一些高级的扩展。 4.1. 带有if语句 我们可以在 for 语句后面跟上一个 if 判断语句,用于过滤掉那些不满足条件的结果项。 例如,我想去除...

    http://www.cnblogs.com/bonelee/p/8545263.html

    高级语法

    除了像上面介绍的 [x ** 2 for x in L] 这种基本语法之外,列表推导式还有一些高级的扩展。

    4.1. 带有if语句

    我们可以在 for 语句后面跟上一个 if 判断语句,用于过滤掉那些不满足条件的结果项。

    例如,我想去除列表中所有的偶数项,保留奇数项,可以这么写:

    >>> L = [1, 2, 3, 4, 5, 6]
    >>> L = [x for x in L if x % 2 != 0]
    >>> L
    [1, 3, 5]
    

    4.2. 带有for嵌套

    在复杂一点的列表推导式中,可以嵌套有多个 for 语句。按照从左至右的顺序,分别是外层循环到内层循环。

    例如:

    >>> [x + y for x in 'ab' for y in 'jk']
    ['aj', 'ak', 'bj', 'bk']
    

    4.3. 既有if语句又有for嵌套

    列表推导式可以带任意数量的嵌套 for 循环,并且每一个 for 循环后面都有可选的 if 语句。

    通用语法:

    [ expression for x in X [if condition]
                 for y in Y [if condition]
                 ...
                 for n in N [if condition] ]
    

    例如,下面的代码输出了0~4之间的偶数和奇数的组合。

    >>> [(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)]
    

    等价于下面的一般 for 循环:

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

    4.4. 列表推导式生成矩阵

    生成矩阵的方式有多种,例如手动赋值、一般for循环,还有就是列表推导式。如果我们要用列表推导式生成下面的矩阵,可以怎么写?

    >>> M = [[1, 2, 3],
    ... [4, 5, 6],
    ... [7, 8, 9]]
    

    一种方法是:

    >>> M = [[x, x+1, x+2] for x in [1, 4, 7]]
    >>> M
    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    

    矩阵的列数少时可以使用这种方法。

    如果矩阵的列数较多,我们可以使用另外一种方式:在循环变量的表达式中使用列表推导式。

    具体代码如下:

    >>> M = [[y for y in range(x, x+3)] for x in [1, 4, 7]]
    >>> M
    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    

    与之前带 for 嵌套的语法不同,这个例子中,实际使用的是最基本的 [expression for x in L] 语法,只有一个 for 语句。

    复杂的地方在于前面的变量表达式 expression 不再是简单的变量运算,而是一个列表推导式,在这个例子中就是 [y for y in range(x, x+3)]
    内层的列表推导式返回一个行向量,而这些行向量经由外层的列表推导式,最终形成一个二维列表,也就是我们想要的矩阵。

    当然,在实际的应用中不能单纯追求代码的简洁,还要考虑到代码的可读性和维护成本。
    如果代码变得过于复杂,不易于理解,我们宁可多写几行代码来增加它的可读性。

    5. 生成器表达式

    生成器表达式与列表推导式的语法相同,区别在于生成器表达式的外面使用圆括号,而列表推导式使用方括号。

    有关生成器的介绍,请参考这篇文章:《Python高级编程之初识生成器》

    6. 集合推导式和字典推导式

    注意:集合推导式和字典推导式只有在Python2.7以及之后的版本中才有,Python2.7之前的版本不支持这两种推导式。

    集合推导式的语法与列表推导式相同,只需要把外面的方括号改成花括号即可。

    例如,我们可以通过以下方式来生成一个集合:

    >>> {x ** 2 for x in [1, 2, 2]}
    {1, 4}
    

    字典推导式的外面也是使用花括号,不过花括号的内部需要包含键值两部分。

    在值不重复的情况下,我们可以通过字典推导式快速交换键值对:

    >>> D = {'a':1, 'b':2, 'c':3}
    >>> D = {value: key for key, value in D.items()}
    >>> D
    {1: 'a', 2: 'b', 3: 'c'}
    

    from:http://www.codebelief.com/article/2017/02/python-advanced-programming-list-comprehensions/

     

    lix = [];
    for x in range(1, 101):
        lix.push(x ** 2)
    执行结果:lix = [1,4,9,16,25.....]
    

    在列表构建器的表达式中,可以添加简单的条件处理

    lix = [x * x for x in range(1, 101) if x % 2 == 0]
    执行结果:lix = [4,16,36.....]
    

    也可以在循环过程中,来使用多层循环嵌套,实现更加复杂的效果

    lix = [x + y  for x in "abc" for y in "xyz"]
    执行结果:['ax', 'ay', 'az', 'bx', 'by', 'bz', 'cx', 'cy', 'cz']
    

    列表动态构建器

    但是我们通过前面的学习已经知道,这些数据都是加载到内存中的,如果列表中的数据量比较大的情况下,内存消耗是比较严重的
    在某些情况下,我们只需要使用列表中的一部分数据,后面的数据并不是特别关心,如:通过列表来记录一个符合某种规则的序列,每次我们只是关心下一个数据,并不关心后面的N条数据,应该怎么做呢?比如我们需要一个奇数列表

    # 常规构建器的做法
    lix = [2*x + 1 for x in range(1, 101)]
    # 执行结果:[1,3,5,7,9,11,13,15,17.....]
    # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    # 常规构建器可以直接构建生成
    # 但是存在问题,如果一次构建的数据量太大,会严重占用内存
    # 我们在使用该列表的时候,有可能只是使用前10项
    # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    # 使用列表动态构建器
    lix = (2 * x - 1 for x in range(1, 101))
    # 执行结果:print (lix) --> <generator object <genexpr> at 0x7f232e462048>
    next(lix)
    # 执行结果:1
    next(lix)
    # 执行结果:3
    next(lix)
    # 执行结果:5
    next(lix)
    # 执行结果:7
    # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    # 列表动态构建器
    # 和构建器基本没有区别,创建的时候列表中是没有数据的
    # 必须通过next()函数来获取列表中的下一条数据
    # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    


    from:https://www.jianshu.com/p/fa3fda487f15

     

     

    []改成(),就创建了一个generator:

    >>> L = [x * x for x in range(10)]
    >>> L
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    >>> g = (x * x for x in range(10))
    >>> g
    <generator object <genexpr> at 0x1022ef630>
    

    L和g的区别仅在于最外层的[]()L是一个list,而g是一个generator。

    如果要一个一个打印出来,可以通过next()函数获得generator的下一个返回值:

    >>> next(g)
    0
    >>> next(g)
    1
    >>> next(g)
    4
    >>> next(g)
    9
    >>> next(g)

    next(g)实在是太变态了,正确的方法是使用for循环,因为generator也是可迭代对象:

    >>> g = (x * x for x in range(10))
    >>> for n in g:
    ...     print(n)
    ... 
    0
    1
    4
    9
    要把fib函数变成generator,只需要把print(b)改为yield b就可以了:
    def fib(max):
        n, a, b = 0, 0, 1
        while n < max:
            yield b
            a, b = b, a + b
            n = n + 1
        return 'done'
    
    
     

    yield关键字,那么这个函数就不再是一个普通函数,而是一个generator:

    
     
    >>> f = fib(6)
    >>> f
    <generator object fib at 0x104feaaa0>
    
    
     

    return语句或者最后一行函数语句就返回。而变成generator的函数,在每次调用next()的时候执行,遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行。

     
    展开全文
  • x*2 for x in y 链表推导式生成链表的一种办法就是链表推导式,这种形如 x*2 for x in y 的形式就是链表推导式,通俗易懂,简单好用。链表推导式在for语句前面,for后面就是对参数的限定。[ x*2 for x in y ](必须用...
  • js for(x in array )的用法

    2018-11-15 09:36:18
    var person = {fname:"...for(x in person ){  console.log(x);   console.log(person [x])  } 打印出来的内容时 fname  John lname  Doe age 25 x就是他的键。person [x]就是值。这是处理的对象。 ...
  • 列表推导式[x for x in range(n)]

    万次阅读 多人点赞 2018-05-24 00:10:53
    1.匿名函数 匿名函数语法形式: lambda [arg1,arg2,arg3,argn]:expression 注解: lambda 关键字 argi 函数参数 expression 程序逻辑,即函数要返回值的表达式 ... c = lambda x,y:x * x + y...
  • 今天在写一个自定义view时,加入了通过xml传递参数,但是xml出现了No resource identifier found for attribute X in package X,我看了下教程感觉好像基本上代码差不多,后来查了google,发现这个声明的命名空间...
  • x[0] for x in counter.items()的使用

    千次阅读 2018-09-12 16:40:09
    c是类Counter的实例化。c.item()是将字典转化成列表,这个列表的每个元素是一个元组。而我们又需要提取元组的第一位。 代码如下: from collections import ...word_counts = [x for x in c.items()] word=[x...
  • python中[x for x in range(n)]列表推导式

    千次阅读 2019-12-05 21:25:21
    列表推导式的执行顺序:各语句之间是嵌套关系,左边第二个语句是最外层,依次往右进一层,左边第一条语句是最后一层。...scales = [i for i in range(5, 1, -1)] 也可以配合for in 进行循环 ...
  • for x in ...循环 就是把每个元素代入变量x,然后执行缩进块的语句。 range()函数,可以生成一个整数序列,再通过list()函数可以转换为list。 比如我们想计算1-10的整数之和,可以用一个sum变量做累加: sum = 0...
  • a = [lambda : x for x in range(3)] &gt;&gt;&gt; a [&lt;function &lt;listcomp&gt;.&lt;lambda&gt; at 0x7f79c874ae18&gt;, &lt;function &lt;li
  • python列表解析([ x for x in list])

    千次阅读 2016-03-06 20:30:57
    转载至 列表解析 定义和说明 >Python 的强大特性之一是其对 list 的解析,它提供一种紧凑的方法,...>列表解析比 for 更精简,运行更快,特别是对于较大的数据集合 >列表解析可以替代绝大多数需要用到 map和 filt
  • a = [lambda x:x*i for i in range(3)]问题

    千次阅读 2019-09-20 22:17:56
    a = [lambda x:x*i for i in range(3)]求下列输出 print(a) print(a[0](2)) print(a[1](3)) print(a[2](4)) *输出结果*: [<function <listcomp>.<lambda> at 0x000001DBF9649730>, <...
  • enumerate就是枚举的意思,把元素一个个列举出来,第一个是什么,第二个是什么,所以他返回的是元素以及对应的索引。... for i,j in enumerate(line): ... print(i,j) ... 0 1 1 2 2 3 3 4 4 5 ...
  • print(list(map(lambda x: x * x, [y for y in range(3)])))的输出结果? print(list(map(lambda x: x * x, [y for y in range(3)]))) 首先列表推导式生成[0,1,2] [y for y in range(3)] 然后map函数接受...
  • items是列表 items =[[x, y]for (y, x) in pairs]是什么意思

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 372,281
精华内容 148,912
关键字:

forinxx