python延迟执行函数,python 延迟执行

python生成器到底有什么优点

1. 迭代器协议

成都创新互联主要为客户提供服务项目涵盖了网页视觉设计、VI标志设计、成都营销网站建设、网站程序开发、HTML5响应式重庆网站建设公司、移动网站建设、微商城、网站托管及网站维护、WEB系统开发、域名注册、国内外服务器租用、视频、平面设计、SEO优化排名。设计、前端、后端三个建站步骤的完善服务体系。一人跟踪测试的建站服务标准。已经为成都石雕行业客户提供了网站推广服务。

由于生成器自动实现了迭代器协议，而迭代器协议对很多人来说，也是一个较为抽象的概念。所以，为了更好的理解生成器，我们需要简单的回顾一下迭代器协议的概念。

迭代器协议是指：对象需要提供next方法，它要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代

可迭代对象就是：实现了迭代器协议的对象

协议是一种约定，可迭代对象实现迭代器协议，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有两种不同的方式提供生成器：

生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行

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

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

generator object at 0x00B2EC88

next(squares)

next(squares)

1

next(squares)

4

list(squares)

[9, 16]

Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：

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

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

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

2.3 再看生成器

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

语法上和函数类似：生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义，差别在于，生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值

自动实现迭代器协议：对于生成器，Python会自动实现迭代器协议，以便应用到迭代背景中（如for循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，在没有值可以返回的时候，生成器自动产生StopIteration异常

状态挂起：生成器使用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

使用生成器的情况：

def index_words(text):

if text:

yield 0

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

if letter == ' ':

yield index

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

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

不使用生成器的时候，对于每次结果，我们首先看到的是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语句的时候，就遍历了我们的生成器，当我们再次遍历我们的生成器的时候，将不会有任何记录。所以，上面的代码不会有任何输出。

python延时循环执行导致cpu消耗多过能解决么

可以不用一直保持此程序运行啊，

Linux的话可以用低消耗的crontab 来自定义时间执行此python命令即可。

提供个思路，可以使用python的apscheduler库。

如何更好地理解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的生成器

celery 设置多少时间后运行

许多Django应用需要执行异步任务, 以便不耽误http request的执行. 我们也可以选择许多方法来完成异步任务, 使用Celery是一个比较好的选择, 因为Celery

有着大量的社区支持, 能够完美的扩展, 和Django结合的也很好. Celery不仅能在Django中使用, 还能在其他地方被大量的使用. 因此一旦学会使用Celery, 我

们可以很方便的在其他项目中使用它.

1. Celery版本

本篇博文主要针对Celery 3.0.x. 早期版本的Celery可能有细微的差别.

2. Celery介绍

Celery的主要用处是执行异步任务, 可以选择延期或定时执行功能. 为什么需要执行异步任务呢?

第一, 假设用户正发起一个request, 并等待request完成后返回. 在这一request后面的view功能中, 我们可能需要执行一段花费很长时间的程序任务, 这一时间

可能远远大于用户能忍受的范围. 当这一任务并不需要立刻执行时, 我们便可以使用Celery在后台执行, 而不影响用户浏览网页. 当有任务需要访问远程服务器完

成时, 我们往往都无法确定需要花费的时间.

第二则是定期执行某些任务. 比如每小时需要检查一下天气预报, 然后将数据储存到数据库中. 我们可以编写这一任务, 然后让Celery每小时执行一次. 这样我们

的web应用便能获取最新的天气预报信息.

我们这里所讲的任务task, 就是一个Python功能(function). 定期执行一个任务可以被认为是延时执行该功能. 我们可以使用Celery延迟5分钟调用function

task1, 并传入参数(1, 2, 3). 或者我们也可以每天午夜运行该function.

我们偏向于将Celery放入项目中, 便于task访问统一数据库和Django设置.

当task准备运行时, Celery会将其放入列队queue中. queue中储存着可以运行的task的list. 我们可以使用多个queue, 但为了简单, 这里我们只使用一个.

将任务task放入queue就像加入todo list一样. 为了使task运行, 我们还需要在其他线程中运行的苦工worker. worker实时观察着代运行的task, 并逐一运行这

些task. 你可以使用多个worker, 通常他们位于不同服务器上. 同样为了简单起见, 我们这只是用一个worker.

我们稍后会讨论queue, worker和另外一个十分重要的进程, 接下来我们来动动手:

3. 安装Celery

我们可以使用pip在vietualenv中安装:

pip install django-celery

4. Django设置

我们暂时使用django runserver来启动celery. 而Celery代理人(broker), 我们使用Django database broker implementation. 现在我们只需要知道Celery

需要broker, 使用django自身便可以充当broker. (但在部署时, 我们最好使用更稳定和高效的broker, 例如Redis.)

在settings.py中:

import djcelery

djcelery.setup_loader()

BROKER_URL = 'django://'

...

INSTALLED_APPS = (

...

'djcelery',

'kombu.transport.django',

...

)

第一二项是必须的, 第三项则告诉Celery使用Django项目作为broker.

在INSTALLED_APPS中添加的djcelery是必须的. kombu.transport.django则是基于Django的broker

最后创建Celery所需的数据表, 如果使用South作为数据迁移工具, 则运行:

python manage.py migrate

否则运行: (Django 1.6或Django 1.7都可以)

python manage.py syncdb

5. 创建一个task

正如前面所说的, 一个task就是一个Pyhton function. 但Celery需要知道这一function是task, 因此我们可以使用celery自带的装饰器decorator: @task. 在

