详解Python解析式、 生成器（让你的代码更加简短）

---

这里是一段防爬虫文本，请读者忽略。
本文原创首发于CSDN，作者IDYS
博客首页：https://blog.csdn.net/weixin_41633902/
本文链接：https://blog.csdn.net/weixin_41633902/article/details/107555591
未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

---

写在开头的话

• 请记住：实践是掌握知识的最快方法
• 如果你只是怀着看看的态度去快速浏览文章，而不去认认真真的把文章里面讲的任何一个知识点去实践一遍，那么你永远也掌握不了它
• 生命不息，折腾不止！

Python解析式、 生成器

00. 标准库

00.1 datetime模块

• 对日期、时间、时间戳的处理

• datetime类

  • 类方法
    • today() 返回本地时区当前时间的datetime对象
    • now(tz=None) 返回当前时间的datetime对象，时间到微秒，如果tz为None，返回和today()一样 utcnow() 没有时区的当前时间
    • fromtimestamp(timestamp, tz=None) 从一个时间戳返回一个datetime对象

• datetime对象

  • timestamp() 返回一个到微秒的时间戳.

  • 时间戳：格林威治时间1970年1月1日0点到现在的秒数

  • 构造方法datetime.datetime(2016, 12, 6, 16, 29, 43, 79043)

  • year、month、day、hour、minute、second、microsecond，取datetime对象的年月日时分秒及微秒

  • weekday()返回星期的天，周一0，周日6

  • isoweekday() 返回星期的天，周一1，周日7

  • date() 返回日期date对象

  • time() 返回时间time对象

  • replace() 修改并返回新的时间

  • isocalendar()返回一个三元组(年，周数，周的天)

• 演示

import datetime

a = datetime.datetime.now()  # 返回现在时间，可以选择时区
print(type(a))
print(a)
print()
print(datetime.datetime.now())  
print(datetime.datetime.today())   # 返回当前时区的时间
print(datetime.datetime.utcnow())  # 返回当前的格林威治时间
print(datetime.datetime.now().timestamp())  # 返回时间戳
print(datetime.datetime.fromtimestamp(1595375579.63832))  # 根据时间戳， 返回时间
today_time = datetime.datetime.today()
print("{}年{}月{}日".format(today_time.year, today_time.month, today_time.day))
print(datetime.datetime(2010, 12, 23, 12, 23, 12, 212332).microsecond)
print(today_time.weekday())
print(today_time.isoweekday())
print(today_time.date())
print(today_time.time())
print(today_time.replace(2015, 11, 23))
print(today_time.isocalendar())  # 返回三元组 年 周数 周的天

• 运行结果

<class 'datetime.datetime'>
2020-07-22 09:45:19.014770

2020-07-22 09:45:19.014770
2020-07-22 09:45:19.014771
2020-07-22 01:45:19.014770
1595382319.01477
2020-07-22 07:52:59.638320
2020年7月22日
212332
2
3
2020-07-22
09:45:19.014771
2015-11-23 09:45:19.014771
(2020, 30, 3)

00.2 日期格式化

• 日期格式化
  • 类方法strptime(date_string, format) ，返回datetime对象
  • 对象方法strftime(format)，返回字符串
  • 字符串format函数格式化

import datetime 
dt = datetime.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
print(dt.strftime("%Y-%m-%d %H:%M:%S"))
print("{0:%Y}/{0:%m}/{0:%d} {0:%H}::{0:%M}::{0:%S}".format(dt))

小写%y 显示简要年份，如2012年会显示为 12，大写%Y会显示详细年份，如2012年会显示为2012

• 日期格式化演示

import datetime

dt = datetime.datetime.now()
print(dt.strftime("%Y-%m-%d %H:%M:%S"))  # 格式化输出时间
dt1 = datetime.datetime.strptime("02/12/03 18:30:12", "%y/%m/%d %H:%M:%S")
print(dt1)
print(dt.strftime("%Y/%m/%d %H::%M::%S"))
print("{0:%Y}/{0:%m}/{0:%d} {0:%H}::{0:%M}::{0:%S}".format(dt1))

