Usinglen() With Built-in Sequences

Asequence is a container with ordered items.Lists, tuples, andstrings are three of the basic built-in sequences in Python. You can find the length of a sequence by callinglen():

>>>greeting="Good Day!">>>len(greeting)9>>>office_days=["Tuesday","Thursday","Friday"]>>>len(office_days)3>>>london_coordinates=(51.50722,-0.1275)>>>len(london_coordinates)2

When finding the length of the stringgreeting, the listoffice_days, and the tuplelondon_coordinates, you uselen() in the same manner. All three data types are valid arguments forlen().

The functionlen() always returns an integer as it’s counting the number of items in the object that you pass to it. The function returns0 if the argument is an empty sequence:

>>>len("")0>>>len([])0>>>len(())0

In the examples above, you find the length of an empty string, an empty list, and an empty tuple. The function returns0 in each case.

Arange object is also a sequence that you can create usingrange(). Arange object doesn’t store all the values but generates them when they’re needed. However, you can still find the length of arange object usinglen():

>>>len(range(1,20,2))10

This range of numbers includes the integers from1 to19 with increments of2. The length of arange object can be determined from the start, stop, and step values.

In this section, you’ve used thelen() Python function with strings, lists, tuples, andrange objects. However, you can also use the function with any other built-in sequence.

Usinglen() With Built-in Collections

At some point, you may need to find the number of unique items in a list or another sequence. You can usesets andlen() to achieve this:

>>>importrandom>>>numbers=[random.randint(1,20)for_inrange(20)]>>>numbers[3, 8, 19, 1, 17, 14, 6, 19, 14, 7, 6, 1, 17, 10, 8, 14, 17, 10, 2, 5]>>>unique_numbers=set(numbers)>>>unique_numbers{1, 2, 3, 5, 6, 7, 8, 10, 14, 17, 19}>>>len(unique_numbers)11

You generate the listnumbers using alist comprehension, and it contains twenty random numbers ranging between1 and20. The output will be different each time the code runs since you’re generating random numbers. In this particular run, there are eleven unique numbers in the list of twenty randomly generated numbers.

Another built-in data type that you’ll use often is thedictionary. In a dictionary, each item consists of a key-value pair. When you use a dictionary as an argument forlen(), the function returns the number of items in the dictionary:

>>>len({"James":10,"Mary":12,"Robert":11})3>>>len({})0

The output from the first example shows that there are three key-value pairs in this dictionary. As was the case with sequences,len() will return0 when the argument is either an empty dictionary or an empty set. This leads to empty dictionaries and empty sets being falsy.

Exploringlen() With Other Built-in Data Types

You can’t use all built-in data types as arguments forlen(). For data types that don’t store more than one item within them, the concept of length isn’t relevant. This is the case with numbers and Boolean types:

>>>len(5)Traceback (most recent call last):...TypeError:object of type 'int' has no len()>>>len(5.5)Traceback (most recent call last):...TypeError:object of type 'float' has no len()>>>len(True)Traceback (most recent call last):...TypeError:object of type 'bool' has no len()>>>len(5+2j)Traceback (most recent call last):...TypeError:object of type 'complex' has no len()

Theinteger, float,Boolean, andcomplex types are examples of built-in data types that you can’t use withlen(). The function raises aTypeError when the argument is an object of a data type that doesn’t have a length.

You can also explore whether it’s possible to use iterators and generators as arguments forlen():

>>>importrandom>>>numbers=[random.randint(1,20)for_inrange(20)]>>>len(numbers)20>>>numbers_iterator=iter(numbers)>>>len(numbers_iterator)Traceback (most recent call last):...TypeError:object of type 'list_iterator' has no len()>>>numbers_generator=(random.randint(1,20)for_inrange(20))>>>len(numbers_generator)Traceback (most recent call last):...TypeError:object of type 'generator' has no len()

You’ve already seen that a list has a length, meaning you can use it as an argument inlen(). You create an iterator from the list using the built-in functioniter(). In an iterator, each item is fetched whenever it’s required, such as when the functionnext() is used or in a loop. However, you can’t use an iterator inlen().

You get aTypeError when you try to use an iterator as an argument forlen(). As the iterator fetches each item as and when it’s needed, the only way to measure its length is to exhaust the iterator. An iterator can also be infinite, such as the iterator returned byitertools.cycle(), and therefore its length can’t be defined.

You can’t usegenerators withlen() for the same reason. The length of these objects can’t be measured without using them up.

Verifying the Length of a User Input

A common use case oflen() is to verify the length of a sequence input by a user:

username=input("Choose a username: [4-10 characters] ")if4<=len(username)<=10:print(f"Thank you. The username{username} is valid")else:print("The username must be between 4 and 10 characters long")

