如何获得运行函数'；将输出作为Python中的事件

我有一个关于下面发布的示例的问题

在我的机器上，

calcIt（）

函数大约需要5秒钟才能完成。 从MyClass的callCalcIt（）方法内部调用相同的

calcIt（）

函数。 在循环MyClass“监视”calcIt（）函数完成时使用

问题：calcIt（）方法中的
while
循环只打印出
“…运行”
。老实说，我希望看到至少“无限循环”类型的行为，
“…运行”
每秒打印上千次。观察一个事实，
while
循环只执行一次打印“…运行”

行，这让我相信

，而
循环非常“松散地”监视
calcIt（）
的进程。如果是这样的话，除了
while
loop之外，还应该使用什么方法来确保您得到想要的：calcIt（）函数的即时反馈

def calcIt():
    a=True
    while a:
        for i in range(25000000):
            pass
        a=False
    return True

class MyClass(object):
    def __init__(self):
        super(MyClass, self).__init__()

    def callCalcIt(self):
        b=True
        while b:
            result=calcIt()
            print '...running'
            if result: b=False

print 0    
calcIt()
print 1

c=MyClass()
c.callCalcIt()
print 2

稍后编辑：
发布修订后的代码，并实施Ebarr建议的解决方案：

import threading

updateMe=[]

def calcIt():
    a=True
    while a:
        for y in range(3):
            for i in range(15000000):
                pass
            updateMe.append(1)
        a=False
    return True

class MyClass(object):
    def __init__(self):
        super(MyClass, self).__init__()

    def callCalcIt(self):
        thread = threading.Thread(target=calcIt)   
        thread.start()
        print '\n...thread started'
        while thread.is_alive():
            if len(updateMe)==1: print '...stage 1'
            if len(updateMe)==2: print '...stage 2'
            if len(updateMe)==3: print '...stage 3'

    def printUpdate(self):
        print 'updateMe=', len(updateMe)


c=MyClass()
c.callCalcIt()

我不确定你期望发生什么，但解释很简单。您正在运行单线程代码。这意味着上述所有操作都将以串行方式执行，因此代码中的两个while循环之间不会并发

您似乎要问的是如何对代码执行线程，以便检查正在运行的函数的进度。如果是这种情况，您可以将
calcIt
转换为线程

import threading

