- 在线时间
- 661 小时
- 最后登录
- 2023-8-1
- 注册时间
- 2017-5-2
- 听众数
- 32
- 收听数
- 1
- 能力
- 10 分
- 体力
- 55507 点
- 威望
- 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 田老师国赛冲刺课 |
一、可迭代对象
+ C5 Q! Y, N' K2 T4 l/ I- O' t字面意思:4 g! u' P4 }9 c
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))
6 l/ U' ~% d% L3 d可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容
# _! K; j0 h1 p- v专业角度:内部含有 '__iter__‘ 方法的对象
~5 N9 Q% s1 V! r目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等( k1 [% Z8 B' a9 G' `$ J7 r1 T& T
判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例
) B7 B1 f& X) d![]()
1 f0 y( P# s9 n# C$ Z" o3 j$ q+ K W6 |$ ^+ }0 e
优点:! ]1 ?) p) B( X3 Z# v; t+ y6 |
存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来
5 K" @0 ` P' t9 |) X, h拥有较多的方法,操作方便:增删查改等
) R3 Z! ]( W5 K- {# Y1 Y3 [* ^6 v缺点:+ S- I+ T$ N# ~' `0 b$ C
占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中9 m0 l# D: x7 o4 X
不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取
/ _$ @) @2 W! W( a二、迭代器
3 |1 F- h1 e8 p* q: y字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具3 m$ I5 H5 w0 J' k, B
专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例- M: o) y. F4 G2 v! i
把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法, F' n' G6 j4 K0 d% z& `
![]()
" f8 W4 W k" w, J2 N迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理5 [/ N! h6 X: m; \ c! r, E& c( A/ W
![]()
$ [- L$ g& H2 `; _8 |7 K优点
1 I+ r _- g4 B5 _) h节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)9 X9 A: E9 X, @& P# v7 K0 o O
惰性机制:next 一次只取一个值,绝对不多取* x( z E" c1 s" d
缺点:
, ? V' t R/ v; l! T速度慢:需要一直 next) B4 w9 \& l" e
不能回头:只能一直往下取值,取过的值没保存就没了`) } O0 S) M1 C9 O1 P, p
不能直观的看到里面的数据6 M+ ~6 r; i- e/ ^9 i1 H
三、可迭代对象与迭代器对比
, T* z* E+ k( ^. r( q4 T) v7 `可迭代对象:! x' [0 l- q8 z+ y, e4 s; q+ X
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)
+ g, S* C% f3 _5 \4 S y直观,可以直接看到里面的数据
/ l( y; z. d, I' g. n占用内存
9 o8 Q+ l- h( A9 I0 ?, f不能直接通过循环迭代取值
. { Q+ B+ }' S应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择
( \: J8 @1 b+ H9 S4 }迭代器:
; m8 B& [" T# k$ K p' Z* U0 M节省内存,按需取值: v# \ ^7 x# u/ D( h! K/ B
可以直接通过循环迭代取值( G5 H8 _5 {1 _- _! r" m7 f
数据不直观,操作方法单一
7 Z* G J3 \, l3 z6 }9 B应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择
/ v+ u. f$ {- ^* Z5 `四、生成器: ^9 t0 e3 Q! q; l. l4 e
生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的
% }8 i8 r$ m+ m8 A: O/ E6 u. v6 c2 k. w' ]2 T% S! q0 ^5 J
定义生成器的方式:
5 [! L: s0 z) o' [+ L# q通过生成器函数构建生成器
$ b) b- w) q( `0 @+ g8 _" P7 A
5 f0 R3 C2 i- z6 y. ]% a$ L7 [
6 m" t. ^7 s# N. T. E8 p![]()
+ k. T3 M @, n4 n+ l. U* r这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来
% K2 t4 t1 y; u1 ^ 7 c* W2 H7 S- G7 v/ C' G: w& h
也可以在一个函数里定义多个 yield# O# O$ E# n+ P' D b8 _
![]()
( i& V; Y; V" M之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration
( ]5 B, e# |! u7 Q' d1 |% S, l1 [8 q; |
yield 与 return 的区别
. y8 Y4 Q; h3 C" `' ~1 f: X
% V* i2 S0 G. F- @7 X3 Lreturn一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值+ Z# t) ?5 d2 U# [0 O5 K
yield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素
' H8 ] M8 E, r9 b) T0 ]应用举例:
+ B3 ~+ Y. d! X: Z p9 E. c- }
买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了# d2 u( B0 ?) W& L$ L! u# o
! T, y! s7 d( I+ N! W( f- ?2 r9 x
/ @* R- e+ h) U/ }; j4 _
如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):+ R$ Y4 R+ R; A6 |3 C
5 T0 p) t. t. `; ~- T
6 m9 n" ^$ ] `+ J3 A除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部( { i2 u: T8 W5 d, l# S, ~' e
![]()
3 A$ ^, r+ Q: K- ]/ n- I0 P: f可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值9 m9 l: Z1 U: g8 D9 N9 [
![]()
/ _7 W" G; T3 i. u在使用 send() 的时候,可以将参数传入生成器中使用( t- k4 t3 x* \5 @& E: T
( _: o$ `! _4 V( z2 }
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下/ l E5 U# q5 U0 R6 Y
![]()
" t4 D! E3 h1 ^- y7 K m2 ]( iyield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回
9 s' I" t* i1 l6 K" C! U
' U6 i4 b5 L. c / T, L. u: e: \3 u( a) s: b3 g& g
yield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果) x+ Q( ^7 J' D, c) E3 ~
" Y9 A7 U) ^, N" `* d8 A7 @
6 h) s; @7 f" Y" X3 W& x& k8 x
. P- X0 @' ~/ R# o+ ]通过推导式构建生成器8 Y$ d5 F& X" {( O$ ]& p: C( y
列表推导式:
% D1 T7 C# r/ N ) R3 U/ l8 |! p2 U/ g
生成器表达式:和列表推导式差不多,把 [] 改成 () 即可; i8 t+ X% K4 P! w0 X2 V' F0 U
![]()
8 r v* M4 K3 `# ^8 K
8 X; v$ ^* ^5 k/ ?6 O5 o1 i+ ?列表推导式和生成器推导式的区别:
4 \# x' J, U* v; V+ J a8 i5 m& j
/ `9 |1 o0 H2 \5 O; A% Y5 o列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素
. Q! y0 E B( ], V R得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器
, q4 J8 d3 N- k; ~% Q$ c0 Z' _7 m! S列表推导式一目了然,生成器表达式只是一个内存地址) W( k: ^ K1 W, J* w" g
————————————————
/ U* k/ |# p# }; }- m+ J, W版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。 I% }! ], d2 G" N8 ^
原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143
2 M0 |( m- K2 u3 B f8 u5 {8 I( v/ P9 R5 g8 |! c
2 V0 o# _! i+ O3 n$ a6 r
|
zan
|