python延迟函数 python 延迟1秒

python中，怎么更新labelz中的文本

#-*- coding: utf-8 -*-

成都创新互联公司主营临邑网站建设的网络公司,主营网站建设方案,成都App制作,临邑h5小程序制作搭建,临邑网站营销推广欢迎临邑等地区企业咨询

'''

按照我个人的理解：

你的time.sleep调用在了mainloop之前，就是在显示label之前delay就已经完成了，同样config也完成了，所以直接显示了text=2的结果。

但是即使是在label弹出显示之后调用sleep函数（我也试过了），还有一个问题，就是sleep是阻塞式执行的，sleep完之前用户进行不了任何操作，UI也无法更新，必须要等到sleep做完了才能发生。

所以我另外开了一个线程，用于延迟，延迟完成之后通过回调函数通知UI进行更新。

废话不多了，下面是代码，我用的时python 2.7.8。

如果有说的不对的地方，请高手指点。

'''

from Tkinter import *

import time

import threading

#计时线程 用于延时

class MyThread(threading.Thread):

# sleeptime为需要延迟的时间

# callback为延迟结束后触发的回调函数

def __init__(self,id,sleeptime,callback):

threading.Thread.__init__(self)

self.id=id

self.callback = callback

self.sleeptime = sleeptime

# 重写线程run函数

def run(self):

time.sleep(self.sleeptime)

# 延时完成后传入回调函数

self.callback()

class Example(Frame):

def __init__(self, parent):

Frame.__init__(self, parent)

self.parent = parent

self.label = None

self.initUI()

#初始化窗体

def initUI(self):

self.label = Label(self, text='1')

self.label.bind('Visibility',self.onVis)

self.label.pack()

self.parent.title("Label")

self.pack()

#在label显示后进行调用

def onVis(self,*args):

print "Label Visible!"

# 创建一个新的线程用于延迟，并且传入changeText作为回调函数

t = MyThread(001,2,self.changeText)

t.start()

#在延迟完成后进行调用，与Mythread的callback绑定

def changeText(self):

self.label.config(text = '10')

window = Tk()

app = Example(window)

window.mainloop()

python惰性求值有哪些函数

Copyright © 1999-2020, CSDN.NET, All Rights Reserved

惰性计算的序列

打开APP

Python 的惰性求值与惰性序列 翻译

2018-07-23 14:57:48

2点赞

东师小镇

码龄5年

关注

惰性求值

在编程语言理论中，惰性求值（英语：Lazy Evaluation），又译为惰性计算、懒惰求值，也称为传需求调用（call-by-need），是一个计算机编程中的一个概念，它的目的是要最小化计算机要做的工作。它有两个相关而又有区别的含意，可以表示为“延迟求值”和“最小化求值”。

避免不必要的计算，带来性能的提升（最小化求值）。

对于Python中的条件表达式 if x and y,在x为false的情况下y表达式的值将不再计算。而对于if x or y，当x的值为true的时候将直接返回，不再计算y的值。因此编程中可以利用该特性，在 and逻辑中，将小概率发生的条件放在前面或者在or逻辑中，将大概率发生的时间放在前面，有助于性能的提升。

2. 节省空间，使得无线循环的数据结构成为可能（延迟求值）。

延迟求值特别用于函数式编程语言中。在使用延迟求值的时候，表达式不在它被绑定到变量之后就立即求值，而是在该值被取用的时候求值。延迟求值的一个好处是能够建立可计算的无限列表而没有妨碍计算的无限循环或大小问题。例如，可以建立生成无限斐波那契数列表的函数（经常叫做“流”）。第n个斐波那契数的计算仅是从这个无限列表上提取出这个元素，它只要求计算这个列表的前n个成员。

惰性序列

Python的惰性序列多数指 iterator，其特点正如同上文所述，具有惰性计算特点的序列称为惰性序列。

Python的iterator是一个惰性序列，意思是表达式和变量绑定后不会立即进行求值，而是当你用到其中某些元素的时候才去求某元素对的值。 惰性是指，你不主动去遍历它，就不会计算其中元素的值。

一句话理解：

迭代器的一个优点就是它不要求你事先准备好整个迭代过程中所有的元素。

迭代器仅仅在迭代至某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。

这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件，或是斐波那契数列等等。

python中from time import sleep是什么意思

from time import sleep就是从time模块中引入sleep函数，使用sleep函数可以让程序休眠（推迟调用线程的运行）。

具体方法：

1，sleep（时间）。

2，#如果之前引入了time模块，使用time.sleep(时间)语句即可，不需要import这个语句。

3，#具体用法见下其中“时间”以秒为单位，可以是小数，0.1秒则代表休眠100毫秒。

扩展资料：

使用Python编程时的注意事项：

1，初始变化量：

在Python里，一个表达式中的名字在它被赋值之前是没法使用的。这是有意而为的：这样能避免一些输入失误，同时也能避免默认究竟应该是什么类型的问题（0，None，””，[]，?）。记住把计数器初始化为0，列表初始化为[]，以此类推。

2，从第一列开始：

确保把顶层的，未嵌套的代码放在最左边第一列开始。这包括在模块文件中未嵌套的代码，以及在交互提示符中未嵌套的代码。Python使用缩进的办法来区分嵌套的代码段，因此在代码左边的空格意味着嵌套的代码块。除了缩进以外，空格通常是被忽略掉的。

3，缩进一致：

在同一个代码块中避免讲tab和空格混用来缩进，除非知道运行自己的代码的系统是怎么处理tab的。否则的话，在自己的编辑器里看起来是tab的缩进也许Python看起来就会被视作是一些空格。保险起见，在每个代码块中全都是用tab或者全都是用空格来缩进；用多少由自己决定。

4，在函数调用时使用括号：

无论一个函数是否需要参数，必须要加一对括号来调用它。即，使用function()，而不是function。Python的函数简单来说是具有特殊功能的对象，而调用是用括号来触发的。像所有的对象一样，它们也可以被赋值给变量，并且间接的使用它们：x=function:x()。

python如何微秒级延时？

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

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

import time

i = 1

while i = 3:

print i # 输出i

i += 1

time.sleep(1) # 休眠1秒

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

import time

i = 1

while i = 3:

print i # 输出i

i += 1

time.sleep(0.1) # 休眠0.1秒

如何更好地理解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怎么用延时函数，python小白求求帮忙（哭）

用定时器做，1秒钟唤醒一次响应函数，不要用延时函数 sleep

# 定义时间显示

self.timer = QtCore.QTimer(self)

self.timer.timeout.connect(self.act_displayTM) #绑定响应函数

self.timer.setInterval(1000) #设置时间间隔

self.timer.start()

# 定时响应事件对应逻辑

def act_displayTM(self):

s_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

self.ui.label_Date.setText(s_time)

return