Python的递推式构造列表(List comprehension)

介绍



我们在上一章学习了“Lambda 操作, Filter, Reduce 和 Map”, 但相对于map, filter, reduce 和lamdba, Guido van Rossum更喜欢用递推式构造列表(List comprehension)。在这一章我们将会涵盖递推式构造列表(List comprehension)的基础功能。 递推式构造列表(List comprehension)是在Python 2.0中添加进来的。本质上,它是一种数学家用来实现众所周知标记集合的Python方式。

在数学上,自然数的平方数是:{ x2 | x ∈ ? } 或者复数:{ (x,y) | x ∈ ? ∧ y ∈ ? }.

在Python里,递推式构造列表(List comprehension)是一种定义和创建列表的优雅方式,这些列表通常是有一些约束的集合,并不是所有案例的集合。

对于函数map(), filter(), 和reduce(),递推式构造列表(List comprehension)是一个完整的lambda替代者。对于大部分人们,递推式构造列表(List comprehension)的语法更容易被人们掌握。

举列



在lamdba和map()这一章里,我们曾经设计了map()函数去把摄氏度的值转化为华氏度的值及其反函数。用递推式构造列表(List comprehension),可以这样表示:

>>> Celsius = [39.2, 36.5, 37.3, 37.8]
>>> Fahrenheit = [ ((float(9)/5)*x + 32) for x in Celsius ]
>>> print Fahrenheit
[102.56, 97.700000000000003, 99.140000000000001, 100.03999999999999]
>>> 

下面的递推式构造列表(list comprehension)创建了毕达哥拉斯三元组:

>>> [(x,y,z) for x in range(1,30) for y in range(x,30) for z in range(y,30) if x**2 + y**2 == z**2]
[(3, 4, 5), (5, 12, 13), (6, 8, 10), (7, 24, 25), (8, 15, 17), (9, 12, 15), (10, 24, 26), (12, 16, 20), (15, 20, 25), (20, 21, 29)]
>>> 

两个集合的交叉乘积:

>>> colours = [ "red", "green", "yellow", "blue" ]
>>> things = [ "house", "car", "tree" ]
>>> coloured_things = [ (x,y) for x in colours for y in things ]
>>> print coloured_things
[(‘red‘, ‘house‘), (‘red‘, ‘car‘), (‘red‘, ‘tree‘), (‘green‘, ‘house‘), (‘green‘, ‘car‘), (‘green‘, ‘tree‘), (‘yellow‘, ‘house‘), (‘yellow‘, ‘car‘), (‘yellow‘, ‘tree‘), (‘blue‘, ‘house‘), (‘blue‘, ‘car‘), (‘blue‘, ‘tree‘)]
>>> 

递推式构造生成器(Generator Comprehension)



递推式构造生成器(generator comprehension)在Python2.6中被介绍过。它们是一个简单的用圆括号括起来的生成表达式,除此之外,它的语法和工作原来都很像递推式构造列表(List comprehension),但是递推式构造生成器(generator comprehension)返回的是一个生成器而不是一个列表。

>>> x = (x **2 for x in range(20))
>>> print(x)
 at 0xb7307aa4>
>>> x = list(x)
>>> print(x)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]

一些更高级的例子



利用埃拉托斯特尼筛法(Sieve of Eratosthenes)计算1到100的质数:

>>> noprimes = [j for i in range(2, 8) for j in range(i*2, 100, i)]
>>> primes = [x for x in range(2, 100) if x not in noprimes]
>>> print primes
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
>>> 

我们把前面的例子写成更通俗的格式,所以我们可以计算到任意数n的质数的列表:

>>> from math import sqrt
>>> n = 100
>>> sqrt_n = int(sqrt(n))
>>> no_primes = [j for i in range(2,sqrt_n) for j in range(i*2, n, i)]

如果我们去看no_primes的内容,就会发现一个问题。这里有很多重复的元素在这个列表里:

>>> no_primes
[4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99]
>>>

这个无法容忍的问题将会在递推式构造集合(set comprehension)中被解决,我们将会在下一节中讲解

递推式构造集合(set comprehension)



递推式构造集合(set comprehension)与递推式构造列表(list comprehension)是很相似的,但是返回的是一个集合而不是列表。语法上,我们将采用花括号代替方括号去创建一个集合。递推式构造集合(set comprehension)是解决前一节中问题的正确方法。我们可以创建一个没有重复元素的非质数集合:

>>> from math import sqrt
>>> n = 100
>>> sqrt_n = int(sqrt(n))
>>> no_primes = {j for i in range(2,sqrt_n) for j in range(i*2, n, i)}
>>> no_primes
{4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28, 30, 32, 33, 34, 35, 36, 38, 39, 40, 42, 44, 45, 46, 48, 49, 50, 51, 52, 54, 55, 56, 57, 58, 60, 62, 63, 64, 65, 66, 68, 69, 70, 72, 74, 75, 76, 77, 78, 80, 81, 82, 84, 85, 86, 87, 88, 90, 91, 92, 93, 94, 95, 96, 98, 99}
>>> primes = {i for i in range(n) if i not in no_primes}
>>> print(primes)
{0, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97}
>>> 

利用递归函数来计算质数


下面的Python脚本使用递归函数来创建质数,他的功能完全可以去检查一个到n的平方根的多个质数:

from math import sqrt
def primes(n):
    if n == 0:
        return []
    elif n == 1:
        return [1]
    else:
        p = primes(int(sqrt(n)))
        no_p = {j for i in p for j in range(i*2, n, i)}
        p = {x for x in range(2, n) if x not in no_p}
    return p

