本节内容
- 迭代器&生成器
- 装饰器
- 内置参数
- Json & pickle 数据序列化
- 软件目录结构规范
- 作业:ATM项目开发
1.列表生成式,迭代器&生成器
注:生成器只有在调用时才会生成相应的数据
1.1生成器
通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。
所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。
要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]
改成()
,就创建了一个generator:
def fib(max):
n,a,b=0,0,1
while n<max:
yield b
a,b=b,a+b
n=n+1
return "----done"
f=fib(100)
while True: #处理异常的代码
try:
x=next(f)
print("f:",x)
except StopIteration as e:
print('Generator return value:', e.value)
break
print(f.__next__())
print("=====stip===")
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print("==========")
还可通过yield实现在单线程的情况下实现并发运算的效果
import time
def consumer(name):
print("%s 准备吃包子了"%name)
while True:
baozi=yield
print("包子[%s]来了,被[%s]吃了"%(baozi,name))
c=consumer("Alex")
# b1="韭菜馅"
# c.send(b1)
# c.__next__()
# c.__next__()
def pruducer(name):
c1=consumer("A")
c2=consumer("B")
print("我要开始准备做包子啦!")
c1.__next__()
c2.__next__()
for i in range(10):
time.sleep(1)
print("一秒做1个包子,分成两半")
c1.send(i)
c2.send(i)
pruducer("Alex")
1.2迭代器
*可以被next()
函数调用并不断返回下一个值的对象称为迭代器:Iterator
。
我们已经知道,可以直接作用于for
循环的数据类型有以下几种:
一类是集合数据类型,如list
、tuple
、dict
、set
、str
等;
一类是generator
,包括生成器和带yield
的generator function。
这些可以直接作用于for
循环的对象统称为可迭代对象:Iterable
。
可以使用isinstance()
判断一个对象是否是Iterable
对象:
1
2
3
4
5
6
7
8
9
10
11
|
>>>
from
collections
import
Iterable
>>>
isinstance
([], Iterable)
True
>>>
isinstance
({}, Iterable)
True
>>>
isinstance
(
'abc'
, Iterable)
True
>>>
isinstance
((x
for
x
in
range
(
10
)), Iterable)
True
>>>
isinstance
(
100
, Iterable)
False
|
生成器都是Iterator
对象,但list
、dict
、str
虽然是Iterable
,却不是Iterator
。
把list
、dict
、str
等Iterable
变成Iterator
可以使用iter()
函数:
1
2
3
4
|
>>>
isinstance
(
iter
([]), Iterator)
True
>>>
isinstance
(
iter
(
'abc'
), Iterator)
True
|
你可能会问,为什么list
、dict
、str
等数据类型不是Iterator
?
这是因为Python的Iterator
对象表示的是一个数据流,Iterator对象可以被next()
函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration
错误。可以把这个数据流看做是一个有序序列,但我们却不能提前知道序列的长度,只能不断通过next()
函数实现按需计算下一个数据,所以Iterator
的计算是惰性的,只有在需要返回下一个数据时它才会计算。
Iterator
甚至可以表示一个无限大的数据流,例如全体自然数。而使用list是永远不可能存储全体自然数的。
小结
凡是可作用于for
循环的对象都是Iterable
类型;
凡是可作用于next()
函数的对象都是Iterator
类型,它们表示一个惰性计算的序列;
集合数据类型如list
、dict
、str
等是Iterable
但不是Iterator
,不过可以通过iter()
函数获得一个Iterator
对象。
Python的for
循环本质上就是通过不断调用next()
函数实现的,例如:
1
2
|
for
x
in
[
1
,
2
,
3
,
4
,
5
]:
pass
|
实际上完全等价于:
# 首先获得Iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: while True: try: # 获得下一个值: x = next(it) except StopIteration: # 遇到StopIteration就退出循环 break
2.装饰器(语法糖)
装饰器:本质是函数(装饰其他函数)就是为其他函数添加附加功能
原则:1.不能修改被装饰的函数的源代码;2.不能修改被装饰的函数的调用方式(相当于你要x=1,但是y=x,你要加一个y,且x的调用方式不能被修改)
实现装饰器知识储备:
1.函数即“变量”
2.高阶函数
a:把一个函数名当做实参传给另外一个函数
b:返回值找那个包含函数名(不能修改函数的调用方式)
import time
def bar():
time.sleep(3)
print("in the bar")
def test1(func):
print(func)
return func
bar=test1(bar)
bar()
3.嵌套函数
x=0
def grandpa():
x=1
def dad():
x=2
def son():
x=3
print(x)
son()
dad()
grandpa()
高阶函数+嵌套函数==》装饰器
不带参数装饰器
import time
def timmer(func):
def bar():
start_time=time.time()
func()
stop_time = time.time()
print("the func run time is %s"%(stop_time-start_time))
return bar
@timmer
def test1():
time.sleep(3)
print("in the test1")
test1()
带参数装饰器
import time
def timmer(func):
def bar(*args,**kwargs):
start_time=time.time()
func(*args,**kwargs)
stop_time = time.time()
print("the func run time is %s"%(stop_time-start_time))
return bar
@timmer
def test1():
time.sleep(5)
print("in the test1")
@timmer
def test2(name,age):
time.sleep(3)
print("test2:",name,age)
test1()
test2("Alex",22)
装饰器高阶班
3. 内置参数
内置参数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii