- 在线时间
- 661 小时
- 最后登录
- 2023-8-1
- 注册时间
- 2017-5-2
- 听众数
- 32
- 收听数
- 1
- 能力
- 10 分
- 体力
- 55570 点
- 威望
- 51 点
- 阅读权限
- 255
- 积分
- 17622
- 相册
- 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 田老师国赛冲刺课 |
一、可迭代对象
7 E8 t' \7 {' k _$ S8 k字面意思:7 G" S) g6 s- v' ^( ^ V, G
对象:Python 中一切皆为对象(巧了 Java 也是(手动滑稽))
* s( v) m# Q0 }# k' z可迭代:可更新迭代,重复、循环的一个过程,每次更新迭代都会获得新的内容- w6 ~8 S+ Q% _) x) M& }5 e
专业角度:内部含有 '__iter__‘ 方法的对象' R0 |9 _6 X$ g- b3 W
目前学过的可迭代对象:str、list、tuple、dict、set、range、文件句柄等
( x* t. n* y A: p$ e# v. N+ q判断一个对象是否是可迭代对象:看是否有 '__iter__' 方法,dir() 可以获取一个对象的所有方法;或者使用 isinstance(object, collections.iterable) 来判断对象是否是可迭代对象的一个实例! }' d3 e+ f+ u K
![]()
9 J/ ]/ ]# C: q+ D) N' j F A( A' C5 A* A" U1 c; Q
优点:
7 D& i% o B& ]. M; X ~8 ~存储的数据直接能显示,比较直观:比如直接 print 一个可迭代对象,就会调用 __str__ 方法(相当于 Java 中的 toString),把可迭代对象的值打印出来
4 c; `& A, s5 D; C9 V0 v, M$ L拥有较多的方法,操作方便:增删查改等" h2 D9 [" M# p ~8 h) }1 M/ c" a! R
缺点:
$ |9 b- Y& r* K8 P1 E4 h! c1 p- l占用内存:一旦创建了一个可迭代对象,就会将该对象的内容全部加载到内存中
7 n0 a& F" h3 T0 i% x, R不能直接通过 for 循环,不能直接取值(通过索引、key等)。诸如通过 for i in iterable 这种形式获取元素实际上也是调用了 __iter__ 方法先将可迭代对象转换成迭代器再进行获取
s$ G5 g! v% i2 l- p0 j二、迭代器' q2 J; u {. Q! W1 k- V% N
字面意思:器,工具,迭代器也就是可以一直更新迭代取值的工具% k; |8 o# s( i# V5 i6 m
专业角度:内部含有 __iter__ 方法且含有 __next__ 方法的对象就是迭代器;或者使用 isinstance(object, collections.iterator) 来判断对象是否是可迭代对象的一个实例
/ |# E9 ?. B( x1 Q0 n把一个可迭代对象转换成迭代器:使用 iter() 方法或使用对象的 __iter__ 方法$ |7 T0 o& `& E# c
![]()
+ i D5 N( r- M- Y/ X! N) g迭代器取值:使用 next() 方法或对象的 __next__ 方法;当迭代器的值去玩了继续取,就会报StopIteration异常,所以一般使用迭代器需要做异常处理
4 o# b% A+ e$ _+ F+ Y% H& K) D![]()
! z! w9 l2 i% a7 C优点$ T7 u; ` e; ~5 m1 d7 f
节省内存:迭代器并不会一次性将对象的值全部加载到内存中,而是需要时才加载(类似 sed)0 i: c; Q* `6 g- _) O2 f
惰性机制:next 一次只取一个值,绝对不多取
5 t6 Q$ a( T# P% a缺点:2 q* W* Q, A6 c3 h
速度慢:需要一直 next
( H) k$ a% b8 M% B9 ~* w8 }3 h1 [不能回头:只能一直往下取值,取过的值没保存就没了`
: M. M0 G+ J# f5 X& H( S不能直观的看到里面的数据8 e! p3 M( n) y
三、可迭代对象与迭代器对比0 X. N$ x# D7 z( v; C6 I
可迭代对象:4 s- B* k+ u* n F& s, r7 F; m
私有方法多,操作灵活(比如列表,字典的增删改查,字符串的常用操作方法等)
T% H: {% p% ^0 T直观,可以直接看到里面的数据
$ U3 D, q/ \8 h占用内存9 c6 Z* K# A+ r
不能直接通过循环迭代取值4 L8 I8 Z: E$ A
应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择
& `. {" v8 E. Z# }; I1 Q迭代器:
9 P- |! s& h' I9 W( H节省内存,按需取值
6 |, r) _& k, m, W可以直接通过循环迭代取值$ c3 d& A. ~: C* N
数据不直观,操作方法单一
" i8 L" p5 G' E% L# G- A% G9 o. v应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择3 k ]7 z5 D3 z2 `. n# r3 s" b, o( n- x' Y
四、生成器
" n8 L3 z6 y( u0 `( b* ~- l生成器的本质就是迭代器,唯一的区别是生成器是我们自己用代码构建的数据结构,迭代器是 Python 提供的,或者通过可迭代对象转化得来的: j/ l& K* k; r% I$ m
( r h* U0 K) y/ o/ j定义生成器的方式: }. X5 }7 @+ }5 o1 h0 e
通过生成器函数构建生成器
8 g4 K2 g& h; O* A, @
( N! S6 p4 ? B0 C3 a
; }& N* {6 V. j5 ]! O' v![]()
% q* J" |7 l7 r! X6 R5 f这就是最简单的生成器函数。实际上这个 yield 就替代了 return,不仅将函数变成了生成器函数,还会将后面的值在调用 __next__ 的时候返回出来
9 E% G. x2 G: j( U5 Q # K. }& A# z/ G' w, u& f
也可以在一个函数里定义多个 yield" X* v$ |4 }: O4 v
![]()
% J" b2 L& c5 K7 U4 G/ E之前说过,生成器本质上还是迭代器,一个 yield 对应一个 next,当 next 的数量超过了 yield,就会报 StopIteration
; m" W* Y5 m6 ]0 ^
. `3 C9 V. }7 L3 @8 e# `! ~3 zyield 与 return 的区别
; ? E$ E# w( k# D8 i6 D" c3 w7 U2 N9 z* R* U; B4 t
return一般在函数中只设置一个,他的作用是终止函数,并且给函数的执行者返回值0 j! F4 m5 E( z; ~
yield在生成器函数中可设置多个,他并不会终止函数,next会获取对应yield生成的元素, y9 h! n5 `+ E2 U
应用举例:( I' s5 f9 G, [: s3 m
, H9 x) o3 w! ^. I买 5000 个包子,假设这个老板很厉害,一下子就把 5000 个包子做出来卖给我们,可是我们只有 5 个人,一下子吃不完,那包子就会冷掉、臭掉、被丢掉浪费了
9 Q9 c- W4 X: S# r3 E9 P! u% C: u2 I
9 T( }! S* j" b( P: V. ~- Y; R: i$ i( d5 D. Y3 K( N9 Y1 p9 ^4 k
如果这个老板可以在我们需要多少个包子就做出来多少个包子的话,这样做出来的包子就不会被浪费了(比如我们每个人一口气能吃 40 个包子,那每次就做 200 个包子):
* u, [0 \5 ?1 O
$ F( V! B( x8 o- P4 B5 I6 J* E( E
2 _$ I3 p% Q5 h1 f, z+ z: ~% g3 _除了 使用 next() 触发 yield 之外,生成器还有一种方法 send(),这个方法可以在调用 yield 的同时传值给生成器内部
/ x" o& ] }, x; L" G " K B* Z) u) f5 u
可以看到在使用 next() 的时候,只能获取到 yield 的值,但不能传递值
7 y; S% P& Z1 \3 p: l1 K! L 8 R* `! a2 U& {) e5 t4 m
在使用 send() 的时候,可以将参数传入生成器中使用
# n6 U8 J+ V B! H% ?* e) }- `) o1 a
需要注意的是第一次不能直接调用 send() 传参,因为每次调用生成器的时候,实际上只会返回 yield 后面的内容,然后生成器就停止了(睡眠了?),而 send() 传入的参数要通过 yield 传入生成器中(每次调用生成器在 yield 停止,然后在 yield 恢复继续允许),第一次调用并没有 yield 给我们传入参数,可以使用 send(None),可以打断点自己分析一下7 H/ Y7 I# e( j3 R# }
![]()
4 |$ _; n N" oyield 会将它后面跟着的对象直接返回,如果它后面跟着的是可迭代对象,也可以使用 yield from 将这个可迭代对象变成迭代器返回' f% R3 O1 m7 `( a1 p, P
7 L6 R) m- a" W+ V( x! U& `$ `2 _
![]()
) P1 _& ^: w+ M" oyield from 是将列表中的每一个元素返回,所以写两个 yield from 并不会有交替执行的效果
$ @6 D1 K. A5 ] 3 s; J/ k6 R. R* d, c. y
3 D1 y- T7 S% j! F, F, t
% g/ I$ N8 o+ A- H" ?$ J$ u
通过推导式构建生成器0 m7 Q+ g n. D! x
列表推导式:9 a/ U4 z9 W" k# b( Q0 K9 u6 o/ z1 N' q
![]()
6 p/ {. \+ Z! E& Y生成器表达式:和列表推导式差不多,把 [] 改成 () 即可
9 W8 I: ?) ]- q6 _3 q, x" O![]()
8 x' D# [, A6 | t5 f7 b+ f5 p% Q" z! o) T8 |# x! @+ A: ~/ i5 Q
列表推导式和生成器推导式的区别:
. }8 @+ W w* V
[4 k' H7 ]/ L4 Y: a列表推导式比较耗内存,所有数据一次性加载到内存;而生成器表达式遵循迭代器协议,逐个产生元素, W p; _% k' m4 M
得到的值不一样:列表推导式得到的是一个列表;生成器表达式获取的是一个生成器
. s1 F x$ \+ V7 ]2 g列表推导式一目了然,生成器表达式只是一个内存地址
% D8 \' I6 Z: h————————————————
5 r# x5 s+ F4 A8 h7 w. x版权声明:本文为CSDN博主「阿玮d博客」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。! b8 [& X* @# d0 N
原文链接:https://blog.csdn.net/weixin_42511320/article/details/105676143
7 O6 z' D7 X. P
9 E Y X7 |# A# Q- `6 Q1 g4 H) X% n
|
zan
|