Por que o código Python usa a função len () em vez de um método length?

Eu sei que python tem uma len()função que é usada para determinar o tamanho de uma string, mas eu queria saber por que não é um método do objeto string.

Atualizar

Ok, eu percebi que estava embaraçosamente enganado. __len__()é realmente um método de um objeto string. Parece estranho ver código orientado a objetos em Python usando a função len em objetos de string. Além disso, também é estranho ver __len__como o nome em vez de apenas len.

Strings têm um método de comprimento: __len__()

O protocolo no Python é implementar esse método em objetos que possuem um comprimento e usam a len()função interna, que o chama, semelhante à maneira como você implementaria __iter__()e usaria a iter()função interna (ou tenha o método chamado por trás cenas para você) em objetos iteráveis.

Consulte Emulando tipos de contêiner para obter mais informações.

Aqui está uma boa leitura sobre o assunto de protocolos em Python: Python e o princípio da menor surpresa

A resposta de Jim para essa pergunta pode ajudar; Eu copio aqui. Citando Guido van Rossum:

Primeiro, escolhi len (x) em vez de x.len () por razões de HCI (def __len __ () veio muito mais tarde). Na verdade, existem duas razões entrelaçadas, ambas HCI:

(a) Para algumas operações, a notação de prefixo apenas lê melhor que as operações de prefixo - prefixo (e infixo!) têm uma longa tradição em matemática, que gosta de notações em que o visual ajuda o matemático a pensar em um problema. Compare o modo fácil com o qual reescrevemos uma fórmula como x * (a + b) em x a + x b com a falta de jeito de fazer a mesma coisa usando uma notação OO bruta.

(b) Quando leio o código que diz len (x) eu sei que ele está pedindo o tamanho de algo. Isso me diz duas coisas: o resultado é um número inteiro e o argumento é algum tipo de contêiner. Pelo contrário, quando leio x.len (), já tenho que saber que x é algum tipo de contêiner implementando uma interface ou herdando de uma classe que possui um len () padrão. Testemunhe a confusão que ocasionalmente temos quando uma classe que não está implementando um mapeamento tem um método get () ou keys () ou algo que não é um arquivo tem um método write ().

Dizendo a mesma coisa de outra maneira, vejo 'len' como uma operação interna. Eu odiaria perder isso. /… /

Existe um lenmétodo:

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

Python é uma linguagem de programação pragmática, e as razões para len()ser uma função e não um método de str, list, dictetc. são pragmáticos.

A len()função interna lida diretamente com os tipos internos: a implementação do CPython len()na verdade retorna o valor do ob_sizecampo na PyVarObjectestrutura C que representa qualquer objeto interno de tamanho variável na memória. Isso é muito mais rápido do que chamar um método - nenhuma pesquisa de atributo precisa acontecer. Obtendo o número de itens em uma coleção é uma operação comum e deve trabalhar de forma eficiente para tais tipos básicos e diversos como str, list, array.arrayetc.

No entanto, para promover consistência, ao se aplicar len(o)a um tipo definido pelo usuário, o Python chama o.__len__()como fallback. __len__, __abs__e todos os outros métodos especiais documentados no Python Data Model facilitam a criação de objetos que se comportam como os incorporados, habilitando as APIs expressivas e altamente consistentes que chamamos de "Pythonic".

Ao implementar métodos especiais, seus objetos podem oferecer suporte à iteração, sobrecarregar operadores de infixos, gerenciar contextos em withblocos etc.

Uma segunda razão, apoiada em citações de Guido van Rossum como essa , é que é mais fácil ler e escrever do len(s)que s.len().

A notação len(s)é consistente com operadores unários com notação de prefixo, como abs(n). len()é usado com mais frequência abs()e merece ser tão fácil de escrever.

Também pode haver uma razão histórica: na linguagem ABC que precedeu o Python (e foi muito influente em seu design), havia um operador unário escrito como o #sque significava len(s).

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

Há ótimas respostas aqui e, antes de dar as minhas, gostaria de destacar algumas das gemas (sem trocadilhos de rubi) que li aqui.

• O Python não é uma linguagem pura de OOP - é uma linguagem de múltiplos paradigmas de propósito geral que permite ao programador usar o paradigma com o qual se sente mais confortável e / ou o paradigma mais adequado para sua solução.
• Python tem funções de primeira classe, então lené realmente um objeto. Ruby, por outro lado, não possui funções de primeira classe. Portanto, o lenobjeto de função possui seus próprios métodos que você pode inspecionar executando dir(len).

Se você não gosta da maneira como isso funciona em seu próprio código, é trivial reimplementar os contêineres usando seu método preferido (veja o exemplo abaixo).

>>> 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

Você também pode dizer

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

Usando o Python 2.7.3.

Algo está faltando no restante das respostas aqui: a lenfunção verifica se o __len__método retorna um resultado não negativo int. O fato de lenser uma função significa que as classes não podem substituir esse comportamento para evitar a verificação. Como tal, len(obj)fornece um nível de segurança que obj.len()não pode.

Exemplo:

>>> 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

Obviamente, é possível "substituir" a lenfunção reatribuindo-a como uma variável global, mas o código que faz isso é muito mais obviamente suspeito do que o código que substitui um método em uma classe.

Não faz?

>>> "abc".__len__()
3