• 运行结果

2020-07-22 10:27:20
2002-12-03 18:30:12
2020/07/22 10::27::20
2002/12/03 18::30::12

00.3 timedelta对象

• datetime2 = datetime1 + timedelta
• datetime2 = datetime1 - timedelta
• timedelta = datetime1 - datetime2
• 构造方法
  • datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
  • year = datetime.timedelta(days=365)
  • total_seconds() 返回时间差的总秒数

有了timedelta对象就可以方便的对datetime类型做加减了

• 演示

import datetime

my_time = datetime.timedelta(days=1, hours=5)
print(my_time)
print(my_time.total_seconds())
print(datetime.datetime.today() - my_time)

• 运行结果

1 day, 5:00:00
104400.0
2020-07-21 05:56:50.705545

00.4 标准库time

• time
  • time.sleep(secs) 将调用线程挂起指定的秒数

01. 列表解析

1.1举例

• 生成一个列表，元素0~9，对每一个元素自增1后求平方返回新列表

• 我的解法1

list1 = list(range(10))
print(list1)

for i in range(10):
    list1[i] = (list1[i]+1)**2

print(list1)

• 运行结果

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

• 我的解法二

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

print(list2)

• 运行结果

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

• 列表解析式方法

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

print(list2)

• 运行结果

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[[0], [0], [0], [0], [0], [0], [0], [0], [0], [0]]
[[0, 1], [0], [0], [0], [0], [0], [0], [0], [0], [0]]
[[0], [0], [0], [0], [0], [0], [0], [0], [0], [0]]
[[0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]]
[[0], [0], [0], [0], [0], [0], [0], [0], [0], [0]]
[[0, 1], [0], [0], [0], [0], [0], [0], [0], [0], [0]]

1.2 列表解析List Comprehension

• 语法
  • [返回值 for 元素 in 可迭代对象 if 条件]
  • 使用中括号[]，内部是for循环，if条件语句可选
  • 返回一个新的列表
• 列表解析式是一种语法糖
  • 编译器会优化，不会因为简写而影响效率，反而因优化提高了效率
  • 减少程序员工作量，减少出错
  • 简化了代码，但可读性增强

• 举例
  • 获取10以内的偶数，比较执行效率

list1 = [i for i in range(1, 11) if i % 2 == 0]
print(list1)

• 运行结果

[2, 4, 6, 8, 10]

• 思考
  • 有这样的赋值语句newlist = [print(i) for i in range(10)]，请问newlist的元素打印出来是什么？

new_list = [print(i) for i in range(10)]
print(new_list)

• 运行结果

0
1
2
3
4
5
6
7
8
9
[None, None, None, None, None, None, None, None, None, None]

02. 列表解析进阶

2.1 介绍

1. [expr for item in iterable if cond1 if cond2]

ret = [] 
for item in iterable: 
    if cond1: 
        if cond2:
            ret.append(expr)

• 举例

  • 20以内，既能被2整除又能被3整除的数

• 解题

list1 = [i for i in range(21) if i % 2 == 0 if i % 3 == 0]
print(list1)
list2 = [i for i in range(0, 24, 2*3)]
print(list2)

• 运行结果

[0, 6, 12, 18]
[0, 6, 12, 18]

2. [expr for i in iterable1 for j in iterable2 ]

• 等价于

ret = []
for i in iterable1:
    for j in iterable2:
        ret.append(expr)

• 举例一

list1 = [[i, j] for i in 'idys' for j in range(3)]
print(list1)

list2 = [(i, j) for i in 'idys' for j in range(3)]
print(list2)
list3 = [{i: j} for i in 'idys' for j in range(3)]
print(list3)

• 运行结果

[['i', 0], ['i', 1], ['i', 2], ['d', 0], ['d', 1], ['d', 2], ['y', 0], ['y', 1], ['y', 2], ['s', 0], ['s', 1], ['s', 2]]
[('i', 0), ('i', 1), ('i', 2), ('d', 0), ('d', 1), ('d', 2), ('y', 0), ('y', 1), ('y', 2), ('s', 0), ('s', 1), ('s', 2)]
[{'i': 0}, {'i': 1}, {'i': 2}, {'d': 0}, {'d': 1}, {'d': 2}, {'y': 0}, {'y': 1}, {'y': 2}, {'s': 0}, {'s': 1}, {'s': 2}]

