È più efficiente usare if-return-return o if-else-return?

Supponiamo che io abbia una ifdichiarazione con a return. Dal punto di vista dell'efficienza, dovrei usare

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

o

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

Dovrei preferire l'uno o l'altro quando uso un linguaggio compilato (C) o uno script (Python)?

Poiché l' returnistruzione termina l'esecuzione della funzione corrente, le due forme sono equivalenti (sebbene la seconda sia probabilmente più leggibile della prima).

L'efficienza di entrambe le forme è comparabile, il codice macchina sottostante deve eseguire un salto se la ifcondizione è comunque falsa.

Nota che Python supporta una sintassi che ti consente di usare solo returnun'istruzione nel tuo caso:

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

Dalla guida di stile di Chromium :

Non usare altro dopo il ritorno:

# Bad
if (foo)
  return 1
else
  return 2

# Good
if (foo)
  return 1
return 2

return 1 if foo else 2

Per quanto riguarda lo stile di codifica:

La maggior parte degli standard di codifica, indipendentemente dalla lingua, vieta più dichiarazioni di ritorno da una singola funzione come cattiva pratica.

(Anche se personalmente direi che ci sono diversi casi in cui hanno più senso dichiarazioni di ritorno: parser di protocolli di testo / dati, funzioni con ampia gestione degli errori, ecc.)

Il consenso di tutti quegli standard di codifica del settore è che l'espressione dovrebbe essere scritta come:

int result;

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

Per quanto riguarda l'efficienza:

L'esempio sopra e i due esempi nella domanda sono tutti completamente equivalenti in termini di efficienza. Il codice macchina in tutti questi casi deve confrontare A> B, quindi ramificare il calcolo A + 1 o A-1, quindi memorizzare il risultato in un registro CPU o nello stack.

MODIFICARE :

fonti:

• MISRA-C: 2004 14.7, che a sua volta cita ...:
• IEC 61508-3. Parte 3, tabella B.9.
• IEC 61508-7. C.2.9.

Con qualsiasi compilatore sensibile, non dovresti osservare alcuna differenza; dovrebbero essere compilati con codice macchina identico in quanto equivalenti.

Questa è una questione di stile (o preferenza) poiché l'interprete non se ne cura. Personalmente proverei a non fare la dichiarazione finale di una funzione che restituisce un valore a un livello di rientro diverso dalla base delle funzioni. L'altro nell'esempio 1 oscura, anche se solo leggermente, dove si trova la fine della funzione.

Per preferenza utilizzo:

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

Poiché obbedisce sia alla buona convenzione di avere una singola dichiarazione di ritorno come ultima affermazione nella funzione (come già accennato) sia al buon paradigma di programmazione funzionale di evitare risultati intermedi di stile imperativo.

Per funzioni più complesse preferisco suddividere la funzione in più sotto-funzioni per evitare ritorni prematuri, se possibile. Altrimenti torno a usare una variabile di stile imperativa chiamata rval. Cerco di non usare più dichiarazioni di ritorno a meno che la funzione non sia banale o che la dichiarazione di ritorno prima della fine sia il risultato di un errore. Il ritorno prematuro evidenzia il fatto che non è possibile continuare. Per funzioni complesse progettate per ramificarsi in più funzioni secondarie, provo a codificarle come istruzioni di caso (guidate da un dict per esempio).

Alcuni poster hanno menzionato la velocità di funzionamento. La velocità di runtime è secondaria per me poiché se hai bisogno di velocità di esecuzione Python non è il linguaggio migliore da usare. Uso Python per quanto riguarda l'efficienza della codifica (ovvero la scrittura di codice privo di errori) che conta per me.

Personalmente evito elseblocchi quando possibile. Vedi la campagna Anti-if

Inoltre, non fanno pagare "extra" per la linea, sai: p

"Semplice è meglio di complesso" & "La leggibilità è re"

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

La versione A è più semplice ed è per questo che la userei.

E se attivi tutti gli avvisi del compilatore in Java riceverai un avviso sulla seconda versione perché è inutile e aumenta la complessità del codice.

So che la domanda è taggata in pitone, ma menziona linguaggi dinamici, quindi ho pensato che dovrei menzionare che in ruby ​​l'istruzione if ha effettivamente un tipo di ritorno in modo da poter fare qualcosa di simile

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

O perché ha anche un ritorno implicito semplicemente

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

che aggira il problema di stile di non avere più ritorni abbastanza bene.