заставить программу работать в Python неопределенно долго

Question

Есть ли способ сделать функцию (те, о которых я думаю, в стиле простых, которые я сделал, которые генерируют последовательность Фибоначчи от 0 до точки и все простые числа между двумя точками) бегать до бесконечности. Например. пока я не нажму определенную клавишу или пока не пройдет время, а не пока число не достигнет определенной точки?

Кроме того, если оно основано на времени, то есть ли способ, с помощью которого я мог бы просто продлить время и начать его снова с этой точки, вместо того, чтобы начинать заново с 0? Я знаю, что есть модуль времени, я просто не знаю много об этом.

Answer 1

Самый простой способ - написать программу с бесконечным циклом, а затем нажать control-C, чтобы остановить ее. Без подробного описания трудно понять, работает ли это для вас.

Если вы делаете это по времени, вам не нужен генератор. Вы можете просто сделать паузу для пользовательского ввода, что-то вроде «Продолжить? [Y / n]», читать из стандартного ввода и в зависимости от того, что вы получаете, выходить из цикла или нет.

Answer 2

Вы можете использовать генератор для этого:

def finished():
    "Define your exit condition here"
    return ...

def count(i=0):
    while not finished():
        yield i
        i += 1

for i in count():
    print i

Если вы хотите изменить условие выхода, вы можете передать значение обратно в функцию генератора и использовать это значение, чтобы определить, когда выйти.

Answer 3

Вы можете сделать что-то подобное, чтобы сгенерировать числа Фибоначчи на 1 секунду, а затем остановиться.

fibonnacci = [1,1]
stoptime = time.time() + 1 # set stop time to 1 second in the future
while time.time() < stoptime:
  fibonnacci.append(fibonnacci[-1]+fibonnacci[-2])

print "Generated %s numbers, the last one was %s." % (len(fibonnacci),fibonnacci[-1])

Я не уверен, насколько эффективно вызывать time.time () в каждом цикле - в зависимости от того, что вы делаете внутри цикла, это может привести к снижению производительности.

Answer 4

Если вы хотите выйти в зависимости от времени, вы можете использовать функцию будильника (времени) сигнального модуля и поймать SIGALRM - вот пример http://docs.python.org/library/signal.html#example

Вы можете позволить пользователю прервать программу в том же духе, перехватывая KeyboardInterrupt. Просто перехватите исключение KeyboardInterrupt снаружи основного цикла и выполните любую необходимую очистку.

Если вы хотите продолжить позже с того места, на котором остановились, вам придется добавить какое-то постоянство. Я бы перебрал структуру данных на диск, чтобы вы могли прочитать обратно, чтобы продолжить операции.

Я не пробовал ничего подобного, но вы можете использовать что-то вроде , запоминать и кэшировать на диск.

Answer 5

Если вы действительно хотите, чтобы ваша функция работала и по-прежнему требуется ввод данных пользователем (или системой), у вас есть два решения:

1. Многопоточной
2. многозадачность

Это будет зависеть от того, насколько хорошо взаимодействие. Если вы просто хотите прервать функцию и не заботиться о выходе, тогда многопроцессорность подойдет.

В обоих случаях вы можете полагаться на некоторые общие ресурсы (файл или общую память для многопоточности, переменную с соответствующим мьютексом для многопоточности) и регулярно проверять состояние этого ресурса в своей функции. Если он настроен на то, чтобы сказать вам выйти, просто сделайте это.

Пример для многопоточности:

from threading import Thread, Lock
from time import sleep

class MyFct(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.mutex = Lock()
        self._quit = False

    def stopped(self):
        self.mutex.acquire()
        val = self._quit
        self.mutex.release()
        return val

    def stop(self):
        self.mutex.acquire()
        self._quit = True
        self.mutex.release()

    def run(self):
        i = 1
        j = 1
        print i
        print j
        while True:
            if self.stopped():
                return
            i,j = j,i+j
            print j

def main_fct():
    t = MyFct()
    t.start()
    sleep(1)
    t.stop()
    t.join()
    print "Exited"

if __name__ == "__main__":
    main_fct()

Answer 6

Если вы используете дочерний поток для запуска функции, пока основной поток ожидает ввода символов, он должен работать. Просто не забудьте иметь что-то, что останавливает дочерний поток (в примере ниже глобального runthread)

Например:

import threading, time
runthread = 1
def myfun():
   while runthread:
      print "A"
      time.sleep(.1)

t = threading.Thread(target=myfun)
t.start()
raw_input("")
runthread = 0
t.join()

делает именно это

Answer 7

Как почти на всех языках:

while True:
  # check what you want and eventually break
  print nextValue()

Вторая часть вашего вопроса более интересна:

Кроме того, если оно основано на времени, то в любом случае я могу просто продлить время и начать его снова с этой точки, вместо того, чтобы начинать заново с 0

Вы можете использовать yield вместо return в функции nextValue()