- 在线时间
- 661 小时
- 最后登录
- 2023-8-1
- 注册时间
- 2017-5-2
- 听众数
- 32
- 收听数
- 1
- 能力
- 10 分
- 体力
- 55578 点
- 威望
- 51 点
- 阅读权限
- 255
- 积分
- 17625
- 相册
- 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 田老师国赛冲刺课 |
一、可迭代对象
% }( {3 m3 c3 e+ y( K字面意思:0 n- D3 M. f9 e4 o0 r3 [
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))5 B j: w$ h7 S4 U! `' G, B5 d2 Z
可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容
) o2 |1 V- _0 L4 U5 t专业角度:内部含有 '__iter__‘ 方法的对象
' q. Y( X3 }7 c8 H3 D* i9 Q0 \目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等
# e3 K8 C7 H) }2 U0 \% \& q; x5 K判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例( l/ W8 B2 g6 M% F3 o
![]()
6 f( J9 i3 { z1 i3 ~. b! t% } K/ [% O- u$ a; Q! P- s
优点:8 w r. W2 G n+ j
存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来# F3 l- j$ o+ K, F( v3 M$ Y
拥有较多的方法,操作方便:增删查改等* Y! W% @4 u5 _* J; m! M
缺点: z# t2 l$ L, j5 h4 v/ a
占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中5 @5 E$ w& R ?
不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取
( u {0 Q7 Z! |: L7 _1 \二、迭代器
1 i0 h, r( t3 c; \字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具4 x4 o. u2 N7 H+ G( x7 W. o7 a
专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例
0 h- S& X5 G, f3 J8 S把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法* H6 `& [7 ?$ K
: g P2 P# J2 z# ?
迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理3 H: J& V0 d2 ?' i' q
8 ^( q6 \7 f$ Y/ k
优点
4 }3 k6 K/ F0 m. L! G节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)
) k1 B6 E& L# d0 B惰性机制:next 一次只取一个值,绝对不多取
6 ~; a9 d; r1 J1 y' l, r/ W1 j缺点:
3 d5 R$ r+ k( \: T1 J/ t速度慢:需要一直 next
* @4 O/ t4 l6 A8 w不能回头:只能一直往下取值,取过的值没保存就没了`
' p" [' W" t8 C# }% z' t& i6 ?: q# E0 {不能直观的看到里面的数据( Q( f( d3 b) n/ E K
三、可迭代对象与迭代器对比$ O! D% ]& P- {* c; r1 [
可迭代对象:% e6 E! a7 d. i+ _
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)
6 ~' O. @5 F; Z直观,可以直接看到里面的数据
- ^7 S ^, i) h7 M( A0 a占用内存; f2 U7 s1 P; |
不能直接通过循环迭代取值, v4 }" O( @+ D. X, w$ a
应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择& Z1 T+ M& T( W$ c
迭代器:
4 w( ?. [" k& c: K节省内存,按需取值4 ?( i$ O6 K |7 D
可以直接通过循环迭代取值
4 n' b6 S; b/ d ~/ q& K数据不直观,操作方法单一6 }6 j. S7 m2 M" f) n. f
应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择
* I6 O4 e6 a( m8 b7 q g( U四、生成器/ P. y, N8 a4 Y% C5 Z9 P( m
生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的
: ]6 L: D9 g4 M! e% b5 r' e8 b) |' Y; |9 ?1 v x; w8 }; j
定义生成器的方式:: K& C6 J0 y: H
通过生成器函数构建生成器4 ?0 ~2 |" N% K, x, i
d+ p+ P9 B% m
! l* \$ F- @5 H, k) J6 |0 j
% z5 X& G" P! L& _( d, |2 s
这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来
, J' o. K5 W( i' z) P # g1 Q- f' }; q7 p
也可以在一个函数里定义多个 yield+ K+ i9 ^4 f6 x& x" p4 c
9 Z( i8 |; \( p; W/ ]
之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration# p7 u. ^& C, ~% b7 Q# ~" h
/ t+ V5 f( Q* C( Q7 Wyield 与 return 的区别& w! H9 t3 ^7 z" U0 Y# i$ O* a7 N
& g1 _+ d4 m/ I" h D
return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值
8 \9 h* s+ _/ M$ }yield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素% o% X3 V( Q _6 Q! z+ J! K
应用举例:* O; Z! B& g+ b: B, u+ d0 Z
. c, N& I% T% E& l$ s
买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了
- V' |% {) b X! n. H0 N
/ F- [+ z0 y- j1 ]2 f+ _: N
6 B3 U) d- K' G# X3 i如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):
5 m. O3 p( J' V) D$ `5 R
1 u2 S; l; }8 g% h
) S( O' D2 ^, I5 b" z/ _& Q7 X2 |除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部
# g" ~/ O" N+ {% D![]()
3 @( r: G b4 V0 |可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值
! O$ f* \1 i% p9 Z![]()
7 T1 x8 x: ?2 ]在使用 send() 的时候,可以将参数传入生成器中使用
; M- z" {" T) V7 J1 B2 A! M" D/ r# L' B3 m( w W
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下
1 A* ]& Q' w9 d2 [( u 1 @( ^" A: r* N
yield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回
( W" I& Q& O" v/ V3 K: _
$ J, \3 D% V& z) k# I* i7 r![]()
9 W# g8 [0 f0 y7 v; W7 D- jyield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果
, u2 n$ a2 e* r![]()
7 e* {. g ^8 O$ h+ f4 K1 g* X: ?7 D, t }/ t
3 _9 I, H" a1 M6 ~ p4 H
通过推导式构建生成器
9 o7 P& ]/ h& S; J' V" [2 P列表推导式:
, ^; }) B3 B) p1 Z1 X. ^![]()
5 ~6 z3 Z% a0 e+ h1 d生成器表达式:和列表推导式差不多,把 [] 改成 () 即可) L7 A4 b6 c' u2 u
! e$ d( Z/ q, m$ k% Z' A
( P- h, v8 Q! n3 p1 v列表推导式和生成器推导式的区别:
! W* e' x/ d, p, \5 b/ i( t2 C' r$ P- T s! V& F$ M1 J" q
列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素8 _: O, A! W6 E; G+ t
得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器+ `- _, k" V$ j, }. E
列表推导式一目了然,生成器表达式只是一个内存地址
5 d2 ]6 z% U% o q: v, s————————————————
1 r! p/ }! t" @' ], E. i+ E版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。" S" [) M5 g6 G! D' ~$ c. A( D
原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143% I$ ^" Z* `; b
# @% x+ a1 _' {5 u M
# }& u r4 n- J2 z, d |
zan
|