facendo eseguire un programma indefinitamente in Python

Question

Esiste un modo per creare una funzione (quelli a cui sto pensando sono nello stile di quelli semplici che ho creato che generano la sequenza fibonnacci da 0 a un punto e tutti i numeri primi tra due punti) correre indefinitamente. Per esempio. fino a quando non premo un determinato tasto o fino a quando non è trascorso un tempo, anziché fino a quando un numero raggiunge un determinato punto?

Inoltre, se è basato sul tempo, allora c'è un modo in cui posso semplicemente prolungare il tempo e ricominciare da quel punto, piuttosto che dover ricominciare da 0? Sono consapevole che esiste un modulo temporale, ma non ne so molto.

Answer 1

Il modo più semplice è semplicemente scrivere un programma con un ciclo infinito, quindi premere control-C per fermarlo. Senza ulteriori descrizioni è difficile sapere se questo funziona per te.

Se lo fai in base al tempo, non hai bisogno di un generatore. Puoi semplicemente metterlo in pausa per l'input dell'utente, qualcosa del tipo " Continua? [y / n] " ;, leggi da stdin e, a seconda di ciò che ottieni, esci dal ciclo oppure no.

Answer 2

Puoi usare un generatore per questo:

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

Se si desidera modificare la condizione di uscita, è possibile restituire un valore alla funzione generatore e utilizzare quel valore per determinare quando uscire.

Answer 3

Come in quasi tutte le lingue:

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

La seconda parte della tua domanda è più interessante:

  

Inoltre, se si basa sul tempo, allora c'è comunque che potrei semplicemente prolungare il tempo e ricominciare da quel punto piuttosto che dover ricominciare da 0

puoi usare un rendimento invece di return nella funzione nextValue()

Answer 4

Se si utilizza un thread figlio per eseguire la funzione mentre il thread principale attende l'inserimento di caratteri, dovrebbe funzionare. Ricorda solo di avere qualcosa che interrompe il thread figlio (nell'esempio sotto il runthread globale)

Ad esempio:

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()

fa proprio questo

Answer 5

Se vuoi davvero che la tua funzione venga eseguita e desideri comunque l'input dell'utente (o del sistema), hai due soluzioni:

1. multi-thread
2. multi-processo

Dipenderà dalla precisione dell'interazione. Se vuoi solo interrompere la funzione e non preoccuparti dell'uscita, allora il multi-processo va bene.

In entrambi i casi, puoi fare affidamento su alcune risorse condivise (file o memoria condivisa per multi-thread, variabile con mutex associato per multi-thread) e controllare regolarmente lo stato di quella risorsa nella tua funzione. Se è impostato per dirti di smettere, fallo e basta.

Esempio su multi-thread:

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

Se vuoi uscire in base al tempo, puoi usare la funzione di allarme (ora) del modulo di segnale e catturare SIGALRM - ecco un esempio http://docs.python.org/library/signal.html#example

Puoi consentire all'utente di interrompere il programma in modo sano catturando KeyboardInterrupt. Basta catturare l'eccezione KeyboardInterrupt dall'esterno del ciclo principale e fare qualsiasi operazione di pulizia desiderata.

Se vuoi continuare più tardi da dove eri rimasto, dovrai aggiungere un po 'di persistenza. Vorrei decapare una struttura di dati su disco, che potreste rileggere per continuare le operazioni.

Non ho provato nulla di simile, ma potresti esaminare qualcosa come memoizing e memorizzazione nella cache sul disco.

Answer 7

Potresti fare qualcosa del genere per generare numeri di fibonnacci per 1 secondo e poi fermarti.

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])

Non sono sicuro di quanto sia efficiente chiamare time.time () in ogni loop - a seconda di ciò che stai facendo all'interno del loop, potrebbe finire per portare via gran parte delle prestazioni.