¿Es más eficiente usar if-return-return o if-else-return?

Supongamos que tengo una statement if con una return . Desde la perspectiva de la eficiencia, debo usar

 if(A > B): return A+1 return A-1 

o

 if(A > B): return A+1 else: return A-1 

¿Debo preferir uno u otro al usar un lenguaje comstackdo (C) o uno con guión (Python)?

Dado que la statement de return finaliza la ejecución de la función actual, las dos formas son equivalentes (aunque la segunda es posiblemente más legible que la primera).

La eficiencia de ambas formas es comparable, el código de máquina subyacente tiene que realizar un salto si la condición if es falsa de todos modos.

Tenga en cuenta que Python admite una syntax que le permite usar solo una statement de return en su caso:

 return A+1 if A > B else A-1 

De la guía de estilo de Chromium :

No use otra cosa después de regresar

 # Bad if (foo) return 1 else return 2 # Good if (foo) return 1 return 2 return 1 if foo else 2 

Respecto al estilo de encoding:

La mayoría de los estándares de encoding, sin importar el idioma, prohíben múltiples declaraciones de retorno de una sola función como mala práctica.

(Aunque personalmente diría que hay varios casos en los que múltiples declaraciones de devolución tienen sentido: analizadores de protocolo de texto / datos, funciones con un extenso manejo de errores, etc.)

El consenso de todos esos estándares de encoding de la industria es que la expresión debe escribirse como:

 int result; if(A > B) { result = A+1; } else { result = A-1; } return result; 

Respecto a la eficiencia:

El ejemplo anterior y los dos ejemplos de la pregunta son completamente equivalentes en términos de eficiencia. El código de máquina en todos estos casos tiene que comparar A> B, luego derivarse al cálculo A + 1 o A-1, luego almacenar el resultado en un registro de CPU o en la stack.

EDITAR:

Fuentes:

  • MISRA-C: 2004 regla 14.7, que a su vez cita …
  • IEC 61508-3. Parte 3, tabla B.9.
  • IEC 61508-7. C.2.9.

Con cualquier comstackdor sensible, no deberías observar ninguna diferencia; deben comstackrse a un código de máquina idéntico ya que son equivalentes.

La versión A es más simple y es por eso que la usaría.

Y si activa todas las advertencias del comstackdor en Java, recibirá una advertencia en la segunda versión porque es innecesaria y aumenta la complejidad del código.

Personalmente evito lockings cuando sea posible. Ver la Campaña Anti-if

Además, no cobran ‘extra’ por la línea, ya sabes: p

“Lo simple es mejor que lo complejo” y “La legibilidad es el rey”

 delta = 1 if (A > B) else -1 return A + delta 

Sé que la pregunta está etiquetada como python, pero menciona lenguajes dynamics, así que pensé que debería mencionar que en ruby ​​la instrucción if tiene un tipo de retorno para que pueda hacer algo como

 def foo rv = if (A > B) A+1 else A-1 end return rv end 

O porque también tiene retorno implícito simplemente

 def foo if (A>B) A+1 else A-1 end end 

lo que soluciona el problema de estilo de no tener varias devoluciones muy bien.

Piensa en esto, de esta manera:

 if (a > b): output = a + 1 output = a - 1 return output 

Contra esto:

 if (a > b): output = a + 1 else: output = a - 1 return output 

El primer ejemplo no es funcional, mientras que el segundo funciona bien. Tienen el mismo rendimiento, por lo que te recomiendo que uses el ejemplo 2 ya que, en mi opinión, es más fácil de leer.

Esta es una cuestión de estilo (o preferencia) ya que al intérprete no le importa. Personalmente, trataría de no hacer la statement final de una función que devuelve un valor en un nivel de sangría que no sea la base de la función. La otra cosa en el ejemplo 1 oculta, aunque solo sea un poco, dónde está el final de la función.

Por preferencia uso:

 return A+1 if (A > B) else A-1 

Como obedece tanto a la buena convención de tener una única statement de devolución como a la última en la función (como ya se mencionó) y al buen paradigma de progtwigción funcional de evitar resultados intermedios de estilo imperativo.

Para funciones más complejas, prefiero dividir la función en múltiples subfunciones para evitar retornos prematuros si es posible. De lo contrario vuelvo a usar una variable de estilo imperativo llamada rval. Intento no usar varias declaraciones de devolución a menos que la función sea trivial o que la statement de devolución antes del final sea como resultado de un error. El regreso prematuro resalta el hecho de que no se puede continuar. Para las funciones complejas que están diseñadas para derivarse en múltiples subfunciones, trato de codificarlas como declaraciones de caso (impulsadas por un dict, por ejemplo).

Algunos carteles han mencionado la velocidad de operación. La velocidad del tiempo de ejecución es secundaria para mí, ya que si necesita la velocidad de ejecución, Python no es el mejor lenguaje para usar. Yo uso Python como su eficiencia de encoding (es decir, escribir código libre de errores) lo que me importa.