在线时间 661 小时 最后登录 2023-8-1 注册时间 2017-5-2 听众数 32 收听数 1 能力 10 分 体力 55572 点 威望 51 点 阅读权限 255 积分 17623 相册 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 田老师国赛冲刺课
一、可迭代对象$ l( y- N$ B! n, D
字面意思:1 n9 A' i/ a3 Y+ S
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))8 J7 Y' j4 J( x; Y
可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容
9 G0 }3 w7 {. ?/ C0 v W3 n 专业角度:内部含有 '__iter__‘ 方法的对象# i1 k0 X1 o. |- S0 r6 y
目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等
; S3 W# U. B7 O6 q. ^* Y! | 判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例 v' K) D; u- ^
0 A" z% c9 A+ E) W7 N5 _ - M. I+ l) j! V
优点:3 {9 G, j% u" P7 F
存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来
7 B4 U. k# H& N6 U% j" h9 o6 w* a 拥有较多的方法,操作方便:增删查改等6 R) `- y, a8 m) | T5 q. B
缺点:6 v; ?( A' e. a
占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中! W) @! [6 {' t) A% W6 V* ?
不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取
( I* Q/ ~7 |* d. d v+ L$ w3 U 二、迭代器
7 J8 z p1 D; k9 d 字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具
3 `, e( _$ N' z# c8 P% Q* z: F 专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例3 S+ ~4 G, Q- m1 b, Y
把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法
6 T7 H: ]8 D A7 z ' s. k) _1 c" s& h
迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理
% |3 ]. @! P$ Z) e6 L
( I1 K- Y- O/ A, Q# }2 U 优点7 Q8 G$ L/ @2 ?+ [$ n) K( d
节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)
$ A8 i _8 O, T1 i 惰性机制:next 一次只取一个值,绝对不多取% x4 w, z0 v2 V+ g' i! t# D
缺点:% Y: @, W( b3 X7 f9 A7 d4 f
速度慢:需要一直 next
( D3 \ O a7 L& C0 n. W 不能回头:只能一直往下取值,取过的值没保存就没了`
5 Y% j3 }* P5 W j% n' s a" ` 不能直观的看到里面的数据
' D% M1 L2 O$ d' j U 三、可迭代对象与迭代器对比+ s3 H$ X# h4 {- f4 z( J4 ]
可迭代对象:+ s4 \! Z r( X8 R
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)
; e5 c& h0 ~+ e6 } 直观,可以直接看到里面的数据
$ N& z# [# `/ O. M 占用内存. z) B2 p' ]3 x# D m4 B: ~
不能直接通过循环迭代取值9 B/ a) E4 {2 c. {
应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择
4 F y/ i: }5 @$ f: j; J1 s, }$ w0 y 迭代器: y+ ~$ G( ]$ Q, Q8 m; o) H+ u
节省内存,按需取值
- v: D. [/ R' l% C1 h% _! J/ @ 可以直接通过循环迭代取值8 k% }5 C: j3 u' G& Z+ f
数据不直观,操作方法单一
9 W3 e* e5 B6 E 应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择5 _9 g6 d* C, R4 F$ I, l' G
四、生成器
6 {4 H. ~! m" X- G5 y2 M- C6 Q 生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的( a% p% }% {% O
2 J# R" l/ Y2 J- [$ U 定义生成器的方式:
; D" d' ^0 b" `* z( J5 u, C 通过生成器函数构建生成器2 ?1 A( G5 u% {# [
6 b/ g0 I9 q# N6 ?
) y( x& v; m. ^+ H- f, [+ h; g# D
, }: R- }' ?( a6 d+ C5 j$ g: l 这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来
+ Y$ d. `4 u7 q6 s) U' r* K+ ~
, h9 r8 h: ?, V 也可以在一个函数里定义多个 yield3 s' L2 p. _- P: x$ L+ l
# E; a4 ~( b- j0 C; H 之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration
f, |- C! {0 t7 R( t
- B7 ~) Y) z0 w7 L. ? yield 与 return 的区别
, g, L6 J2 n4 N0 c2 { * d% x A, G: b2 _0 i
return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值 V' v7 ~7 _0 w4 \
yield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素
. O% H. X0 r" G4 x" G- g& [! y$ [ 应用举例:
* Z2 Z4 _1 Y4 C
7 ]6 ~( l, G7 | c$ ~ 买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了& v; J+ c# W8 N+ r1 R
8 G: {4 ^, G) P' L8 o
5 m2 V9 d: B. t+ o
如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):( L) D$ c4 f# z4 a ?$ M) p' ~
6 | e) q5 f# N: O1 L
& \7 V1 I3 [% {; [$ N
除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部# { z" n8 g2 D/ _5 T4 h
/ t3 A& S; E3 x7 k* n& j: q
可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值& t0 e! `' e, \1 F
7 C1 o3 O+ f7 o" D- H
在使用 send() 的时候,可以将参数传入生成器中使用7 l" a+ c. E) v/ u9 T
: X6 N$ I; U% m/ b( n$ I
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下
[2 y) ^' ^& h0 c# G
% A3 _1 t! _2 e/ f" g7 L# R yield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回
' r& K5 n1 G( b2 ?
% L* u2 {' G9 g# e( U
N& }/ ~" o3 C+ o2 y yield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果
" c8 ^; n2 ^* X* l
+ ]" o: {- R6 A7 k0 t# M
8 y& ]: M% X9 l9 n, e
9 ~3 z* ~% S3 h/ ]0 J5 z; n 通过推导式构建生成器9 s# c2 N1 \% d4 A/ O1 z
列表推导式:
6 {! P. M2 d& g. [0 o; J0 i! r1 z( ] # N2 f H$ \+ d3 _# e
生成器表达式:和列表推导式差不多,把 [] 改成 () 即可) g! m4 r0 D, `( v4 h8 Y
1 N. \" E/ H, R. a$ G. k3 z
x4 n" ~2 `7 f6 J5 p$ O. n) q 列表推导式和生成器推导式的区别:
- ?6 F5 p/ H+ I7 ] - i9 l+ Z* ?7 U7 s" D: l5 @
列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素
" Y6 r4 D3 A! ^4 R" F% B& W 得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器$ J/ J: h: V8 |% y2 @5 D
列表推导式一目了然,生成器表达式只是一个内存地址
* Z3 i( P$ H. `! v. h ————————————————9 V: O. E& O: n# [8 f( w6 B
版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
9 r3 a. [, `) L w! k6 x2 m4 [9 h 原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143, Q5 y5 z* f& |( r# h7 I( @
1 H6 M! ?: a4 u9 S% Z! r ) z' q. S, M# x) I! E
zan