django app目录中创建taske.py:

from celery import task

@task()

def add(x, y):

return x + y

当settings.py中的djcelery.setup_loader()运行时, Celery便会查看所有INSTALLED_APPS中app目录中的tasks.py文件, 找到标记为task的function, 并

将它们注册为celery task.

将function标注为task并不会妨碍他们的正常执行. 你还是可以像平时那样调用它: z = add(1, 2).

6. 执行task

让我们以一个简单的例子作为开始. 例如我们希望在用户发出request后异步执行该task, 马上返回response, 从而不阻塞该request, 使用户有一个流畅的访问

过程. 那么, 我们可以使用.delay, 例如在在views.py的一个view中:

from myapp.tasks import add

...

add.delay(2, 2)

...

Celery会将task加入到queue中, 并马上返回. 而在一旁待命的worker看到该task后, 便会按照设定执行它, 并将他从queue中移除. 而worker则会执行以下代

码:

import myapp.tasks.add

myapp.tasks.add(2, 2)

7. 关于import

这里需要注意的是, 在impprt task时, 需要保持一致. 因为在执行djcelery.setup_loader()时, task是以INSTALLED_APPS中的app名,

加.tasks.function_name注册的, 如果我们由于python path不同而使用不同的引用方式时(例如在tasks.py中使用from myproject.myapp.tasks import

add形式), Celery将无法得知这是同一task, 因此可能会引起奇怪的bug.

8. 测试

a. 启动worker

正如之前说到的, 我们需要worker来执行task. 以下是在开发环境中的如何启动worker:

首先启动terminal, 如同开发django项目一样, 激活virtualenv, 切换到django项目目录. 然后启动django自带web服务器: python manage.py runserver.

然后启动worker:

python manage.py celery worker --loglevel=info

此时, worker将会在该terminal中运行, 并显示输出结果.

b. 启动task

打开新的terminal, 激活virtualenv, 并切换到django项目目录:

$ python manage.py shell

from myapp.tasks import add

add.delay(2, 2)

此时, 你可以在worker窗口中看到worker执行该task:

[2014-10-07 08:47:08,076: INFO/MainProcess] Got task from broker: myapp.tasks.add[e080e047-b2a2-43a7-af74-d7d9d98b02fc]

[2014-10-07 08:47:08,299: INFO/MainProcess] Task myapp.tasks.add[e080e047-b2a2-43a7-af74-d7d9d98b02fc] succeeded in 0.183349132538s: 4

9. 另一个例子

下面我们来看一个更为真实的例子, 在views.py和tasks.py中:

# views.py

from myapp.tasks import do_something_with_form_data

def view(request):

form = SomeForm(request.POST)

if form.is_valid():

data = form.cleaned_data

# Schedule a task to process the data later

do_something_with_form_data.delay(data)

return render_to_response(...)

# tasks.py

@task

def do_something_with_form_data(data):

call_slow_web_service(data['user'], data['text'], ...)

10. 调试

由于Celery的运行需要启动多个部件, 我们可能会漏掉一两个. 所以我们建议:

使用最简单的设置

使用python debug和logging功能显示当前的进程

11. Eager模式

如果在settings.py设置:

CELERY_ALWAYS_EAGER = True

那么Celery便以eager模式运行, 则task便不需要加delay运行:

# 若启用eager模式, 则以下两行代码相同

add.delay(2, 2)

add(2, 2)

12. 查看queue

因为我们使用了django作为broker, queue储存在django的数据库中. 这就意味着我们可以通过django admin查看该queue:

# admin.py

from django.contrib import admin

from kombu.transport.django import models as kombu_models

admin.site.register(kombu_models.Message)

13. 检查结果

每次运行异步task后, Celery都会返回AsyncResult对象作为结果. 你可以将其保存, 然后在将来查看该task是否运行成功和返回结果:

# views.py

result = add.delay(2, 2)

...

if result.ready():

print "Task has run"

if result.successful():

print "Result was: %s" % result.result

else:

if isinstance(result.result, Exception):

print "Task failed due to raising an exception"

raise result.result

else:

print "Task failed without raising exception"

else:

print "Task has not yet run"

14. 定期任务

还有一种Celery的常用模式便是执行定期任务. 执行定期任务时, Celery会通过celerybeat进程来完成. Celerybeat会保持运行, 一旦到了某一定期任务需要执

行时, Celerybeat便将其加入到queue中. 不像worker进程, Celerybeat只有需要一个即可.

启动Celerybeat:

python manage.py celery beat

使Celery运行定期任务的方式有很多种, 我们先看第一种, 将定期任务储存在django数据库中. 即使是在django和celery都运行的状态, 这一方式也可以让我们

方便的修改定期任务. 我们只需要设置settings.py中的一项便能开启这一方式:

# settings.py

CELERYBEAT_SCHEDULER = 'djcelery.schedulers.DatabaseScheduler'

python如何微秒级延时？

Python中的sleep函数可以传小数进去，就可以进行毫秒级的延时了，代码如下：

# 例1：循环输出休眠1秒

import time

i = 1

while i lt;= 3:

print i # 输出i

i += 1

time.sleep(1) # 休眠1秒

# 例2：循环输出休眠100毫秒

import time

i = 1

while i lt;= 3:

print i # 输出i

i += 1

time.sleep(0.1) # 休眠0.1秒

网站标题：python延迟执行函数,python 延迟执行
地址分享：http://mswzjz.cn/article/hsocss.html