- 在线时间
- 661 小时
- 最后登录
- 2023-8-1
- 注册时间
- 2017-5-2
- 听众数
- 32
- 收听数
- 1
- 能力
- 10 分
- 体力
- 55540 点
- 威望
- 51 点
- 阅读权限
- 255
- 积分
- 17613
- 相册
- 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 田老师国赛冲刺课 |
一、可迭代对象
) J; G p0 A; Y3 o/ e字面意思:
$ J8 i0 O) q- k" B对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽)); ^ `1 D) _: B$ D% n' ^: N! E6 t
可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容
9 o, j8 a0 T) m6 X2 t专业角度:内部含有 '__iter__‘ 方法的对象
! A! R I, Y& N$ L目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等* z$ {3 H2 g* X U' ~; a
判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例4 R. l/ s" x$ K- x
![]()
0 X7 y4 C" o2 p; o$ b' a' V. X7 e8 u( ~; h/ B, K' h& _: }
优点:
* d% O8 o$ }4 z3 X4 i# d! ~存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来8 C7 u. Y9 h2 W' [7 [7 k2 C
拥有较多的方法,操作方便:增删查改等7 u4 J2 ?, F9 X& I1 N5 o
缺点:
( f$ N; X% t* C5 K* B0 F% x占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中
* ~3 A' P X$ Q& t% d+ m0 Q: z: V不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取
; s. i I5 {0 e/ @' x二、迭代器
7 h4 y' J+ ]4 Z7 W字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具
f( P9 B3 Q8 n& [! Y8 @; B9 Y% w专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例
. a4 F$ \9 W2 E7 \把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法# x% }' d/ w( A/ E: R
% V7 ^$ p' R' Z8 H% A( o8 q
迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理
0 K+ \6 U# z& J$ b![]()
5 C [2 C% j+ G; D0 r7 J优点! t3 i4 E/ z; I, e
节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)3 `1 d% h0 p0 Z0 a+ G- x# {* z
惰性机制:next 一次只取一个值,绝对不多取- i: l8 H4 l [3 f8 Q
缺点:( i% W: H& ]* J2 ^% @: ]% }! x
速度慢:需要一直 next
0 ~" T8 i9 m6 [0 i不能回头:只能一直往下取值,取过的值没保存就没了`; {7 J8 K, a4 _. A
不能直观的看到里面的数据2 X. O8 ~$ s$ p5 p+ Y
三、可迭代对象与迭代器对比/ m; S* U2 C4 Z0 [
可迭代对象:
8 K' Z: m) [8 A' k; J& U7 X' R: Q私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)
. s8 K, r6 ?3 U7 y$ O直观,可以直接看到里面的数据
$ K: K- r8 e+ H. S1 t占用内存- ?/ N" r( Z' r# F! Q
不能直接通过循环迭代取值
8 l' j- h( s* p4 P& g6 Q应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择/ [; F s6 r8 I6 U
迭代器:
! i+ K& V6 b$ g% b! \节省内存,按需取值
, h- s7 x/ e% z9 V! e* Y) x可以直接通过循环迭代取值% b6 g! C, ^( z' a, U
数据不直观,操作方法单一3 E& `. k, e: z
应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择8 Y2 ~0 Y2 h! O/ V
四、生成器$ g4 U3 D" O+ A) v- o
生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的
* F% t9 E6 ]/ ~4 U6 B7 l, Y; I/ Z' T& r8 J
定义生成器的方式:
' P8 [7 i3 ? S8 J( e( r/ p通过生成器函数构建生成器
/ k! A6 }" o* C6 C+ R* N `/ L
* v$ W) G$ G- [% c$ h+ V0 w) t5 ?1 k, H! o
, M- M# c1 Y, _1 m, Q* x* ]; D
这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来
) v# A$ B! e9 p6 \7 r) y6 H 7 q* `6 ]; Y: [$ A
也可以在一个函数里定义多个 yield; h" f: e) ^# P6 z
![]()
4 m# _: V/ K' C' L$ i之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration$ h% t9 d2 l5 Q" \# ?
& s9 U Y3 p0 r& m) ryield 与 return 的区别
1 b" U N" Q4 l5 e' q% `" L% i0 j/ Q$ t& z
return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值
$ i+ f& s0 I* zyield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素
: \2 ]0 [" z5 `- U. u m应用举例:4 _1 W7 Z, i5 |$ ~; g) `* B: E; @
8 M" y6 E( o& x: S- h买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了& Z. N$ ^0 E$ @4 N
9 F! S6 b$ H* C4 Q- X* C ~% P
4 `) O; N0 w& [; U1 y如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):
! Q7 y, Q! \. V% b# T" }
2 ?0 P" u9 k* G, D. |* r5 ?: o- g3 T8 ?- `) ~; U3 u0 }
除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部
. i" ~( J* V* S" p, s- h![]()
$ x3 u- }- f) s s4 z3 G% _' O可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值& ?& K! m$ R2 A# C
![]()
F/ O8 Q' \6 K; N# l5 q0 O在使用 send() 的时候,可以将参数传入生成器中使用) ]. g8 {% M- G* H$ N: G
0 L8 M! a! D- L2 v g
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下+ O5 X) N7 ?3 Y, e
![]()
9 i9 o2 q8 ^) yyield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回6 R$ ?- j3 |$ Q. l4 D- A7 ?8 P
' x1 w" c; [& P- s; \! `) @" z . z- V* j( w. `# l/ X, D: c
yield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果
7 M' A6 k( k- ~' j( k! P- D / W3 L q7 x8 S+ r6 y, P7 Y
9 g$ m/ ?+ ^) W! V* F6 t: X! [
3 R* g- o& V+ n M+ \$ O' Z2 F
通过推导式构建生成器! o/ T' d5 Q2 i9 `2 }6 l" o2 P
列表推导式:
v# M' o: B5 y& `9 n) J![]()
' \" o0 |6 ]' y: @7 N: ^. }生成器表达式:和列表推导式差不多,把 [] 改成 () 即可
d D' z2 y- i' O' @ 1 F- |5 H" w1 H1 `' Q
# @1 M6 z! Z: c4 V9 y* m: P) O
列表推导式和生成器推导式的区别:3 W, u' q3 f& Y# [+ F" D# ]
+ L" Q' ~: D% h( X; {列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素" z$ w4 H" N) A+ v, S
得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器
9 I9 L3 z4 \" z( f& D/ t5 ]# I$ n列表推导式一目了然,生成器表达式只是一个内存地址2 ?% N9 m6 p- x( ]
————————————————2 w. C6 f; _! z
版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。4 Z' O. x ~& I- D6 u5 p8 |+ D
原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143
+ {0 O- t0 \- x. t" c- x% B2 i( m9 P5 R7 ~' x- v; y( ?
$ z- C* Y% `4 [# i |
zan
|