Python之列表推导式最全汇总(中篇)

目录
  • 前言
  • 列表推导式
  • 语法规范：
  • 初阶实例
    • 1000~2021中包含7的数字有多少
  • 求所有在100到1000之间的水仙花数
    • 通常的解法，条件表达式比较麻，如果是10位数呢
    • 把数字转成字符串，然后遍历计算立方和
  • 一维与二维列表间的互转
  • 实现二维列表的转置
    • 行列互换，首行变首列，尾行变尾列，如下所示：
  • 求列表嵌套的最大深度
  • 求斜边长小于100的勾股数组
  • 实现随机字符串(可作随机密码)
  • 一个四层嵌套的推导式：求k等差数
  • 附录

前言

网传的七天学Python的路线如下，我觉得可以在学过此表中前几天的内容后，就可以回头来学习一下

列表推导式：它综合了列表、for循环和条件语句。

第一天：基本概念(4小时) ： print,变量，输入，条件语句。

第二天：基本概念(5小时) ：列表，for循环，while循环，函数，导入模块。

第三天：简单编程问题(5小时) ：交换两个变量值，将摄氏度转换为华氏温度，求数字中各位数之和， 判断某数是否为素数， 生成随机数，删除列表中的重复项等等。

第四天：中级编程问题(6小时) ：反转-个字符串(回文检测)，计算最大公约数，合并两个有序数组，猜数字游戏，计算年龄等等。

第五天：数据结构(6小时) ：栈，队列，字典，元组，树，链表。

第六天：面向对象编程(OOP) (6小时) ：对象，类，方法和构造函数，面向对象编程之继承。

第七天：算法(6小时) ：搜索(线性和二分查找)、 排序(冒泡排序、 选择排序)、递归函数(阶乘、斐波那契数列)时间复杂度(线性、二次和常量)。

列表推导式

  • list comprehension或译为列表解析式，是一种创建列表的简洁语法；
  • 也可认为它是一个简版的for循环，但执行效率高于for循环。
  • python 2.7+ 开始又引入了集合推导式、字典推导式，原理与列表推导式相近。

语法规范：

out_list = [out_express for out_express in input_list if out_express_condition]

其中，

  • if 条件可有可无；
  • for 循环可以嵌套多层，内外层循环的变量不可以同名；
  • 推导式中也可以嵌套推导式，内外层推导式的变量互不影响，可以同名；
  • 推导表达式out_express尽可能用内置函数，省得import或def function()。

初阶实例

1000~2021中包含7的数字有多少

>>> sum([1 for i in range(1000,2022) if '7' in str(i)])
273
>>> [i for i in range(1000,2022) if '7' in str(i)]
[1007, 1017, 1027, 1037, 1047, 1057, 1067, 1070, 1071, 1072, 1073, 1074, 1075, 1076,
 1077, 1078, 1079, 1087, 1097, 1107, 1117, 1127, 1137, 1147, 1157, 1167, 1170, 1171,
 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1187, 1197, 1207, 1217, 1227, 1237,
 1247, 1257, 1267, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1287,
 1297, 1307, 1317, 1327, 1337, 1347, 1357, 1367, 1370, 1371, 1372, 1373, 1374, 1375,
 1376, 1377, 1378, 1379, 1387, 1397, 1407, 1417, 1427, 1437, 1447, 1457, 1467, 1470,
 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1487, 1497, 1507, 1517, 1527,
 1537, 1547, 1557, 1567, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579,
 1587, 1597, 1607, 1617, 1627, 1637, 1647, 1657, 1667, 1670, 1671, 1672, 1673, 1674,
 1675, 1676, 1677, 1678, 1679, 1687, 1697, 1700, 1701, 1702, 1703, 1704, 1705, 1706,
 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720,
 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734,
 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748,
 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762,
 1763, 1764, 1765, 1766, 1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776,
 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785, 1786, 1787, 1788, 1789, 1790,
 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1807, 1817, 1827, 1837, 1847,
 1857, 1867, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1887, 1897,
 1907, 1917, 1927, 1937, 1947, 1957, 1967, 1970, 1971, 1972, 1973, 1974, 1975, 1976,
 1977, 1978, 1979, 1987, 1997, 2007, 2017]
>>>

1000~2021中“包含7且能被7整除”的数字有多少

>>> sum([1 for i in range(1000,2022) if '7' in str(i) and i%7==0])
39
>>> [i for i in range(1000,2022) if '7' in str(i) and i%7==0]
[1057, 1071, 1078, 1127, 1176, 1197, 1267, 1274, 1337, 1372, 1379, 1407, 1470, 1477, 1547, 1575, 1617, 1673, 1687, 1701, 1708, 1715, 1722, 1729, 1736, 1743, 1750, 1757, 1764, 1771, 1778, 1785, 1792, 1799, 1827, 1876, 1897, 1967, 1974]
>>>

小于1000000的所有正整数一共包含有多少个数字“7”

>>> num=lambda n:sum([str(i).count('7') for i in [i for i in range(1,n+1)] if '7' in str(i)])
>>> num(999999)
600000
>>> # if '7' in str(i) 可省掉，即0也合计结果一样

求所有在100到1000之间的水仙花数

水仙花数定义：指一个正整数的各位数字的立方和等于其本身。

通常的解法，条件表达式比较麻，如果是10位数呢

>>> for i in range(100,1000):
	if i==(i //100)**3 + (i//10%10)**3 + (i%10)**3:
		print(i, end=' ')

153 370 371 407
>>>
>>> # 改写成列表推导式：
>>> [i for i in range(100,1000) if i==(i //100)**3 + (i//10%10)**3 + (i%10)**3]
[153, 370, 371, 407]
>>>

把数字转成字符串，然后遍历计算立方和

>>> >>> for i in range(100,1000):
	k=0
	for j in str(i):
		k+=int(j)**3
	if k==i:
        print(i,end=' ')

153 370 371 407
>>>
>>> # 转成列表推导式：
>>> [n for i,n in enumerate([sum([int(i)**3 for i in str(j)]) for j in range(100,1000)]) if i+100==n]
[153, 370, 371, 407]
>>>

一维与二维列表间的互转

>>> *a,=range(1,10)
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b=[a[i:i+3] for i in range(0,len(a),3)]
>>> b
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>>
>>> c=[j for i in b for j in i]
>>> c
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> sum(b,[])
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> # 很高级的方法 # pythonic

 实现二维列表的转置

行列互换，首行变首列，尾行变尾列，如下所示：

'''''''''''''''''''
[ [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9] ]
     ↓↓↓
[ [1, 4, 7],
  [2, 5, 8],
  [3, 6, 9] ]
推导式如下：
'''''''''''''''''''

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

使用zip()函数：优点不用考虑数组的行数和列数，但直接结果是元组的列表，需转换下

>>> arr=[[1,2,3], [4,5,6], [7,8,9]]
>>> list(zip(*arr))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>>
>>> arr=[[1,2,3], [4,5,6], [7,8,9]]
>>> arr=[list(i) for i in zip(*arr)]
>>> arr
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
>>> arr=[list(i) for i in zip(*arr)]
>>> arr
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> # 换一个3行4列的：
>>> arr=[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
>>> arr=[list(i) for i in zip(*arr)]
>>> arr
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
>>> arr=[list(i) for i in zip(*arr)]
>>> arr
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
>>>

使用numpy库：特有numpy.array()可与list()相互转换

>>> import numpy as np
>>> np.arange(1,10)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> # 或者：
>>> np.array([*range(1,10)])
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>>
>>> list(np.arange(1,10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> np.arange(1,10).reshape((3, 3))
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> arr=np.arange(1,10).reshape((3, 3))
>>> [list(i) for i in arr]
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>>
>>> [j for i in arr for j in i]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> 

# 附：用numpy生成一个3行5列的随机数矩阵，数值范围[1,10)：
>>> [list(i) for i in __import__('numpy').random.randint(1,10,(3,5))]
[[6, 3, 6, 7, 8], [4, 9, 5, 8, 7], [8, 4, 1, 2, 1]]
>>>

求列表嵌套的最大深度

思路：遍历列表，只要还有一个元素是列表，就删除非列表元素然后进行降维；循环到所有元素都为非列表为止。

代码如下，自定义函数就用了两个推导式一个循环语句

>>> def func(L):
	if not isinstance(L,list):  # or: if type(L) is not list:
		return 0
	k=1
	while any([isinstance(i,list) for i in L]):
		k+=1
		L=[j for i in [i for i in L if isinstance(i,list)] for j in i]
	return k

>>> l = [1, 2, [3, [4, [5, 6], [7, [8], [[9, 10], [11, [12, 13, 14], 15]]]]]]
>>> func(l)
7
>>>

注：内置函数 isinstance(i,list) 判断一个对象i是否为某个指定类型，等价于type(i) is list。

例如： isinstance(123,int) 和 type(123) is int 都返回True。

 求斜边长小于100的勾股数组

代码如下，其中 A 有直角边互换的重复，B用条件a<b约束，C把约束条件放进 range() 函数中。

>>> A=[(a,b,c) for a in range(1,100) for b in range(1,100) for c in range(1,100) if a**2+b**2==c**2]
>>> B=[(a,b,c) for a in range(1,100) for b in range(1,100) for c in range(1,100) if a<b and a**2+b**2==c**2]
>>> C=[(a,b,c) for a in range(1,100) for b in range(a,100) for c in range(1,100) if a**2+b**2==c**2]
>>> A==B
False
>>> len(A)==len(B)*2
True
>>> B==C
True
>>> C
[(3, 4, 5), (5, 12, 13), (6, 8, 10), (7, 24, 25), (8, 15, 17), (9, 12, 15), (9, 40, 41),
(10, 24, 26), (11, 60, 61), (12, 16, 20), (12, 35, 37), (13, 84, 85), (14, 48, 50), (15,
20, 25), (15, 36, 39), (16, 30, 34), (16, 63, 65), (18, 24, 30), (18, 80, 82), (20, 21,
29), (20, 48, 52), (21, 28, 35), (21, 72, 75), (24, 32, 40), (24, 45, 51), (24, 70, 74),
(25, 60, 65), (27, 36, 45), (28, 45, 53), (30, 40, 50), (30, 72, 78), (32, 60, 68), (33,
44, 55), (33, 56, 65), (35, 84, 91), (36, 48, 60), (36, 77, 85), (39, 52, 65), (39, 80,
89), (40, 42, 58), (40, 75, 85), (42, 56, 70), (45, 60, 75), (48, 55, 73), (48, 64, 80),
(51, 68, 85), (54, 72, 90), (57, 76, 95), (60, 63, 87), (65, 72, 97)]

实现随机字符串(可作随机密码)

>>> import string,random
>>> [''.join(random.sample(string.printable[:-6],10)) for _ in range(30)]
['\\T[~(]J#"+', '):0~He7Dam', 'zw=?>7a(&^', 'v<c@W:!&VP', 'y\\~W6{u:P1', 'R)il~3p+;y',
 "PGQ_'{.k15", 'Z"^w=P&3{R', 'yMGR[g_65$', "4.)Q7$COd'", 'WTptgYS$Nj', 'Ra$4Lrvu2)',
 ',V$z.C8>L(', '/YwfR#ZuM@', '>~){Q7ayUo', 'Ol]54z|a;\\', 'Dp80fV,\\-@', '[kB{he98&r',
 "E]$'Q@R-`0", 'm{qMBRD.p2', '=.Is;r>%/x', 'o7zS{DQ~Tx', 'hH:E{s?#Gt', 'WB]`%\\f.FT',
 'Mbxu&8YEN_', '5Et+3dGAf%', 'k5#o_]2Y?T', '$K3(yD7wvJ', '^5kJ*Nn:jz', '8,q7/Oyb*3']
>>>
>>> [''.join(random.sample(string.ascii_letters+string.digits*5,10)) for _ in range(30)]
['ugON2AoS10', '3E62mQ2sP8', 'sL76c4Ppyj', 'hS967O15bX', '7n8580rq01', 'B75C178051',
 '8Mvc0g52wd', 'Zv08H3GED8', '158F1Kd36o', '914FM222TK', 'n5I5aqY66h', '91Tz8P5yMf',
 '22K9tPLoHn', 'gR5862BZj9', '319pO53389', 'z31R67r811', 'E1duG7mzPS', 't6kx344cCU',
 '3b66u5yOc3', '387s3bj031', 'J665322viO', 'N4Y76QmfO9', '9d4038O7fD', '2lQ8D41z3G',
 'l03P7146G4', 'n716wj2b9c', '4av2g6dDb7', '6q65ro2z43', 'LJC77i56xq', 'hHBGA547a5']
>>>

不使用string库，只用字母、数字和下划线：

>>> pwd = lambda x=10:[''.join(__import__('random').sample((*map(chr,[*range(48,58),*range(65,91),*range(97,123)]),'_'),8)) for _ in range(x)]
>>>
>>> print(*pwd())
NVKfO5Du HxT2qSJF _GzK1kD3 KVw1OWjB Ob8fRswa MFqvpEWK fPDzuj8e ZndGFAs7 VHMp3FtX Hc7o642q
>>> print(*pwd())
c2HEwvkn I9wH1Vjm yOCaqzNR pXMqRuDg nUfTKXuV Co5Ebq7g mBCkDco1 ieUzSTpu y1s8zVct OiK3GFTw
>>> print(*pwd(5))
xTd69oJW Ob6pFsaq 4XW5lw_Y aHJxiZgr Z0VAGhNB
>>> print(*pwd(8))
BP1bpzlv VBvnFQE5 kmFZSLid WyCpqvK_ vOyQlB4c VSY8q67y 8lkGBRbt _I4MfqJk

一个四层嵌套的推导式：求k等差数

“k等差数”定义：任意相邻两位之间的差的绝对值都为 k 的正十进制整数。

给定整数的位数 n 和 等差值 k，求所有 k等差数：

>>> iscdnum = lambda n,k:[num for num in range(10**(n-1),10**n) if all([i==k for i in [abs(int(j[0])-int(j[1])) for j in [str(num)[i:i+2] for i in range(len(str(num))-1)]]])]
>>> iscdnum(2,5)
[16, 27, 38, 49, 50, 61, 72, 83, 94]
>>> iscdnum(3,2)
[131, 135, 202, 242, 246, 313, 353, 357, 420, 424, 464, 468, 531, 535, 575, 579,
 642, 646, 686, 753, 757, 797, 864, 868, 975, 979]
>>> iscdnum(3,3)
[141, 147, 252, 258, 303, 363, 369, 414, 474, 525, 585, 630, 636, 696, 741, 747,
 852, 858, 963, 969]
>>> iscdnum(3,4)
[151, 159, 262, 373, 404, 484, 515, 595, 626, 737, 840, 848, 951, 959]
>>> iscdnum(3,9)
[909]
>>> iscdnum(5,2)
[13131, 13135, 13531, 13535, 13575, 13579, 20202, 20242, 20246, 24202, 24242,
 24246, 24642, 24646, 24686, 31313, 31353, 31357, 35313, 35353, 35357, 35753,
 35757, 35797, 42020, 42024, 42420, 42424, 42464, 42468, 46420, 46424, 46464,
 46468, 46864, 46868, 53131, 53135, 53531, 53535, 53575, 53579, 57531, 57535,
 57575, 57579, 57975, 57979, 64202, 64242, 64246, 64642, 64646, 64686, 68642,
 68646, 68686, 75313, 75353, 75357, 75753, 75757, 75797, 79753, 79757, 79797,
 86420, 86424, 86464, 86468, 86864, 86868, 97531, 97535, 97575, 97579, 97975, 97979]
>>>

附录

到此这篇关于Python之列表推导式最全汇总(中篇)的文章就介绍到这了,其他两个部分的内容(上、下篇)请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

赞 (0)

相关推荐

  • python之列表推导式的用法

    1. 定义 用一行构建代码 例题 # 构建一个1-100的列表 l1 = [i for i in range(1,101)] print(l1) # 输出结果 [1,2,3,4,5,6,...100] 2. 两种构建方式 2.1 循环模式: [变量(加工后的变量) for 变量 in iterable] 例题 1. 将10以内所有整数写入列表 print([i for i in range(1,11)]) # 输出结果 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 2. 将10

  • Python列表推导式,元组推导式,字典推导式,集合推导式

    目录 1 介绍 2 列表推导式 3 元组推导式 4 字典推导式 5 集合推导式 1 介绍 推导式(解析器):是Python独有的一种特性.使用推导式可以快速生成列表.元组.字典以及集合类型的数据,因此推导式又可分为列表推导式. 2 列表推导式 格式: 格式1: [表达式 for 变量 in 列表][out_exp_res for out_exp in input_list] 格式2:[表达式 for 变量 in 列表 if 条件][out_exp_res for out_exp in input

  • Python列表推导式实现代码实例

    列表推倒式 [结果 for 变量 in 可迭代对象 if 筛选] 字典推倒式 {结果 for 变量 in 可迭代对象 if 筛选} 结果 => key:value 集合推倒式 {结果 for 变量 in 可迭代对象 if 筛选} 结果 => key 自带去重功能 列表推导式的执行顺序:各语句之间是嵌套关系,左边第二个语句是最外层,依次往右进一层,左边第一条语句是最后一层 生成一个存放1-100中个位数为3的数据列表 普通写法 #生成一个存放1-100中个位数为3的数据列表 # 普通写法 lis

  • Python 列表推导式需要注意的地方

    原文地址:The Do's and Don'ts of Python List Comprehension 原文作者:Yong Cui, Ph.D. 译文出自:掘金翻译计划 本文永久链接:github.com/xitu/gold-m- 译者:samyu2000 校对者:luochen1992,shixi-li Python 列表推导式并不是给初学者用的,因为它非常反直觉,甚至对于有其他编程语言背景的人也是如此. 我们接触到 List 的使用时,学习的内容都是零散的.所以我们缺少一个关于如何在各种

  • python 列表推导式使用详解

    所谓的列表推导式,就是指的轻量级循环创建列表. 基本使用方式 # 创建一个0-10的列表 a = [x for x in range(11)] print(a) """ 输出结果: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] """ 上面的列表推导式等价于下面,只是代码非常简化. a = [] for x in range(10): a.append(x) 在循环的过程中使用if # 创建一个1-10之间偶数的列表 a = [x

  • 什么是python的列表推导式

    乍一看到列表推导式你可能会感到疑惑.它们是一种创建和使用列表的简洁方式.理解列表推导式是有用的,因为你可能在其他人的代码里看到列表推导式.下面来了解下列表推导式吧. 数字列表的推导式 回顾之前学过的知识,我们可以创建一个包含前10个数字的列表,如下所示: squares = [] for number in range(1,11): new_square = number**2 squares.append(new_square) for square in squares: print(squ

  • python列表推导式实现找出列表中长度大于5的名字

    目录 列表推导式找出列表中长度大于5的名字 任务 我的笨办法 python列表推导式 例如 列表推导式找出列表中长度大于5的名字 任务 给定一个列表,使用列表推导式找出列表中长度大于5的名字,并打印该列表 names = [[‘Tom’, ‘Billy’, ‘Jefferson’, ‘Andrew’, ‘Wesley’, ‘Steven’, ‘Joe’],[‘Alice’, ‘Jill’, ‘Ana’, ‘Wendy’, ‘Jennifer’, ‘Sherry’, ‘Eva’]] 我的笨办法 刚

  • Python之列表推导式最全汇总(下篇)

    目录 前言 列表推导式 语法规范: 进阶实例 乘法口诀表 求100以内的质数(或称素数) 求出字符串的所有字串(可推广到所有可切片数据类型) 根据方程式画出字符图 EXCEL表格列号字串转整数 打印Gray格雷码序列 高阶实例 杨辉三角形 斐波那契数列 曼德勃罗集(Mandelbrot Set)分形 附录 前言 网传的七天学Python的路线如下,我觉得可以在学过此表中前几天的内容后,就可以回头来学习一下 列表推导式:它综合了列表.for循环和条件语句. 第一天:基本概念(4小时) : prin

  • python列表推导式操作解析

    这篇文章主要介绍了python列表推导式操作解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 基本格式 ​[表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件] 例子:将a列表中大于5的数*10储存到b中 一般操作: a = [5,10,15,20] b = [] for n in a: if n > 5: b.append(n*10) print(b) 使用推导式可以令代码简洁 a = [5,10,15

  • Python的列表推导式你了解吗

    目录 语法 实例 总结 语法 1.普通 [expression for target in iterable] 2.带条件 [expression for target in iterable if condition] 3.嵌套 [expression for target1 in iterable1 if condition1 for target2 in iterable2 if condition2 ... for targetN in iterableN if conditionN]

  • python列表推导式入门学习解析

    这篇文章主要介绍了python列表推导式入门学习解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.什么是推导式 推导式是从一个或者多个迭代器快速简洁地创建数据类型的一种方法,它将循环和条件判断结合,从而避免语法冗长的代码,提高代码运行效率.能熟练使用推导式也可以间接说明你已经超越了python初学者的水平. 报错 二.条件推导式 1.语法 ''' value1:如果条件表达式condition成立,返回value1 : 如果条件表达式不成

  • python列表推导式 经典代码

    python列表推导式 经典代码

    目录 一.什么是推导式 二.条件推导式 1.语法 2.实战练习 三.列表推导式 1.语法 2.实战练习 3.效率对比 四.重点总结 在学习编程过程中,我们不仅要学习python语法,同时也需要学习如何把自己代码写的更美观,效率更高. 一.什么是推导式 推导式是从一个或者多个迭代器快速简洁地创建数据类型的一种方法,它将循环和条件判断结合,从而避免语法冗长的代码,提高代码运行效率.能熟练使用推导式也可以间接说明你已经超越了python初学者的水平. 二.条件推导式 1.语法 ''' value1:如

  • 简单了解python 生成器 列表推导式 生成器表达式

    生成器就是自己用python代码写的迭代器,生成器的本质就是迭代器. 通过以下两种方式构建一个生成器: 1.通过生成器函数 2.生成器表达式 生成器函数: 函数 def func1(x): x += 1 return x print(func1(5)) 生成器函数 def func1(x): x += 1 yield x g_obj = func1(5) print(g_obj.__next__()) 一个next对应一个yield. yield VS return return 结束函数,给函

  • python中列表推导式与生成器表达式对比详解

    目录 概述 列表推导式 生成器表达式 使用场景选择 参考 总结 概述 Python中的列表推倒式(List Comprehension) 和 生成器表达式(Generator Expression)是两种很相似的表达式,但含义却不大不同,这里做一个对比. 列表推导式 列表推导式是比较常用的技术,能将本来需要for loop 和 if else 语句的情况简化成一条指令,最终得到一个列表对象: even = [e for e in range(10) if e % 2 == 0] 具体细节不过多展

  • python列表推导式的原理及使用方法

    python列表推导式的原理及使用方法

    偶尔会在python中看见这样一行代码: data = [x**2 for x in range(0, 5)] # 此时data = [0, 1, 4, 9, 16] 如果不知道背后的语法规则,那么很难理解为什么可以在列表的方括号中写一个“for”循环?实际上,这种语法称为列表推导式,和lambda表达式类似,都是在代码很短的情况下被使用. 本文将从两个方面讲解列表推导式: (1)什么是列表推导式 (2)如何使用列表推导式 1.什么是列表推导式? 列表推导式对应的英文是list comprehe

  • Python之列表推导式最全汇总(上篇)

    目录 前言 列表推导式 语法规范: 入门实例 生成过程 方法一: 方法二: 列表元素间的运算 附录 前言 网传的七天学Python的路线如下,我觉得可以在学过此表中前几天的内容后,就可以回头来学习一下 列表推导式:它综合了列表.for循环和条件语句. 第一天:基本概念(4小时) : print,变量,输入,条件语句. 第二天:基本概念(5小时) :列表,for循环,while循环,函数,导入模块. 第三天:简单编程问题(5小时) :交换两个变量值,将摄氏度转换为华氏温度,求数字中各位数之和, 判

  • Python 列表推导式与字典推导式的实现

    目录 列表推导式 for 循环写法 列表推导式写法 列表推导式还支持嵌套 字典推导式 元组推导式与集合推导式 总结 在 Python 中推导式是一种非常 Pythonic 的知识,本篇博客将为你详细解答列表推导式与字典推导式相关的技术知识. 列表推导式 列表推导式可以利用列表,元组,字典,集合等数据类型,快速的生成一个特定需要的列表. 语法格式如下: [表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]] if 条件表达式 非必选,学完列表推导式之后,你可以发现它就是 for 循环

  • Python列表推导式详情

    目录 1.列表生成式 1.1 案例 2.集合生成式 3.字典生成式 1.列表生成式 列表生成式即List Comprehensions,是Python内置的非常简单却强大的可以用来创建list的生成式. 语法结构如下: # 普通的生成式 [表达式 for 变量 in 旧列表] # 加条件的生成式 [表达式 for 变量 in 旧列表 if 条件] # if...else条件的生成式 [表达式 if 条件1 else 条件2for 变量 in 旧列表] 1.1 案例 过滤掉名词字母不足4的名字,示

随机推荐