Python list limit size

To determine how many items a list has, use the len() function:

Print the number of items in the list:

thislist = ["apple", "banana", "cherry"]
print(len(thislist))

Use the len() method to return the length of an array (the number of elements in an array).

Note: The length of an array is always one more than the highest array index.

How to create a python list that can only contain a maximum number of elements

In this tutorial you will learn how to create a stack-like list class that can contain only a certain number of elements, any additional elements pushed to this list that cause it to exceed the limit will result in the elements at the tail of the stack being removed.

Creating our stack-like list object

The built-in list type in python can be used as a stack using the append() and pop() functions, the only additional functionality we would want to add on top is to have a maximum capacity to this list, so the easiest way to go about this would be to simply extend the built-in list class.

In the above code we are overriding the constructor to allow for a max_size argument, and the append method to handle the logic for removing excess elements. We also add a push method for this class to behave more like a stack (even though it acts only as an alias to append)

Using the list and exceeding the maximum number of elements

This object will behave much like a regular python list, simply instantiate it with the maximum number of desired elements, then you can start using it just like a normal list, however in this example we'll use our push() alias method

As you can see, you can append to this list normally until the limit is exceeded at which point the list will start trimming itself from the tail.

The pop() function still works as expected and will remove and return the element from the head of the list.

If your aim is to make this new object behave somewhat like a list, implement it as closely to a real Python list as possible by inheriting its behavior from the built-in list class. Then extend your class to add the behavior you want. Here's a partial implementation:

Output:

Now, why do I say that this is a "partial" implementation? Because there are many ways to add elements to a list. For example, if you add these lines to the end of the above script:

You'll see this output at the end:

Oops. Your work is not done. We've overridden the append method, but not the extend method. And there are others, like __setslice__, __mul__, and so on.

Essentially, to create a complete implementation, you'd have to extend your class to provide implementations for every built-in method of the list class that could conceivably enlarge the length of the list. Do a dir(list) to see all its built-in "magic" methods, and figure out which ones you'd need to extend.

Thanks G-Do for your information, so NumPy eventually replaces Numeric and Numarray. Interesting!

When I was coding in C, I used to sample lab data and put it into a circular or ring buffer to keep the thing from overflowing. This was an easy way to calculate a moving average.

You can do a similar thing in Python using a list and keeping track of the index. When the index reaches the limit you have set, new data starts at index zero again.

A queue makes this simpler, particularly the deque container, because you can add to the end and pop the front. Here is an example, I hope you can see what is happening: