- 在线时间
- 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 田老师国赛冲刺课 |
一、可迭代对象
6 L$ R( Y8 S9 `8 a" ]字面意思:1 q4 l6 b t4 e3 p; C3 U _
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))- r' q" s/ S. a+ H
可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容
' Y8 H' n5 h2 J( K+ H' _1 U5 R, i专业角度:内部含有 '__iter__‘ 方法的对象
0 t# e+ X y; _6 x目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等2 r2 ^" s2 q m: m! U
判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例
5 Y( k" {2 s8 u- E( I / X7 q8 i! l" A; ?
' }7 g. c/ _2 I
优点:
% @9 j2 A8 n3 }8 s8 F1 k3 E存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来
, \8 i+ E0 G/ H5 T: L) w/ L/ m2 ^+ N$ A拥有较多的方法,操作方便:增删查改等
5 W2 }% j9 r5 Y: T, F5 U& }& D5 q6 [4 A) t1 t缺点:3 { S- t U+ _ \( i
占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中4 t. l0 b- ^: N d
不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取+ n. f6 K J6 p8 z
二、迭代器: E& e* z8 d4 m i; q5 ~( k0 i
字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具% i- e* H1 {! B A
专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例
3 w3 ]3 }4 A" j把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法
; n0 Y# J3 x9 e) m/ l ! k% E6 \) F \+ h9 A& t, b6 P& q+ ?
迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理
/ y% M9 a: I5 ~: E, }![]()
, O4 v6 K; {$ S4 f& q$ p9 Q. ]优点
& A; f7 O. ` H* k" Z节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)- x; ?6 k- r. W) W e' `1 A
惰性机制:next 一次只取一个值,绝对不多取: F" A* f) k3 x+ [0 h
缺点:) G' r$ d& U7 W {5 K8 o
速度慢:需要一直 next! Y7 w' f' c* y4 K4 `) g" C& B' u
不能回头:只能一直往下取值,取过的值没保存就没了`
, O& t- Y. C4 r, H' y不能直观的看到里面的数据
7 I: L- g$ ^9 e9 u三、可迭代对象与迭代器对比
* z' i0 N" L1 y I/ h% X S可迭代对象:, q" }3 B$ u* d6 p3 p+ R' d7 |
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)2 d. I! F8 a1 Y7 K v
直观,可以直接看到里面的数据# k% P2 x0 i1 I- o
占用内存
/ h; R( Z4 |0 m" ^( y* _' }' d不能直接通过循环迭代取值
: l( `1 c3 W# x z3 t应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择; b' T7 F% U* N( q! c7 q
迭代器:
* _1 L0 w% M4 t; r节省内存,按需取值' @, w. W$ c" s2 a
可以直接通过循环迭代取值
+ i6 e" D7 }8 H1 s2 I) H: g! n R数据不直观,操作方法单一
3 I' Y* L% J3 K. H8 J" L应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择" L1 o- D) t) g" A+ |( D
四、生成器) B X: ]4 N- {5 \$ |( Z* B
生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的, o r( x$ X- i( ?; i
4 i5 d8 X* s. s: M& M6 p/ J, D定义生成器的方式:# [* z; H, j* }/ `3 z! i
通过生成器函数构建生成器( E2 S% J. {" |- S2 t- U4 [
/ i( Y* A( c/ p/ N9 ]; [7 h; r: E% X/ I" i4 f8 @/ s
# E5 ^9 T8 T' h
这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来% E) _) `/ E5 T; f
* f) J4 t+ U7 n8 G% z2 {
也可以在一个函数里定义多个 yield
7 H e1 t$ g, J7 G8 E' L q# H& V g4 r6 f- f
之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration
- Z" C2 K# C1 o# L6 o4 M
6 x' k1 R+ H7 D6 ~7 Wyield 与 return 的区别8 T0 |' z/ n. n% t* ]
! Q9 F7 O `! h: Q
return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值# ?* j/ D7 F1 q7 o6 f7 k: u
yield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素$ |; Y( T2 F8 p6 O' [
应用举例:
! t1 u; q7 J8 Z' n- T' H
: R/ Z, P8 ^* [/ u) w+ Q7 D# B买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了
5 h9 A/ ?, R, f8 ?9 }% i+ A' r
3 s' V; b& g- b2 @) m
: X8 Q5 E; W+ ~0 N, `+ r# J ^2 l
如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):9 c) x2 s1 d$ x# F* F- A% g
6 S5 H& ?2 y* j7 U( L4 l; j- a0 n2 e$ h9 l) D9 c" {1 n' @
除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部, R% E: I9 k q
- p* X4 t" o( Z; s; C: q& ^# \
可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值3 U3 H) x4 s) ^/ p1 q: S
![]()
% @; V- g: X" |2 O' Q在使用 send() 的时候,可以将参数传入生成器中使用5 |# q g! n [7 X# M' x
' z+ ^2 k+ Y% I/ q
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下. c" f, r! f2 P1 u
# c2 b- p! g# [ o/ w
yield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回% H7 a1 d0 W0 L) W/ s
( x; g* m; T/ N! t6 l, y6 ?
6 G( r, t* ^8 N; c% ^3 c. z2 Q& W
yield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果
5 e7 N1 s7 [8 X) E; ^" d G3 J![]()
$ v% x# W" t, V' U# W3 N0 a+ i" ~$ V8 \! H" A- b/ S
# C7 G& ~. z, @5 E
通过推导式构建生成器
6 M% k( v- z; a列表推导式:& a3 q3 r$ V) O S1 Q- ^+ f
![]()
& t* @- v, @+ r0 T' C. b生成器表达式:和列表推导式差不多,把 [] 改成 () 即可9 q. U! ^- N# z/ ]; B4 `$ R
. ]2 e& S7 y3 a7 Z% l2 L& Y
/ R$ p( U% L1 V6 X. ]. A: j8 C" Y- f列表推导式和生成器推导式的区别:. R/ P: F& c6 I! v# ?" F. L7 C
* Q L% F( ~6 v& A) m& C
列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素! y9 y/ q( j; d7 Q @( o
得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器
: f+ O$ V, F, l1 e0 G列表推导式一目了然,生成器表达式只是一个内存地址
9 W/ w; t7 m, h' o+ y————————————————
( C' G: h4 a4 m: N+ ]4 ?版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。; l. H$ p; x8 ]: V* `
原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143& b& Y4 S$ Z |- I) w5 K
; h% e8 e7 }+ ^2 c# |; L
) S3 |+ {; s- d% V( _3 C9 ~ G6 x |
zan
|