заставить программу работать в 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

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

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

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

  

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

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

Answer 4

Если вы используете дочерний поток для запуска функции, пока основной поток ожидает ввода символов, он должен работать. Просто не забудьте иметь что-то, что останавливает дочерний поток (в примере ниже глобального 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 5

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

<Ол>

многопоточной

<Литий> мульти-процесс

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

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

Пример в многопоточности:

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

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

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

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

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

Answer 7

Вы можете сделать что-то подобное, чтобы сгенерировать числа Фибоначчи за 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 () в каждом цикле - в зависимости от того, что вы делаете внутри цикла, это может привести к снижению производительности.