class CalcIt(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        for i in range(25000000):
            pass

然后将
callCalcIt
更改为：

def callCalcIt(self): 
    thread = CalcIt()     
    thread.start()
    while thread.is_alive():
        print '...running'

或者，您可以使其更简单：

import threading

def calcIt():
    for i in range(25000000):
        pass

def callCalcIt():
    thread = threading.Thread(target=calcIt)
    thread.start()
    while thread.is_alive():
        print '...running'

callCalcIt()

我不确定你期望发生什么，但解释很简单。您正在运行单线程代码。这意味着上述所有操作都将以串行方式执行，因此代码中的两个while循环之间不会并发

您似乎要问的是如何对代码执行线程，以便检查正在运行的函数的进度。如果是这种情况，您可以将
calcIt
转换为线程

import threading

class CalcIt(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        for i in range(25000000):
            pass

然后将
callCalcIt
更改为：

def callCalcIt(self): 
    thread = CalcIt()     
    thread.start()
    while thread.is_alive():
        print '...running'

或者，您可以使其更简单：

import threading

def calcIt():
    for i in range(25000000):
        pass

def callCalcIt():
    thread = threading.Thread(target=calcIt)
    thread.start()
    while thread.is_alive():
        print '...running'

callCalcIt()

我可以想出两种方法，但都需要对
calcIt
函数进行一些修改

方法1，回调：

def calc_it(callback):
    r = 25000000
    for x in xrange(r+1):
        if not (x % 1000):
            callback(x, r)  # report every 1000 ticks

class Monitor(object):
    def print_status(self, x, r):
        print "Done {0} out of {1}".format(x, r)

    def call(self):
        calc_it(self.print_status)

方法2，发电机：

def calc_it():
    r = 25000000
    for x in xrange(r+1):
        if not (x % 1000):  # report every 1000 ticks
            yield x, r

class Monitor(object):
    def call(self):
        for x, r in calc_it():
            print "Done {0} out of {1}".format(x, r)

（旁注：在这两种情况下，
Monitor
都不必是类，这只是为了与原始代码保持一致。）
我可以想出两种方法，但都需要对
calcIt
函数进行一些修改

方法1，回调：

def calc_it(callback):
    r = 25000000
    for x in xrange(r+1):
        if not (x % 1000):
            callback(x, r)  # report every 1000 ticks

class Monitor(object):
    def print_status(self, x, r):
        print "Done {0} out of {1}".format(x, r)

    def call(self):
        calc_it(self.print_status)

方法2，发电机：

def calc_it():
    r = 25000000
    for x in xrange(r+1):
        if not (x % 1000):  # report every 1000 ticks
            yield x, r

class Monitor(object):
    def call(self):
        for x, r in calc_it():
            print "Done {0} out of {1}".format(x, r)

（旁注：在这两种情况下，
Monitor
都不必是一个类，这只是为了与原始代码保持一致。）
不确定您想要完成什么，但您可以使用。像这样：

from generatorstate import State

def calcIt():
    while True:
        for i in range(25000000):
            pass
        yield

tick = State(calcIt)
print 0
tick()
print 1
tick()
print 2

我已经添加了几个示例，如果您认为合适，可以偷偷看一看这些示例。
不确定您正试图完成什么，但您可以使用。像这样：

from generatorstate import State

def calcIt():
    while True:
        for i in range(25000000):
            pass
        yield

tick = State(calcIt)
print 0
tick()
print 1
tick()
print 2

我已经添加了几个示例，如果您认为合适的话，可以偷看一下这些示例。
在
result=calcIt（）
result
为
True
，因此
b
变为
False
，因此循环退出。我认为您根本上误解了单线程应用程序的行为。函数调用阻塞，直到它们返回某些内容。确定。那么你的答案是什么？对不起，我不太明白你的意思。但是，如果您在单线程上运行同步代码，那么在下一个函数启动之前，一个函数将返回/放弃。在本例中，循环似乎只运行一次，因为控制变量（例如，
a
）设置为
False
。所以我现在只看到一次“跑步”。我想，当循环以光速“循环”或自我迭代时：一次又一次：直到遇到False。我需要一个解决方案。什么可以用来连续地“听”calcIt（）呢？请发布一个示例。在
result=calcIt（）
result
为
True
之后，因此
b
变为
False
，因此循环退出。我认为您根本上误解了单线程应用程序的行为。函数调用阻塞，直到它们返回某些内容。确定。那么你的答案是什么？对不起，我不太明白你的意思。但是，如果您在单线程上运行同步代码，那么在下一个函数启动之前，一个函数将返回/放弃。在本例中，循环似乎只运行一次，因为控制变量（例如，
a
）设置为
False
。所以我现在只看到一次“跑步”。我想，当循环以光速“循环”或自我迭代时：一次又一次：直到遇到False。我需要一个解决方案。什么可以用来连续地“听”calcIt（）呢？请发布一个示例。如果我将
thread=CalcIt（）
替换为小写
thread=CalcIt（）
并运行您发布的内容，我会得到一个
AttributeError:'bool'对象没有属性“start”
，但谢谢您的建议！经过编辑，它做得很漂亮！从我身上爬起来！谢谢~；）@Sputnix I改变了案例，以反映
CalcIt
在第一个案例中已成为一个类的事实。请参阅PEP8（）。如果我将
thread=CalcIt（）
替换为小写
thread=CalcIt（）
并运行您发布的内容，我会得到一个
AttributeError:'bool'对象没有属性“start”
，但感谢您的建议！经过编辑，它做得很漂亮！从我身上爬起来！谢谢~；）@Sputnix I改变了案例，以反映
CalcIt
在第一个案例中已成为一个类的事实。请参阅PEP8（）。感谢您提供的信息！我正设法把它全部存起来。但我会记住，总有另一件事发生！感谢