En términos de cómo funciona len(), esto es su implementación en C:

static PyObject *
builtin_len(PyObject *module, PyObject *obj)
/*[clinic end generated code: output=fa7a270d314dfb6c input=bc55598da9e9c9b5]*/
{
    Py_ssize_t res;

    res = PyObject_Size(obj);
    if (res < 0) {
        assert(PyErr_Occurred());
        return NULL;
    }
    return PyLong_FromSsize_t(res);
}

Py_ssize_t es la longitud máxima que puede tener el objeto. PyObject_Size() es una función que devuelve el tamaño de un objeto. Si no puede determinar el tamaño de un objeto, devuelve -1. En ese caso, este bloque de código se ejecutará:

if (res < 0) {
        assert(PyErr_Occurred());
        return NULL;
    }

Y como resultado se plantea una excepción. De lo contrario, este bloque de código se ejecutará:

return PyLong_FromSsize_t(res);

res, que es un entero C, se convierte en una pitón long y se devuelve. Todos los enteros de Python se almacenan como longs desde Python 3.

Y para completar (principalmente educativo), es posible sin usar la función len(). No aprobaría esto como una buena opción NO PROGRAMAR ASÍ EN PYTHON , pero sirve para aprender algoritmos.

def count(list):
    item_count = 0
    for item in list[:]:
        item_count += 1
    return item_count

count([1,2,3,4,5])

(Los dos puntos en list[:] son implícitos y, por lo tanto, también son opcionales).

La lección aquí para los nuevos programadores es: no se puede obtener el número de elementos en una lista sin contarlos en algún momento. La pregunta es: ¿cuándo es un buen momento para contarlos? Por ejemplo, el código de alto rendimiento, como la llamada al sistema de conexión para enchufes (escrito en C) connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);, no calcula la longitud de los elementos (dando esa responsabilidad al código de llamada). ¿Observe que se pasa la longitud de la dirección para guardar el paso de contar primero la longitud? Otra opción: computacionalmente, podría tener sentido hacer un seguimiento de la cantidad de elementos a medida que los agrega dentro del objeto que pasa. Tenga en cuenta que esto ocupa más espacio en la memoria. Consulte la respuesta de Naftuli Kay .

class MyList(object):
    def __init__(self):
        self._data = []
        self.length = 0 # length tracker that takes up memory but makes length op O(1) time


        # the implicit iterator in a list class
    def __iter__(self):
        for elem in self._data:
            yield elem

    def add(self, elem):
        self._data.append(elem)
        self.length += 1

    def remove(self, elem):
        self._data.remove(elem)
        self.length -= 1

mylist = MyList()
mylist.add(1)
mylist.add(2)
mylist.add(3)
print(mylist.length) # 3
mylist.remove(3)
print(mylist.length) # 2

Además de len también puede usar operator.length_hint (requiere Python 3.4+). Para un list normal, ambos son equivalentes, pero length_hint hace posible obtener la longitud de un iterador de lista, que podría ser útil en ciertas circunstancias:

>>> from operator import length_hint
>>> l = ["apple", "orange", "banana"]
>>> len(l)
3
>>> length_hint(l)
3

>>> list_iterator = iter(l)
>>> len(list_iterator)
TypeError: object of type 'list_iterator' has no len()
>>> length_hint(list_iterator)
3

Pero length_hint es, por definición, solo una "pista", por lo que la mayoría de las veces len es mejor.

He visto varias respuestas que sugieren acceder a __len__. Esto está bien cuando se trata de clases integradas como list, pero podría generar problemas con las clases personalizadas, porque len (y length_hint) implementan algunas comprobaciones de seguridad. Por ejemplo, ambos no permiten longitudes negativas o longitudes que excedan un cierto valor (el valor sys.maxsize). ¡Así que siempre es más seguro usar la función len en lugar del método __len__!

Si bien esto puede no ser útil debido al hecho de que tendría mucho más sentido como una funcionalidad "lista para usar", un truco bastante simple sería construir una clase con una propiedad length:

class slist(list):
    @property
    def length(self):
        return len(self)

Puedes usarlo así:

>>> l = slist(range(10))
>>> l.length
10
>>> print l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Esencialmente, es exactamente idéntico a un objeto de lista, con el beneficio adicional de tener una propiedad length compatible con OOP.

Como siempre, su kilometraje puede variar.

¿Cómo obtener el tamaño de una lista?

Para encontrar el tamaño de una lista, use la función integrada, len:

items = []
items.append("apple")
items.append("orange")
items.append("banana")

Y ahora:

len(items)

Devuelve 3.

Explicación

Todo en Python es un objeto, incluidas las listas. Todos los objetos tienen un encabezado de algún tipo en la implementación de C.

Las listas y otros objetos incorporados similares con un "tamaño" en Python, en particular, tienen un atributo llamado ob_size, donde se almacena en caché el número de elementos en el objeto. Por lo tanto, verificar el número de objetos en una lista es muy rápido.

Pero si está comprobando si el tamaño de la lista es cero o no, no use len; en su lugar, coloque la lista en un contexto booleano: se trata como Falso si está vacío, Verdadero de lo contrario.

De los documentos

len(s)

Devuelve la longitud (el número de elementos) de un objeto. El argumento puede ser una secuencia (como una cadena, bytes, tupla, lista o rango) o una colección (como un diccionario, conjunto o conjunto congelado).

len se implementa con __len__, del modelo de datos documentos:

object.__len__(self)

Llamado para implementar la función incorporada len(). Debe devolver la longitud del objeto, un número entero> = 0. Además, un objeto que no definir un método __nonzero__() [en Python 2 o __bool__() en Python 3] y cuyo método __len__() devuelva cero se considera falso en un contexto booleano.

Y también podemos ver que __len__ es un método de listas:

items.__len__()

Devuelve 3.

Tipos incorporados puede obtener el len (longitud) de

Y, de hecho, vemos que podemos obtener esta información para todos los tipos descritos:

>>> all(hasattr(cls, '__len__') for cls in (str, bytes, tuple, list, 
                                            xrange, dict, set, frozenset))
True

No use len para probar una lista vacía o no vacía

Para probar una longitud específica, por supuesto, simplemente pruebe la igualdad:

if len(items) == required_length:
    ...

Pero hay un caso especial para probar una lista de longitud cero o la inversa. En ese caso, no pruebe la igualdad.

Además, no hagas:

if len(items): 
    ...

En cambio, simplemente haz:

if items:     # Then we have some items, not empty!
    ...

O

if not items: # Then we have an empty list!
    ...

explica por qué aquí pero en En resumen, if items o if not items es más legible y más eficiente.