- 在线时间
- 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 田老师国赛冲刺课 |
一、可迭代对象. A7 k( M: O' c) V! j% w& \
字面意思:3 U4 [, V' k! y9 _
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))
# W ]) i4 d: Q V可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容
1 n( r: U7 T3 T4 m, e: M专业角度:内部含有 '__iter__‘ 方法的对象( O8 X+ J ], t+ ~# r/ B3 ~. j
目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等2 E7 t0 Y5 s7 n4 k
判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例! T9 z7 w0 _2 w. f- a
![]()
" `% W- k% Z' a$ T8 l% s* O& q$ X4 t' T0 n+ X
优点:
% m' p3 j8 V" A, _- ?5 {3 @存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来, \' T1 W# a- `3 l& n
拥有较多的方法,操作方便:增删查改等9 I9 [2 b$ t9 C4 G5 B' F8 w
缺点:
: I% W0 c4 s( x占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中+ Y: Q, n0 e- |1 b1 w( E- p
不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取
" g7 K5 ~2 L3 r二、迭代器8 S5 j+ _+ f' j- p6 w
字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具( \8 l" @% h) F; Y
专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例
/ V0 L1 I+ D A* h' Z' ~/ g/ A把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法4 M+ I# n+ [2 u6 x
![]()
4 q! X3 y4 F9 G) m& i迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理
: ]: t+ Q4 S7 r( j2 O1 A![]()
8 y( h% r0 [! k% e* y- Q5 w优点: q0 e! ~' ^( K) n& R
节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)
2 S5 i; H/ h' L" K2 G: A惰性机制:next 一次只取一个值,绝对不多取7 @5 e) v) P: y
缺点:- j7 [/ @4 y; ^& [( ?( c# M8 n1 c! K+ S
速度慢:需要一直 next/ U9 P! ]" G# r+ w8 C# j: h' l3 K
不能回头:只能一直往下取值,取过的值没保存就没了`
3 h+ W% R; n' }2 |不能直观的看到里面的数据$ K! o# v5 e, K; q- G4 m
三、可迭代对象与迭代器对比3 W* `; A6 M6 H' F' R
可迭代对象:
$ E; D; C$ ?$ l- Q: E! V: G私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)
8 G+ b1 J) B7 ?/ s. Z( Z1 B直观,可以直接看到里面的数据$ R! \4 O( Q5 x* p
占用内存
. V Q/ C; ]* n: r不能直接通过循环迭代取值
$ a1 V7 b7 m e" h5 v7 M5 [2 E应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择: [$ X* ]# L1 J% @7 h/ U2 H
迭代器:9 Z& O' s; n& E! S9 Y$ g
节省内存,按需取值3 R1 B- k$ P0 K; t3 Z
可以直接通过循环迭代取值# d' @8 T; d5 s/ r
数据不直观,操作方法单一1 J# V) |9 U# S
应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择
& i% g1 e# l1 I# |' r* Q `四、生成器
8 m* f* E" ^1 y, g# C生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的# i2 P( u2 B, }
1 {- [5 R+ \0 W. p. d" r' X' G定义生成器的方式:6 d8 J' Q) F5 }
通过生成器函数构建生成器
7 u$ [/ Y3 S: t7 g7 k& K7 T
% y. ?" K5 a; ?+ H6 v5 \, g9 h$ |. d# j% J5 w9 Y
- A. t: u0 O% m% d7 K% C
这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来2 G* p! d+ t, s1 p. r
' r, x# a. h# S5 }3 s+ c
也可以在一个函数里定义多个 yield
* U$ S1 d$ e( B* @/ T$ X2 V" W0 @- B4 A![]()
0 Q* T9 V' ^, j/ F之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration6 ^0 |6 x9 Q. X+ A' H0 s
0 L c# p6 z1 l5 x: D* V N
yield 与 return 的区别$ t' I- |$ J, w0 v) ~
( m, x3 l, z5 G4 Z# ^+ c9 freturn一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值
7 p2 a! e! z% T/ ]. l. l; Qyield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素6 T2 U/ T# M) U0 r) r
应用举例:$ w3 b( \1 a4 m0 H1 D
) T; n3 R4 r' M. C5 f& [买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了
1 z! ~9 j& J- Z
e# {* }0 ^9 _5 I/ [7 [/ V
" H' n; J9 T, U$ c4 I1 Y6 v- w( k4 m
如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):0 K$ B; x+ ~0 t
( h* m. i0 v; F" @- |8 }+ x# l9 M: ]
除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部; C4 x6 S K+ w7 l y% Z
8 U& {( e" ~+ k/ n; Z0 m
可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值
/ p* ^2 D6 Y/ a" R2 A! S8 W![]()
/ A) j7 Y6 `0 v8 W1 K l7 T在使用 send() 的时候,可以将参数传入生成器中使用
' I5 x$ s! _6 l: V5 u, H2 o" W' r! e G
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下: I& m8 M$ Y* {0 w! q; _. D6 N
" D( }; t, ^: h- y- E$ q) N; A" `
yield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回9 r1 w0 N6 ]! H1 S2 c
! U% H4 S8 [& u0 I. _/ }2 y( _![]()
! Z- `( o1 \: B* Wyield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果3 o: V3 k4 @( N" s; {/ [" U& w
![]()
/ d* N/ d2 i$ @0 k6 x/ d1 i2 m) e; U! _/ Z
1 X) z! j/ r& d! v) Q2 a7 P
通过推导式构建生成器
# U" P% C! W6 I7 n, k) s, J! N列表推导式:
( i! W& Y4 D) g+ v& T 4 K( @& F. S- r; A: |
生成器表达式:和列表推导式差不多,把 [] 改成 () 即可/ D5 _" e- j# j2 H2 d
![]()
3 h) R0 M+ C. t0 O# Y, T- B& i' y: |" k: I* g( V
列表推导式和生成器推导式的区别:1 H$ d+ b1 g0 W. p1 X$ ]8 ^1 B( z9 k
( W; X6 t0 W P4 L! S列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素4 K- X) B+ l1 Y9 F
得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器0 G# m% D( m- _7 }& Q
列表推导式一目了然,生成器表达式只是一个内存地址3 X7 r: e/ ^( Z
————————————————* t1 v9 J' L1 u/ p' O
版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
c; C# j" ?5 [原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143% j% ^; J- P0 b. B' d/ e7 W
# A/ l" L* s- w* U3 J3 g$ e; R" K* E; {3 ~
|
zan
|