• 举例二

list1 = [(i, j) for i in range(7) if i > 4 for j in range(20, 25) if j > 23]
list2 = [(i, j) for i in range(7) for j in range(20, 25) if i > 4 if j > 23]
list3 = [(i, j) for i in range(7) for j in range(20, 25) if i > 4 and j > 23]
print(list1, list2, list3, sep='\n')

• 运行结果

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

2.2 列表解析练习

2.2.1 练习一

• 返回1-10平方的列表

• 演示

list1 = [i**2 for i in range(1, 11)]
print(list1)

• 运行结果

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

2.2.2 练习二

• 有一个列表lst = [1,4,9,16,2,5,10,15]，生成一个新列表，要求新列表元素是lst相邻2项的和

• 演示

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

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

• 运行结果

[5, 13, 25, 18, 7, 15, 25]

2.2.3 练习三

• 打印九九乘法表
• 方法一

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

• 运行结果

1*1=1  
1*2=2   2*2=4  
1*3=3   2*3=6   3*3=9  
1*4=4   2*4=8   3*4=12  4*4=16 
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25 
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36 
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49 
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64 
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81 

• 方法二

print("\n".join([" ".join([str(j)+"*"+str(i)+"="+str(i*j) for j in range(1,i+1)]) for i in range(1, 10)]))

• 运行结果

1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

2.2.4 练习四

• 从数字1打印到数字10，数字之间用,做分隔
• 演示

print(",".join(str(i) for i in range(1, 11)))
list1 = [print("{}{}".format(i,"," if i != 10 else " "),end=" ") for i in range(1, 11)]

• 运行结果

1,2,3,4,5,6,7,8,9,10
1, 2, 3, 4, 5, 6, 7, 8, 9, 10  

2.2.5 练习五

• "0001.abadicddws"是ID格式，要求ID格式是以点号分割，左边是4位从1开始的整数，右边是10位随机小写英文字母。请依次生成前100个ID的列表
• 方法一

mport random
import string
[print("{:04d}.{}".format(i, "".join([random.choice(string.ascii_lowercase) for i in range(10)]))) for i in range(1, 101)]

• 运行结果

0001.rxwqgnctri
0002.xjctxoloxu
0003.ajmltokmdd
0004.ttxitdrlut
0005.iawzxuugjn
0006.gaxfkbmcwq
0007.mpvsrcvtzb
0008.aptfowpuue
0009.plnawreyvb
0010.xokefdsbdf
0011.urmkkwvdwu
0012.foudweafod
0013.pndnoqvkep
0014.lesrxpxlaj
0015.mgowwnywvn
0016.uxxqdbcbiu
0017.idxhugmplq
0018.wnvzitzygt
0019.hjcxigwhgq
0020.nktkkecneg
0021.wvcabmjfju
0022.nfnawsonct
0023.ochgxhovqf
0024.szxpomxxtb
0025.qsgvqoauco
0026.tqaoexicar
0027.nicjkuordq
0028.mfqagshamf
0029.zgonqeqxvj
0030.syfntgdhun
0031.rzykppkcag
0032.sfphvcxezn
0033.jlmrskgqoy
0034.fpsqkznlnn
0035.otwxubdrgv
0036.extotkuyhy
0037.ubuhkofdle
0038.auklglzopc
0039.gmvlqkbnqy
0040.wjmwybluts
0041.kfgjwidoxb
0042.wcxunyvvff
0043.mjvkgcqiet
0044.rxogehnviv
0045.qcwqriawzp
0046.rdhgeyytnc
0047.zhusfbcxzh
0048.toffaacrwg
0049.auiybnxxek
0050.dopnoqofas
0051.mrbqdqdeey
0052.exjinehbur
0053.ldbalsdipi
0054.ebpkepmlmh
0055.pdircccskc
0056.dpqebrosmm
0057.kenzctxors
0058.lqmlzbqpwb
0059.evkuwevakf
0060.vobmodppaj
0061.bchmkuanjg
0062.qjxnjaqnfv
0063.zdtxtnwqyq
0064.jzrujdduph
0065.zpvxwqoobn
0066.slurhhpowz
0067.uqqvhvovho
0068.izkhwybaia
0069.adrnznbkse
0070.tnbwvezkwg
0071.iyveadxngt
0072.nujdzbtfsy
0073.dijomjvdmr
0074.rjmgeehoyi
0075.oyvbuzwbdk
0076.xyqgtaxjli
0077.kwmqprxsbt
0078.iyiaujczbc
0079.fxsztnzmyt
0080.mjojyjvvao
0081.tvbwjidqhm
0082.mwqziadpzf
0083.jyfpvwartd
0084.jeuyzuzzgn
0085.hyilohfayg
0086.tatlbxlmtm
0087.uzdceaibvi
0088.sxaexbhfjq
0089.tsslinsrzr
0090.zznswpojkk
0091.chpcdrrjul
0092.lyaaarcrho
0093.gijhfkjnze
0094.rhidqxqbis
0095.xydvfzbdsk
0096.ztlfeskzsl
0097.fndgnzkivc
0098.oekmhvzopb
0099.znwhcrnxkp
0100.qtvkuxgfru

