क्या अधिक से अधिक संख्या में कुछ करने की कोशिश करने का एक पैथोनिक तरीका है? [डुप्लिकेट]

Question 1

मेरे पास एक पायथन स्क्रिप्ट है जो एक साझा लिनक्स होस्ट पर MySQL सर्वर को क्वेरी कर रही है। किसी कारण से, MySQL के लिए प्रश्न अक्सर "सर्वर दूर चला गया" त्रुटि लौटाते हैं:

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

यदि आप क्वेरी को तुरंत बाद में आज़माते हैं, तो यह आमतौर पर सफल होता है। इसलिए, मैं जानना चाहूंगा कि क्या किसी प्रश्न को निष्पादित करने की कोशिश करने के लिए अजगर में एक समझदार तरीका है, और यदि यह विफल हो जाता है, तो निश्चित संख्या में फिर से प्रयास करने के लिए। शायद मैं इसे पूरी तरह से देने से पहले 5 बार कोशिश करना चाहता हूं।

यहाँ कोड की तरह मैं है:

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

स्पष्ट रूप से मैं इसे खंड में छोड़कर एक और प्रयास कर सकता था, लेकिन यह अविश्वसनीय रूप से बदसूरत है, और मुझे लगता है कि इसे प्राप्त करने का एक सभ्य तरीका होना चाहिए।

Question 2

कैसा रहेगा:

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

Question 3

दाना के जवाब पर निर्माण, आप एक डेकोरेटर के रूप में ऐसा करना चाह सकते हैं:

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

फिर...

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

उन्नत संस्करण जो `decorator`मॉड्यूल का उपयोग करता है

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

फिर...

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

मॉड्यूल स्थापित करने के लिएdecorator :

$ easy_install decorator

Question 4

अद्यतन: रिटेनिंग लाइब्रेरी के एक बेहतर बनाए रखा कांटा को तप कहा जाता है , जो अधिक सुविधाओं का समर्थन करता है और सामान्य रूप से अधिक लचीला होता है।

हां, रिट्रीइंग लाइब्रेरी है , जिसमें एक डेकोरेटर है जो कई तरह के रिट्रीइंग लॉजिक को लागू करता है जिसे आप जोड़ सकते हैं:

कुछ उदाहरण:

@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"

Question 5

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

Question 6

मैं इसे पसंद करना चाहूंगा:

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

calleeफ़ंक्शन को बाहर करने से कार्यक्षमता टूटने लगती है, जिससे कि रिट्रीट कोड में फंसने के बिना व्यापार तर्क को देखना आसान है।

Question 7

एस.लॉट की तरह, मुझे यह जांचने के लिए एक ध्वज पसंद है कि क्या हम कर रहे हैं:

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

Question 8

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

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

Question 9

1.Definition:

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

2.Usage:

try_three_times(lambda: do_some_function_or_express())

मैं इसे पार्स html संदर्भ के लिए उपयोग करता हूं।

Question 10

यह मेरा सामान्य समाधान है:

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

यह निम्नलिखित की तरह कोड की अनुमति देता है:

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

यह भी संभव है:

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

मुझे आशा है कि अपवादों को अधिक सहज तरीके से संभालकर इसे बेहतर बनाया जा सकता है। सुझाव के लिए खोलें।

Question 11

आप अधिकतम प्रभाव के लिए forएक elseखंड के साथ एक लूप का उपयोग कर सकते हैं :

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

जैसे ही क्वेरी सफल होती है, कुंजी लूप से बाहर हो जाती है। elseपाश एक के बिना पूरा करता है, तो खंड केवल तभी ट्रिगर होंगे break।

क्या अधिक से अधिक संख्या में कुछ करने की कोशिश करने का एक पैथोनिक तरीका है? [डुप्लिकेट]

उन्नत संस्करण जो decoratorमॉड्यूल का उपयोग करता है

उन्नत संस्करण जो `decorator`मॉड्यूल का उपयोग करता है