So beenden Sie eine unendliche Schleife sicher in Python?

Ich habe ein Skript, das läuft auf einer Endlosschleife, und fügt die Dinge in eine Datenbank und nicht Dinge, die ich kann nicht aufhören auf halbem Weg durch, also kann ich nicht einfach Strg+C drücken und es zu stoppen.

Ich möchte in der Lage sein, um irgendwie zu stoppen eine while-Schleife, aber lassen Sie es zu beenden, es ist letzten iteration, bevor es Stoppt.

Lassen Sie mich klarstellen:

mein code sieht ungefähr so aus:

while True:
    does something
    does more things
    does more things

Ich möchte in der Lage sein, zu unterbrechen, die while-Schleife am Ende, oder am Anfang, aber nicht zwischen die Dinge zu tun, weil das wäre schlecht.

und ich will nicht, es zu Fragen, mich nach jeder iteration, ob ich den Vorgang fortsetzen möchten.

danke für die tollen Antworten, ich bin super dankbar aber meine Implementierung scheint nicht zu funktionieren:

def signal_handler(signal, frame):
        global interrupted
        interrupted = True

class Crawler():
    def __init__(self):
    # not relevent

    def crawl(self):
        interrupted = False
        signal.signal(signal.SIGINT, signal_handler)
        while True:
            doing things
            more things

            if interrupted:
                print("Exiting..")
                break

wenn ich drücken Sie Strg+c das Programm einfach immer weiter, ignoriert mich

Sie haben keine Möglichkeit zu bestimmen, in deinem Skript, wenn der Auftrag abgeschlossen ist (letzten)! Wenn Sie tun, dann verwenden Sie es in einem Zustand und verwenden eine break-Anweisung
Der job in diesem Fall ist ein web-crawler kann, als weiterzumachen auf unbestimmte Zeit. Ich möchte in der Lage sein zu sagen, es zu stoppen, kriecht aber nicht nur unterbrechen, es in der Mitte einer Seite zum Beispiel.
lassen Sie es zu beenden, es ist letzten iteration, bevor es Stoppt? Wie wissen Sie, wenn es getan hat, den job oder nicht?
das script crawlt Webseiten. es hat eine for-Schleife im inneren eine unendliche while-Schleife. Ich möchte in der Lage zu stoppen die unendliche while-Schleife, aber nicht während einer iteration der for-Schleife im inneren.
Hmm...könntest du der wichtige Teil des Skripts? Dies kann anderen helfen, zu verstehen, was Sie wollen 😛
Die Frage ist klar: Beenden Sie diese iteration der Schleife, die dann beendet wird. Und wer denkt, dass es off-topic?

InformationsquelleAutor davegri | 2015-10-03

infinite-loop python

15

