Python if not == vs if! =

Qual è la differenza tra queste due righe di codice:

if not x == 'val':

e

if x != 'val':

Uno è più efficiente dell'altro?

Sarebbe meglio usare

if x == 'val':
    pass
else:

Usando disper guardare il bytecode generato per le due versioni:

not ==

  4           0 LOAD_FAST                0 (foo)
              3 LOAD_FAST                1 (bar)
              6 COMPARE_OP               2 (==)
              9 UNARY_NOT           
             10 RETURN_VALUE   

!=

  4           0 LOAD_FAST                0 (foo)
              3 LOAD_FAST                1 (bar)
              6 COMPARE_OP               3 (!=)
              9 RETURN_VALUE   

Quest'ultimo ha meno operazioni ed è quindi probabile che sia leggermente più efficiente.

È stato sottolineato nei commenti (grazie, @Quincunx ) che dove hai if foo != barrispetto if not foo == baral numero di operazioni è esattamente lo stesso, è solo che le COMPARE_OPmodifiche e POP_JUMP_IF_TRUEpassano a POP_JUMP_IF_FALSE:

not ==:

  2           0 LOAD_FAST                0 (foo)
              3 LOAD_FAST                1 (bar)
              6 COMPARE_OP               2 (==)
              9 POP_JUMP_IF_TRUE        16

!=

  2           0 LOAD_FAST                0 (foo)
              3 LOAD_FAST                1 (bar)
              6 COMPARE_OP               3 (!=)
              9 POP_JUMP_IF_FALSE       16

In questo caso, a meno che non ci fosse una differenza nella quantità di lavoro richiesta per ciascun confronto, è improbabile che tu possa vedere alcuna differenza di prestazioni.

Tuttavia, si noti che le due versioni non saranno sempre logicamente identiche , poiché dipenderà dalle implementazioni di __eq__e __ne__per gli oggetti in questione. Secondo la documentazione del modello di dati :

Non ci sono relazioni implicite tra gli operatori di confronto. La verità di x==ynon implica che x!=ysia falso.

Per esempio:

>>> class Dummy(object):
    def __eq__(self, other):
        return True
    def __ne__(self, other):
        return True


>>> not Dummy() == Dummy()
False
>>> Dummy() != Dummy()
True

Infine, e forse soprattutto, in generale, dove i due sono logicamente identici, x != yè molto più leggibile dinot x == y .

@jonrsharpe ha un'ottima spiegazione di ciò che sta succedendo. Ho pensato di mostrare semplicemente la differenza di tempo quando eseguivo ciascuna delle 3 opzioni 10.000.000 di volte (abbastanza per mostrare una leggera differenza).

Codice utilizzato:

def a(x):
    if x != 'val':
        pass


def b(x):
    if not x == 'val':
        pass


def c(x):
    if x == 'val':
        pass
    else:
        pass


x = 1
for i in range(10000000):
    a(x)
    b(x)
    c(x)

E i risultati del profiler di cProfile:

Quindi possiamo vedere che c'è una differenza molto piccola di ~ 0,7% tra if not x == 'val':e if x != 'val':. Di questi, if x != 'val':è il più veloce.

Tuttavia, sorprendentemente, possiamo vederlo

if x == 'val':
        pass
    else:

è infatti il ​​più veloce e batte if x != 'val':di ~ 0,3%. Questo non è molto leggibile, ma immagino che se tu volessi un trascurabile miglioramento delle prestazioni, si potrebbe seguire questa strada.

Nel primo Python deve eseguire una delle operazioni in più del necessario (invece di limitarsi a verificare che non sia uguale a esso, deve verificare se non è vero che è uguale, quindi un'altra operazione). Sarebbe impossibile dire la differenza da un'esecuzione, ma se eseguito più volte, il secondo sarebbe più efficiente. Nel complesso userei il secondo, ma matematicamente sono gli stessi

>>> from dis import dis
>>> dis(compile('not 10 == 20', '', 'exec'))
  1           0 LOAD_CONST               0 (10)
              3 LOAD_CONST               1 (20)
              6 COMPARE_OP               2 (==)
              9 UNARY_NOT
             10 POP_TOP
             11 LOAD_CONST               2 (None)
             14 RETURN_VALUE
>>> dis(compile('10 != 20', '', 'exec'))
  1           0 LOAD_CONST               0 (10)
              3 LOAD_CONST               1 (20)
              6 COMPARE_OP               3 (!=)
              9 POP_TOP
             10 LOAD_CONST               2 (None)
             13 RETURN_VALUE

Qui puoi vedere che not x == yha un'istruzione in più di x != y. Quindi la differenza di prestazioni sarà molto piccola nella maggior parte dei casi a meno che tu non stia facendo milioni di confronti e anche in questo caso probabilmente non sarà la causa di un collo di bottiglia.

Una nota aggiuntiva, poiché le altre risposte hanno risposto alla tua domanda principalmente in modo corretto, è che se una classe definisce __eq__()e non solo __ne__(), allora la COMPARE_OP (!=)eseguirai __eq__()e la annullerai. A quel tempo, la tua terza opzione sarà probabilmente un po 'più efficiente, ma dovrebbe essere considerata solo se AVETE BISOGNO della velocità, poiché è difficile da capire rapidamente.

Riguarda il tuo modo di leggerlo. notl'operatore è dinamico, ecco perché puoi applicarlo

if not x == 'val':

Ma !=potrebbe essere letto in un contesto migliore come operatore che fa il contrario di ciò che ==fa.

Voglio espandere il mio commento di leggibilità sopra.

Ancora una volta, sono completamente d'accordo con la leggibilità prevalente su altre preoccupazioni (insignificanti).

Quello che vorrei sottolineare è che il cervello interpreta "positivo" più velocemente di quanto non lo sia "negativo". Ad esempio, "stop" vs. "non andare" (un esempio piuttosto scadente a causa della differenza nel numero di parole).

Quindi una scelta:

if a == b
    (do this)
else
    (do that)

è preferibile all'equivalente dal punto di vista funzionale:

if a != b
    (do that)
else
    (do this)

Una minore leggibilità / comprensibilità porta a più bug. Forse non nella codifica iniziale, ma la manutenzione (non intelligente come te!) Cambia ...