您的位置:

python项目的单文件生成器(python 批量生成文件夹)

本文目录一览:

如何更好地理解Python迭代器和生成器

Python这门语言中,生成器毫无疑问是最有用的特性之一。与此同时,也是使用的最不广泛的Python特

性之一。究其原因,主要是因为,在其他主流语言里面没有生成器的概念。正是由于生成器是一

个“新”的东西,所以,它一方面没有引起广大工程师的重视,另一方面,也增加了工程师的学习成本,

最终导致大家错过了Python中如此有用的一个特性。

我的这篇文章,希望通过简单易懂的方式,深入浅出地介绍Python的生成器,以改变“如此有用的特性却

使用极不广泛”的现象。本文的组织如下:在第1章,我们简单地介绍了Python中的迭代器协议;在本文

第2章,将会详细介绍生成器的概念和语法;在第3章,将会给出一个有用的例子,说明使用生成器的好

处;在本文最后,简单的讨论了使用生成器的注意事项。

1. 迭代器协议

由于生成器自动实现了迭代器协议,而迭代器协议对很多人来说,也是一个较为抽象的概念。所以,为了

更好的理解生成器,我们需要简单的回顾一下迭代器协议的概念。

1. 迭代器协议是指:对象需要提供next方法,它要么返回迭代中的下一项,要么就引起一个

StopIteration异常,以终止迭代

2. 可迭代对象就是:实现了迭代器协议的对象

3. 协议是一种约定,可迭代对象实现迭代器协议,Python的内置工具(如for循环,sum,min,max函

数等)使用迭代器协议访问对象。

举个例子:在所有语言中,我们都可以使用for循环来遍历数组,Python的list底层实现是一个数组,所

以,我们可以使用for循环来遍历list。如下所示:

for n in [1, 2, 3, 4]:

... print n

但是,对Python稍微熟悉一点的朋友应该知道,Python的for循环不但可以用来遍历list,还可以用来遍历

文件对象,如下所示:

with open(‘/etc/passwd’) as f: # 文件对象提供迭代器协议

... for line in f: # for循环使用迭代器协议访问文件

... print line

...

为什么在Python中,文件还可以使用for循环进行遍历呢?这是因为,在Python中,文件对象实现了迭代

器协议,for循环并不知道它遍历的是一个文件对象,它只管使用迭代器协议访问对象即可。正是由于

Python的文件对象实现了迭代器协议,我们才得以使用如此方便的方式访问文件,如下所示:

f = open('/etc/passwd')

dir(f)

