usar - for i in range python español

Python: ¿Cómo decirle al bucle for que continúe desde una función?

Question

A veces necesito el siguiente patrón dentro de un bucle for . A veces más de una vez en el mismo bucle:

    try:
        var = ''attempt to do something that may fail on a number of levels''
    except Exception, e:
        log(e)
        continue

Ahora no veo una buena forma de envolver esto en una función, ya que no se puede return continue :

def attempt(this):
    try:
        return this
    except Exception, e:
        log(e)
        # 1. continue # <-- syntax error: continue not properly in loop or
        # 2. return continue # <-- invalid syntax
        # 3.
        return False # <-- this sort of works, but makes me feel powerless

Si return False de lo que podría:

    var = attempt(''to do something that may fail on a number of levels'')
    if not var:
        continue

Pero no creo que lo haga la justicia. Quiero decirle al bucle for que continue (o lo simule) desde dentro attempt función de attempt .

Answer 1

coloca el bucle for fuera del intento, excepto el bloque ... simple ... ;-)

import sys if ''3.4'' in sys.version: from termcolor import colored

def list_attributes(module_name): ''''''Import the module before calling this func on it.s '''''' for index, method in enumerate(dir(module_name)): try: method = str(method) module = ''email'' expression = module + ''.'' + method print(''*'' * len(expression), ''/n'') print( str(index).upper() + ''. '',colored( expression.upper(), ''red''), '' '', eval( expression ).dir() , ''...'' , ''/n''2 ) print('''' * len(expression), ''/n'') print( eval( expression + ''.doc'' ), ''/n''*4, ''END OF DESCRIPTION FOR: '' + expression.upper(), ''/n''*4) except (AttributeError, NameError): continue else: pass finally: pass

Answer 2

Aparte del contexto, solo quiero responder a la pregunta de manera breve. No, una función no puede continue un bucle al que se puede llamar. Esto se debe a que no tiene información sobre este contexto. Además, plantearía una nueva clase de preguntas como: ¿qué pasará si se llama a esa función sin un bucle circundante para que continue ?

PERO una función puede señalar por varios medios que quiere que la persona que llama continue cualquier bucle que realice actualmente. Uno de los medios, por supuesto, es el valor de retorno. Devuelve False o None para indicar esto, por ejemplo. Otra forma de señalar esto es plantear una Exception especial:

class ContinuePlease(Exception): pass

def f():
    raise ContinuePlease()

for i in range(10):
    try:
        f()
    except ContinuePlease:
        continue

Answer 3

Edit: Eliminado toda esa estupidez que dije ...

La respuesta final fue reescribir todo, para que no tenga que codificar así.

Answer 4

La idea general de las excepciones es que funcionan en múltiples niveles de direccionamiento indirecto, es decir, si tiene un error (o cualquier otro estado excepcional ) dentro de su jerarquía de llamadas, aún puede capturarlo en un nivel superior y manejarlo adecuadamente.

En su caso, supongamos que tiene un intento de función () que llama a las funciones intento2 () e intento3 () por debajo de la jerarquía de llamadas, e intento3 () puede encontrar un estado excepcional que debería hacer que el ciclo principal finalice:

class JustContinueException(Exception):
    pass

for i in range(0,99):
    try:
        var = attempt() # calls attempt2() and attempt3() in turn
    except JustContinueException:
        continue # we don''t need to log anything here
    except Exception, e:
        log(e)
        continue

    foo(bar)

def attempt3():
    try:
        # do something
    except Exception, e:
        # do something with e, if needed
        raise # reraise exception, so we catch it downstream

Incluso puedes lanzar una excepción ficticia, eso solo haría que el bucle finalizara y ni siquiera se registraría.

def attempt3():
    raise JustContinueException()

Answer 5

Normalmente no publicaría una segunda respuesta, pero este es un enfoque alternativo si realmente no te gusta mi primera respuesta .

Recuerda que una función puede devolver una tuple .

#!/usr/bin/env python

def something_that_mail_fail(i):
    failed = False
    result = None
    try:
        result = 1.0 / (i % 4)
    except:
        failed = True # But we don''t care
    return failed, result

for i in range(20):
    failed, result = something_that_mail_fail(i)
    if failed:
        continue
    for rah in [''rah''] * 3:
        print(rah)
    print(result)

Mantengo ese try ... except ... else es el camino a seguir, y no deberías ignorar los errores en silencio. Cavtor emptor y todo eso.

Answer 6

Piensa que estás mapeando foo en todos los elementos donde el attempt funcionó. Así que attempt es un filtro y es fácil escribir esto como un generador:

def attempted( items ):
    for item in items:
        try:
            yield attempt( item )
        except Exception, e:
            log(e)

print [foo(bar) for bar in attempted( items )]

Answer 7

Podrías usar esto:

for l in loop:
  attempt() and foo(bar)

pero debes asegurarte de que try () devuelva True o False.

Realmente, sin embargo, la respuesta de Johnsyweb es probablemente mejor.

Answer 8

Python ya tiene una construcción muy buena para hacer esto y no usa continue :

for i in range(10):
    try:
        r = 1.0 / (i % 2)
    except Exception, e:
        print(e)
    else:
        print(r)

Sin embargo, no anidaría más que esto o tu código pronto se pondrá muy feo.

En su caso, probablemente haría algo más como esto, ya que es mucho más fácil probar las funciones individuales y es mejor que anidado plano :

#!/usr/bin/env python

def something_that_may_raise(i):
    return 1.0 / (i % 2)

def handle(e):
    print("Exception: " + str(e))

def do_something_with(result):
    print("No exception: " + str(result))

def wrap_process(i):
    try:
        result = something_that_may_raise(i)
    except ZeroDivisionError, e:
        handle(e)
    except OverflowError, e:
        handle(e) # Realistically, this will be a different handler...
    else:
        do_something_with(result)

for i in range(10):
    wrap_process(i)

Recuerda siempre atrapar excepciones específicas . Si no esperaba que se lanzara una excepción específica , probablemente no sea seguro continuar con su ciclo de procesamiento.

Editar los siguientes comentarios:

Si realmente no quieres manejar las excepciones, lo que sigo pensando que es una mala idea, entonces captura todas las excepciones ( except: y en lugar de handle(e) , simplemente pass . En este punto, wrap_process() finalizará, omitiendo el else: -block donde se realiza el trabajo real, y pasará a la siguiente iteración de for loop.

Tenga en cuenta, los errores nunca deben pasar en silencio .

Answer 9

Tal vez quieres hacer continuaciones? Podrías ir y ver cómo los explica Eric Lippert (si estás listo para hacer volar tu mente, pero en Python podría verse un poco así:

def attempt(operation, continuation):
    try:
        operation()
    except:
        log(''operation failed!'')
    continuation()

Dentro de tu bucle puedes hacer:

attempt(attempt_something, lambda: foo(bar)) # attempt_something is a function