- 在线时间
- 661 小时
- 最后登录
- 2023-8-1
- 注册时间
- 2017-5-2
- 听众数
- 32
- 收听数
- 1
- 能力
- 10 分
- 体力
- 55509 点
- 威望
- 51 点
- 阅读权限
- 255
- 积分
- 17604
- 相册
- 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 田老师国赛冲刺课 |
一、可迭代对象
* R5 [1 o0 j( C+ ? F" H, Q字面意思:3 z$ w$ H1 Y* H
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))
8 ?5 X* u/ {$ M) \& B. N( ]可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容- W- o; a p# K5 e4 |" i
专业角度:内部含有 '__iter__‘ 方法的对象
# M* c% P# \) i- G目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等
1 \: h$ d" l1 U8 I4 ]# a判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例7 C! m; P2 i0 B( E( X3 r
3 ]7 y7 X* T$ E% S
* }$ G$ ]5 H% k: Y4 J" G& E优点:
" _8 e: I$ v# W% p" B' M/ h存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来: [: Q9 E5 ~# e; J" G
拥有较多的方法,操作方便:增删查改等7 w% m. w3 U7 K+ V
缺点:
. Q. i. p1 q) b) D& p; b# ?占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中. _. e9 A" n* N* Z( ~
不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取! _! A* ]/ I' u) E6 t; W
二、迭代器3 y" I1 |) V3 }( h# i% r6 I
字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具
* E4 n: G8 r P z专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例
1 {0 ^- q0 i4 M5 k, J: Y( {. m把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法
% n5 N8 Q, `) Q' g) ~$ i! C" D . Q5 U) w: o, Z! f' x8 b# e
迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理# s3 F, S4 N* n
& Z7 G" \5 c4 V4 H n7 _
优点
7 ?1 s/ @% K3 \0 d+ l+ F, v节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)
/ T6 c) u+ G; E9 X# |9 E) g* a7 j惰性机制:next 一次只取一个值,绝对不多取4 q, S! Q! K+ }6 a
缺点:0 G. ]( S( n j" l
速度慢:需要一直 next
1 d% I9 e5 O* N% U, Q7 ?+ f8 Y不能回头:只能一直往下取值,取过的值没保存就没了`
+ M0 `& V2 |7 H* D% w不能直观的看到里面的数据; ~$ D2 g/ h2 u% R7 X
三、可迭代对象与迭代器对比4 O* r/ o: }- G+ o
可迭代对象:: h& @' v2 V; t( O) S/ h% f X
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)
, I9 @, w* A1 f$ E直观,可以直接看到里面的数据
' w1 w1 Y* P, H* c占用内存
! [) Z; G/ T! m. F不能直接通过循环迭代取值
4 C2 n. ~; v# Q' `( o应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择; k: A- a5 n. K5 ?. g
迭代器:
$ A3 Z+ J7 A' x. d) w7 d& }! H( b节省内存,按需取值
8 q ^$ I9 b. X' T6 V: s5 p: c" F可以直接通过循环迭代取值+ K1 s- R8 p0 x! B8 T$ ?( F- r
数据不直观,操作方法单一6 ]6 B8 k4 v# ?2 h& w: y! g, ?
应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择
8 C+ L4 \; _& `4 U; ]9 P% Y# d四、生成器3 W: m) v, {/ Y7 ?6 t: X3 `) m: L# m _
生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的
# z( K4 t7 O' V: C1 k
9 |4 t; @" l( Z7 ~- T& T5 z定义生成器的方式:! E, S, ]4 J) D) `
通过生成器函数构建生成器( f1 O) p1 Y" e: m' u" U) x
* H* M! C1 u5 s& |8 b/ k7 a1 ?: V( E, @) ?& h' y0 Q6 U8 ~! Q
4 ]/ [# s& I0 v( u
这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来
6 @+ S( G' z4 p- y# x![]()
3 k2 n- R8 Y' L1 m" w2 d- K也可以在一个函数里定义多个 yield8 o* ]# u8 W; A+ ^$ q. N
' v$ E& l$ h9 N" k: W7 c$ B0 V
之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration
i: f9 Z w6 a* w8 ~7 ?/ K- b7 T. _2 e5 D& o, ? z5 |2 P( m
yield 与 return 的区别. s% E1 y- b6 U6 h4 a4 f3 m
6 W9 B: ^+ C4 l% l
return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值- _$ o+ V4 S" ~2 I6 Q4 R
yield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素9 }! ^6 R# v1 s/ U. O; W4 v* U- c- P
应用举例:: }1 n9 o* a" h0 c7 Y" Z
% p# x* d/ ]# X) C" Q
买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了' }) K: l% U4 @1 c
; P! g" K1 ?* `
4 f }2 {$ ?0 i) v4 C" Q- J. X如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):2 b7 O% E/ h4 V* L7 M
. @! f) R' H1 k* G; |2 U; N
5 Z0 h! }! f# K n除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部. F7 \( S! |& F
3 I8 Y N+ ^$ A( y c5 i
可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值5 y+ c& d& \# }. E0 m
& y9 k# s& J, K* @7 G" z6 F4 Q
在使用 send() 的时候,可以将参数传入生成器中使用
4 Q! n2 {% z2 v( R; \' }5 ~' j+ y M7 C: y# y% M5 J
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下4 f( e& J! ~+ c1 v
! q2 Y# L$ A! K% G; I
yield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回* F F) B- j8 [7 n! T; |
4 d* b$ ]9 R. r
![]()
- d2 p9 x% E( `7 M1 \yield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果, T; m' I" @, t
![]()
( u$ B: P# x) o; u) A5 b8 \2 Q1 n2 J) ^+ h) _5 X8 _1 I
2 m" d/ x# |- d% {4 i, y6 z通过推导式构建生成器
& R# `1 o/ x z% T/ f* Y7 y列表推导式:
$ c; n6 h7 K+ s4 m4 G![]()
& ^, L1 a8 u* @7 i3 H7 k8 J4 `$ w# R生成器表达式:和列表推导式差不多,把 [] 改成 () 即可
% `" x& p$ H" j/ q' F% n6 x![]()
# ] S$ W9 N' _; b8 c; P* C' f! [3 X' `% F+ A7 `% a5 u
列表推导式和生成器推导式的区别:
7 H& S# A$ R: h% W& [% E3 T# Y; W8 ~1 j) O0 c* t5 A
列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素
( K( `2 T# j6 c# _1 i/ F得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器2 |0 y- I9 l; H/ F B8 T0 C
列表推导式一目了然,生成器表达式只是一个内存地址
! m V: k) r; }! @6 N————————————————3 }5 f5 E# ~! g4 D8 M8 b7 }
版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
. i3 W' r- j/ b1 ^9 F7 v0 ~0 S原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143
# m& S) _# ?! a( p$ Z7 F/ i0 N" s, F2 t# P9 K& O
( z4 E. w% U; g. d
|
zan
|