• 方法二

import random
[print("{:04d}.{}".format(i, "".join(random.choice(bytes(range(97, 123)).decode()) for j in range(10)))) for i in range(1, 101)]

• 运行结果

0001.ywkcpvmhoj
0002.rjzjqyrznz
0003.ppgatgkwmq
0004.amzhylsucv
0005.jgxblrnplw
0006.pvaqlgivbt
0007.xbooypqmmq
0008.fqhrkkoqac
0009.plomigyxnv
0010.amszfzvcvz
0011.ydcsllxujb
0012.zrdmocvzlp
0013.amgwmrueet
0014.uxkxfbiars
0015.xxozgcrfro
0016.vxocxnkiht
0017.tlwlsjfhuj
0018.srftcbkqid
0019.ztbrybgzgj
0020.ceruwoonhi
0021.ucrfbyuwnf
0022.oxegbgyrvi
0023.solosizgau
0024.uvtmjmxkco
0025.tmzpjdvnso
0026.qzbefdiqgi
0027.fmlymafwvg
0028.hcsijrxlei
0029.xxxrmqsnnw
0030.mujuhkkanc
0031.ogujnukbds
0032.otpviovkuh
0033.syhqezftqh
0034.fciqwwwxcv
0035.kakhhiiyik
0036.spqgbqahco
0037.cwwfjgtnfl
0038.hzscfwqfgt
0039.jpjkvrhnkc
0040.rbuuidsnjl
0041.lvlnqmxkbp
0042.ykwcillvng
0043.yhhadageai
0044.usmekapsos
0045.vfzstfejfu
0046.ldmkihmzvp
0047.kjnvhssmnp
0048.lozajoonpq
0049.rrkffkqojv
0050.lxmbirgyqk
0051.jlcxspqcbq
0052.bptirqyicn
0053.qatovbhdil
0054.ebediwztrp
0055.sazktajlqi
0056.yfwdivklmh
0057.crzzixkltr
0058.hdzciqgfka
0059.loqftwsucx
0060.zkwckiflmd
0061.mbeehabicy
0062.iiofnyjzjz
0063.nmghpkxihn
0064.cbmmbzygee
0065.kyvysyuwbg
0066.lyxvtqhlwu
0067.lpoidpodia
0068.phzunympve
0069.ectuilxexd
0070.jqbyzejoif
0071.ysbkibcamu
0072.gvrkehzsfw
0073.gehphujzit
0074.ddvykotwpc
0075.zmobmmzwoq
0076.pmdicmqagd
0077.nqbcpjqkyl
0078.sxxvmwprcr
0079.jylddyorzw
0080.mfcgeznqkd
0081.cusssivhks
0082.wlphcisupf
0083.glrtqcvdnd
0084.bshcavfkkx
0085.vhllowcqop
0086.mllrmttlue
0087.bcmhumihmr
0088.guhrvvnrcs
0089.wvydcmcoqk
0090.qjjgufucqk
0091.mospckqisw
0092.lrkhomlubh
0093.otzuuhqggf
0094.wsfzcoygyy
0095.xwezrdnmad
0096.dvsikpdxjp
0097.iadtmqutts
0098.lvyqwnnsaf
0099.gotlwifsgu
0100.yoijlnksqh

