Perché l'uso di Len (SEQUENZA) in valori di condizione considerati errati da Pylint?

Considerando questo frammento di codice:

from os import walk

files = []
for (dirpath, _, filenames) in walk(mydir):
    # more code that modifies files
if len(files) == 0: # <-- C1801
    return None

Sono stato allarmato da Pylint con questo messaggio per quanto riguarda la riga con l'istruzione if:

[pylint] C1801: non utilizzare len(SEQUENCE)come valore di condizione

La regola C1801, a prima vista, non mi sembrava molto ragionevole e la definizione sulla guida di riferimento non spiega perché questo sia un problema. In effetti, lo chiama decisamente un uso errato .

len-as-condition (C1801) : non utilizzare len(SEQUENCE)come valore condizione Utilizzato quando Pylint rileva un uso errato di len (sequenza) all'interno delle condizioni.

Anche i miei tentativi di ricerca non sono riusciti a fornirmi una spiegazione più approfondita. Comprendo che la proprietà della lunghezza di una sequenza può essere valutata pigramente e che __len__può essere programmata per avere effetti collaterali, ma è discutibile se questo da solo sia abbastanza problematico per Pylint da chiamare un tale uso errato. Quindi, prima di configurare semplicemente il mio progetto per ignorare la regola, vorrei sapere se mi manca qualcosa nel mio ragionamento.

Quando l'uso di len(SEQ)come condizione è problematico? Quali sono le principali situazioni che Pylint sta tentando di evitare con C1801?

Quando l'uso di len(SEQ)come condizione è problematico? Quali sono le principali situazioni che Pylint sta tentando di evitare con C1801?

Non è davvero problematico da usare len(SEQUENCE), anche se potrebbe non essere così efficiente (vedi il commento di Chepner ). Indipendentemente da ciò, Pylint verifica la conformità del codice con la guida di stile PEP 8 che lo afferma

Per le sequenze (stringhe, elenchi, tuple), usa il fatto che le sequenze vuote sono false.

Yes: if not seq:
     if seq:

No:  if len(seq):
     if not len(seq):

Come programmatore Python occasionale, che scorre tra le lingue, considererei il len(SEQUENCE)costrutto più leggibile ed esplicito ("Explicit è meglio che implicito"). Tuttavia, l'utilizzo del fatto che una sequenza vuota viene valutata Falsein un contesto booleano è considerato più "pitonico".

Si noti che l'uso di len (seq) è in effetti richiesto (invece di controllare solo il valore bool di seq) quando si usano gli array NumPy.

a = numpy.array(range(10))
if a:
    print "a is not empty"

genera un'eccezione: ValueError: il valore di verità di un array con più di un elemento è ambiguo. Usa a.any () o a.all ()

E quindi per il codice che utilizza sia gli elenchi Python sia gli array NumPy, il messaggio C1801 è poco utile.

Questo era un problema in Pylint e non è più considerato len(x) == 0errato.

Non dovresti usare un nudo len(x) come condizione. Confrontando len(x)contro un valore esplicito, come if len(x) == 0di if len(x) > 0è assolutamente soddisfacente e non vietato dalla PEP 8.

Da PEP 8 :

# Correct:
if not seq:
if seq:

# Wrong:
if len(seq):
if not len(seq):

Si noti che il test esplicito per la lunghezza non è proibito. Lo Zen di Python afferma:

Esplicito è meglio che implicito.

Nella scelta tra if not seqe if not len(seq), entrambi sono impliciti ma il comportamento è diverso. Ma if len(seq) == 0o if len(seq) > 0sono confronti espliciti e in molti contesti il ​​comportamento corretto.

In pylint, PR 2815 ha corretto questo bug, segnalato per la prima volta come numero 2684 . Continuerà a lamentarsi if len(seq), ma non si lamenterà più if len(seq) > 0. Il PR è stato unito il 19-03-2019, quindi se si utilizza il pilastro 2.4 (rilasciato il 14.09.2019) non si dovrebbe vedere questo problema.

Pylint stava fallendo il mio codice e la ricerca mi ha portato a questo post:

../filename.py:49:11: C1801: Do not use `len(SEQUENCE)` to determine if a sequence is empty (len-as-condition)
../filename.py:49:34: C1801: Do not use `len(SEQUENCE)` to determine if a sequence is empty (len-as-condition)

Questo era il mio codice prima:

def list_empty_folders(directory):
"""The Module Has Been Build to list empty Mac Folders."""
for (fullpath, dirnames, filenames) in os.walk(directory):
    if len(dirnames) == 0 and len(filenames) == 0:
        print("Exists: {} : Absolute Path: {}".format(
            os.path.exists(fullpath), os.path.abspath(fullpath)))

Questo è stato dopo la mia correzione del codice. Usando il int() attribute, mi sembra di aver soddisfatto Pep8 / Pylint e non sembra avere un impatto negativo sul mio codice:

def list_empty_folders(directory):
"""The Module Has Been Build to list empty Mac Folders."""
for (fullpath, dirnames, filenames) in os.walk(directory):
    if len(dirnames).__trunc__() == 0 and len(filenames).__trunc__() == 0:
        print("Exists: {} : Absolute Path: {}".format(
            os.path.exists(fullpath), os.path.abspath(fullpath)))

La mia correzione

Aggiungendo .__trunc__()alla sequenza sembra aver risolto il bisogno.

Non vedo differenze nel comportamento, ma se qualcuno conosce i dettagli che mi mancano, per favore fatemelo sapere.