['__class__', '__enter__', '__exit__', '__iter__', '__new__', 'writelines', '...'

2. 生成器

Python使用生成器对延迟操作提供了支持。所谓延迟操作,是指在需要的时候才产生结果,而不是立即产

生结果。这也是生成器的主要好处。

Python有两种不同的方式提供生成器:

2017/11/6 如何更好地理解Python迭代器和生成器? - 知乎

2/5

1. 生成器函数:常规函数定义,但是,使用yield语句而不是return语句返回结果。yield语句一次返回一

个结果,在每个结果中间,挂起函数的状态,以便下次重它离开的地方继续执行

2. 生成器表达式:类似于列表推导,但是,生成器返回按需产生结果的一个对象,而不是一次构建一个

结果列表

2.1 生成器函数

我们来看一个例子,使用生成器返回自然数的平方(注意返回的是多个值):

def gensquares(N):

for i in range(N):

yield i ** 2

for item in gensquares(5):

print item,

使用普通函数:

def gensquares(N):

res = []

for i in range(N):

res.append(i*i)

return res

for item in gensquares(5):

print item,

可以看到,使用生成器函数代码量更少。

2.2 生成器表达式

使用列表推导,将会一次产生所有结果:

squares = [x**2 for x in range(5)]

squares

[0, 1, 4, 9, 16]

将列表推导的中括号,替换成圆括号,就是一个生成器表达式:

squares = (x**2 for x in range(5))

squares next(squares)

next(squares)

1

next(squares)

4

list(squares)

[9, 16]

Python不但使用迭代器协议,让for循环变得更加通用。大部分内置函数,也是使用迭代器协议访问对象

的。例如, sum函数是Python的内置函数,该函数使用迭代器协议访问对象,而生成器实现了迭代器协

2017/11/6 如何更好地理解Python迭代器和生成器? - 知乎

3/5

议,所以,我们可以直接这样计算一系列值的和:

sum(x ** 2 for x in xrange(4))

而不用多此一举的先构造一个列表:

sum([x ** 2 for x in xrange(4)])

2.3 再看生成器

前面已经对生成器有了感性的认识,我们以生成器函数为例,再来深入探讨一下Python的生成器:

1. 语法上和函数类似:生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义,差别在

于,生成器使用yield语句返回一个值,而常规函数使用return语句返回一个值

2. 自动实现迭代器协议:对于生成器,Python会自动实现迭代器协议,以便应用到迭代背景中(如for

循环,sum函数)。由于生成器自动实现了迭代器协议,所以,我们可以调用它的next方法,并且,

在没有值可以返回的时候,生成器自动产生StopIteration异常

3. 状态挂起:生成器使用yield语句返回一个值。yield语句挂起该生成器函数的状态,保留足够的信息,

以便之后从它离开的地方继续执行

3. 示例

我们再来看两个生成器的例子,以便大家更好的理解生成器的作用。

首先,生成器的好处是延迟计算,一次返回一个结果。也就是说,它不会一次生成所有的结果,这对于大

数据量处理,将会非常有用。

大家可以在自己电脑上试试下面两个表达式,并且观察内存占用情况。对于前一个表达式,我在自己的电

脑上进行测试,还没有看到最终结果电脑就已经卡死,对于后一个表达式,几乎没有什么内存占用。

sum([i for i in xrange(10000000000)])

sum(i for i in xrange(10000000000))

除了延迟计算,生成器还能有效提高代码可读性。例如,现在有一个需求,求一段文字中,每个单词出现

的位置。

不使用生成器的情况:

def index_words(text):

result = []

if text:

result.append(0)

for index, letter in enumerate(text, 1):

if letter == ' ':

result.append(index)

return result

使用生成器的情况:

2017/11/6 如何更好地理解Python迭代器和生成器? - 知乎

4/5

def index_words(text):

if text:

yield 0

for index, letter in enumerate(text, 1):

if letter == ' ':

yield index

这里,至少有两个充分的理由说明 ,使用生成器比不使用生成器代码更加清晰:

1. 使用生成器以后,代码行数更少。大家要记住,如果想把代码写的Pythonic,在保证代码可读性的前

提下,代码行数越少越好

2. 不使用生成器的时候,对于每次结果,我们首先看到的是result.append(index),其次,才是index。

也就是说,我们每次看到的是一个列表的append操作,只是append的是我们想要的结果。使用生成

器的时候,直接yield index,少了列表append操作的干扰,我们一眼就能够看出,代码是要返回

index。

这个例子充分说明了,合理使用生成器,能够有效提高代码可读性。只要大家完全接受了生成器的概念,

理解了yield语句和return语句一样,也是返回一个值。那么,就能够理解为什么使用生成器比不使用生成

器要好,能够理解使用生成器真的可以让代码变得清晰易懂。

4. 使用生成器的注意事项

相信通过这篇文章,大家已经能够理解生成器的作用和好处。但是,还没有结束,使用生成器,也有一点

注意事项。

我们直接来看例子,假设文件中保存了每个省份的人口总数,现在,需要求每个省份的人口占全国总人口

的比例。显然,我们需要先求出全国的总人口,然后在遍历每个省份的人口,用每个省的人口数除以总人

口数,就得到了每个省份的人口占全国人口的比例。

如下所示:

def get_province_population(filename):

with open(filename) as f:

for line in f:

yield int(line)

gen = get_province_population('data.txt')

all_population = sum(gen)

#print all_population

for population in gen:

print population / all_population

执行上面这段代码,将不会有任何输出,这是因为,生成器只能遍历一次。在我们执行sum语句的时候,

就遍历了我们的生成器,当我们再次遍历我们的生成器的时候,将不会有任何记录。所以,上面的代码不

会有任何输出。

因此,生成器的唯一注意事项就是:生成器只能遍历一次。

5. 总结

2017/11/6 如何更好地理解Python迭代器和生成器? - 知乎

5/5

本文深入浅出地介绍了Python中,一个容易被大家忽略的重要特性,即Python的生成器。为了讲解生成

器,本文先介绍了迭代器协议,然后介绍了生成器函数和生成器表达式,并通过示例演示了生成器的优点

和注意事项。在实际工作中,充分利用Python生成器,不但能够减少内存使用,还能够提高代码可读性。

掌握生成器也是Python高手的标配。希望本文能够帮助大家理解Python的生成器

闲话python 45: 浅谈生成器yield

生成器似乎并不是一个经常被开发者讨论的语法,因此也就没有它的大兄弟迭代器那么著名。大家不讨论它并不是说大家都已经对它熟悉到人尽皆知,与之相反,即使是工作多年的开发者可能对生成器的运行过程还是知之甚少。这是什么原因导致的呢?我猜想大概有以下几点原因: (1)运行流程不同寻常,(2)日常开发不需要,(3)常常将生成器与迭代器混淆。 生成器的运行流程可以按照协程来理解,也就是说 返回中间结果,断点继续运行 。这与我们通常对于程序调用的理解稍有差异。这种运行模式是针对什么样的需求呢? 一般而言,生成器是应用于大量磁盘资源的处理。 比如一个很大的文件,每次读取一行,下一次读取需要以上一次读取的位置为基础。下面就通过代码演示具体看看生成器的运行机制、使用方式以及与迭代器的比较。

什么是生成器?直接用文字描述可能太过抽象,倒不如先运行一段代码,分析这段代码的运行流程,然后总结出自己对生成器的理解。

从以上演示可以看出,这段代码定义了一个函数,这个函数除了yield这个关键字之外与一般函数并没有差异,也就是说生成器的魔法都是这个yield关键字引起的。 第一点,函数的返回值是一个生成器对象。 上述代码中,直接调用这个看似普通的函数,然后将返回值打印出来,发现返回值是一个对象,而并不是普通函数的返回值。 第二点,可以使用next对这个生成器对象进行操作 。生成器对象天然的可以被next函数调用,然后返回在yield关键字后面的内容。 第三,再次调用next函数处理生成器对象,发现是从上次yield语句之后继续运行,直到下一个yield语句返回。

生成器的运行流程确实诡异,下面还要演示一个生成器可以执行的更加诡异的操作:运行过程中向函数传参。

返回生成器和next函数操作生成器已经并不奇怪了,但是在函数运行过程中向其传参还是让人惊呆了。 调用生成器的send函数传入参数,在函数内使用yield语句的返回值接收,然后继续运行直到下一个yield语句返回。 以前实现这种运行流程的方式是在函数中加上一个从控制台获取数据的指令,或者提前将参数传入,但是现在不用了,send方式使得传入的参数可以随着读取到的参数变化而变化。

很多的开发者比较容易混淆生成器和迭代器,而迭代器的运行过程更加符合一般的程序调用运行流程,因此从亲进度和使用熟悉度而言,大家对迭代器更有好感。比如下面演示一个对迭代器使用next方法进行操作。

从以上演示来看,大家或许会认为迭代器比生成器简单易用得太多了。不过,如果你了解迭代器的实现机制,可能就不会这么早下结论了。python内置了一些已经实现了的迭代器使用确实方便,但是如果需要自己去写一个迭代器呢?下面这段代码就带大家见识以下迭代器的实现。

在python中,能被next函数操作的对象一定带有__next__函数的实现,而能够被迭代的对象有必须实现__iter__函数。看了这么一段操作,相信大家对迭代器实现的繁琐也是深有体会了,那么生成器的实现是不是会让你觉得更加简单易用呢?不过千万别产生一个误区,即生成器比迭代器简单就多用生成器。 在实际开发中,如果遇到与大量磁盘文件或者数据库操作相关的倒是可以使用生成器。但是在其他的任务中使用生成器难免有炫技,并且使逻辑不清晰而导致可读性下降的嫌疑。 这大概也能解释生成器受冷落的原因。不过作为一个专业的开发者,熟悉语言特性是分内之事。

到此,关于生成器的讨论就结束了。本文的notebook版本文件在github上的cnbluegeek/notebook仓库中共享,欢迎感兴趣的朋友前往下载。

python生成器是怎么使用的

生成器(generator)概念

生成器不会把结果保存在一个系列中,而是保存生成器的状态,在每次进行迭代时返回一个值,直到遇到StopIteration异常结束。

生成器语法

生成器表达式: 通列表解析语法,只不过把列表解析的[]换成()

生成器表达式能做的事情列表解析基本都能处理,只不过在需要处理的序列比较大时,列表解析比较费内存。

Python

1

2

3

4

5

6

7

8

9

10

11

gen = (x**2 for x in range(5))

gen

generator object genexpr at 0x0000000002FB7B40

for g in gen:

... print(g, end='-')

...

0-1-4-9-16-

for x in [0,1,2,3,4,5]:

... print(x, end='-')

...

0-1-2-3-4-5-

生成器函数: 在函数中如果出现了yield关键字,那么该函数就不再是普通函数,而是生成器函数。

但是生成器函数可以生产一个无线的序列,这样列表根本没有办法进行处理。

yield 的作用就是把一个函数变成一个 generator,带有 yield 的函数不再是一个普通函数,Python 解释器会将其视为一个 generator。

下面为一个可以无穷生产奇数的生成器函数。

Python

1

2

3

4

5

6

7

8

9

10

11

def odd():

n=1

while True:

yield n

n+=2

odd_num = odd()

count = 0

for o in odd_num:

if count =5: break

print(o)

count +=1

当然通过手动编写迭代器可以实现类似的效果,只不过生成器更加直观易懂

Python

1

2

3

4

5

6

7

8

9

10

11

class Iter:

def __init__(self):

self.start=-1

def __iter__(self):

return self

def __next__(self):

self.start +=2

return self.start

I = Iter()

for count in range(5):

print(next(I))

题外话: 生成器是包含有__iter()和next__()方法的,所以可以直接使用for来迭代,而没有包含StopIteration的自编Iter来只能通过手动循环来迭代。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

from collections import Iterable

from collections import Iterator

isinstance(odd_num, Iterable)

True

isinstance(odd_num, Iterator)

True

iter(odd_num) is odd_num

True

help(odd_num)

Help on generator object:

odd = class generator(object)

| Methods defined here:

|

| __iter__(self, /)

| Implement iter(self).

|

| __next__(self, /)

| Implement next(self).

......

看到上面的结果,现在你可以很有信心的按照Iterator的方式进行循环了吧!

在 for 循环执行时,每次循环都会执行 fab 函数内部的代码,执行到 yield b 时,fab 函数就返回一个迭代值,下次迭代时,代码从 yield b 的下一条语句继续执行,而函数的本地变量看起来和上次中断执行前是完全一样的,于是函数继续执行,直到再次遇到 yield。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次,每次中断都会通过 yield 返回当前的迭代值。

yield 与 return

在一个生成器中,如果没有return,则默认执行到函数完毕时返回StopIteration;

Python

1

2

3

4

5

6

7

8

9

10

11

def g1():

... yield 1

...

g=g1()

next(g) #第一次调用next(g)时,会在执行完yield语句后挂起,所以此时程序并没有执行结束。

1

next(g) #程序试图从yield语句的下一条语句开始执行,发现已经到了结尾,所以抛出StopIteration异常。

Traceback (most recent call last):

File "stdin", line 1, in module

StopIteration

如果遇到return,如果在执行过程中 return,则直接抛出 StopIteration 终止迭代。

Python

1

2

3

4

5

6

7

8

9

10

11

12

def g2():

... yield 'a'

... return

... yield 'b'

...

g=g2()

next(g) #程序停留在执行完yield 'a'语句后的位置。

'a'

next(g) #程序发现下一条语句是return,所以抛出StopIteration异常,这样yield 'b'语句永远也不会执行。

Traceback (most recent call last):

File "stdin", line 1, in module

StopIteration

如果在return后返回一个值,那么这个值为StopIteration异常的说明,不是程序的返回值。

生成器没有办法使用return来返回值。

Python

1

2

3

4

5

6

7

8

9

10

11

def g3():

... yield 'hello'

... return 'world'

...

g=g3()

next(g)

'hello'

next(g)

Traceback (most recent call last):

File "stdin", line 1, in module

StopIteration: world

生成器支持的方法

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

help(odd_num)

Help on generator object:

odd = class generator(object)

| Methods defined here:

......

| close(...)

| close() - raise GeneratorExit inside generator.

|

| send(...)

| send(arg) - send 'arg' into generator,

| return next yielded value or raise StopIteration.

|

| throw(...)

| throw(typ[,val[,tb]]) - raise exception in generator,

| return next yielded value or raise StopIteration.

......

close()

手动关闭生成器函数,后面的调用会直接返回StopIteration异常。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

def g4():

... yield 1

... yield 2

... yield 3

...

g=g4()

next(g)

1

g.close()

next(g) #关闭后,yield 2和yield 3语句将不再起作用

Traceback (most recent call last):

File "stdin", line 1, in module

StopIteration

send()

生成器函数最大的特点是可以接受外部传入的一个变量,并根据变量内容计算结果后返回。

这是生成器函数最难理解的地方,也是最重要的地方,实现后面我会讲到的协程就全靠它了。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

def gen():

value=0

while True:

receive=yield value

if receive=='e':

break

value = 'got: %s' % receive

g=gen()

print(g.send(None))

print(g.send('aaa'))

print(g.send(3))

print(g.send('e'))

执行流程:

通过g.send(None)或者next(g)可以启动生成器函数,并执行到第一个yield语句结束的位置。此时,执行完了yield语句,但是没有给receive赋值。yield value会输出初始值0注意:在启动生成器函数时只能send(None),如果试图输入其它的值都会得到错误提示信息。

通过g.send(‘aaa’),会传入aaa,并赋值给receive,然后计算出value的值,并回到while头部,执行yield value语句有停止。此时yield value会输出”got: aaa”,然后挂起。

通过g.send(3),会重复第2步,最后输出结果为”got: 3″

当我们g.send(‘e’)时,程序会执行break然后推出循环,最后整个函数执行完毕,所以会得到StopIteration异常。

最后的执行结果如下:

Python

1

2

3

4

5

6

7

got: aaa

got: 3

Traceback (most recent call last):

File "h.py", line 14, in module

print(g.send('e'))

StopIteration

throw()

用来向生成器函数送入一个异常,可以结束系统定义的异常,或者自定义的异常。

throw()后直接跑出异常并结束程序,或者消耗掉一个yield,或者在没有下一个yield的时候直接进行到程序的结尾。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

def gen():

while True:

try:

yield 'normal value'

yield 'normal value 2'

print('here')

except ValueError:

print('we got ValueError here')

except TypeError:

break

g=gen()

print(next(g))

print(g.throw(ValueError))

print(next(g))

print(g.throw(TypeError))

输出结果为:

Python

1

2

3

4

5

6

7

8

normal value

we got ValueError here

normal value

normal value 2

Traceback (most recent call last):

File "h.py", line 15, in module

print(g.throw(TypeError))

StopIteration

解释:

print(next(g)):会输出normal value,并停留在yield ‘normal value 2’之前。

由于执行了g.throw(ValueError),所以会跳过所有后续的try语句,也就是说yield ‘normal value 2’不会被执行,然后进入到except语句,打印出we got ValueError here。然后再次进入到while语句部分,消耗一个yield,所以会输出normal value。

print(next(g)),会执行yield ‘normal value 2’语句,并停留在执行完该语句后的位置。

g.throw(TypeError):会跳出try语句,从而print(‘here’)不会被执行,然后执行break语句,跳出while循环,然后到达程序结尾,所以跑出StopIteration异常。

下面给出一个综合例子,用来把一个多维列表展开,或者说扁平化多维列表)

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

