- 在线时间
- 661 小时
- 最后登录
- 2023-8-1
- 注册时间
- 2017-5-2
- 听众数
- 32
- 收听数
- 1
- 能力
- 10 分
- 体力
- 55502 点
- 威望
- 51 点
- 阅读权限
- 255
- 积分
- 17602
- 相册
- 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 田老师国赛冲刺课 |
一、可迭代对象( }: d) I q8 S+ b# Z
字面意思:& K! t5 b( s4 l: E
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))9 S" B y6 I/ V" u% A; L9 |
可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容
( g* a$ x0 I ~专业角度:内部含有 '__iter__‘ 方法的对象
2 h A9 @$ v& ?' x目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等 | T( W$ ?% o( m7 E' w; z7 c- ]
判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例
, l) y' H/ n1 t1 w0 h+ M2 q" @![]()
* n+ c3 @$ Q- l$ G9 p* d
4 w: r e% T6 R5 g1 x" f l! u优点:/ m# W. k. ]2 t, g/ h
存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来
; }" Q+ p2 ~) k. t) e+ V+ |拥有较多的方法,操作方便:增删查改等
( r. q( M! \" Q8 n. }: _0 n: e缺点:( ~# z! T& f: d. Z' u: m
占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中
( n/ ?0 X L* M" R R1 m不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取+ o4 `5 d$ g. s0 U0 ?" ]
二、迭代器( o& a% E4 E k+ j
字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具. Z7 _+ U# P2 J2 c* `% {5 A+ q
专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例
3 S1 r2 M( s0 m0 g/ q4 B. P1 y把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法
) M* V+ s1 k) C0 E3 b% @, m2 Q 2 q( Y( ?# H% v& B# ~, |5 V
迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理( G3 b. }0 _# X* _ d( p% Y
![]()
0 P' q' A( `- A) Y9 G/ e# x优点" d1 @ k3 B' g/ ?
节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)/ R* S1 ^ [* V
惰性机制:next 一次只取一个值,绝对不多取
. T2 F t: r7 E& S8 X缺点:$ ?1 ^6 P1 i) h) k
速度慢:需要一直 next- t0 o( Q, I& S ]3 Y
不能回头:只能一直往下取值,取过的值没保存就没了`
3 h* M& X1 a/ W, k, O" Z不能直观的看到里面的数据/ R: w2 |7 p+ M7 ~' A
三、可迭代对象与迭代器对比) n& B2 q$ @' z6 v* X& r$ V
可迭代对象:1 J9 w* g$ K5 ?- B# Q& b, |, U
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)3 t1 t1 t0 Q" }( e+ h
直观,可以直接看到里面的数据3 p( r( T0 f/ V0 f- H+ A
占用内存8 w# Q; s. ]! j* \9 c$ z( s9 e* }$ b
不能直接通过循环迭代取值
w" U$ w5 ]6 O应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择
Z- r5 Z! m# @% ^迭代器:3 f& E6 E! f6 ?* m( b
节省内存,按需取值 p) d. E6 W! T* `/ Q
可以直接通过循环迭代取值* v! {5 G" [$ \1 |! [2 H
数据不直观,操作方法单一
' U+ {6 \& z7 b5 X# J应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择
/ A- h$ H# {$ g) i( e四、生成器
* Q- o* c8 z/ M! a4 I; y5 D$ _8 D生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的
2 t0 K; k* |1 q! ]
' w5 X8 k0 [# a2 {定义生成器的方式:
V+ Q0 F9 R+ k& [通过生成器函数构建生成器
; Y, J6 P8 \8 l* S; n
: ^) f& Y/ {% c* \! ^( j
b1 U" d' n+ T/ x- x! U/ h7 U![]()
: n% X" y, q0 L5 d: q& k% `% c这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来6 E& i5 Z) Z, P0 Q! m* e0 s' F( ~
8 ~3 `- t; ]1 \$ R6 n0 \# q
也可以在一个函数里定义多个 yield
6 A3 J$ R5 B7 K2 @4 k7 B , v* Q0 a# m% _5 l( u* `9 ?
之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration
7 g( z+ Y, r+ j/ H: i- d8 \: H; P" {
yield 与 return 的区别 Z& S8 ?% |; f& [
: Y) m# i9 q+ [! H. Z3 `3 e; I
return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值2 e. A0 W/ I( R l3 |
yield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素9 S3 R3 p+ u# [" w' j
应用举例:3 h; Z+ G/ k! t8 B4 T
; R! |: Z" b! n8 X* M6 S买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了; ~8 l5 Q" ^1 ], t- d* U
3 I0 P+ W# d" `5 n' i8 c
, T8 g, ~; ^4 @+ j如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):
5 X8 o/ L2 h: _) N9 l3 [$ d
3 g8 Q* _- `" J m; T
4 M2 L/ H3 s" L6 c1 b: {3 q' v除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部
4 b3 r2 d$ [" t0 P0 Z![]()
5 i- @0 P9 H' e: d# E A可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值& Z' b z3 n' H- ?- {9 u# {
) N1 ]( V8 J6 r, x! `
在使用 send() 的时候,可以将参数传入生成器中使用
3 B, W3 l% L" a" x& R. ^% [7 N) H8 y
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下
" E" U4 b, @ p7 f![]()
: C# Q4 [8 @7 ]* q. Y& C' fyield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回
7 C) ~9 s: D2 j! `# |
8 H& e+ k/ d# C1 P; q2 s$ K 5 f" {7 W' {# M0 k
yield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果
* f# V5 M% u9 j 8 n. A. }3 y" Y+ L U+ B+ \) J/ Q9 \ y$ I
2 B7 V% T+ t4 V5 B+ `5 L
/ A( z0 j: y: a+ e* Q: J; u0 V/ u通过推导式构建生成器: E" F6 o- X# c6 B
列表推导式:
* I& Y7 h" j2 E3 y4 w & J4 L, \. Q. ^0 V6 h% |9 g8 V9 f6 k
生成器表达式:和列表推导式差不多,把 [] 改成 () 即可, j7 C1 T+ ^8 F6 x1 \: C2 f& R H, z0 h
![]()
5 X; U" F3 Y2 X9 a% F0 ?& ]- f4 R$ Y5 C; R) _/ @
列表推导式和生成器推导式的区别:1 N. v2 a) [' K1 ]' O, {5 d
/ L: v; r! s" t" E7 Y列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素9 k2 H7 Z- |* t, ^3 ~+ x L
得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器
) k' V" G6 l! r: l' J列表推导式一目了然,生成器表达式只是一个内存地址3 B2 @- v: _0 X) e* c8 B
————————————————# B" K1 z: u# }1 h; |
版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。, ~9 d+ z) K k0 F/ J5 E
原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143
, y5 F) {% R# X/ b! Y6 p
0 ~0 z1 C" i. F4 i2 {2 m
g' U) j7 J" s$ k5 Y: U |
zan
|