- 在线时间
- 661 小时
- 最后登录
- 2023-8-1
- 注册时间
- 2017-5-2
- 听众数
- 32
- 收听数
- 1
- 能力
- 10 分
- 体力
- 55556 点
- 威望
- 51 点
- 阅读权限
- 255
- 积分
- 17618
- 相册
- 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 田老师国赛冲刺课 |
一、可迭代对象
" f" X; {7 s# {' a/ O字面意思:) [& P/ h. x$ O' [5 J
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽)), c7 b( o4 H" S6 B. J# U- L; X
可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容
# b9 u; j1 d7 X! e2 i6 U专业角度:内部含有 '__iter__‘ 方法的对象
2 w& ~# R/ G- F2 c目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等
5 }+ D! h2 y8 s# V c0 \9 v, v {# q判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例0 I3 l* W( g8 F7 U
![]()
- `$ ^% \8 P& ^& H
& `; r$ O* [: A! ]$ u" k. K/ i, U. V优点:) g. Y, a; j( ?3 C6 R3 [( W" H
存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来! Z' c' ?6 x, X2 F
拥有较多的方法,操作方便:增删查改等# i: L! B- S/ }# b2 v& o- D
缺点:
3 I0 {- n* L0 f4 t2 v4 v占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中$ H, x3 J! Y7 z4 I7 o S2 y- Y
不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取3 ? e7 G1 x: P% d1 H/ q9 G# [5 `
二、迭代器3 n& {5 a8 w. M
字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具
- E; f! R9 n8 i专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例 L, a% i s$ R9 m2 O+ {( A
把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法
0 F# e4 l N5 N/ h, B ( J$ w, G! G" K/ \! n
迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理5 [2 O5 m/ B* ~8 O" K
![]()
5 [: Q; t0 U c% ~1 A: U5 m0 ]7 H优点
' R8 y" y" F9 t1 t5 n& }节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)7 x& z* k* ^9 F( q9 H- n+ n( Y, ^. J
惰性机制:next 一次只取一个值,绝对不多取1 X% ~+ M1 e( v' `9 Y& @1 V) I
缺点:. G* m9 s1 O; K" \
速度慢:需要一直 next4 o( a3 m! \5 k
不能回头:只能一直往下取值,取过的值没保存就没了`. `2 w$ a7 c4 ]
不能直观的看到里面的数据
I" e3 y! j5 n: z0 M9 p9 S8 Y e三、可迭代对象与迭代器对比
4 r4 j. J; t: ~5 W0 O1 k可迭代对象:
( E* l3 R' C2 i- z私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)1 M+ a$ k( h7 n1 s2 w, `
直观,可以直接看到里面的数据* F W' e- h9 z' x( e" B" E
占用内存2 `& H7 }. I' R# N, S4 k% @
不能直接通过循环迭代取值
6 r0 S# W* o4 `- R! |7 J: j应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择
$ Y& C! `% p7 A1 T0 p4 `. ?迭代器:# y" E6 J! ^ I# J( l
节省内存,按需取值$ n( F# q. w# P* Z: |: D3 U/ z
可以直接通过循环迭代取值4 n$ Y1 p5 Z; x0 b
数据不直观,操作方法单一4 \* o* n# c, ]* ]7 m# P1 U
应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择3 r S7 {) p. b+ k1 |' `- w; ~( l) J
四、生成器
; o# S, j# d6 i生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的
( \+ H9 _2 l/ @7 _% k/ A
' H& i( J; l$ W# i定义生成器的方式:
5 T$ M% |" N3 i/ U2 R- H3 \+ V' P通过生成器函数构建生成器
$ L9 G) v* \) r) v
( E2 a& q# ]9 I) p: ?" H& S
* Z" U( q% ~" h8 U![]()
5 G( m$ G/ d1 D/ J这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来1 \8 U5 _8 c* B5 K
' c- a, T6 o' M
也可以在一个函数里定义多个 yield m/ k- |- E% Z& u8 a
![]()
+ z* C$ C" o& U8 N; y; w之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration5 c& C3 a$ A8 q
@; U) {- U- `3 l6 a
yield 与 return 的区别
8 p/ I( y; S/ T7 q/ l
% |4 N$ l9 v% |return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值2 W* t2 |# Z7 h
yield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素
5 ^9 Y7 C* L2 J1 v应用举例:
2 F" _- G1 I& ], c
9 c( [( E. w" x1 H买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了
4 {7 _# p' }8 t# x1 W" S* R* z
8 l0 d0 S, j) |& F I
- W9 y) t$ p6 J E u
如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):
7 o1 \3 S: J" S7 q7 A' r
# E; m, {3 x2 }& e) r/ X
! u+ |4 N: N' q5 P7 L" V除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部
7 {. m* X5 a7 w: S * n2 h- ^) y% [9 Z0 O8 h
可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值# T+ d' t( P$ r* w; g
![]()
5 k x0 ~0 Z, s M8 M2 |% k* I在使用 send() 的时候,可以将参数传入生成器中使用8 F" N4 `$ [5 u% y
( {& J4 Y+ P- G3 }6 d4 B$ z, n需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下/ `5 X9 B- `$ o$ Z9 C! U3 Q
0 m4 U8 ~4 ]3 ^: h2 j* h% r6 Z
yield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回+ E" v+ |* I- E1 T" f' Q4 g3 X
' l; F1 H5 }, ~& M9 b
![]()
9 x/ j2 y1 E, syield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果# ^. g; |5 _$ L! e- b) x+ D
) [1 W+ T4 N6 x8 _- @8 F) u3 X
@' u' ` `' l# a
/ a5 `1 S5 L2 j2 t' u' A
通过推导式构建生成器
& S$ X3 ^/ d) M# r. ]2 x u列表推导式:
0 Y1 s) j$ R, H* ?) X& \. z 3 T* r, Z: E* P6 {: q( X" U4 g* y/ o
生成器表达式:和列表推导式差不多,把 [] 改成 () 即可; G4 S1 x! n$ Z- S7 F
6 F. i9 a$ N' d) ]* `
/ U( W3 g) b: K3 y( L6 j# H1 V3 `列表推导式和生成器推导式的区别:5 ?' a. K$ X: m# ? U' G6 G9 [
+ _% Y1 m8 F( s. N( f$ e列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素8 i1 p4 h. V# b8 ?( R) @0 m! c+ \; Q
得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器
- c6 ^8 z+ A: h3 Y列表推导式一目了然,生成器表达式只是一个内存地址
3 z6 l; ~' @# L: F————————————————
7 L% J& @+ C2 r; D: T6 U版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
; o5 ~9 a+ S: R( V原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143# J$ q. a ]( z( Y1 o
7 k% p* `$ \% O; |
* U& x5 T z: c |
zan
|