def flatten(nested):

try:

#如果是字符串,那么手动抛出TypeError。

if isinstance(nested, str):

raise TypeError

for sublist in nested:

#yield flatten(sublist)

for element in flatten(sublist):

#yield element

print('got:', element)

except TypeError:

#print('here')

yield nested

L=['aaadf',[1,2,3],2,4,[5,[6,[8,[9]],'ddf'],7]]

for num in flatten(L):

print(num)

如果理解起来有点困难,那么把print语句的注释打开在进行查看就比较明了了。

总结

按照鸭子模型理论,生成器就是一种迭代器,可以使用for进行迭代。

第一次执行next(generator)时,会执行完yield语句后程序进行挂起,所有的参数和状态会进行保存。再一次执行next(generator)时,会从挂起的状态开始往后执行。在遇到程序的结尾或者遇到StopIteration时,循环结束。

可以通过generator.send(arg)来传入参数,这是协程模型。

可以通过generator.throw(exception)来传入一个异常。throw语句会消耗掉一个yield。可以通过generator.close()来手动关闭生成器。

next()等价于send(None)

vs2017如何打包python项目,生成exe文件

可以使用PyInstaller把python程序打包成exe,安装使用pip install pyinstaller,使用时,使用pyinstaller打包,参数如下

-F, –onefile 打包一个单个文件,如果你的代码都写在一个.py文件的话,可以用这个,如果是多个.py文件就别用

