Python: How to Create List of Lists (with examples)
The python programming language has many features built into it to make writing python code quick and easy. In this Python tutorial we are going to cover different ways to create a lists of lists as well as how to add new items to the contents of a list
Initialize the list directly
The simplest way to create a nested list in python is to just define all the lists then create a new list composeof the previously defined lists. However, if you have a variable number of items it is probably better to look at some of the different methods listed below
listOne = ["one", "two", "three"]
listTwo = ["four", "five", "six"]
listThree = ["seven", "eight", "nine"]
listOfLists = [listOne, listTwo, listThree]
print(listOfLists)
[['one', 'two', 'three'], ['four', 'five', 'six'], ['seven', 'eight', 'nine']]
Using a loop
The above code does work but is limited, especially if the number of elements of the list are not know until runtime.
A more useful way of creating lists within lists is to use a loop. We used the enumerate function on the addresses
list so that we would have the current index numbers for the list elements as we loop over them. Notice the two
different methods we are using to accessing list items. In the addresses list we are getting the address component
from the range output. Furthermore, in order to line up the lists we also use the enumerate function to provide us
with the current list indices in the loop.
addresses = ["123 main", "456 main", "789 main"]
bedrooms = [5, 2, 1]
bathrooms = [3, 2, 1]
houses = []
for i, address in enumerate(addresses):
houses.append([address, bedrooms[i], bathrooms[i]])
print(houses)
[['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
Using zip
In the code below we show how to use the zip function with a python list to quickly produce a list of tuples. Zip is nice because it will take the lists you give it and zip them together until it gets to the last item of the smallest list. If that is not what you want check out the next example where we use list comprehension to do even more list manipulation
addresses = ["123 main", "456 main", "789 main"]
bedrooms = [5, 2, 1]
bathrooms = [3, 2, 1]
houses = list(zip(addresses, bedrooms, bathrooms))
print(houses)
[('123 main', 5, 3), ('456 main', 2, 2), ('789 main', 1, 1)]
Using list comprehension
In the previous example we showed how to create a list of tuples, in the following code we will show how to modify that list of tuples to create a list of lists. List comprehensions in Python are a nice feature of the language and is a more concise way to modify a list. However, you should try not to put too much logic in a list comprehension otherwise it becomes hard to read. This is important because the version of yourself that has to come back in a few months to debug the code will thank you for being more explicit…or future you may let out a sigh of frustration when trying to remember what that list comprehension is doing
addresses = ["123 main", "456 main", "789 main"]
bedrooms = [5, 2, 1]
bathrooms = [3, 2, 1]
houses = list(zip(addresses, bedrooms, bathrooms))
houses = [[i, j, k] for i, j, k in houses]
print(houses)
[['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
Converting to a Numpy multidimensional array
Numpy is a great package in Python and is used a lot by data scientist and machine learning engineers. One of the reasons is because of all the built-in linear algebra functionally that Numpy has packed into it. The linear algebra functions are very helpful as many of the algorithms used in ML and data science require this type of math.
import numpy as np
data1 = [1, 2, 3]
data2 = [5, 2, 1]
data3 = [3, 2, 1]
listOfList = [data1, data2, data3]
numpyArray = np.array(listOfList)
print(numpyArray)
[[1 2 3]
[5 2 1]
[3 2 1]]
Converting from a Numpy array
The toList method in Numpy will convert directly to a python list of lists while keeping the order of the inner lists intact. No need to create a new empty list and load it up with all the individual items. The toList method does all the heavy lifting for you.
import numpy as np
npArray = np.array([
[1, 2, 3],
[5, 2, 1],
[3, 2, 1]])
listOfLists = npArray.tolist()
print(listOfLists)
[[1, 2, 3], [5, 2, 1], [3, 2, 1]]
Converting to a Pandas Data Frame
Pandas Data frames are very powerful and incredibly useful for machine learning and data science tasks. Data frames can take in different types of data and group them all together and perform a tun of different built-in operations to make large data sets easy to work with. To get a better understanding of how data frames work the following example shows how to convert a lists of lists into a data frame
import pandas as pd
houses = [['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1], ['321 park', 5, 3], ['432 park', 2, 2], ['543 park', 1, 1]]
df = pd.DataFrame(houses, columns=["address", "bedrooms", "bathrooms"])
print(df)
address bedrooms bathrooms
0 123 main 5 3
1 456 main 2 2
2 789 main 1 1
3 321 park 5 3
4 432 park 2 2
5 543 park 1 1
Converting from a Pandas Data Frame
Another one of the different approaches is to go from a pandas dataframe directly to a list vai pandas built in tolist() method
import pandas as pd
df = pd.DataFrame([['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]], columns=["address", "bedrooms", "bathrooms"])
housesList = df.values.tolist()
print(housesList)
[['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
Converting to a Dictionary
Another use case to is to convert a multidimensional list into a dictionary. To do this we will need to define a new value for the dict keys to story the different lists values in. In below example we will be using the address as the top dictionary key and the name of each value as the individual element keys
import pandas as pd
houses = [["123 main", 5, 3], ["456 main", 2, 2], ["789 main", 1, 1]]
housesDict = {}
for house in houses:
housesDict[house[0]] = {"address": house[0], "bedrooms": house[1], "bathrooms": house[2]}
print(housesDict)
{'123 main': {'address': '123 main', 'bedrooms': 5, 'bathrooms': 3}, '456 main': {'address': '456 main', 'bedrooms': 2, 'bathrooms': 2}, '789 main': {'address': '789 main', 'bedrooms': 1, 'bathrooms': 1}}
Converting from a Dictionary
Just like when converting a list to a dictionary we needed to add in the keys. The opposite is true when going from a dictionary to a list of lists. We can get just the values of a dictionary by calling the values() method on the dictionary object
housesDict = {'123 main': {'address': '123 main', 'bedrooms': 5, 'bathrooms': 3}, '456 main': {'address': '456 main', 'bedrooms': 2, 'bathrooms': 2}, '789 main': {'address': '789 main', 'bedrooms': 1, 'bathrooms': 1}}
housesList = []
for house in housesDict.values():
housesList.append(list(house.values()))
print(housesList)
[['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
Converting to a Tuples
This can be done pretty compactly using tuple comprehension
housesList = [['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
housesTuple = tuple(tuple(item for item in house) for house in housesList)
print(housesTuple)
(('123 main', 5, 3), ('456 main', 2, 2), ('789 main', 1, 1))
Converting from a Tuples
This too can be done pretty compactly using list comprehension
housesTuple = (('123 main', 5, 3), ('456 main', 2, 2), ('789 main', 1, 1))
housesList = list(list(item for item in house) for house in housesTuple)
print(housesList)
[['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
How to prepend to a List of Lists
Here we are going to add a new object to the first element of the original list
houses = [['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
moreHouses = [['321 park', 5, 3], ['654 park', 2, 2], ['987 park', 1, 1]]
for house in moreHouses:
houses.insert(0, house)
print(houses)
[['987 park', 1, 1], ['654 park', 2, 2], ['321 park', 5, 3], ['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
How to append to a List of Lists
In the below code snippet we are going to add a new element to the end of the list
houses = [['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
anotherHouse = ['900 main', 5, 3]
houses.append(anotherHouse)
print(houses)
[['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1], ['900 main', 5, 3]]
How to insert into the middle of a List of Lists
Here we are adding a new object in the middle of a list by specifying the list index to insert into
houses = [['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
anotherHouse = ['400 main', 5, 3]
houses.insert(1, anotherHouse)
print(houses)
[['123 main', 5, 3], ['400 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
Concatenate two multidimensional list together
houses = [['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
moreHouses = [['321 park', 5, 3], ['654 park', 2, 2], ['987 park', 1, 1]]
for house in moreHouses:
houses.append(house)
print(houses)
[['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1], ['321 park', 5, 3], ['654 park', 2, 2], ['987 park', 1, 1]]
Remove last element
houses = [['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
houses.pop()
print(houses)
[['123 main', 5, 3], ['456 main', 2, 2]]
Remove the first item
houses = [['123 main', 5, 3], ['456 main', 2, 2], ['789 main', 1, 1]]
houses.pop(0)
print(houses)
[['456 main', 2, 2], ['789 main', 1, 1]]
Converting to a flat list
There are several ways to convert a whole list of lists into a flat list. If you are dealing with numbers than the easiest way is to use a Numpy array
import numpy as np
data1 = [1, 2, 3]
data2 = [5, 2, 1]
data3 = [3, 2, 1]
listOfList = [data1, data2, data3]
numpyArray = np.array(listOfList)
flatList = list(numpyArray.flat)
print(flatList)
[1, 2, 3, 5, 2, 1, 3, 2, 1]