- 在线时间
- 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 田老师国赛冲刺课 |
一、可迭代对象
& a4 K" W' ?: G5 P4 J2 b( z- s b字面意思:% k; d' L# Z7 B! J& h9 A$ Y
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))
7 I$ u5 a. f! N' o1 P可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容2 u6 z; t3 V: q) k- c& z7 i3 {
专业角度:内部含有 '__iter__‘ 方法的对象
: }8 _- H; ]) J# U `5 ]+ ~目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等3 C5 h4 |6 z6 x1 B* j
判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例& [+ {/ k' p/ i% @5 Z. l
![]()
- u' ?% Q, @- }; n$ I& U5 i& K6 i1 n3 }
优点:4 D. D. E3 Z. V3 N0 M; r+ v9 Q
存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来% M" G6 ?1 ^3 e
拥有较多的方法,操作方便:增删查改等. {: m* i: a( m1 u6 R* p+ B
缺点:5 s! O. j; P0 A4 X$ ^0 H6 D
占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中1 y# {5 y4 u& \. O3 M$ g
不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取9 c, V7 C6 e% f( M% C
二、迭代器
, `# P) C0 s: E& l1 z字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具
4 K& i5 B$ p2 f& M专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例
7 Y3 X# M7 U" z9 G. d. \把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法
: V Q3 p/ S7 c' e 0 R+ Q& k+ a; K! j n
迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理4 p$ U2 V9 e' [& v' \$ {2 s
![]()
% A: V1 H( [& d优点1 y* e$ ^' u! T( T6 d
节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)" E& B( d+ J5 Q* w
惰性机制:next 一次只取一个值,绝对不多取
$ Z/ A) o$ j" H; f- G缺点:+ d& y: M2 K, C, S$ N# M w
速度慢:需要一直 next0 A4 g- H" u; O2 A
不能回头:只能一直往下取值,取过的值没保存就没了`" d7 |* @( O( B% u
不能直观的看到里面的数据
- x4 Y7 H4 ~& Q l' f三、可迭代对象与迭代器对比& ?( L: A* x2 z; `1 c0 }- Q
可迭代对象:
; }* A8 J$ g$ w% F9 _$ T& M私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等); y$ p9 W6 P, o: F- U4 i
直观,可以直接看到里面的数据& K2 k$ R. H% ^( U1 |$ a, V& h
占用内存
' N) Y9 ^5 n6 _8 D5 j不能直接通过循环迭代取值+ ?* M }: J/ i* I- o
应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择
7 }9 f- I4 Q# }) D' V; A8 _迭代器:8 C* K* a& _+ h/ P" a$ D- n0 b
节省内存,按需取值
7 o! ^! o6 k9 \# X, e' h可以直接通过循环迭代取值
) [) x( Z# P* l2 h* O/ F K, n8 A0 q数据不直观,操作方法单一
$ M, I2 R" ^$ {7 f应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择
0 c6 s# }% v0 s3 R+ c. [. ?四、生成器
4 ]7 Q. p! k6 U* Y+ V) G* N生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的6 s+ v$ w! x+ g) ~# k- \. [
: ?) \- p( a& W2 H5 T0 t
定义生成器的方式:0 }, \8 s( x! N) b
通过生成器函数构建生成器# ~; u+ R( u4 M Q0 c6 p& O
; W3 H) ]: h# ?9 e3 k
/ w2 H; K' {* z( `7 A; [* m7 ^6 _% P3 f- g![]()
" k$ \7 }* ^" U0 y& |) l这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来
# {7 `2 p6 E6 K ?( M/ K1 q; L
也可以在一个函数里定义多个 yield0 c8 N6 V' N" |' i
![]()
0 U: o! P0 |% B9 L之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration
. U/ I. [! B& r0 B. ^6 @# Z V) r8 R; [7 ?" D7 u; G2 Q4 E
yield 与 return 的区别
; t* ]! q9 \; ?9 y+ a [( C$ r" q5 [6 N9 M3 E2 d' U
return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值7 n3 N& ~+ d- i, c& N, r: H* ~
yield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素; i! h8 \' |) V+ G/ ^& q* V4 [
应用举例:# E! C2 k; j# C
7 \ Q% I' I R7 a/ M买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了1 i& K8 F% k. D" h! J
X: [# [* L! x+ S5 J& F% s1 Z4 `* j
如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):" C- g9 {: k2 H
) w, b; S/ {8 |: [0 u5 ?
7 Q+ l% s1 P4 u) u8 G# U- M- X* R
除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部* Q8 U$ u- t- K: O3 E& U; }7 X5 K
[$ l1 {& v+ y5 \3 a) i9 v
可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值
, D: h6 J6 t4 P: f! j![]()
/ q; y X3 @# a0 S6 o5 B在使用 send() 的时候,可以将参数传入生成器中使用8 t& @1 ], _/ |0 {( v0 R% w' c6 [
' l m0 e0 V$ R9 p* q0 V需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下
- m" w6 |0 o* {" t6 k " E% U1 |8 E, D, h! _# ]
yield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回+ j6 z/ P! O6 m- E4 C/ _4 o1 t$ C
, ^# x( _; v5 p& E# Z/ Y x![]()
" h: R$ Y7 K8 p/ L7 Jyield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果: e4 |3 S& ?* @! d
![]()
3 M& B% h% u4 P0 p" J; ?. B# X" \% w3 J
" X% b" R3 M* o. c通过推导式构建生成器
. A% ^6 ]( f4 S6 ]3 l5 \: s列表推导式:
/ C m4 J7 H1 f. j/ i+ t/ u 7 M! I, [1 s( G& H* s
生成器表达式:和列表推导式差不多,把 [] 改成 () 即可
3 o1 }9 o, @: u2 q0 N) f: ]! x![]()
7 q1 [" e, ~+ ], F: ?& w; P
' u$ N5 Z4 R* p. `& f列表推导式和生成器推导式的区别:
( A/ f+ O: L. E9 l: W: [$ \; d+ m/ \+ {: ^' B4 }; G/ x
列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素7 b5 F7 p' W1 `. i! e) g
得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器& j, O# V( _, L+ W) |0 n
列表推导式一目了然,生成器表达式只是一个内存地址
% I9 D+ \) r3 s' [————————————————( g. l$ N Y1 M1 r# T
版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。/ \8 x, }6 n9 f0 S: g
原文链接:https://blog.csdn.net/weixin_42511320/article/details/1056761435 v) U* f, A$ M7 y. ~2 N
0 Y8 | G4 S5 e( u8 t
' X; A$ g3 ?1 w9 P+ \
|
zan
|