Why does Python code use len() function instead of a length method?

Posted on

Question :

Why does Python code use len() function instead of a length method?

I know that python has a len() function that is used to determine the size of a string, but I was wondering why it’s not a method of the string object.


Ok, I realized I was embarrassingly mistaken. __len__() is actually a method of a string object. It just seems weird to see object oriented code in Python using the len function on string objects. Furthermore, it’s also weird to see __len__ as the name instead of just len.

Answer #1:

Strings do have a length method: __len__()

The protocol in Python is to implement this method on objects which have a length and use the built-in len() function, which calls it for you, similar to the way you would implement __iter__() and use the built-in iter() function (or have the method called behind the scenes for you) on objects which are iterable.

See Emulating container types for more information.

Here’s a good read on the subject of protocols in Python: Python and the Principle of Least Astonishment

Answered By: Jonny Buchanan

Answer #2:

Jim’s answer to this question may help; I copy it here. Quoting Guido van Rossum:

First of all, I chose len(x) over x.len() for HCI reasons (def __len__() came much later). There are two intertwined reasons actually, both HCI:

(a) For some operations, prefix notation just reads better than postfix — prefix (and infix!) operations have a long tradition in mathematics which likes notations where the visuals help the mathematician thinking about a problem. Compare the easy with which we rewrite a formula like x*(a+b) into xa + xb to the clumsiness of doing the same thing using a raw OO notation.

(b) When I read code that says len(x) I know that it is asking for the length of something. This tells me two things: the result is an integer, and the argument is some kind of container. To the contrary, when I read x.len(), I have to already know that x is some kind of container implementing an interface or inheriting from a class that has a standard len(). Witness the confusion we occasionally have when a class that is not implementing a mapping has a get() or keys() method, or something that isn’t a file has a write() method.

Saying the same thing in another way, I see ‘len‘ as a built-in operation. I’d hate to lose that. /…/

Answer #3:

There is a len method:

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

Answer #4:

Python is a pragmatic programming language, and the reasons for len() being a function and not a method of str, list, dict etc. are pragmatic.

The len() built-in function deals directly with built-in types: the CPython implementation of len() actually returns the value of the ob_size field in the PyVarObject C struct that represents any variable-sized built-in object in memory. This is much faster than calling a method — no attribute lookup needs to happen. Getting the number of items in a collection is a common operation and must work efficiently for such basic and diverse types as str, list, array.array etc.

However, to promote consistency, when applying len(o) to a user-defined type, Python calls o.__len__() as a fallback. __len__, __abs__ and all the other special methods documented in the Python Data Model make it easy to create objects that behave like the built-ins, enabling the expressive and highly consistent APIs we call “Pythonic”.

By implementing special methods your objects can support iteration, overload infix operators, manage contexts in with blocks etc. You can think of the Data Model as a way of using the Python language itself as a framework where the objects you create can be integrated seamlessly.

A second reason, supported by quotes from Guido van Rossum like this one, is that it is easier to read and write len(s) than s.len().

The notation len(s) is consistent with unary operators with prefix notation, like abs(n). len() is used way more often than abs(), and it deserves to be as easy to write.

There may also be a historical reason: in the ABC language which preceded Python (and was very influential in its design), there was a unary operator written as #s which meant len(s).

Answered By: Luciano Ramalho

Answer #5:

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

Answer #6:

There are some great answers here, and so before I give my own I’d like to highlight a few of the gems (no ruby pun intended) I’ve read here.

  • Python is not a pure OOP language — it’s a general purpose, multi-paradigm language that allows the programmer to use the paradigm they are most comfortable with and/or the paradigm that is best suited for their solution.
  • Python has first-class functions, so len is actually an object. Ruby, on the other hand, doesn’t have first class functions. So the len function object has it’s own methods that you can inspect by running dir(len).

If you don’t like the way this works in your own code, it’s trivial for you to re-implement the containers using your preferred method (see example below).

>>> 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()
Answered By: Charles Addis

Answer #7:

Something missing from the rest of the answers here: the len function checks that the __len__ method returns a non-negative int. The fact that len is a function means that classes cannot override this behaviour to avoid the check. As such, len(obj) gives a level of safety that obj.len() cannot.


>>> class A:
...     def __len__(self):
...         return 'foo'
>>> len(A())
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
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>
ValueError: __len__() should return >= 0

Of course, it is possible to “override” the len function by reassigning it as a global variable, but code which does this is much more obviously suspicious than code which overrides a method in a class.

Answered By: kaya3

Answer #8:

You can also say

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

Using Python 2.7.3.

Answered By: SpanosAngelos

Leave a Reply

Your email address will not be published. Required fields are marked *