列表、集合、字典解析式、生成器表达式

newlist = []
for i in range(10):
    newlist.append((i + 1) ** 2)

print(newlist)

newlist1 = [(i+1)**2 for i in range(10)]
print(newlist1)

语法 [返回值 for 元素 in 可迭代对象 if 条件]

if条件语句可选

返回一个新的列表

 

作用：

一种语法糖

编译器会优化，提高效率

减少工作量，减少出错

简化代码，但可读性增加

 

获取20以内的偶数

print([i for i in range(20) if i % 2 == 0])

获取20以内的偶数，如果是3的倍数也打印出来

print([i for i in range(21) if i % 2 == 0 and i % 3 == 0])

 

ret = []
for i in 'abc':
    for j in range(3):
        ret.append({i: j})


print(ret)


print([{i: j} for i in 'abc' for j in range(3)])
print([[i, j] for i in 'abc' for j in range(3)])
print([(i, j) for i in 'abc' for j in range(3)])

out:
[{'a': 0}, {'a': 1}, {'a': 2}, {'b': 0}, {'b': 1}, {'b': 2}, {'c': 0}, {'c': 1}, {'c': 2}]
[{'a': 0}, {'a': 1}, {'a': 2}, {'b': 0}, {'b': 1}, {'b': 2}, {'c': 0}, {'c': 1}, {'c': 2}]
[['a', 0], ['a', 1], ['a', 2], ['b', 0], ['b', 1], ['b', 2], ['c', 0], ['c', 1], ['c', 2]]
[('a', 0), ('a', 1), ('a', 2), ('b', 0), ('b', 1), ('b', 2), ('c', 0), ('c', 1), ('c', 2)]

print([(i, j) for i in range(7) if i > 4 for j in range(20, 25) if j > 23])
print([(i, j) for i in range(7) for j in range(20, 25) if i > 4 and j > 23])

out:
[(5, 24), (6, 24)]
[(5, 24), (6, 24)]

newlist = [i**2 for i in range(11)]
print(newlist)

lst = [1, 4, 9, 16, 2, 5, 10, 15]

lst1 = [lst[i]+lst[i+1] for i in range(len(lst)-1)]
print(lst1)

# 9*9
mul = ['{0}*{1}={2:<3}'.format(j, i, i*j) for i in range(1, 10) for j in range(1, 10) if j <= i]
print(mul)

mul1 = ([['{}*{}={:<3}'.format(j, i, i*j) for j in range(1, i+1)] for i in range(1, 10)])
for i in mul1:
    print(i)


[print('{}*{}={:<3}{}'.format(j, i, i*j, '\n' if i == j else ' '), end='') for i in range(1, 10) for j in range(1, i+1)]

import random

[print('{:04}.{}'.format(i, ''.join(([random.choice(bytes(range(97, 123)).decode()) for _ in range(5)])))) for i in range(5)]

print('---------')

[print('{:04}.{}'.format(i, ''.join(([chr(random.randint(97, 123)) for _ in range(4)])))) for i in range(5)]



out:
0000.nmmff
0001.zvtbe
0002.jorxi
0003.hodrh
0004.owvrp
---------
0000.mwol
0001.bdgm
0002.gjlp
0003.nths
0004.eygr

---

生成器表达式

语法（返回值 for 元素 in 可迭代对象 if 条件）

返回一个生成器

惰性求值，需要的时候才计算值

可迭代对象

迭代器

g = ('{:04}'.format(i) for i in range(1, 5))
print(next(g))
next(g)
[print(i) for i in g]

print('------------')
g = ['{:04}'.format(i) for i in range(1, 5)]
for i in g:
    print(i)

print('-------')

for i in g:
    print(i)


OUT:
0001           惰性求值  
0003           返回迭代器，可以迭代
0004           从前到后走完一遍，不能回头
------------
0001
0002           立即计算
0003           返回的不是迭代器，返回可迭代对象列表
0004           从前到后走完一遍后，可以重新回头迭代
-------
0001
0002
0003
0004

it = (x for x in range(10) if x % 2)
first = next(it)
second = next(it)
val = first + second
print(val)

4

生成器表达式和列表解析式的对比

计算方式：生成器表达式，惰性求值，列表解析式立即计算

内存占用：

单从返回值本身来说，生成器表达式省内存，列表解析式返回新的列表

生成器没有数据，内存占用极少，但是使用的时候，虽然一个个返回数据，但合起来占用的内存也差不多

列表解析式构造新的列表需要占用内存

计算速度：

单看计算时间，生成器表达式耗时非常短，列表解析式耗时长

但是生成器本身并没有返回任何值，只返回了一个生成器对象

列表解析式构造并返回了一个新的列表

 

集合解析式：

｛返回值 for 元素 in 可迭代对象 if 条件｝

立即返回一个集合

print({(x, x+1) for x in range(10)})
{(0, 1), (1, 2), (7, 8), (6, 7), (5, 6), (4, 5), (8, 9), (9, 10), (2, 3), (3, 4)}

print({[x] for x in range(10)})  # TypeError: unhashable type: 'list'

字典解析式

语法：

｛返回值 for 元素 in 可迭代对象 if 条件｝

使用key:value形式

立即返回一个字典

用法：

print({x: (x, x+1) for x in range(5)})
print({x: [x, x+1] for x in range(5)})
print({(x,): [x, x+1] for x in range(5)})
# print({[x]: [x, x+1] for x in range(5)})  TypeError: unhashable type: 'list'
print({chr(0x41+x): x**2 for x in range(5)})
print({str(x): y for x in range(3) for y in range(4)})

out:
{0: (0, 1), 1: (1, 2), 2: (2, 3), 3: (3, 4), 4: (4, 5)}
{0: [0, 1], 1: [1, 2], 2: [2, 3], 3: [3, 4], 4: [4, 5]}
{(2,): [2, 3], (0,): [0, 1], (3,): [3, 4], (1,): [1, 2], (4,): [4, 5]}
{'D': 9, 'A': 0, 'C': 4, 'E': 16, 'B': 1}
{'2': 3, '1': 3, '0': 3}

生成器和迭代器是不同的对象，但都是可迭代对象