print(primes(40))

转载请注明出处



原文(英文):http://www.python-course.eu/list_comprehension.php

译文(中文):http://www.cnblogs.com/reanote/p/python_list_comprehension.html

时间: 2024-10-15 15:42:56

Python的递推式构造列表(List comprehension)的相关文章

hdu 1757 A Simple Math Problem (构造矩阵解决递推式问题)

题意:有一个递推式f(x) 当 x < 10    f(x) = x.当 x >= 10  f(x) = a0 * f(x-1) + a1 * f(x-2) + a2 * f(x-3) + -- + a9 * f(x-10) 同时ai(0<=i<=9) 不是 0 就是 1: 现在给你 ai 的数字,以及k和mod,请你算出 f(x)%mod 的结果是多少 思路:线性递推关系是组合计数中常用的一种递推关系,如果直接利用递推式,需要很长的时间才能计算得出,时间无法承受,但是现在我们已知

【HDU4990】递推式

题目大意:给定序列 1, 2, 5, 10, 21, 42, 85, 170, 341 …… 求第n项 模 m的结果 递推式 f[i]  = f[i - 2] + 2 ^ (i - 1); 方法一: 构造矩阵, 求递推式 方法二: 直接推公式,递推式求和,得到 f[n] = [2 ^ (n + 1) - 1] / 3 奇数, f[n] = [2 ^ (n + 1) - 2] / 3 偶数: 其实还可以进一步化简, 注意到 2 ^ 2k % 3 = 1, 2 ^ (2k + 1) % 3 = 2,

错排递推式推导

今天听课讲容斥,提到错排,突然发现错排公式什么的好像已经忘了233 努力地回忆了一下,算出前几项,终于还原出了那个递推式↓ f(n)=(n-1)*(f(n-1)+f(n-2)) 根据人赢的教导,只要思(yi)考(yin)下错排的构造就能记住了 然后就认(meng)认(you)真(yi)真(yang)地思(yi)考(yin)了下 用自己的理解把这玩意儿整理了一下↓ 先加一点平时我们说的错排通常是指1~n,f(i)≠i, 其实脑补一下,它也可以看成A,B两个集合,|A|=|B|,对于每一个Ai,都对

[题解][SHOI2013]超级跳马 动态规划/递推式/矩阵快速幂优化

这道题... 让我见识了纪中的强大 这道题是来纪中第二天(7.2)做的,这么晚写题解是因为 我去学矩阵乘法啦啦啦啦啦对矩阵乘法一窍不通的童鞋戳链接啦 层层递推会TLE,正解矩阵快速幂 首先题意就是给你一个 n 行m 列 的格子图 一只马从棋盘的左上角跳到右下角.每一步它向右跳奇数列,且跳到本行或相邻行. 题意很简单暴力dp的思路也很简单但是数据很恶心虽然远古一点,但毕竟是省选题 1 ≤ n ≤ 50,2 ≤ m ≤ 10^9 不过还是给了我们一点提示:n这么小? 总之我们先找出转移式对于每一个点

矩阵乘法(四):分析问题,确定递推式,采用矩阵快速幂求解

应用矩阵快速幂运算可以解决递推问题.在实际应用中,有时候题目并没有直接给出递推式,需要认真分析问题,找出递推式,然后再利用矩阵快速幂运算加快问题的求解. [例1]程序阅读理解. 有如下的C语言程序: #include <stdio.h>int main(){     int n,m,f,i;     while(scanf("%d%d",&n,&m)!=EOF)     {           f=0;           for(i=1;i<=n;i

递推式转化为矩阵形式

EXAMPLE: 递推式: d(n + 2) = p * d(n + 1) + (1 - p) * d(n); 令G(n) = (d(n + 2), d(n + 1))^T; 则 G(n + 1) = M * G(n); 解得 M = p   1 - p 1    0 G(n) = (M ^ n) * G(0); #

hiho 1143 矩阵快速幂 求递推式

题目链接: hihocoder 1143 思路见题目上 快速幂模板: // m^n % k int quickpow(int m,int n,int k) { int b = 1; while (n > 0) { if (n & 1) b = (b*m)%k; n = n >> 1 ; m = (m*m)%k; } return b; } 题解: #include<iostream> #include<cstdio> #include<cstring

51nod1149 Pi的递推式

基准时间限制:1 秒 空间限制:131072 KB 分值: 640 F(x) = 1 (0 <= x < 4) F(x) = F(x - 1) + F(x - pi) (4 <= x) Pi = 3.1415926535..... 现在给出一个N,求F(N).由于结果巨大,只输出Mod 10^9 + 7的结果即可. Input 输入一个整数N(1 <= N <= 10^6) Output 输出F(N) Mod 10^9 + 7 Input示例 5 Output示例 3 数学问

一只青蛙从第一级台阶跳到第n级,每次可以跳任意级,共有多少种跳法,并写出递推式

是斐波那契数列问题 假设f(n)是n个台阶跳的次数:(假设已经调到第n个台阶,最后一次是由哪个台阶跳上来的) f(n) = f(n-1)+f(n-2)+...+f(n-(n-1)) + f(n-n) == f(0) + f(1) + f(2) + f(3) + ... + f(n-2) + f(n-1) == f(n) = 2*f(n-1) 所以,可以得出递推式: 1 public static int jumpFloor(int n) { 2 if (n <= 0) 3 return 0; 4