-D, –onedir 打包多个文件,在dist中生成很多依赖文件,适合以框架形式编写工具代码,我个人比较推荐这样,代码易于维护

-K, –tk 在部署时包含 TCL/TK

-a, –ascii 不包含编码.在支持Unicode的python版本上默认包含所有的编码.

-d, –debug 产生debug版本的可执行文件

-w,–windowed,–noconsole 使用Windows子系统执行.当程序启动的时候不会打开命令行(只对Windows有效)

-c,–nowindowed,–console

使用控制台子系统执行(默认)(只对Windows有效)

pyinstaller -c xxxx.py

pyinstaller xxxx.py --console

-s,–strip 可执行文件和共享库将run through strip.注意Cygwin的strip往往使普通的win32 Dll无法使用.

-X, –upx 如果有UPX安装(执行Configure.py时检测),会压缩执行文件(Windows系统中的DLL也会)(参见note)

-o DIR, –out=DIR 指定spec文件的生成目录,如果没有指定,而且当前目录是PyInstaller的根目录,会自动创建一个用于输出(spec和生成的可执行文件)的目录.如果没有指定,而当前目录不是PyInstaller的根目录,则会输出到当前的目录下.

-p DIR, –path=DIR 设置导入路径(和使用PYTHONPATH效果相似).可以用路径分割符(Windows使用分号,Linux使用冒号)分割,指定多个目录.也可以使用多个-p参数来设置多个导入路径,让pyinstaller自己去找程序需要的资源

–icon=FILE.ICO

将file.ico添加为可执行文件的资源(只对Windows系统有效),改变程序的图标 pyinstaller -i ico路径 xxxxx.py

–icon=FILE.EXE,N 将file.exe的第n个图标添加为可执行文件的资源(只对Windows系统有效)

-v FILE, –version=FILE 将verfile作为可执行文件的版本资源(只对Windows系统有效)

-n NAME, –name=NAME 可选的项目(产生的spec的)名字.如果省略,第一个脚本的主文件名将作为spec的名字