Gibt es eine pythonische Möglichkeit, etwas maximal maximal auszuprobieren? [Duplikat]

Ich habe ein Python-Skript, das einen MySQL-Server auf einem gemeinsam genutzten Linux-Host abfragt. Aus irgendeinem Grund geben Abfragen an MySQL häufig den Fehler "Server ist weg" zurück:

_mysql_exceptions.OperationalError: (2006, 'MySQL server has gone away')

Wenn Sie die Abfrage unmittelbar danach erneut versuchen, ist sie normalerweise erfolgreich. Ich würde gerne wissen, ob es in Python eine sinnvolle Möglichkeit gibt, eine Abfrage auszuführen, und wenn dies fehlschlägt, versuchen Sie es erneut, bis zu einer festgelegten Anzahl von Versuchen. Wahrscheinlich möchte ich, dass es 5 Mal versucht wird, bevor ich ganz aufgebe.

Hier ist die Art von Code, die ich habe:

conn = MySQLdb.connect(host, user, password, database)
cursor = conn.cursor()

try:
    cursor.execute(query)
    rows = cursor.fetchall()
    for row in rows:
        # do something with the data
except MySQLdb.Error, e:
    print "MySQL Error %d: %s" % (e.args[0], e.args[1])

Natürlich könnte ich es tun, indem ich einen weiteren Versuch in der Ausnahmeklausel mache, aber das ist unglaublich hässlich, und ich habe das Gefühl, dass es einen anständigen Weg geben muss, um dies zu erreichen.

Wie wäre es mit:

conn = MySQLdb.connect(host, user, password, database)
cursor = conn.cursor()
attempts = 0

while attempts < 3:
    try:
        cursor.execute(query)
        rows = cursor.fetchall()
        for row in rows:
            # do something with the data
        break
    except MySQLdb.Error, e:
        attempts += 1
        print "MySQL Error %d: %s" % (e.args[0], e.args[1])

Aufbauend auf Danas Antwort möchten Sie dies vielleicht als Dekorateur tun:

def retry(howmany):
    def tryIt(func):
        def f():
            attempts = 0
            while attempts < howmany:
                try:
                    return func()
                except:
                    attempts += 1
        return f
    return tryIt

Dann...

@retry(5)
def the_db_func():
    # [...]

Erweiterte Version, die das decoratorModul verwendet

import decorator, time

def retry(howmany, *exception_types, **kwargs):
    timeout = kwargs.get('timeout', 0.0) # seconds
    @decorator.decorator
    def tryIt(func, *fargs, **fkwargs):
        for _ in xrange(howmany):
            try: return func(*fargs, **fkwargs)
            except exception_types or Exception:
                if timeout is not None: time.sleep(timeout)
    return tryIt

Dann...

@retry(5, MySQLdb.Error, timeout=0.5)
def the_db_func():
    # [...]

So installieren Sie das decoratorModul :

$ easy_install decorator

UPDATE: gibt es eine besseren gehaltene Gabel der retrying Bibliothek namens Hartnäckigkeit , die mehr Funktionen unterstützt und ist in der Regel flexibler.

Ja, es gibt die Wiederholungsbibliothek mit einem Dekorator, der verschiedene Arten von Wiederholungslogik implementiert, die Sie kombinieren können:

Einige Beispiele:

@retry(stop_max_attempt_number=7)
def stop_after_7_attempts():
    print "Stopping after 7 attempts"

@retry(wait_fixed=2000)
def wait_2_s():
    print "Wait 2 second between retries"

@retry(wait_exponential_multiplier=1000, wait_exponential_max=10000)
def wait_exponential_1000():
    print "Wait 2^x * 1000 milliseconds between each retry,"
    print "up to 10 seconds, then 10 seconds afterwards"

conn = MySQLdb.connect(host, user, password, database)
cursor = conn.cursor()

for i in range(3):
    try:
        cursor.execute(query)
        rows = cursor.fetchall()
        for row in rows:
            # do something with the data
        break
    except MySQLdb.Error, e:
        print "MySQL Error %d: %s" % (e.args[0], e.args[1])

Ich würde es so umgestalten:

def callee(cursor):
    cursor.execute(query)
    rows = cursor.fetchall()
    for row in rows:
        # do something with the data

def caller(attempt_count=3, wait_interval=20):
    """:param wait_interval: In seconds."""
    conn = MySQLdb.connect(host, user, password, database)
    cursor = conn.cursor()
    for attempt_number in range(attempt_count):
        try:
            callee(cursor)
        except MySQLdb.Error, e:
            logging.warn("MySQL Error %d: %s", e.args[0], e.args[1])
            time.sleep(wait_interval)
        else:
            break

Das Ausklammern der calleeFunktion scheint die Funktionalität aufzubrechen, so dass die Geschäftslogik leicht zu erkennen ist, ohne im Wiederholungscode hängen zu bleiben.

Wie S.Lott mag ich eine Flagge, um zu überprüfen, ob wir fertig sind:

conn = MySQLdb.connect(host, user, password, database)
cursor = conn.cursor()

success = False
attempts = 0

while attempts < 3 and not success:
    try:
        cursor.execute(query)
        rows = cursor.fetchall()
        for row in rows:
            # do something with the data
        success = True 
    except MySQLdb.Error, e:
        print "MySQL Error %d: %s" % (e.args[0], e.args[1])
        attempts += 1

def successful_transaction(transaction):
    try:
        transaction()
        return True
    except SQL...:
        return False

succeeded = any(successful_transaction(transaction)
                for transaction in repeat(transaction, 3))

1. Definition:

def try_three_times(express):
    att = 0
    while att < 3:
        try: return express()
        except: att += 1
    else: return u"FAILED"

2.Verwendung:

try_three_times(lambda: do_some_function_or_express())

Ich benutze es zum Parsen von HTML-Kontext.

Dies ist meine generische Lösung:

class TryTimes(object):
    ''' A context-managed coroutine that returns True until a number of tries have been reached. '''

    def __init__(self, times):
        ''' times: Number of retries before failing. '''
        self.times = times
        self.count = 0

    def __next__(self):
        ''' A generator expression that counts up to times. '''
        while self.count < self.times:
            self.count += 1
        yield False

    def __call__(self, *args, **kwargs):
        ''' This allows "o() calls for "o = TryTimes(3)". '''
        return self.__next__().next()

    def __enter__(self):
        ''' Context manager entry, bound to t in "with TryTimes(3) as t" '''
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        ''' Context manager exit. '''
        return False # don't suppress exception

Dies ermöglicht Code wie den folgenden:

with TryTimes(3) as t:
    while t():
        print "Your code to try several times"

Auch möglich:

t = TryTimes(3)
while t():
    print "Your code to try several times"

Ich hoffe, dies kann verbessert werden, indem Ausnahmen intuitiver behandelt werden. Offen für Vorschläge.

Sie können eine forSchleife mit einer elseKlausel verwenden, um maximale Wirkung zu erzielen:

conn = MySQLdb.connect(host, user, password, database)
cursor = conn.cursor()

for n in range(3):
    try:
        cursor.execute(query)
    except MySQLdb.Error, e:
        print "MySQL Error %d: %s" % (e.args[0], e.args[1])
    else:
        rows = cursor.fetchall()
        for row in rows:
            # do something with the data
        break
else:
    # All attempts failed, raise a real error or whatever

Der Schlüssel ist, aus der Schleife auszubrechen, sobald die Abfrage erfolgreich ist. Die elseKlausel wird nur ausgelöst, wenn die Schleife ohne a abgeschlossen ist break.