- 在线时间
- 661 小时
- 最后登录
- 2023-8-1
- 注册时间
- 2017-5-2
- 听众数
- 32
- 收听数
- 1
- 能力
- 10 分
- 体力
- 55572 点
- 威望
- 51 点
- 阅读权限
- 255
- 积分
- 17623
- 相册
- 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 田老师国赛冲刺课 |
一、可迭代对象
2 w' F9 n6 T. }1 j: Q3 n+ r字面意思:
1 |: }, K: n6 u- M5 E) U# u对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))( a! `2 E% H9 C' j( k/ _9 R' @
可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容- V" {- m E& S
专业角度:内部含有 '__iter__‘ 方法的对象
6 X% F+ Z, }# ~* C% I目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等! {2 k* L# S2 } C
判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例
4 T3 J5 u1 P: |* ]$ o" e) B1 v0 u![]()
: [$ M: M# Y. I1 K. R; y
( y! V# P+ \: m8 a3 l: e+ {8 [, _ T优点:
|5 q$ F! K k0 a1 l. u存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来+ z# U1 E: L& H y/ F( y
拥有较多的方法,操作方便:增删查改等5 y; n7 G1 k0 N
缺点:, k# }. x, {$ u3 o/ Z
占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中
6 j8 L2 L; c# w. ~" P不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取9 h) I6 E- B* U+ F1 V$ |' e# J
二、迭代器" `7 P, }- |2 w8 r5 x$ @6 X. z
字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具" m6 V* [# R* B" R* G% d# k/ C) B
专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例$ [0 a0 o8 Z$ G3 d9 T
把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法
+ ]6 D0 Q( b Q5 N& G![]()
6 Y- F _3 I3 [- x迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理+ V9 ~2 C$ @; Y8 {" J2 b5 r3 |
![]()
; H0 |9 \6 @& y% b优点
5 _6 M" W9 h' s* N0 H节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)
* k7 j+ _3 o& h% F惰性机制:next 一次只取一个值,绝对不多取
& O; N7 V/ [) \* V+ e0 a; ~6 F6 Y缺点:
" D% f8 a- g3 K- N) g速度慢:需要一直 next% s; T8 h5 z% R0 Q9 Y* O% |8 [5 S% e
不能回头:只能一直往下取值,取过的值没保存就没了`
+ N: p0 P( }: u' G3 U/ |不能直观的看到里面的数据0 x$ a! u/ [/ z& Q7 ?
三、可迭代对象与迭代器对比
. _( x2 ]+ k, F可迭代对象:+ x, R/ {! o7 u, `# t/ b0 K) R8 a; @
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)
9 ]& V& [! {2 F! o直观,可以直接看到里面的数据
+ g- U( F: v y* f3 ^% K占用内存; e8 T; ^& @ T* o* w) j
不能直接通过循环迭代取值$ o5 U ?8 a% @6 U" g- C3 s
应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择+ g. Y# J9 S) U C0 [
迭代器:$ K2 R2 ]4 }$ m6 q/ f5 Z8 L2 i
节省内存,按需取值5 G* F8 k6 T6 g7 M: G5 }* c
可以直接通过循环迭代取值6 n9 f2 p8 C8 \1 J7 j3 v
数据不直观,操作方法单一( z5 ?' C, W9 V; z# g. J
应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择
6 n: g+ t8 m) p' T' Q四、生成器
: d4 |" _$ l7 g9 F5 G生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的4 T' G" U9 T! ?& `+ y6 L' v/ u5 e
- v3 n. N4 Z1 z
定义生成器的方式:
, r" q& D6 ^& Y" r: ~. A" c通过生成器函数构建生成器8 c8 z* }0 t4 T2 |5 q( q
7 a- @( ~/ v+ T9 \" @5 ^- h( n
3 i z0 [) u* | % b. k# Z+ b6 T1 h7 _
这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来! s' q9 U6 u; n1 _
" V* L4 g; ] m: A$ e1 h
也可以在一个函数里定义多个 yield
2 I0 m8 t* m' m, ^. L' m7 |![]()
5 U, g7 S7 l( `7 j; g( I之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration, |- f9 j8 ]8 b, K' A; q+ ~
2 W: f& _" \) lyield 与 return 的区别& |2 C% ?/ ?" c4 Y0 N- V/ |% t$ d
m$ }& S# r U9 y$ V5 O8 v8 h7 x) ureturn一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值
4 J7 G" i, t7 ~+ fyield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素
* M6 k" @- v8 T, P m; D应用举例:
- O9 C8 R h" M! l# W- V% v4 \$ x
* L! ?' _$ m$ ~) ~% Z; l买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了
' [ V7 Y4 g9 i% s2 a: v
6 X% S6 o0 r9 |6 T* i8 w
( L r- d( A4 V5 C6 L" f: q如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):
S9 _8 x4 i$ t% j- @
; `6 V, E7 d/ T9 }- Y
) T$ S, L7 P' p ~除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部- }& l% b" M% `/ V" F
8 A9 A" `$ j# r: v
可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值
1 g$ K: H" |4 {6 @( \2 K2 s![]()
9 f& }4 t% e% W9 I: g4 A在使用 send() 的时候,可以将参数传入生成器中使用
4 q* m- j6 S2 s) Z G# j$ p9 ^) X" K. Q
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下
$ N+ Q N0 x% n1 _' x4 f 6 }$ p6 Q. l2 ^
yield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回
9 y. l, l7 F$ C0 [8 r: I
- V/ m+ {( c8 s4 f$ z. b- D) U![]()
1 S4 e4 E6 o- V) B8 lyield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果8 Z; a- K$ d. G! x& g
; _' A: `. b; ]# z2 f3 k/ Q5 h; r
" V# L( ]" D" `/ g5 L3 _2 }1 C
3 x$ D) [ t) u通过推导式构建生成器+ T7 }9 y4 @. S: b
列表推导式:+ V% U7 K3 ?0 g* ?# X4 v0 d: P
% W8 q1 s( Y) p$ C& u3 k
生成器表达式:和列表推导式差不多,把 [] 改成 () 即可) n4 `6 k2 m! B1 }) N0 b
( w. `, W4 F c' Y4 U
/ J$ Y4 ~% q. W# w
列表推导式和生成器推导式的区别:- G# I3 ^% }3 h
I/ W! T& n, N列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素
' [- o6 K4 i3 t5 y得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器
- Y! d4 O+ M2 Z# u- h! ]列表推导式一目了然,生成器表达式只是一个内存地址
5 U" ^' _ q0 W8 k————————————————
6 [1 Q6 B7 @- I/ W& Q' [版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
7 y* b* n& z" f9 x原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143
" \( q# T& f. ^2 t
! x* a% A L" @* `) \0 v* ^- W2 `+ A6 T3 _
|
zan
|