- 在线时间
- 661 小时
- 最后登录
- 2023-8-1
- 注册时间
- 2017-5-2
- 听众数
- 32
- 收听数
- 1
- 能力
- 10 分
- 体力
- 55557 点
- 威望
- 51 点
- 阅读权限
- 255
- 积分
- 17619
- 相册
- 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 田老师国赛冲刺课 |
一、可迭代对象6 n# ?( ^6 G4 s. l- I7 U$ @
字面意思:& _) T9 }: [" _) r+ y
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))( W6 ?# L6 q2 W/ n7 l8 ^
可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容* b g7 a& Y( q, b6 A; W& Q
专业角度:内部含有 '__iter__‘ 方法的对象
( w ~7 T' n M4 N目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等
3 C( c6 i- r- @% L* A+ }. L! m* Z判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例3 J8 a3 q3 y: H4 n6 p, v% G! \( P
) w2 a9 p! P6 c6 d2 o
: _# K/ i1 c) P b6 d. e优点:7 U9 _+ Z5 y! a: C F6 {# P- Q/ Q
存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来
6 S# Y0 K$ N2 i6 x' m% J拥有较多的方法,操作方便:增删查改等
; ^& P/ a6 m0 e! G6 R; o$ _% M' f缺点:
- {6 u0 c: @7 D* F% U* a/ a占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中7 j( F ^( x2 O; N& a
不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取# { ]) H3 J; X9 i T" l
二、迭代器
+ T9 q% |) I/ z6 D- ?- F( K$ I7 H) {# W字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具
# H. J6 O0 C1 t3 y! _3 v专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例) W) W F' L5 D8 u- x2 y
把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法
* K1 U- t( V9 ^- G9 M ! y! D3 E+ f6 z& `: T# K/ Y
迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理4 ?) b$ Q: @4 a- y/ D
![]()
5 \$ y& a$ k; f优点
! i O N a# Y: x4 j0 @, y节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)7 S& l; _, j& G) F+ N0 r
惰性机制:next 一次只取一个值,绝对不多取& ~- h' {2 H' S% _1 D( W! P
缺点:% W! j1 ]. t: O$ B& ^
速度慢:需要一直 next
6 |1 H. O& ]. y. ]: ^. E- G9 E不能回头:只能一直往下取值,取过的值没保存就没了`
- s( j0 }2 E! _9 C) L不能直观的看到里面的数据7 _! ~9 g$ y& i% b& W8 |
三、可迭代对象与迭代器对比
9 {) u/ i5 p+ t2 h3 N$ r8 a可迭代对象:: ^; E' o8 N- n
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等), q* ^: i. C- }
直观,可以直接看到里面的数据
& k. n! O( w6 ^% W. o占用内存, t7 m' e5 }2 r d4 { J7 B
不能直接通过循环迭代取值
: k( h( e; _% p+ A2 W3 f1 y应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择
: T8 t L' I0 t' t迭代器:8 ^% m* O1 n4 t5 V4 E
节省内存,按需取值
8 V. O* u- X: |可以直接通过循环迭代取值
/ {' m2 l2 X1 u$ ]- z2 T( a数据不直观,操作方法单一2 [! Q. F6 G8 T0 a0 z
应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择$ c0 `. |- X1 B8 B
四、生成器
/ }6 x8 K0 R8 M% O4 l( |生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的9 [7 T: l6 O' L3 Y" W+ o6 o5 C
" r, R# N5 N6 K7 c% ^6 F
定义生成器的方式:1 \# g6 ?' n$ ^/ A( U
通过生成器函数构建生成器
! i. K8 g1 Q5 A# W
" ^) x' |- v( E1 E1 ?5 n
, N* j7 r" v( ?7 A" {![]()
; K1 O1 A g4 }& I' N这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来( a; H9 y9 ?* v$ i
; h$ |9 A! w( c) y4 R1 X; N
也可以在一个函数里定义多个 yield/ N/ Y6 j$ j( D5 t9 Q$ w6 |
. b1 B2 s0 H( Z! p. [
之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration
! i8 i ^% `$ _' F9 ^6 E( a: p' y1 ?% r E( J
yield 与 return 的区别
9 v8 K0 d* c9 _# a. d; k: p% H2 j6 X; W: u0 b6 |7 A
return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值
0 |: H& S" g! [* syield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素
9 w) v7 k" y9 e$ s应用举例:
3 s7 H" I- e4 X' d8 z7 I$ F. j' [) g l" o% {4 X" s
买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了
7 F* I! B8 N2 E3 n1 k
' Z+ D* O/ ]; K% Q! J+ P9 Z/ O
5 J8 L" B% }3 }) X$ d2 d! `7 n) @$ l如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):3 w( M# n+ C. I) g4 C
+ x {4 |0 U( i
5 {0 M' e& u0 o8 a9 C' C8 p除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部
! x* d/ w; [9 c6 S: p9 j $ [8 s0 Y. i" B, J7 }
可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值
8 l( W! ]7 A9 o& O2 s ! [2 r) N4 W9 f ^
在使用 send() 的时候,可以将参数传入生成器中使用, m, r5 e! o, c9 g3 m
& d _ d# B# [' k# C0 s需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下0 Y; I6 a% g3 N' L$ K% u' w* h
( x6 {7 V# s/ j- m( B3 b! a9 G( G
yield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回. @8 g8 `8 G8 m6 E* J, Q
6 s! `. |* G( l* G* K! v8 W/ `
7 w: q2 ^2 \* g
yield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果' q. j! U4 b- L
![]()
1 P% L' P+ C: p/ ]1 g+ d8 X" N
5 X4 \& l8 s, g' L, T* O/ Z
k; w* V; ]8 v, g1 e% D通过推导式构建生成器1 ?! j3 j' |; n& o$ _7 M: i
列表推导式:
( e$ C3 k2 [/ d' P( v $ i: j$ ^3 H I5 w8 p: O
生成器表达式:和列表推导式差不多,把 [] 改成 () 即可 `' l, z8 x1 R' G
8 ?# Q/ N, H$ y2 @
+ `" @3 l2 W6 L" ], p- ^ w: w
列表推导式和生成器推导式的区别:
% M+ h' q( B3 }& Q$ i
& w7 c: [8 D, P. R! d列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素9 Q3 `' F& `7 K D7 A; l* o
得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器
( ^ S' X. k2 G0 m: k& m列表推导式一目了然,生成器表达式只是一个内存地址
5 J, A. |: p9 s/ K6 K' I$ X————————————————
+ E- Q5 T% x3 E: ~+ J# F6 D版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。; F: V3 Y) ?6 ~7 q. I% y+ q" R
原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143
: k" V2 K# v$ Q5 L9 o5 `
# z! R" ?3 p4 Q# B$ b8 _+ ^. _* u2 Z3 {. g ]
|
zan
|