- 在线时间
- 661 小时
- 最后登录
- 2023-8-1
- 注册时间
- 2017-5-2
- 听众数
- 32
- 收听数
- 1
- 能力
- 10 分
- 体力
- 55582 点
- 威望
- 51 点
- 阅读权限
- 255
- 积分
- 17626
- 相册
- 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 田老师国赛冲刺课 |
一、可迭代对象
. l! D4 z/ ~7 ~/ |字面意思:" Q( ^ D9 D9 u" y
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))
9 D$ V) g& m, W- G) k. k可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容. Y2 \ [9 L4 U4 v* ]9 B
专业角度:内部含有 '__iter__‘ 方法的对象7 l% B% Q2 E+ [( G/ x
目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等 k% m. w# Q) @+ S) c& s: B
判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例" I, j2 n/ Q" u# J: [# `7 f
![]()
- W! O% }+ T3 n/ \0 F4 L0 L( F; |3 G9 o9 G& d9 u: j) t
优点:) s% Z, K+ w- K, K2 c! e
存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来6 r. V0 N# }7 }* b
拥有较多的方法,操作方便:增删查改等, n7 E; R+ F4 H# N
缺点: ?$ V5 i: e/ i# \
占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中8 z9 |( z, l$ Y
不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取
% p9 l3 k% B6 \* G二、迭代器' E7 b: d* x e, O) a' R9 f2 a2 e
字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具
3 {( W) G! z2 m" r专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例, I; |* I1 m( q% ~' p: Z3 l) K
把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法
2 Y- E Z: k0 J4 W4 Y- J$ z4 p, p $ ? x0 b1 E" M) W9 F! G
迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理
; X \* s2 U" A![]()
1 D" N* ]4 v9 k+ k4 D+ L9 V {$ K优点
3 C7 a/ Q$ R2 v" E7 j* X节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)
: o& {. g0 h1 A* H6 s- m惰性机制:next 一次只取一个值,绝对不多取
! x$ u1 d+ W" ^' i, W1 C3 w缺点:3 T3 L. Q# G) x4 E3 P2 x1 ^
速度慢:需要一直 next
9 \2 w. g7 r! K7 e不能回头:只能一直往下取值,取过的值没保存就没了`
3 x0 l E# m8 l t4 z8 z a不能直观的看到里面的数据
d: B' E& p5 X( \三、可迭代对象与迭代器对比
5 |# W# o4 ?: c! P; G8 ^可迭代对象:& r4 E' W# M' X7 W
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)3 ~7 R6 l" {3 N
直观,可以直接看到里面的数据
% Q! n& E% x# O占用内存; n2 f4 L4 F- M: @
不能直接通过循环迭代取值5 v! U/ D, r- `) p! a6 B
应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择1 Z2 Q j4 h' ^5 {- J6 Z6 B. [1 ~1 ~
迭代器: D7 t- U" d Y5 `7 D3 a5 H4 ^
节省内存,按需取值: t& o. H3 }& V1 d3 y
可以直接通过循环迭代取值
. `% ^3 v: X. X3 p1 @; d6 c数据不直观,操作方法单一& n" _2 c% p; x' P2 j, E# c5 m
应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择" O: v8 g ?( _1 ^' E3 e
四、生成器8 V4 y q3 X% f* C6 _5 C& V
生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的
/ F2 t2 Q6 x2 C! P a' o+ W
8 f) N- Z. I% D; a6 b6 x7 ?定义生成器的方式:
3 E2 F8 ?" N6 e0 W! H( g4 Q, B" W通过生成器函数构建生成器' f& ]& K+ q6 o- c: \- M6 F! V# ^, w
9 ]- [: T$ c& h% P M! n- R" F5 l5 e0 Y& j& s; S# H8 N6 G
. |7 |6 x! |! y0 \* G# g' q
这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来' X) P+ f7 A$ B0 O' ?7 V2 k
( [2 x+ R4 F9 @! S6 j
也可以在一个函数里定义多个 yield) d p9 K$ R d- k6 h% N
![]()
+ [$ x9 D7 B' i- q' U8 J之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration
) _1 l' [3 c3 M* Q
* n( w( z2 U# E/ h; t. g- |, c7 ryield 与 return 的区别2 r' Y" ~. D9 x( K+ a7 V+ _
8 x% J5 a7 }2 o( y& z
return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值" Z0 y( |4 B2 z) t5 D, V& E
yield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素& e' z I) y/ O' l- E
应用举例:
( P. m. o# k2 }8 x" K8 ~. a
7 T! u+ [& W+ Z" j8 c' q买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了
/ l+ l. |% K8 _% L- \8 V/ T
v4 U+ t7 \0 t+ c9 u& Z
- E! j/ a$ x7 _ ~0 {' ~4 v如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):1 L6 B, u3 b8 }9 }2 S
% r( ~+ \1 G- U D0 O7 w
" @1 e& Y; E7 u. a% p7 D! f. U除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部$ g4 n2 d% h* o" w h# O# f
![]()
6 e* R8 d h7 \6 {; a. G/ P可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值
7 K+ j* b9 G* j9 G* D1 w 0 h( ?# S/ U/ \ l" ?
在使用 send() 的时候,可以将参数传入生成器中使用
8 H, O- b* P Z9 Y! l8 L* z; N/ V: ~
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下% }9 U( C& \. x
{1 x% W9 M2 o# |6 `& Z0 |
yield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回
, |) x( t# [: |" p( t @
" u- J3 r0 m" e, y2 o7 N; F: |* s v " d; }' l( O4 F& z7 V7 _
yield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果# C1 B& V* ]& S( C/ h
![]()
# a* ]1 \8 |0 _: A) f% a1 ?, r$ L0 O. _9 z' A, T/ w
6 ~$ G8 b. Q, y* Q" R3 J: I9 q0 R' ?/ S
通过推导式构建生成器; |6 s4 W7 Q }6 J- D& {) J
列表推导式:
u& z* g; g; w5 J4 x- j![]()
5 R% p) ^5 s* g' g* u% t7 z生成器表达式:和列表推导式差不多,把 [] 改成 () 即可/ E% i% D2 ^) R t3 X; M
![]()
4 V- b$ u, [+ [: H5 s; u) ]* u, |* D6 w4 k5 V$ u2 A' G
列表推导式和生成器推导式的区别:
% u- \% _1 |; H# L: Y! i; c) y: y) S6 U9 n- O7 B! ]
列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素
. ^* Z( ]$ Y3 j7 \. a, B得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器
: o9 h7 _; t; y5 ?& _9 C列表推导式一目了然,生成器表达式只是一个内存地址; p! c: {. z! Y
————————————————* L$ R! M/ L! Q A* w" l5 A) u
版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
- r( M4 C4 E% \( Y/ j- h; r: U原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143; a) J6 L& j6 s0 @( p
& z; ^2 {- S3 e1 ]# f9 G5 F- G$ m
7 @0 [8 i% S& ^3 s: D: K2 L- ` |
zan
|