In this example, you use anif statement to check if the integer returned bylen() is greater than or equal to4 and less than or equal to10. You can run this script and you’ll get an output similar to the one below:

$pythonusername.pyChoose a username: [4-10 characters] stephen_gThank you. The username stephen_g is valid

The username is nine characters long in this case, so the condition in theif statement evaluates toTrue. You can run the script again and input an invalid username:

$pythonusername.pyChoose a username: [4-10 characters] sgThe username must be between 4 and 10 characters long

In this case,len(username) returns2, and the condition in theif statement evaluates toFalse.

Ending a Loop Based on the Length of an Object

You’ll uselen() if you need to check when the length of a mutable sequence, such as a list, reaches a specific number. In the following example, you ask the user to enter three username options, which you store in a list:

usernames=[]print("Enter three options for your username")whilelen(usernames)<3:username=input("Choose a username: [4-10 characters] ")if4<=len(username)<=10:print(f"Thank you. The username{username} is valid")usernames.append(username)else:print("The username must be between 4 and 10 characters long")print(usernames)

You’re now using the result fromlen() in thewhile statement. If the user enters an invalid username, you don’t keep the input. When the user enters a valid string, you append it to the listusernames. The loop repeats until there are three items in the list.

You could even uselen() to check when a sequence is empty:

>>>colors=["red","green","blue","yellow","pink"]>>>whilelen(colors)>0:...print(f"The next color is{colors.pop(0)}")...The next color is redThe next color is greenThe next color is blueThe next color is yellowThe next color is pink

You use the list method.pop() to remove the first item from the list in each iteration until the list is empty. If you’re using this method on large lists, you should remove items from the end of the list as this is more efficient. You can also use thedeque data type from thecollections built-in module, which allows you to pop from the left efficiently.

There’s a more Pythonic way of achieving the same output by using thetruthiness of sequences:

>>>colors=["red","green","blue","yellow","pink"]>>>whilecolors:...print(f"The next color is{colors.pop(0)}")...The next color is redThe next color is greenThe next color is blueThe next color is yellowThe next color is pink

An empty list is falsy. This means that thewhile statement interprets an empty list asFalse. A non-empty list is truthy, and thewhile statement treats it asTrue. The value returned bylen() determines the truthiness of a sequence. A sequence is truthy whenlen() returns any non-zero integer and falsy whenlen() returns0.

Finding the Index of the Last Item of a Sequence

Imagine you want to generate a sequence of random numbers in the range1 to10 and you’d like to keep adding numbers to the sequence until the sum of all the numbers exceeds21. The following code creates an empty list and uses awhile loop to populate the list:

>>>importrandom>>>numbers=[]>>>whilesum(numbers)<=21:...numbers.append(random.randint(1,10))...>>>numbers[3, 10, 4, 7]>>>numbers[len(numbers)-1]7>>>numbers[-1]# A more Pythonic way to retrieve the last item7>>>numbers.pop(len(numbers)-1)# You can use numbers.pop(-1) or numbers.pop()7>>>numbers[3, 10, 4]

You append random numbers to the list until the sum exceeds21. The output you’ll get will vary as you’re generating random numbers. To display the last number in the list, you uselen(numbers) and subtract1 from it since the first index of the list is0. Indexing in Python allows you to use the index-1 to obtain the last item in a list. Therefore, although you can uselen() in this case, you don’t need to.

You want to remove the last number in the list so that the sum of all numbers in the list doesn’t exceed21. You uselen() again to work out the index of the last item in the list, which you use as an argument for the list method.pop(). Even in this instance, you could use-1 as an argument for.pop() to remove the last item from the list and return it. As a final option, you could leave out the argument altogether as the default is to pop the last element.

Splitting a List Into Two Halves

If you need to split a sequence into two halves, you’ll need to use the index that represents the midpoint of the sequence. You can uselen() to find this value. In the following example, you’ll create a list of random numbers and then split it into two smaller lists:

>>>importrandom>>>numbers=[random.randint(1,10)for_inrange(10)]>>>numbers[9, 1, 1, 2, 8, 10, 8, 6, 8, 5]>>>first_half=numbers[:len(numbers)//2]>>>second_half=numbers[len(numbers)//2:]>>>first_half[9, 1, 1, 2, 8]>>>second_half[10, 8, 6, 8, 5]

In the assignment statement where you definefirst_half, you use the slice that represents the items from the beginning ofnumbers up to the midpoint. You can work out what the slice represents by breaking down the steps you use in the slice expression:

1. First,len(numbers) returns the integer10.
2. Next,10 // 2 returns the integer5 as you use theinteger division operator.
3. Finally,0:5 is a slice that represents the first five items, which have indices0,1,2,3, and4. Note that the endpoint is excluded.

In the next assignment, where you definesecond_half, you use the same expression in the slice. However, in this case, the integer5 represents the start of the range. The slice is now5: to represent the items from index5 up to the end of the list.

If your original list contains an odd number of items, then half of its length will no longer be a whole number. When you use integer division, you obtain thefloor of the number. The listfirst_half will now contain one less item thansecond_half.

You can try this out by creating an initial list of eleven numbers instead of ten. The resulting lists will no longer be halves, but they’ll represent the closest alternative to splitting an odd sequence.

NumPy’sndarray

TheNumPy module is the cornerstone of all quantitative applications of programming in Python. The module introduces thenumpy.ndarray data type. This data type, along with functions within NumPy, is ideally suited for numerical computations and is the building block for data types in other modules.

Before you can start using NumPy, you’ll need to install the library. You can use Python’s standard package manager,pip, and run the following command in the console:

$python-mpipinstallnumpy

You’ve installed NumPy, and now you can create a NumPy array from a list and uselen() on the array:

>>>importnumpyasnp>>>numbers=np.array([4,7,9,23,10,6])>>>type(numbers)<class 'numpy.ndarray'>>>>len(numbers)6

The NumPy functionnp.array() creates an object of typenumpy.ndarray from the list you pass as an argument.

However, NumPy arrays can have more than one dimension. You can create a two-dimensional array by converting a list of lists into an array:

>>>importnumpyasnp>>>numbers=[    [11, 1, 10, 10, 15],    [14, 9, 16, 4, 4],    [28, 1, 19, 7, 7],]>>>numbers_array=np.array(numbers)>>>numbers_arrayarray([[11,  1, 10, 10, 15],       [14,  9, 16,  4,  4],       [28,  1, 19,  7,  7])>>>len(numbers_array)3>>>numbers_array.shape(3, 5)>>>len(numbers_array.shape)2>>>numbers_array.ndim2

The listnumbers consists of three lists, each containing five integers. When you use this list of lists to create a NumPy array, the result is an array with three rows and five columns. The function returns the number of rows in the array when you pass this two-dimensional array as an argument inlen().

To get the size of both dimensions, you use the property.shape, which is a tuple showing the number of rows and columns. You obtain the number of dimensions of a NumPy array either by using.shape andlen() or by using the property.ndim.

In general, when you have an array with any number of dimensions,len() returns the size of the first dimension:

>>>importnumpyasnp>>>array_3d=np.random.randint(1,20,[2,3,4])>>>array_3darray([[[14,  9, 15, 14],        [17, 11, 10,  5],        [18,  1,  3, 12]],       [[ 1,  5,  6, 10],        [ 6,  3,  1, 12],        [ 1,  4,  4, 17]]])>>>array_3d.shape(2, 3, 4)>>>len(array_3d)2

In this example, you create a three-dimensional array with the shape(2, 3, 4) where each element is a random integer between1 and20. You use the functionnp.random.randint() to create an array this time. The functionlen() returns2, which is the size of the first dimension.

Check outNumPy Tutorial: Your First Steps Into Data Science in Python to learn more about using NumPy arrays.

Pandas’DataFrame

TheDataFrame type in thepandas library is another data type that is used extensively in many applications.

Before you can use pandas, you’ll need to install it by using the following command in the console:

$python-mpipinstallpandas

You’ve installed the pandas package, and now you can create a DataFrame from a dictionary:

>>>importpandasaspd>>>marks={    "Robert": [60, 75, 90],    "Mary": [78, 55, 87],    "Kate": [47, 96, 85],    "John": [68, 88, 69],}>>>marks_df=pd.DataFrame(marks,index=["Physics","Math","English"])>>>marks_df         Robert  Mary  Kate  JohnPhysics      60    78    47    68Math         75    55    96    88English      90    87    85    69>>>len(marks_df)3>>>marks_df.shape(3, 4)

The dictionary’s keys are strings representing the names of students in a class. The value of each key is a list with the marks for three subjects. When you create a DataFrame from this dictionary, you define the index using a list containing the subject names.

The DataFrame has three rows and four columns. The functionlen() returns the number of rows in the DataFrame. TheDataFrame type also has a.shape property, which you can use to show that the first dimension of a DataFrame represents the number of rows.

You’ve seen howlen() works with a number of built-in data types and also with some data types from third-party modules. In the following section, you’ll learn how to define any class so that it’s usable as an argument for thelen() Python function.

You can explore the pandas module further inThe Pandas DataFrame: Make Working With Data Delightful.