`if key in dict` vs.` try / tranne` - qual è l'idioma più leggibile?

Ho una domanda sugli idiomi e la leggibilità, e sembra che ci sia uno scontro tra le filosofie Python per questo caso particolare:

Voglio costruire il dizionario A dal dizionario B. Se una chiave specifica non esiste in B, non fare nulla e continuare.

Qual è il modo migliore?

try:
    A["blah"] = B["blah"]
except KeyError:
    pass

o

if "blah" in B:
    A["blah"] = B["blah"]

"Fai e chiedi perdono" contro "semplicità e chiarezza".

Qual è il migliore e perché?

Le eccezioni non sono condizionali.

La versione condizionale è più chiara. È naturale: questo è un controllo di flusso diretto, che è ciò per cui sono progettati i condizionali, non le eccezioni.

La versione dell'eccezione viene utilizzata principalmente come ottimizzazione quando si eseguono queste ricerche in un ciclo: per alcuni algoritmi consente di eliminare i test dai cicli interni. Non ha quel vantaggio qui. Ha il piccolo vantaggio di evitare di doverlo dire "blah"due volte, ma se stai facendo molti di questi probabilmente dovresti comunque avere una move_keyfunzione di aiuto .

In generale, consiglio vivamente di attenersi alla versione condizionale per impostazione predefinita a meno che tu non abbia un motivo specifico per non farlo. I condizionali sono il modo più ovvio per farlo, che di solito è una forte raccomandazione per preferire una soluzione rispetto a un'altra.

C'è anche un terzo modo che evita sia le eccezioni che la doppia ricerca, che può essere importante se la ricerca è costosa:

value = B.get("blah", None)
if value is not None: 
    A["blah"] = value

Nel caso in cui ti aspetti che il dizionario contenga Nonevalori, puoi usare alcune costanti più esoteriche come NotImplemented, Ellipsiso crearne uno nuovo:

MyConst = object()
def update_key(A, B, key):
    value = B.get(key, MyConst)
    if value is not MyConst: 
        A[key] = value

Ad ogni modo, l'utilizzo update()è l'opzione più leggibile per me:

a.update((k, b[k]) for k in ("foo", "bar", "blah") if k in b)

Da quello che ho capito, vuoi aggiornare il dict A con la chiave, le coppie di valori dal dict B.

update è una scelta migliore.

A.update(B)

Esempio:

>>> A = {'a':1, 'b': 2, 'c':3}
>>> B = {'d': 2, 'b':5, 'c': 4}
>>> A.update(B)
>>> A
{'a': 1, 'c': 4, 'b': 5, 'd': 2}
>>> 

Citazione diretta dal wiki delle prestazioni di Python:

Tranne che per la prima volta, ogni volta che viene vista una parola il test dell'istruzione if fallisce. Se stai contando un numero elevato di parole, molte probabilmente si verificheranno più volte. In una situazione in cui l'inizializzazione di un valore avverrà solo una volta e l'aumento di quel valore si verificherà molte volte, è più economico utilizzare un'istruzione try.

Quindi sembra che entrambe le opzioni siano praticabili a seconda della situazione. Per maggiori dettagli potresti controllare questo link: Try-tranne-performance

Penso che la regola generale qui A["blah"]esisterà normalmente, in tal caso prova, tranne che è buono, altrimenti usaif "blah" in b:

Penso che "provare" sia economico nel tempo, ma "tranne" è più costoso.

Penso che il secondo esempio sia quello che dovresti cercare a meno che questo codice non abbia senso:

try:
    A["foo"] = B["foo"]
    A["bar"] = B["bar"]
    A["baz"] = B["baz"]
except KeyError:
    pass

Tieni presente che il codice verrà interrotto non appena c'è una chiave che non è in B . Se questo codice ha senso, è necessario utilizzare il metodo di eccezione, altrimenti utilizzare il metodo di test. A mio parere, poiché è più breve ed esprime chiaramente l'intento, è molto più facile da leggere rispetto al metodo delle eccezioni.

Naturalmente, le persone che ti dicono di usare updatehanno ragione. Se stai usando una versione di Python che supporta la comprensione del dizionario, preferirei fortemente questo codice:

updateset = {'foo', 'bar', 'baz'}
A.update({k: B[k] for k in updateset if k in B})

La regola in altre lingue è di riservare eccezioni per condizioni eccezionali, cioè errori che non si verificano durante l'uso regolare. Non so come quella regola si applichi a Python, poiché StopIteration non dovrebbe esistere secondo quella regola.

Personalmente, propendo per il secondo metodo (ma utilizzando has_key):

if B.has_key("blah"):
  A["blah"] = B["blah"]

In questo modo, ogni operazione di assegnazione è solo di due righe (invece di 4 con try / tranne), e tutte le eccezioni che vengono lanciate saranno errori reali o cose che ti sei perso (invece di provare ad accedere a chiavi che non ci sono) .

A quanto pare (vedi i commenti alla tua domanda), has_keyè deprecato, quindi immagino che sia meglio scritto come

if "blah" in B:
  A["blah"] = B["blah"]

A partire Python 3.8e con l'introduzione delle espressioni di assegnazione (PEP 572) ( :=operatore), possiamo catturare il valore della condizione dictB.get('hello', None)in una variabile valuein modo da verificare se non lo è None(poiché dict.get('hello', None)restituisce il valore associato o None) e quindi utilizzarlo all'interno del corpo di la condizione:

# dictB = {'hello': 5, 'world': 42}
# dictA = {}
if value := dictB.get('hello', None):
  dictA["hello"] = value
# dictA is now {'hello': 5}

Sebbene l'enfasi della risposta accettata sul principio "guarda prima di saltare" possa applicarsi alla maggior parte delle lingue, il primo approccio potrebbe essere più pitonico, basato sui principi di Python. Per non parlare del fatto che è uno stile di codifica legittimo in Python. La cosa importante è assicurarsi di utilizzare il blocco try tranne nel giusto contesto e seguire le migliori pratiche. Per esempio. fare troppe cose in un blocco try, catturare un'eccezione molto ampia o, peggio, la clausola nuda tranne ecc.

Più facile chiedere perdono che permesso. (EAFP)

Vedi il riferimento alla documentazione di Python qui .

Inoltre, questo blog di Brett, uno degli sviluppatori principali, tocca la maggior parte di questo in breve.

Vedi un'altra discussione SO qui :