• 方法三

import random

[print("{:04d}.{}".format(i, "".join(chr(random.randint(97, 122)) for j in range(10)))) for i in range(1, 101)]

• 运行结果

0001.nvondxwblm
0002.xakhpaphwf
0003.uweqczyapz
0004.rtdefffdyi
0005.aiuwzwoqpf
0006.fxygiyhsjg
0007.jznsthwqmh
0008.wwbjbftwdn
0009.euseuwfcac
0010.hfhucjrzdi
0011.brgcyvogxk
0012.iwwkuskgvb
0013.vdtyjxhdqc
0014.kidrktiiyh
0015.vmxwdonard
0016.mfsikmpxkh
0017.mkynlcrina
0018.poglpylijs
0019.znurqcgjiw
0020.omtpznbuey
0021.dnevzmcitt
0022.yxwxbojcqh
0023.rbkrjhfnhq
0024.gwfmkdordt
0025.sbdeihtdiq
0026.msjqeclhxy
0027.ecylpgyxpa
0028.utjluysspm
0029.micjvothyr
0030.miblrghlmt
0031.xzsqsenecc
0032.wwpxzlksss
0033.qjrganbbcl
0034.fldqoxvwop
0035.yjcqbzjvbs
0036.ailigcdmhh
0037.yxouptfnbt
0038.ropdgiqlje
0039.fznhucwydq
0040.owsaugwwhy
0041.loqbjjthtx
0042.fdtjekxoxq
0043.gtnupgvkcl
0044.egxkzkxsvy
0045.lgzqvhgyym
0046.iscuzgtozw
0047.ozmdayaesr
0048.wdwzelabxx
0049.kgyyhzsiwv
0050.qesngfqoow
0051.lvwbbaundb
0052.hwursgvpyt
0053.lmgxgoezab
0054.texvmqjnzy
0055.hhzgznbugc
0056.mrwkzxfaqt
0057.wejysmlrsp
0058.njygckmzpa
0059.cdiwdwobxt
0060.ogooeulyvs
0061.amaawqarrq
0062.czuumlnske
0063.ctmxpdfgha
0064.fywhkvhvis
0065.zopnfttzcy
0066.nkxzxpifjr
0067.wkwofbqycz
0068.hkrbujghpp
0069.dxwoxlleuc
0070.lmndnudlgn
0071.iyogjhldwh
0072.ablbxkixws
0073.hntevieapc
0074.ovwgcydaia
0075.gqrzerlsor
0076.gsqdijrrly
0077.sczmrjhwiv
0078.pvntlmubgw
0079.xlbulaoesd
0080.nkmrblaeqi
0081.tqsdzleodq
0082.jqrurixaku
0083.cxkhtocldq
0084.rlakplunsx
0085.binqzkjbkf
0086.wcbxzymsgs
0087.bfxjkhhudx
0088.pqysiptxsp
0089.tpaupjofed
0090.lgietttsvo
0091.jyihpqoflx
0092.ewdrfhxhrd
0093.tfgrmheeql
0094.uddkkfucej
0095.natufaabzg
0096.rxsohlsyyn
0097.yuuprykvii
0098.omlxowuhqk
0099.aztltvzbsp
0100.nuihrfmjak

03. 生成器表达式Generator expression

3.1 概述

• 语法
  • (返回值 for 元素 in 可迭代对象 if 条件)
  • 列表解析式的中括号换成小括号就行了
  • 返回一个生成器
• 和列表解析式的区别
  • 生成器表达式是按需计算（或称惰性求值、延迟计算），需要的时候才计算值
  • 列表解析式是立即返回值
