Adventures in Machine Learning

Mastering Lists in Python: Creating Accessing and Manipulating Data

Creating and Accessing Lists in Python

Python is one of the most popular programming languages used today. Its simplicity, wide range of libraries, and ease of use make it a favorite among developers.

One of the most fundamental data structures in Python is the list, which is a collection of items stored in a single variable. Lists are versatile and can store a variety of data types such as integers, strings, and even other lists.

In this article, we will discuss how to create and access lists in Python.

Creating a List

Before we start creating a list, it is important to know the general format or the list template that we will use. The template consists of the variable name followed by the equal sign (=) then the opening square bracket ([) to signify the start of the list.

Here’s an example:


list_name = []


To add items to the list, we just need to use the append method and add any value we want. Here’s how we add a number to our variable:




We can also add strings to the list.

Let’s say we wanted to add the words “apple,” “banana,” and “orange.” We would do it like this:






We can also create a list with pre-populated values like this:


list_name = [1, 2, 3, “apple”, “banana”, “orange”]


In this case, we don’t need to add each item one by one as we did before.

Verifying List Creation

We can verify that a list was created by using the type() function. The type() function returns the data type of an object.

Here’s an example where we create a list of integers and then verify that it is indeed a list:


number_list = [1, 2, 3, 4, 5]



This code will output “class ‘list’ “.

Accessing an Item within a List

To access a particular item within a list, we use the index. An index is a number that corresponds to the position of the item in the list.

Python also allows negative indexing, meaning we can count from the end of the list with the last item having an index of -1. Here’s an example where we access the first and last item of a list:


fruit_list = [“apple”, “banana”, “orange”]

first_fruit = fruit_list[0]

last_fruit = fruit_list[-1]




This code will output “apple” and “orange” respectively.

Accessing a Range of Values in a List

We can also access a range of values in a list by using a colon to indicate a start and end index. Here’s an example where we print a range of values within our list:


numbers_list = [1, 2, 3, 4, 5]



This code will output “[2, 3, 4]”.


In conclusion, lists are powerful tools for data storage and manipulation in Python. They are easy to create, and we can add and remove items as we please.

We can also access single or multiple items by using the index or ranges of index values. Practicing using lists will make working with more complex data structures easier in the long run.

Examples of Working with Lists in Python

Now that we understand how to create and access lists in Python, let’s look at some examples of working with them. In this section, we will create two lists, access specific items within those lists, and perform arithmetic operations with them.

We will also provide links to additional resources to help you expand your knowledge on working with lists in Python. Example 1: Creating Two Lists

In this example, we will create two lists, one containing a list of products and the other containing a list of prices.

We will then use these lists to perform arithmetic operations. Here is the code:


# create list of products

products = [“shampoo”, “toothpaste”, “soap”, “conditioner”]

# create list of prices

prices = [3.50, 2.25, 1.75, 5.00]


We have created two lists: `products` and `prices`.

`products` contains a list of products, and `prices` contains the corresponding prices of each product. To access the value of an element in a list, we use the index of that element.

The index of the first element in a list is always 0. So, to access the second element in the `products` list, we would use the index 1:


# access the second element in the products list



This code will output “toothpaste”.

Example 2: Accessing Items in Two Lists

In this example, we will access specific items in two lists and perform arithmetic operations with them. We will multiply each price by 2.25 and store the result in a new list.

Here is the code:


# access items in products and prices lists and multiply

result = []

for i in range(len(products)):

item = products[i] + “: $” + str(prices[i])




This code will output a list in the following format:



“shampoo: $3.5”,

“toothpaste: $2.25”,

“soap: $1.75”,

“conditioner: $5.0”



This example is a bit more complicated than the previous one. First, we create an empty list called `result` where we will store our final data.

We then use a `for` loop to iterate over the `products` and `prices` lists using the `range` function and `len` function to ensure we loop over both lists for the same number of times. Within the loop, we concatenate the name of the product and its corresponding price and store that as `item`.

Then, we append `item` to the `result` list. Finally, we use the `print()` function to output the contents of the `result` list.

Additional Tutorials on Lists in Python

Lists are an essential data structure in Python, and there is always more to learn. If you want to expand your knowledge of lists, there are plenty of online resources to help you.

Here are a few tutorials to get you started:

1. The Python documentation has plenty of information about lists, including how to create and modify them.

2. The Real Python website offers an in-depth tutorial on lists in Python, complete with examples and exercises.

3. The GeeksforGeeks website also offers a comprehensive tutorial on lists in Python.

It includes examples and explanations of various list operations.

By utilizing these resources, you can gain a deeper understanding of lists and what they can do in Python.


Lists are an essential data type in Python that enable developers to store and manipulate collections of variables. In this article, we have reviewed how to create and access lists in Python, as well as some examples of working with them.

We hope that this article has provided you with a solid foundation for working with lists, and that you will continue to build upon it by exploring additional resources and conducting your own experiments. In conclusion, lists are a fundamental concept in Python and a powerful tool for manipulating data.

They enable developers to store and access collections of variables, as well as perform arithmetic operations on them. This article covered the basics of creating and accessing lists, and provided examples of how to work with them.

We also shared additional resources for those looking to expand their knowledge of lists in Python. By utilizing lists, developers can write more efficient and elegant code that is easier to read and maintain.

Whether you’re a beginner or an experienced developer, understanding lists is an essential skill that will serve you well in your Python programming endeavors.

Popular Posts