- 在线时间
- 661 小时
- 最后登录
- 2023-8-1
- 注册时间
- 2017-5-2
- 听众数
- 32
- 收听数
- 1
- 能力
- 10 分
- 体力
- 55507 点
- 威望
- 51 点
- 阅读权限
- 255
- 积分
- 17604
- 相册
- 0
- 日志
- 0
- 记录
- 0
- 帖子
- 447
- 主题
- 326
- 精华
- 1
- 分享
- 0
- 好友
- 79
TA的每日心情 | 慵懒 2020-7-12 09:52 |
---|
签到天数: 116 天 [LV.6]常住居民II 管理员
 群组: 2018教师培训(呼和浩 群组: 2017-05-04 量化投资实 群组: 2017“草原杯”夏令营 群组: 2018美赛冲刺培训 群组: 2017 田老师国赛冲刺课 |
一、可迭代对象* d9 u0 ]6 S- x7 _ r' P: ]
字面意思:6 F/ @/ N' U: `/ Y. J
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))
" O2 M1 C. l4 b- Y, I" G$ w( k可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容
8 U: }, a* H% V( k; L+ j0 ]专业角度:内部含有 '__iter__‘ 方法的对象
! j; h5 F5 }8 g X+ o( @目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等
9 y5 ]. p2 W4 S, e) R4 z判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例& K: \( n0 x1 D! K2 |. h* ^6 ~
![]()
+ a/ X& u& z% y, o' h3 l; X& ~/ Z1 n' N7 j6 V, w+ B
优点:% |" u: x* Y x% r6 w
存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来, z3 ~8 c- d9 }8 `0 ^: `+ j* m& ~
拥有较多的方法,操作方便:增删查改等
, U* i8 G. X O7 f0 ?2 r/ B缺点:2 h( X; ~3 u9 e0 g
占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中5 Q5 d q: `) ^; w
不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取5 A+ z0 S# Q* k9 m! M% M
二、迭代器) [- t6 G1 [5 s* q
字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具# Q, U6 @3 A. q! J R
专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例% P6 g2 K/ v9 v; W+ E) V" U# g
把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法: v* {8 _3 S# I8 t# m
4 H8 l4 m N; W2 ~2 p1 E
迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理
# X: W0 V& Z& y3 E/ ]5 D* o 5 |& m$ u! F6 _ m. ~8 [7 ?
优点( P1 D9 `1 J/ m+ k/ O' X/ u Y
节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed): u8 e% y5 O2 i; t" Z' d1 O1 m+ M
惰性机制:next 一次只取一个值,绝对不多取" R4 l6 i, |5 {& X8 e0 e
缺点:( D [3 C3 S0 u X' o
速度慢:需要一直 next
: f' \! S6 c5 `# N5 V不能回头:只能一直往下取值,取过的值没保存就没了`/ |' T4 A# X6 h( k; @ y
不能直观的看到里面的数据( A [# r7 x0 ^' F
三、可迭代对象与迭代器对比+ R5 B6 q0 P8 h# j F0 n
可迭代对象:5 C6 L) f. f, b `
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)
+ Q2 y/ B3 l% L- L直观,可以直接看到里面的数据& |2 d, q; ^ r- C* p, f j
占用内存# C4 C* s7 P- v' s2 o2 a" i- {0 `
不能直接通过循环迭代取值
# T( E6 F$ a! L5 s应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择
q7 j- T. x m/ H3 V/ V; J迭代器:
0 _: q# j3 a' x/ E, C$ K1 F. N节省内存,按需取值
# W/ p6 }' P. o9 l可以直接通过循环迭代取值
' ^* v* K. d4 v5 W# ~0 A& E数据不直观,操作方法单一; k2 r q6 V4 b1 Y4 s" u! W# t
应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择
! ]( [+ p6 M5 [0 v四、生成器/ C+ {0 G/ o' A/ \0 l8 B) r8 p
生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的
) E E- G+ F2 C2 p9 j) F3 |' x
! _& C6 s( ~. O( V9 h& V定义生成器的方式:0 k* |; l. _: m) M, \
通过生成器函数构建生成器, r1 x, i3 N& o! z' V' T" H4 b
) s: g# a9 j2 z$ O/ e0 r
- D* ^0 X. w# a+ ~" ^ i1 B
![]()
) `8 q( V0 g( [* }: a这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来
8 h, i$ g0 s( Y) i) Q , ^) D. S: `0 V
也可以在一个函数里定义多个 yield) s1 y, w2 H3 E
3 Z/ v' c5 w1 U& V0 o
之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration
) r. p0 c' E% V- n9 `1 O* V$ _9 ]
; b1 K* X1 D' T4 d8 Q X6 L1 gyield 与 return 的区别 c+ D+ l0 L0 z
8 [+ L. k* @$ ~& }return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值
0 c3 k. D( N1 o, Z4 l0 ?6 zyield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素
5 K/ K( \# N* W6 F应用举例:
) L9 {" T. b. I4 A$ L) f! O% f
) C' Y, P- s9 U( o5 [* @3 p" |买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了
' Y5 ~5 \2 v2 b+ G" d. _- T6 H
7 v% I9 n, g Q" j. i4 q5 V
% Z* _: e+ t. L) K; `) M# P如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):- b1 X0 u! |: M7 `
# V p5 n$ }* @% d% I+ B: K; |" ~1 |, I0 ?9 U; b: f6 {' H4 G
除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部
/ ?/ P# g, S8 {![]()
% L' ~& w$ ?2 G" r) B1 Z可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值
" `4 _, ^) ?) Y M# J6 g' A 7 p+ S, x* w. C" D% {
在使用 send() 的时候,可以将参数传入生成器中使用
' A1 Y- W4 B. d6 b, V' N( [
8 F- z( G/ i7 k5 Z% n需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下# f& A& ^$ k2 e7 o6 s, E% G( t
![]()
" R* ?( Z; ^) T: M( e$ Myield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回
# W; p, ^/ N. b! {, I& b8 q& r; J$ w* E# L! d) J
! h- n* m [6 x+ l; g* ]
yield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果
* [0 M+ \$ J3 ?9 i 3 @7 T6 Y& w2 ? l b
1 [; d8 q+ `+ g' s* u
# Y) Q, Y; v+ o通过推导式构建生成器4 E2 w' _4 z( g- p8 B/ Q
列表推导式:
) Q1 R* }2 J+ R9 i' Z& O, e8 R9 V![]()
6 Q, S _: p! x! j4 ^2 K生成器表达式:和列表推导式差不多,把 [] 改成 () 即可
W/ f2 q5 b9 z , M1 w4 q/ I, Z5 ?" @* A6 q1 J
1 H2 E2 l! j3 j! s& E
列表推导式和生成器推导式的区别:
5 p# z. B# w9 J4 }% d7 x. H
( p4 L1 W6 s) o5 Z P列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素
8 Z4 ^' f7 p. o得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器
4 p1 z4 m6 M+ K" n2 Y& d列表推导式一目了然,生成器表达式只是一个内存地址, r9 p3 a$ h- \2 T
————————————————
9 _0 c' }+ W9 n; W版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
0 M( D( F* d( c原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143
5 n' m5 ^6 z3 e& B8 f
/ L3 F/ N& Y- l5 X9 B O8 U" v8 y
4 R- l8 m& ^# }' ?5 E( S. b |
zan
|