How do I get the number of elements in a list?
Consider the following:
items =  items.append("apple") items.append("orange") items.append("banana") # FAKE METHOD: items.amount() # Should return 3
How do I get the number of elements in the list
len() function can be used with several different types in Python - both built-in types and library types. For example:
>>> len([1,2,3]) 3
Read more... Read less...
How to get the size of a list?
To find the size of a list, use the builtin function,
items =  items.append("apple") items.append("orange") items.append("banana")
Everything in Python is an object, including lists. All objects have a header of some sort in the C implementation.
Lists and other similar builtin objects with a "size" in Python, in particular, have an attribute called
ob_size, where the number of elements in the object is cached. So checking the number of objects in a list is very fast.
But if you're checking if list size is zero or not, don't use
len - instead, put the list in a boolean context - it treated as False if empty, True otherwise.
From the docs
Return the length (the number of items) of an object. The argument may be a sequence (such as a string, bytes, tuple, list, or range) or a collection (such as a dictionary, set, or frozen set).
len is implemented with
__len__, from the data model docs:
Called to implement the built-in function
len(). Should return the length of the object, an integer >= 0. Also, an object that doesn’t define a
__nonzero__()[in Python 2 or
__bool__()in Python 3] method and whose
__len__()method returns zero is considered to be false in a Boolean context.
And we can also see that
__len__ is a method of lists:
Builtin types you can get the
len (length) of
And in fact we see we can get this information for all of the described types:
>>> all(hasattr(cls, '__len__') for cls in (str, bytes, tuple, list, xrange, dict, set, frozenset)) True
Do not use
len to test for an empty or nonempty list
To test for a specific length, of course, simply test for equality:
if len(items) == required_length: ...
But there's a special case for testing for a zero length list or the inverse. In that case, do not test for equality.
Also, do not do:
if len(items): ...
Instead, simply do:
if items: # Then we have some items, not empty! ...
if not items: # Then we have an empty list! ...
I explain why here but in short,
if items or
if not items is both more readable and more performant.
While this may not be useful due to the fact that it'd make a lot more sense as being "out of the box" functionality, a fairly simple hack would be to build a class with a
class slist(list): @property def length(self): return len(self)
You can use it like so:
>>> l = slist(range(10)) >>> l.length 10 >>> print l [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Essentially, it's exactly identical to a list object, with the added benefit of having an OOP-friendly
As always, your mileage may vary.
len you can also use
operator.length_hint (requires Python 3.4+). For a normal
list both are equivalent, but
length_hint makes it possible to get the length of a list-iterator, which could be useful in certain circumstances:
>>> 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
length_hint is by definition only a "hint", so most of the time
len is better.
I've seen several answers suggesting accessing
__len__. This is all right when dealing with built-in classes like
list, but it could lead to problems with custom classes, because
length_hint) implement some safety checks. For example, both do not allow negative lengths or lengths that exceed a certain value (the
sys.maxsize value). So it's always safer to use the
len function instead of the
Answering your question as the examples also given previously:
items =  items.append("apple") items.append("orange") items.append("banana") print items.__len__()
And for completeness (primarily educational), it is possible without using the
len() function. I would not condone this as a good option DO NOT PROGRAM LIKE THIS IN PYTHON, but it serves a purpose for learning algorithms.
def count(list): item_count = 0 for item in list[:]: item_count += 1 return item_count count([1,2,3,4,5])
(The colon in
list[:] is implicit and is therefore also optional.)
The lesson here for new programmers is: You can’t get the number of items in a list without counting them at some point. The question becomes: when is a good time to count them? For example, high-performance code like the connect system call for sockets (written in C)
connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);, does not calculate the length of elements (giving that responsibility to the calling code). Notice that the length of the address is passed along to save the step of counting the length first? Another option: computationally, it might make sense to keep track of the number of items as you add them within the object that you pass. Mind that this takes up more space in memory. See Naftuli Kay‘s answer.
Example of keeping track of the length to improve performance while taking up more space in memory. Note that I never use the len() function because the length is tracked:
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