Was Sie tun müssen, ist zu fangen den interrupt ein flag setzen, sagen, dass Sie unterbrochen wurden, aber dann arbeiten Sie weiter, bis es ist Zeit, um die Flagge (am Ende jeder Schleife). Da python try-except-Konstrukt verlassen wird der aktuelle Durchlauf der Schleife, die Sie benötigen, um ein geeignetes signal-handler; es werde behandeln Sie die Unterbrechung, aber dann lass python weiter, wo es aufgehört hat. Hier ist, wie:
```
import signal

import time   # For the demo only

def signal_handler(signal, frame):
    global interrupted
    interrupted = True

signal.signal(signal.SIGINT, signal_handler)


interrupted = False
while True:
    print("Working hard...")
    time.sleep(3)
    print("All done!")

    if interrupted:
        print("Gotta go")
        break
```
Hinweise:
1. Verwenden Sie diese von der Kommandozeile aus. In der IDLE-Konsole, es werde trampeln auf IDLE eigenen interrupt-handling.
2. Eine bessere Lösung wäre, um "block" KeyboardInterrupt für die Dauer der Schleife, und entsperren Sie Sie, wenn es Zeit, um Abfragen für interrupts. Dies ist ein feature von einigen Unix-Varianten, aber nicht alle, daher python nicht unterstützt (siehe die Dritte "Regel")
3. Den OP will, um dies zu tun, die in einer Klasse. Aber die interrupt-Funktion aufgerufen wird, indem Sie die signal-handling-system, mit zwei Argumenten: mit Der signal-Nummer und ein pointer zum stack-frame-- kein Platz für ein self argument, die Zugang zu der Klasse object. Daher ist der einfachste Weg, ein flag zu setzen ist eine Globale variable verwenden. Sie können rig einen Zeiger auf den lokalen Kontext durch die Verwendung von closures (D. H., definieren Sie die signal-handler dynamisch in __init__(), aber ehrlich gesagt, ich würde nicht stören, es sei denn eine Globale Frage wegen multi-threading oder was auch immer.
Einschränkung: Wenn Ihr Prozess ist in der Mitte von einem system-call, handling ein signal interrupt system call. So dies möglicherweise nicht sicher für alle Anwendungen. Sicherere alternativen wäre (ein), Anstatt sich auf Signale, verwenden Sie eine nicht-blockierende lese-am Ende jeder loop-iteration (und geben Sie input drücken Sie anstelle des Schlagens ^C); (b) Benutzung von threads oder der Kommunikation zwischen Prozessen zu isolieren, die Arbeiter aus dem signal-handling; oder (c) die Arbeit der Umsetzung real signal-blockieren, wenn Sie auf einem OS, die es hat. Alle von Ihnen sind OS-abhängig zum Teil, also werde ich es dabei belassen.
- Ok, ich denke, ich verstehe, aber meine Funktion ausgeführt wird, in einer Klasse, so brauche ich, um zu definieren, die signal_handler als eine Funktion der Klasse?
- Signal-Handler aufgerufen werden, die außerhalb der normalen Ablaufsteuerung. Sie nicht müssen zu machen, eine Methode der Klasse, und ich bin mir nicht sicher, ob es auch funktioniert. Suche in der signal - Dokumentation...
- Kurze Antwort: nutzen Sie Einfach die top-level-Funktion und eine Globale variable. Es sei denn, Sie sind multi-threaded-usw., in dem Fall wird das Leben schwer...
- können Sie sich noch an meinem edit? meine Umsetzung funktioniert nicht, bearbeitet ich meine post enthalten es nun.
- Leicht zu erkennen: crawl() setzen, und dann prüfen, eine local variable interrupted 🙂 Es muss global sein, so wird der interrupt-handler kann um es zu bekommen.
- Sie sind ein Lebensretter
InformationsquelleAutor alexis

die unter Logik wird Ihnen dabei helfen,

import signal
import sys
import time

run = True

def signal_handler(signal, frame):
    global run
    print "exiting"
    run = False

signal.signal(signal.SIGINT, signal_handler)
while run:
    print "hi"
    time.sleep(1)
    # do anything
    print "bye"

während Sie dies ausführen, drücken Sie STRG+C

InformationsquelleAutor praba230890

Ich hoffe, dass Sie folgenden code würde helfen:

#!/bin/python

import sys
import time
import signal

def cb_sigint_handler(signum, stack):
    global is_interrupted
    print "SIGINT received"
    is_interrupted = True

if __name__ == "__main__":
    is_interrupted = False
    signal.signal(signal.SIGINT, cb_sigint_handler)
    while(1):
        # do stuff here 
        print "processing..."
        time.sleep(3)
        if is_interrupted:
            print "Exiting.."
            # do clean up
            sys.exit(0)

InformationsquelleAutor pdave

0

Klären @praba230890 die Lösung: Die interrupted variable wurde nicht definiert, in den richtigen Bereich. Es wurde definiert, in der crawl Funktion und der hf nicht erreichen konnte, die es als Globale variable, die nach der definition der Prozedur auf die Wurzel des Programms.

InformationsquelleAutor Anthony Scemama

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.