Perché il codice Python usa la funzione len () invece di un metodo length?

So che Python ha una len()funzione che viene utilizzata per determinare la dimensione di una stringa, ma mi chiedevo perché non fosse un metodo dell'oggetto stringa.

Aggiornare

Ok, mi sono reso conto di essermi sbagliato in modo imbarazzante. __len__()è in realtà un metodo di un oggetto stringa. Sembra strano vedere il codice orientato agli oggetti in Python usando la funzione len sugli oggetti stringa. Inoltre, è anche strano vedere __len__come il nome anziché solo len.

Le stringhe hanno un metodo di lunghezza: __len__()

Il protocollo in Python è quello di implementare questo metodo su oggetti che hanno una lunghezza e usano la len()funzione integrata, che lo chiama per te, in modo simile al modo in cui implementeresti __iter__()e utilizzeresti la iter()funzione integrata (o far chiamare il metodo dietro le scene per te) su oggetti iterabili.

Vedere Emulazione dei tipi di contenitore per ulteriori informazioni.

Ecco una buona lettura sull'argomento dei protocolli in Python: Python e il principio del minimo stupore

La risposta di Jim a questa domanda può essere d'aiuto; Lo copio qui. Citando Guido van Rossum:

Prima di tutto, ho scelto len (x) su x.len () per motivi HCI (def __len __ () è arrivato molto più tardi). Esistono in realtà due motivi intrecciati, entrambi HCI:

(a) Per alcune operazioni, la notazione con prefisso è semplicemente migliore delle operazioni postfisso - prefisso (e infisso!) hanno una lunga tradizione in matematica a cui piacciono le notazioni in cui la grafica aiuta il matematico a pensare a un problema. Confronta la facilità con cui riscriviamo una formula come x * (a + b) in x a + x b alla goffaggine di fare la stessa cosa usando una notazione OO grezza.

(b) Quando leggo il codice che dice len (x) so che sta chiedendo la lunghezza di qualcosa. Questo mi dice due cose: il risultato è un numero intero e l'argomento è una specie di contenitore. Al contrario, quando leggo x.len (), devo già sapere che x è un tipo di contenitore che implementa un'interfaccia o eredita da una classe che ha un standard len (). Testimone della confusione che occasionalmente abbiamo quando una classe che non implementa una mappatura ha un metodo get () o keys () o qualcosa che non è un file ha un metodo write ().

Dicendo la stessa cosa in un altro modo, vedo 'len' come un'operazione integrata. Odierei perderlo. / ... /

C'è un lenmetodo:

>>> a = 'a string of some length'
>>> a.__len__()
23
>>> a.__len__
<method-wrapper '__len__' of str object at 0x02005650>

Python è un linguaggio di programmazione pragmatico, e le ragioni per len()essere una funzione e non un metodo di str, list, dictecc, sono pragmatici.

La len()funzione integrata si occupa direttamente dei tipi integrati: l'implementazione di CPython len()restituisce effettivamente il valore del ob_sizecampo nella PyVarObjectstruttura C che rappresenta qualsiasi oggetto incorporato di dimensioni variabili in memoria. Questo è molto più veloce rispetto alla chiamata di un metodo: non deve avvenire la ricerca degli attributi. Ottenere il numero di elementi in una collezione è un'operazione comune e deve lavorare in modo efficiente per tali tipi di base e diversi come str, list, array.arrayetc.

Tuttavia, per promuovere la coerenza, quando si applica len(o)a un tipo definito dall'utente, Python chiama o.__len__()come fallback. __len__, __abs__E tutti gli altri metodi speciali documentati nel modello di dati Python rendono facile per creare oggetti che si comportano come i built-in, permettendo le API espressivi e altamente coerenti noi chiamiamo "Pythonic".

Implementando metodi speciali i tuoi oggetti possono supportare l'iterazione, sovraccaricare gli operatori infix, gestire i contesti in withblocchi ecc. Puoi pensare al Modello Dati come un modo di usare il linguaggio Python stesso come un framework in cui gli oggetti che crei possono essere integrati senza problemi.

Un secondo motivo, supportato da citazioni di Guido van Rossum come questo , è che è più facile da leggere e scrivere len(s)che s.len().

La notazione len(s)è coerente con operatori unari con notazione prefisso, come abs(n). len()è usato molto più spesso di abs()e merita di essere facile da scrivere.

Ci può anche essere una ragione storica: nel linguaggio ABC che ha preceduto Python (ed era molto influente nel suo design), ci fu un operatore unario scritto come #sche significava len(s).

met% python -c 'import this' | grep 'only one'
There should be one-- and preferably only one --obvious way to do it.

Ci sono alcune risposte fantastiche qui, e quindi prima di dare la mia vorrei evidenziare alcune delle gemme (nessun gioco di rubini previsto) che ho letto qui.

• Python non è un linguaggio OOP puro: è un linguaggio multi-paradigma per scopi generali che consente al programmatore di utilizzare il paradigma con cui si trova più a suo agio e / o il paradigma più adatto alla propria soluzione.
• Python ha funzioni di prima classe, quindi in lenrealtà è un oggetto. Ruby, d'altra parte, non ha funzioni di prima classe. Quindi l' lenoggetto funzione ha i propri metodi che è possibile controllare eseguendo dir(len).

Se non ti piace il modo in cui funziona nel tuo codice, è banale implementare nuovamente i contenitori usando il tuo metodo preferito (vedi esempio sotto).

>>> class List(list):
...     def len(self):
...         return len(self)
...
>>> class Dict(dict):
...     def len(self):
...         return len(self)
...
>>> class Tuple(tuple):
...     def len(self):
...         return len(self)
...
>>> class Set(set):
...     def len(self):
...         return len(self)
...
>>> my_list = List([1,2,3,4,5,6,7,8,9,'A','B','C','D','E','F'])
>>> my_dict = Dict({'key': 'value', 'site': 'stackoverflow'})
>>> my_set = Set({1,2,3,4,5,6,7,8,9,'A','B','C','D','E','F'})
>>> my_tuple = Tuple((1,2,3,4,5,6,7,8,9,'A','B','C','D','E','F'))
>>> my_containers = Tuple((my_list, my_dict, my_set, my_tuple))
>>>
>>> for container in my_containers:
...     print container.len()
...
15
2
15
15

Puoi anche dire

>> x = 'test'
>> len(x)
4

Utilizzo di Python 2.7.3.

Qualcosa che manca dal resto delle risposte qui: la lenfunzione verifica che il __len__metodo restituisca un valore non negativo int. Il fatto che lensia una funzione significa che le classi non possono ignorare questo comportamento per evitare il controllo. Come tale, len(obj)offre un livello di sicurezza che obj.len()non può.

Esempio:

>>> class A:
...     def __len__(self):
...         return 'foo'
...
>>> len(A())
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    len(A())
TypeError: 'str' object cannot be interpreted as an integer
>>> class B:
...     def __len__(self):
...         return -1
... 
>>> len(B())
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    len(B())
ValueError: __len__() should return >= 0

Naturalmente, è possibile "sovrascrivere" la lenfunzione riassegnandola come variabile globale, ma il codice che lo fa è molto più evidentemente sospetto del codice che sovrascrive un metodo in una classe.

No?

>>> "abc".__len__()
3