• 生成器
  • 可迭代对象
  • 迭代器

3.2 生成器与列表的异同

• 生成器特点

  • 延迟计算
  • 返回迭代器，可以迭代
  • 从前到后走完一遍后，不能回头

• 演示

print((i for i in range(10)))
a_g = (i for i in range(11))
print(a_g)
print([i for i in a_g])
print([i for i in a_g])
print()
a_g = (i for i in range(11))
print(next(a_g))
print(next(a_g))
[print("{}{}".format(i, "," if i != 10 else ""),end="") for i in a_g]

• 运行结果

<generator object <genexpr> at 0x00000144E3A72900>
<generator object <genexpr> at 0x00000144E3A72900>
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[]

0
1
2,3,4,5,6,7,8,9,10

• 列表特点
  • 立即计算
  • 返回的不是迭代器，返回可迭代对象列表
  • 从前到后走完一遍后，可以重新回头迭代
• 演示

a = [i for i in range(10)]
print(a)
print(a)

• 运行结果

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• 习题一

it = (print("{}".format(i+1)) for i in range(2))
first = next(it)
second = next(it)
val = first + second

• 运行结果（报错）

1
2
Traceback (most recent call last):
  File "E:/Users/dayuanshuai/PycharmProjects/douban/time_dir/demo22.py", line 10, in <module>
    val = first + second
TypeError: unsupported operand type(s) for +: 'NoneType' and 'NoneType'

因为print返回的是无类型的对象，所以it里面的值为nonetype

• 习题二

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

• 运行结果

4

3.3 和列表解析式的对比

• 计算方式

  • 生成器表达式延迟计算，列表解析式立即计算

• 内存占用

  • 单从返回值本身来说，生成器表达式省内存，列表解析式返回新的列表
  • 生成器没有数据，内存占用极少，但是使用的时候，虽然一个个返回数据，但是合起来占用的内存也差不多
  • 列表解析式构造新的列表需要占用内存

• 计算速度

  • 单看计算时间看，生成器表达式耗时非常短，列表解析式耗时长
  • 但是生成器本身并没有返回任何值，只返回了一个生成器对象
  • 列表解析式构造并返回了一个新的列表

04集合解析式

• 语法
  • {返回值 for 元素 in 可迭代对象 if 条件}
  • 列表解析式的中括号换成大括号{}就行了
  • 立即返回一个集合
• 用法
  • {(x,x+1) for x in range(10)}
  • {[x] for x in range(10)}

05.字典解析式

• 语法

  • {返回值 for 元素 in 可迭代对象 if 条件}
  • 列表解析式的中括号换成大括号{}就行了
  • 使用key:value形式
  • 立即返回一个字典

• 用法

  • {x:(x,x+1) for x in range(10)}
  • {x:[x,x+1] for x in range(10)}
  • {(x,):[x,x+1] for x in range(10)}
  • {[x]:[x,x+1] for x in range(10)} # 错误
  • {chr(0x41+x):x**2 for x in range(10)}
  • {str(x):y for x in range(3) for y in range(4)} #输出多少个元素？ 输出3种元素

06. 总结

• Python2 引入列表解析式
• Python2.4 引入生成器表达式
• Python3 引入集合、字典解析式，并迁移到了2.7
• 一般来说，应该多应用解析式，简短、高效
• 如果一个解析式非常复杂，难以读懂，要考虑拆解成for循环
• 生成器和迭代器是不同的对象，但都是可迭代对象

写在最后的话：

• 无论每个知识点的难易程度如何，我都会尽力将它描绘得足够细致
• 欢迎关注我的CSDN博客，IDYS’BLOG
• 持续更新内容：
  linux基础 | 数据通信（路由交换，WLAN） | Python基础 | 云计算
• 如果你有什么疑问，或者是难题。欢迎评论或者私信我。你若留言，我必回复！
• 虽然我现在还很渺小，但我会做好每一篇内容。谢谢关注！

本文地址：https://blog.csdn.net/weixin_41633902/article/details/107555591