python3-day4
一、列表生成式,迭代器和生成器
1)列表生成式
把列表 [0,1,2,3,4,5,6,7,8,9]里的每个值添加1
1 >>>a = [0,1,2,3,4,5,6,7,8,9]
2 >>> a
3 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
4 >>> b = []
5 >>> for i in a:b.append(i+1)
6 ...
7 >>> b
8 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
9 >>> a = b
10 >>> a
11 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
原值修改
1 a = [1,3,4,6,7,7,8,9,11]
2
3 for index,i in enumerate(a):
4 a[index] +=1
5 print(a)
1 >>> a
2 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
3 >>> a = map(lambda x:x+1, a)
4 >>> a
5 <map object at 0x101d2c630>
6 >>> for i in a:print(i)
7 ...
8 2
9 3
10 4
11 5
12 6
13 7
14 8
15 9
16 10
17 11
其实还有方法:列表生成式
1 >>> a = [i+1 for i in range(10)]
2 >>> a
3 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2)生成器
通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。
所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。
要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]
改成()
,就创建了一个generator:
1 >>> L = [x * x for x in range(10)]
2 >>> L
3 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
4 >>> g = (x * x for x in range(10))
5 >>> g
6 <generator object <genexpr> at 0x1022ef630>
创建L
和g
的区别仅在于最外层的[]
和()
,L
是一个list,而g
是一个generator。
我们可以直接打印出list的每一个元素,但我们怎么打印出generator的每一个元素呢?
如果要一个一个打印出来,可以通过next()
函数获得generator的下一个返回值:
1 >>> next(g)
2 0
3 >>> next(g)
4 1
5 >>> next(g)
6 4
7 >>> next(g)
8 9
9 >>> next(g)
10 16
11 >>> next(g)
12 25
13 >>> next(g)
14 36
15 >>> next(g)
16 49
17 >>> next(g)
18 64
19 >>> next(g)
20 81
21 >>> next(g)
22 Traceback (most recent call last):
23 File "<stdin>", line 1, in <module>
24 StopIteration
我们讲过,generator保存的是算法,每次调用next(g)
,就计算出g
的下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration
的错误。
当然,上面这种不断调用next(g)
实在是太变态了,正确的方法是使用for
循环,因为generator也是可迭代对象:
1 >>> g = (x * x for x in range(10))
2 >>> for n in g:
3 ... print(n)
4 ...
5 0
6 1
7 4
8 9
9 16
10 25
11 36
12 49
13 64
14 81
所以,我们创建了一个generator后,基本上永远不会调用next()
,而是通过for
循环来迭代它,并且不需要关心StopIteration
的错误。
generator非常强大。如果推算的算法比较复杂,用类似列表生成式的for
循环无法实现的时候,还可以用函数来实现。
比如,著名的斐波拉契数列(Fibonacci),除第一个和第二个数外,任意一个数都可由前两个数相加得到:
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
斐波拉契数列用列表生成式写不出来,但是,用函数把它打印出来却很容易:
1 def fib(max):
2 n, a, b = 0, 0, 1
3 while n < max:
4 print(b)
5 a, b = b, a + b
6 n = n + 1
7 return 'done'
注意,赋值语句:
1 t = (b, a + b) # t是一个tuple
2 a = t[0]
3 b = t[1]
但不必显式写出临时变量t就可以赋值。
上面的函数可以输出斐波那契数列的前N个数:
1 >>> fib(10)
2 1
3 1
4 2
5 3
6 5
7 8
8 13
9 21
10 34
11 55
12 done
仔细观察,可以看出,fib
函数实际上是定义了斐波拉契数列的推算规则,可以从第一个元素开始,推算出后续任意的元素,这种逻辑其实非常类似generator。
也就是说,上面的函数和generator仅一步之遥。要把fib
函数变成generator,只需要把print(b)
改为yield b
就可以了:
1 def fib(max):
2 n,a,b = 0,0,1
3
4 while n < max:
5 #print(b)
6 yield b
7 a,b = b,a+b
8
9 n += 1
10
11 return 'done'
这就是定义generator的另一种方法。如果一个函数定义中包含yield
关键字,那么这个函数就不再是一个普通函数,而是一个generator:
1 >>> f = fib(6)
2 >>> f
3 <generator object fib at 0x104feaaa0>
这里,最难理解的就是generator和函数的执行流程不一样。函数是顺序执行,遇到return
语句或者最后一行函数语句就返回。而变成generator的函数,在每次调用next()
的时候执行,遇到yield
语句返回,再次执行时从上次返回的yield
语句处继续执行。
1 data = fib(10)
2 print(data)
3
4 print(data.__next__())
5 print(data.__next__())
6 print("干点别的事")
7 print(data.__next__())
8 print(data.__next__())
9 print(data.__next__())
10 print(data.__next__())
11 print(data.__next__())
12
13 #输出
14 <generator object fib at 0x101be02b0>
15 1
16 1
17 干点别的事
18 2
19 3
20 5
21 8
22 13
在上面fib
的例子,我们在循环过程中不断调用yield
,就会不断中断。当然要给循环设置一个条件来退出循环,不然就会产生一个无限数列出来。
同样的,把函数改成generator后,我们基本上从来不会用next()
来获取下一个返回值,而是直接使用for
循环来迭代:
1 >>> for n in fib(6):
2 ... print(n)
3 ...
4 1
5 1
6 2
7 3
8 5
9 8
但是用for
循环调用generator时,发现拿不到generator的return
语句的返回值。如果想要拿到返回值,必须捕获StopIteration
错误,返回值包含在StopIteration
的value
中:
1 >>> g = fib(6)
2 >>> while True:
3 ... try:
4 ... x = next(g)
5 ... print('g:', x)
6 ... except StopIteration as e:
7 ... print('Generator return value:', e.value)
8 ... break
9 ...
10 g: 1
11 g: 1
12 g: 2
13 g: 3
14 g: 5
15 g: 8
16 Generator return value: done
还可通过yield实现在单线程的情况下实现并发运算的效果
1 #_*_coding:utf-8_*_
2 __author__ = 'Alex Li'
3
4 import time
5 def consumer(name):
6 print("%s 准备吃包子啦!" %name)
7 while True:
8 baozi = yield
9
10 print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
11
12
13 def producer(name):
14 c = consumer('A')
15 c2 = consumer('B')
16 c.__next__()
17 c2.__next__()
18 print("老子开始准备做包子啦!")
19 for i in range(10):
20 time.sleep(1)
21 print("做了2个包子!")
22 c.send(i)
23 c2.send(i)
24
25 producer("alex")
3)迭代器
我们已经知道,可以直接作用于for
循环的数据类型有以下几种:
一类是集合数据类型,如list
、tuple
、dict
、set
、str
等;
一类是generator
,包括生成器和带yield
的generator function。
这些可以直接作用于for
循环的对象统称为可迭代对象:Iterable
。
可以使用isinstance()
判断一个对象是否是Iterable
对象:
1 >>> from collections import Iterable
2 >>> isinstance([], Iterable)
3 True
4 >>> isinstance({}, Iterable)
5 True
6 >>> isinstance('abc', Iterable)
7 True
8 >>> isinstance((x for x in range(10)), Iterable)
9 True
10 >>> isinstance(100, Iterable)
11 False
而生成器不但可以作用于for
循环,还可以被next()
函数不断调用并返回下一个值,直到最后抛出StopIteration
错误表示无法继续返回下一个值了。
*可以被next()
函数调用并不断返回下一个值的对象称为迭代器:Iterator
。
可以使用isinstance()
判断一个对象是否是Iterator
对象:
1 >>> from collections import Iterator
2 >>> isinstance((x for x in range(10)), Iterator)
3 True
4 >>> isinstance([], Iterator)
5 False
6 >>> isinstance({}, Iterator)
7 False
8 >>> isinstance('abc', Iterator)
9 False
生成器都是Iterator
对象,但list
、dict
、str
虽然是Iterable
,却不是Iterator
。
把list
、dict
、str
等Iterable
变成Iterator
可以使用iter()
函数:
1 >>> isinstance(iter([]), Iterator)
2 True
3 >>> isinstance(iter('abc'), Iterator)
4 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 for x in [1, 2, 3, 4, 5]:
2 pass
实际上完全等价于下面这段:
1 # 首先获得Iterator对象:
2 it = iter([1, 2, 3, 4, 5])
3 # 循环:
4 while True:
5 try:
6 # 获得下一个值:
7 x = next(it)
8 except StopIteration:
9 # 遇到StopIteration就退出循环
10 break
二、装饰器
装饰器:含义是使用一个函数作为另一个函数的参数使用。
- 封闭:已实现的功能代码块不应该被修改
- 开放:对现有功能的扩展开放
高阶函数加嵌套函数组成装饰器
1 #_*_coding:utf-8_*_
2
3
4 user_status = False #用户登录了就把这个改成True
5
6 def login(func): #把要执行的模块从这里传进来
7
8 def inner(*args,**kwargs):#再定义一层函数
9 _username = "alex" #假装这是DB里存的用户信息
10 _password = "abc!23" #假装这是DB里存的用户信息
11 global user_status
12
13 if user_status == False:
14 username = input("user:")
15 password = input("pasword:")
16
17 if username == _username and password == _password:
18 print("welcome login....")
19 user_status = True
20 else:
21 print("wrong username or password!")
22
23 if user_status == True:
24 func(*args,**kwargs) # 看这里看这里,只要验证通过了,就调用相应功能
25
26 return inner #用户调用login时,只会返回inner的内存地址,下次再调用时加上()才会执行inner函数
27
28
29 def home():
30 print("---首页----")
31
32 @login
33 def america():
34 #login() #执行前加上验证
35 print("----欧美专区----")
36
37 def japan():
38 print("----日韩专区----")
39
40 # @login
41 def henan(style):
42 '''
43 :param style: 喜欢看什么类型的,就传进来
44 :return:
45 '''
46 #login() #执行前加上验证
47 print("----河南专区----")
48
49 home()
50 # america = login(america) #你在这里相当于把america这个函数替换了
51 henan = login(henan)
52
53 # #那用户调用时依然写
54 america()
55
56 henan("3p")
需要修改需求,能让用户选择使用qq/weibo/weixin认证
1 #_*_coding:utf-8_*_
2
3
4 user_status = False #用户登录了就把这个改成True
5
6 def login(auth_type): #把要执行的模块从这里传进来
7 def auth(func):
8 def inner(*args,**kwargs):#再定义一层函数
9 if auth_type == "qq":
10 _username = "alex" #假装这是DB里存的用户信息
11 _password = "abc!23" #假装这是DB里存的用户信息
12 global user_status
13
14 if user_status == False:
15 username = input("user:")
16 password = input("pasword:")
17
18 if username == _username and password == _password:
19 print("welcome login....")
20 user_status = True
21 else:
22 print("wrong username or password!")
23
24 if user_status == True:
25 return func(*args,**kwargs) # 看这里看这里,只要验证通过了,就调用相应功能
26 else:
27 print("only support qq ")
28 return inner #用户调用login时,只会返回inner的内存地址,下次再调用时加上()才会执行inner函数
29
30 return auth
31
32 def home():
33 print("---首页----")
34
35 @login('qq')
36 def america():
37 #login() #执行前加上验证
38 print("----欧美专区----")
39
40 def japan():
41 print("----日韩专区----")
42
43 @login('weibo')
44 def henan(style):
45 '''
46 :param style: 喜欢看什么类型的,就传进来
47 :return:
48 '''
49 #login() #执行前加上验证
50 print("----河南专区----")
51
52 home()
53 # america = login(america) #你在这里相当于把america这个函数替换了
54 #henan = login(henan)
55
56 # #那用户调用时依然写
57 america()
58
59 # henan("3p")
三、软件目录结构规范
为什么要设计好目录结构?
如下2点:
- 可读性高: 不熟悉这个项目的代码的人,一眼就能看懂目录结构,知道程序启动脚本是哪个,测试目录在哪儿,配置文件在哪儿等等。从而非常快速的了解这个项目。
- 可维护性高: 定义好组织规则后,维护者就能很明确地知道,新增的哪个文件和代码应该放在什么目录之下。这个好处是,随着时间的推移,代码/配置的规模增加,项目结构不会混乱,仍然能够组织良好。
Foo/
|-- bin/
| |-- foo
|-- conf
|-- foo/
| |-- tests/
| | |-- __init__.py
| | |-- test_main.py
| |
| |-- __init__.py
| |-- main.py
|
|-- docs/
| |-- conf.py
| |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README
简要解释一下:
bin/
: 存放项目的一些可执行文件,当然你可以起名script/
之类的也行。foo/
: 存放项目的所有源代码。(1) 源代码中的所有模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/
存放单元测试代码; (3) 程序的入口最好命名为main.py
。docs/
: 存放一些文档。setup.py
: 安装、部署、打包的脚本。requirements.txt
: 存放软件依赖的外部Python包列表。README
: 项目说明文件。
除此之外,有一些方案给出了更加多的内容。比如LICENSE.txt
,ChangeLog.txt
文件等,我没有列在这里,因为这些东西主要是项目开源的时候需要用到。如果你想写一个开源软件,目录该如何组织,可以参考这篇文章。
下面,再简单讲一下我对这些目录的理解和个人要求吧。
关于README的内容
这个我觉得是每个项目都应该有的一个文件,目的是能简要描述该项目的信息,让读者快速了解这个项目。
它需要说明以下几个事项:
- 软件定位,软件的基本功能。
- 运行代码的方法: 安装环境、启动命令等。
- 简要的使用说明。
- 代码目录结构说明,更详细点可以说明软件的基本原理。
- 常见问题说明。
我觉得有以上几点是比较好的一个README
。在软件开发初期,由于开发过程中以上内容可能不明确或者发生变化,并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候,是需要撰写这样的一个文档的。
可以参考Redis源码中Readme的写法,这里面简洁但是清晰的描述了Redis功能和源码结构。
关于requirements.txt和setup.py
setup.py
一般来说,用setup.py
来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具setuptools来管理这些事情。这种方式普遍应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题,而是说,一个项目一定要有一个安装部署工具,能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。
setup.py
可以将这些事情自动化起来,提高效率、减少出错的概率。"复杂的东西自动化,能自动化的东西一定要自动化。"是一个非常好的习惯。
setuptools的文档比较庞大,刚接触的话,可能不太好找到切入点。学习技术的方式就是看他人是怎么用的,可以参考一下Python的一个Web框架,flask是如何写的: setup.py
当然,简单点自己写个安装脚本(deploy.sh
)替代setup.py
也未尝不可。
requirements.txt
这个文件存在的目的是:
- 方便开发者维护软件的包依赖。将开发过程中新增的包添加进这个列表中,避免在
setup.py
安装依赖时漏掉软件包。 - 方便读者明确项目使用了哪些Python包。
这个文件的格式是每一行包含一个包依赖的说明,通常是flask>=0.10
这种格式,要求是这个格式能被pip
识别,这样就可以简单的通过 pip install -r requirements.txt
来把所有Python包依赖都装好了。具体格式说明: 点这里。
python3-day4的更多相关文章
- python 的基础 学习 第四天 基础数据类型
1,数字 int 数字主要是用于计算,使用方法并不是很多,就记住一种就可以. #bit_length() 当十进制用二进制表示时,转化为最少二进制的最少位数v = 11data = v.bit_len ...
- python3.x Day4 内置方法,装饰器,生成器,迭代器
内置方法,就是python3提供的各种函数,可以认为是关键字,帮助进行一些列的牛x运算. abs()#取绝对值 all([])#可迭代对象中的所有元素都为True 则为True,只要至少一个为Fals ...
- Python3.5 day4作业:对员工信息文件,实现增删改查操作。
需求: 1.可进行模糊查询,语法至少支持下面3种: 1.select name,age from staff_table where age > 22 2.select * from staf ...
- python3 Flask -day4 自定义url转换器
url传参可以限定参数的数据类型,例如:限定user_id数据类型为int @app.route('/user/<int:user_id>') def my_list(user_id): ...
- python3.x Day4 模块!!
json and pickle模块 用途是为了持久化信息,这种持久化方式可以和其他程序语言兼容,一般都支持json,json只能持久化数据,pickle是python特有的方式,可以持久化所有信息和数 ...
- Python3.5学习之旅——day4
本节内容 1.装饰器 2.迭代器与生成器 3.内置方法 4.软件目录结构规范 一.装饰器 装饰器是一个用来装饰其他函数的工具,即为其他函数添加附加功能,其本质就是函数. 装饰器需要遵循的以下两个原则: ...
- 也说python的类--基于python3.5
在面向对象的语言中,除了方法.对象,剩下的一大重点就是类了,从意义上来讲,类就是对具有相同行为对象的归纳.当一个或多个对象有相同属性.方法等共同特征的时候,我们就可以把它归纳到同一个类当中.在使用上来 ...
- python_way,day4 内置函数(callable,chr,随机验证码,ord),装饰器
python_way,day4 1.内置函数 - 下 制作一个随机验证码 2.装饰器 1.内置函数 - 下 callable() #对象能否被调用 chr() #10进制数字对应的ascii码表中的内 ...
- Python基础篇-day4
本节目录: 1.字符编码 2.函数 2.1参数 2.2变量 2.3返回值 2.4递归 2.5 编程范式 2.6 高阶函数 *************************************** ...
- 【Python3之内置函数】
内置函数 简单来说就是python3本身就自带的函数. abs(x) abs()返回一个数字的绝对值.如果给出复数,返回值就是该复数的模 print(abs(-1100)) 输出:1100 all() ...
随机推荐
- 简明python教程--读后感--推荐给python新手
原书名: A Byte of Python作者: Swaroop, C. H.译者: 沈洁元出版社: 未知 优点 1. 讲解很详细,很基础,适合入门,对编译器也做了简单的介绍 2. ...
- 牛客网PAT练兵场-福尔摩斯的约会
题目地址:https://www.nowcoder.com/pat/6/problem/4040 题意:模拟题,循环找相同的字母,但是注意题目的坑 /** * *作者:Ycute *时间:2019-1 ...
- java23种设计模式——三、工厂模式
源码在我的github和gitee中获取 工厂模式 工厂模式介绍 工厂模式是我们最常用的实例化对象模式了,是用工厂方法代替new操作的一种模式.著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在J ...
- 都2020年了,还再问GET和POST的区别?【深度好文】
最近看了一些同学的面经,发现无论什么技术岗位,还是会问到 get 和 post 的区别,而搜索出来的答案并不能让我们装得一手好逼,那就让我们从 HTTP 报文的角度来撸一波,从而搞明白他们的区别. 一 ...
- wmz的数数(数状数组)
wmz的数数(数状数组) 题目描述 \(wmz\)从小就显现出了过人的天赋,他出生的第三天就证明了哥德巴赫猜想,第五天就证明了质能方程,出生一星期之后,他觉得\(P\)是否等于\(NP\)这个问题比前 ...
- Selenium执行js脚本
如何使用Selenium来执行Javascript脚本呢 Selenium中提供了一个方法:execute_script 来执行js脚本 return 可以返回js的返回结果 execute_scri ...
- Fitness - 05.19
倒计时226天 运动45分钟,共计9组,4.7公里.拉伸10分钟. 每组跑步3分钟(6.5KM/h),走路2分钟(5.5KM/h). 上周的跑步计划中断了,本周重复第三阶段的跑步计划. 一共掉了10斤 ...
- Azure Storage 系列(二) .NET Core Web 项目中操作 Blob 存储
一,引言 上一篇文章,我们介绍到在实际项目中系统会产生大量的日志文件,用户上传的头像等等,同时也介绍到可以使用Azure Blob Storage 来存储项目中的一些日志文件,用户头像,用户视频等等. ...
- HashMap源码解析、jdk7和8之后的区别、相关问题分析(多线程扩容带来的死循环)
一.概览 HashMap<String, Integer> map = new HashMap<>(); 这个语句执行起来,在 jdk1.8 之前,会创建一个长度是 16 的 ...
- 3 path核心模块
const path = require('path') // require('./static/test/test') { /* 总结: __dirname: 获得当前执行文件所在目录的完整目录名 ...