- 在线时间
- 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 田老师国赛冲刺课 |
一、可迭代对象8 ]$ M. K: Y* |/ t% n
字面意思:
* x5 E5 e+ t8 r8 a) X6 J% e对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽)), O! e$ @( G. r9 G
可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容
( M8 G& }* T' {, X6 e, B0 d7 U专业角度:内部含有 '__iter__‘ 方法的对象9 v+ g& |2 z8 ^' S v. n
目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等
% R. M" Y6 D# I: k5 `8 B- b判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例0 `: @4 ]# i5 r. @* q- B7 R0 ]
/ F q, E' x6 b B
1 k$ E, U6 }. U1 _2 l& E+ y优点:3 J, z: x" M# q$ X% x- k
存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来, i1 j- o4 m/ \! [
拥有较多的方法,操作方便:增删查改等) C0 f: p+ }8 T
缺点:' D$ Y3 D( L' d- I5 F& j3 g6 ^
占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中
+ I# d" J: q8 h2 Y$ B7 C+ k不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取
" q* i1 e1 Z& A$ n" W7 R2 H二、迭代器
: @$ |% H1 ?6 w! X& M& v字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具
( U( k \- V1 y" V2 o/ _' `专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例
5 M. {" r4 M! w( g6 n( S把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法# r+ y& L- G# e' |% x0 L
![]()
( L8 v6 E2 [5 Q5 P% q+ }迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理
/ Y a# T" e9 l& x0 m![]()
6 U+ Z/ f: Z) A: K+ S3 p" u优点( S$ q% P1 R' C( f7 O) C
节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)
) h4 \ b$ ]% f7 b) ^3 q惰性机制:next 一次只取一个值,绝对不多取
- k$ \# n3 D& y1 {" F5 j缺点:7 {9 a. E( ^; ?( a+ k
速度慢:需要一直 next
' E/ X7 G1 f. h9 V6 J" l* A' O- f不能回头:只能一直往下取值,取过的值没保存就没了`
% [' ?: g7 n G$ i不能直观的看到里面的数据" ~+ R- S) c z5 a- U0 Z
三、可迭代对象与迭代器对比* J4 g& L' A+ A0 B( {4 G
可迭代对象:/ F4 a. `+ X$ m3 k: u
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等): d5 n8 h7 @5 L" B X2 |" H t
直观,可以直接看到里面的数据6 C: C: t; }! J: @1 @
占用内存
; e2 V* s6 [( e6 T不能直接通过循环迭代取值% ]. z! C+ V3 ~& s C
应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择
7 G3 z8 v: r4 ~4 v7 d: `7 P" n& \迭代器:
" e( c% n c4 |$ w- G& ~# U8 _! {节省内存,按需取值
- o( u T+ b" j5 w1 j可以直接通过循环迭代取值* b1 ^+ J/ P( F8 k/ \& D0 @' p0 G3 p
数据不直观,操作方法单一
1 X% P i2 C8 z+ O5 g$ G1 i应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择* J: _. n3 H- }4 d4 j7 Z
四、生成器" ^4 K( P a, s$ x) M
生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的' `) P2 x# j& W3 l% H! N6 M( A
# z! l4 u8 `6 j0 I8 }- H定义生成器的方式:
: }! G) m& i+ ?0 e5 @通过生成器函数构建生成器
/ j1 G1 H) p# U. y, j; }
9 n( L# M8 g8 S/ ?& y5 O. [7 }1 M9 t3 [+ K2 O9 w1 t1 H0 g
![]()
) O" t8 \! ^" [9 L这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来1 ]* }) H/ q, U$ _# Y
4 z3 _' \4 F4 R
也可以在一个函数里定义多个 yield+ c" }; I0 J+ t( ]; m
![]()
1 M' M+ q4 y6 u之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration; ^- K3 A e0 _2 v+ e
! e' K* }8 d/ C+ x; y: O7 i
yield 与 return 的区别$ B6 D0 [3 _" T2 b' c9 d
: I! e% Y1 ~- y3 ?* Breturn一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值
7 C# \ d! P$ }' ?5 p' {yield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素
( A' J6 {* j+ M! ` Y3 f5 B应用举例:
: g1 o5 U' ~: K0 Q6 p* ~- m8 ?& b
9 @$ t+ k- h0 H买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了. D4 V8 y* F* j9 C# I7 X3 k
+ i$ y% b# t0 A1 y2 m
# N& ^, s5 E! b$ r. V1 `9 E; ]1 B如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):
P7 L9 `2 a4 q: T
3 i4 I \! a" c9 Q
7 X- e$ Z6 F) G; r t; [- r除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部; {2 _' y L7 T# f; e
![]()
9 R3 t6 n& I1 J可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值/ C" p$ T0 n) f* W( B8 o% }
![]()
2 g- k$ x2 _" R& t1 Y. l在使用 send() 的时候,可以将参数传入生成器中使用6 Y; k; w: a* a' a1 U* Y) \& K
4 x+ Z' r8 C" q
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下
. V J. {' @$ k, l' L . e5 l& @6 X5 D# \
yield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回
5 i% J H8 ?/ O" V4 z2 k; \
' G# a+ q/ y" ]+ N/ {+ [ + _( y( @/ V2 g+ Q" e$ @
yield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果
0 z; Q$ h( e2 T% B8 E$ W1 G I8 W![]()
. n5 G8 C' X K+ ^' R Z$ G/ f
. v5 U; c/ ~, Z; a' W* a
: ^) s3 ?9 V2 c通过推导式构建生成器0 n! t& m; B/ e
列表推导式:
8 t0 J) a N: n: s! P![]()
' \( R* r7 s5 Z! l# `生成器表达式:和列表推导式差不多,把 [] 改成 () 即可
& w& X$ L$ k+ {# y' w' I1 j![]()
* U' J' a3 j& @# p( s9 Q& {* u1 m8 U9 B
列表推导式和生成器推导式的区别:& h! X+ j5 z, ^) C
& y# E( S6 m8 H7 N
列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素
1 V- g: A7 l) B; n. D得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器
, Q3 f" ^7 ]) H8 i列表推导式一目了然,生成器表达式只是一个内存地址
& M: y9 a" ~" S————————————————9 `) t1 Y+ F5 k
版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。1 X* r3 k, q# z0 j
原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143
$ b+ D2 |5 F1 U+ \' s6 q3 s' Q' ?* ?# X. h4 A: l
' P: d; W. r& x* T" |# v" ~
|
zan
|