nested list in python assignment expert

• How it works
• Homework answers

Answer to Question #256682 in Python for Raju

Accessing Nested Lists

Write a program to create a list with the values at the given Indexes.

Sample Input 1

Sample Output 1

['hockey','grapes','banana']

SOLUTION CODE FOR THE ABOVE QUESTION

SAMPLE PROGRAM OUTPUT

Need a fast expert's response?

and get a quick answer at the best price

for any assignment or question with DETAILED EXPLANATIONS !

Leave a comment

Ask your question, related questions.

• 1. Nested List IndexingWrite a program to print the index of the given number N in the list of tuples.S
• 2. List of Lists to List of TuplesWrite a program to convert the list of lists to a list of tuples.Samp
• 3. Remove N in all TuplesWrite a program to remove the given number N in all the tuples if it present.S
• 4. List of Unique TuplesWrite a program to print the lists which contain the unique elements in the giv
• 5. Character FrequencyWrite a program to compute the frequency of characters other than space.Sample In
• 6. First Perfect Square Given two integers (M and N), write a program to print the first perfect square
• 7. Add two polynomials Given two polynomials A and B, write a program that adds the given two polynomia
• Programming
• Engineering

Who Can Help Me with My Assignment

There are three certainties in this world: Death, Taxes and Homework Assignments. No matter where you study, and no matter…

How to Finish Assignments When You Can’t

Crunch time is coming, deadlines need to be met, essays need to be submitted, and tests should be studied for.…

How to Effectively Study for a Math Test

Numbers and figures are an essential part of our world, necessary for almost everything we do every day. As important…

CodeFatherTech

Learn to Code. Shape Your Future

Nested List in Python: Here is What You Have to Know

Do you want to use a nested list in Python but don’t know where to start? This tutorial will show you how to start using nested lists.

Python, a versatile and beginner-friendly programming language, offers a wide range of data structures to help you organize and manipulate data in your programs effectively and nested lists are one of those.

One very handy type of data structure in Python is the nested list, a concept that can initially seem complex but is incredibly useful once you understand it. In simple words, a nested list is a list that contains other lists. This is also called a list of lists.

In this article, we will take a deep dive into nested lists, exploring what they are, why they are useful, how to work with them, and how they differ from regular lists in Python.

What Is a Nested List in Python?

A nested list is simply a list that contains other lists as its elements. Think of it as one or more lists within a list. This structure allows you to create multi-dimensional data structures, making it easier to represent complex data hierarchies.

Each inner list can contain different types of data, such as integers, strings, or even other lists, providing great flexibility.

To create a nested list in Python, you enclose one or more lists within square brackets, like this:

This code defines a variable named nested_list , which is a Python list containing three inner lists. Each inner list in this example, holds different types of data, such as numbers, letters, and boolean values.

Here’s a breakdown of the structure:

• The first inner list [8, 9, 10] contains three integers: 8, 9, and 10.
• The second inner list [‘x’, ‘y’, ‘z’] contains three strings: ‘x’, ‘y’, and ‘z’.
• The third inner list [True, False] contains two boolean values : True and False.

This is an example of a Python nested list. It is made of one or more lists inside a list.

Why Use Nested Lists in Python?

Now that we know what nested lists are, let’s explore why they are important for your Python programs.

Nested lists are particularly useful for organizing data that has a hierarchical or structured nature.

Here are some common use cases:

• Matrices and Grids: When working with mathematical matrices or representing grids, you can use nested lists to store the data row-wise or column-wise.
• Data Tables: In data analysis and manipulation, you might encounter datasets with rows and columns. Nested lists allow you to represent this type of data efficiently.
• Tree Structures: If you need to work with hierarchical data like organizational charts or family trees, nested lists can be a natural choice.
• Complex Data Structures: Sometimes, you will have data with multiple levels of complexity, such as a list of students in different classes, where each class contains a list of students.

How Do You Get Values From a Python Nested List?

Accessing elements of a nested list in Python requires a combination of square brackets to navigate through the layers of the list.

Let’s break down the process step by step.

Suppose you have the following nested list:

To access an element, you start by specifying the index of the outer list:

Now, you have isolated the first inner list [8, 9, 10]. To access an element within this inner list, use another set of square brackets:

In this example, the variable element will contain the value 9.

You can also access elements directly by chaining the square brackets:

Remember that Python uses zero-based indexing , so the first element of a list is at index 0, the second at index 1, and so on.

How Do You Store Elements in a Nested List in Python?

To store elements in a nested list, you can use assignment statements. To add an element to an existing inner list, simply reference it using its index and assign a new value:

After this operation, nested_list will become:

You can also add new inner lists to the nested list by using the append method:

This appends the new_inner_list at the end of nested_list . And the result is:

Learn more about the list append() method in the CodeFatherTech tutorial about adding items to a list in Python .

How Do You Loop Through a Nested List in Python?

Iterating through a nested list in Python often involves nested loops. You’ll need an outer loop to go through the outer list and an inner loop to navigate through the inner lists.

Let’s see how you can do this.

To loop through all the elements, you can use two nested for loops:

This code will print each element in the nested list one by one. It starts with 8, 9, 10 then moves on to ‘x’, ‘y’, ‘z’, and finally to True and False.

Here is the output of the code:

Creating a Nested List Using a List Comprehension

You can also create nested lists using list comprehensions. This can work well with data structures used to solve mathematical problems.

Here is how you would create a matrix using list comprehensions:

In this example, we created a 4×4 matrix where each row is a list containing four numbers.

The result is the following matrix:

You can see that the nested list we created contains four sublists.

As explained before, you can access individual elements of this nested list using two indices. For example, let’s print the value of the first element in the second sublist:

What is The Difference Between a List and a Nested List in Python?

Understanding the distinction between a regular list and a nested list is important for effective programming. The main difference lies in the structure and use cases:

• Structure: A regular list in Python contains a sequence of elements of any data type, while a nested list contains one or more lists as its elements.
• Use Cases: Regular lists are suitable for storing one-dimensional data, whereas nested lists are ideal for multi-dimensional data and hierarchical structures.
• Accessing Elements : Accessing elements in a regular list involves using a single set of square brackets and an index, whereas nested lists require multiple sets of square brackets and indices for deeper nesting.
• Looping: Looping through a regular list is straightforward with a single for loop, while for nested lists you have to use nested for loops.

In this article, we have studied the concept of nested lists in Python. We have explored what they are, how to access and manipulate their elements, and the key differences between regular lists and nested lists.

As you continue your Python journey, mastering nested lists will empower you to work with more complex data structures and tackle a wide range of programming challenges.

So, embrace the power of nesting and elevate your Python programming skills!

Related article : Learn more about working with nested lists by going through the CodeFatherTech tutorial on how to flatten a nested list in Python .

Claudio Sabato is an IT expert with over 15 years of professional experience in Python programming, Linux Systems Administration, Bash programming, and IT Systems Design. He is a professional certified by the Linux Professional Institute .

With a Master’s degree in Computer Science, he has a strong foundation in Software Engineering and a passion for robotics with Raspberry Pi.

Related posts:

• Python List Methods: A Practical Guide to Work with Lists
• Python List Comprehension: Is It Easy to Comprehend?!?
• 5 Ways to Prepend an Element to the Front of a List in Python
• How to Create a List of Random Numbers in Python

Leave a Comment Cancel reply

Save my name, email, and website in this browser for the next time I comment.

• Privacy Overview
• Strictly Necessary Cookies

This website uses cookies so that we can provide you with the best user experience possible. Cookie information is stored in your browser and performs functions such as recognising you when you return to our website and helping our team to understand which sections of the website you find most interesting and useful.

Strictly Necessary Cookie should be enabled at all times so that we can save your preferences for cookie settings.

If you disable this cookie, we will not be able to save your preferences. This means that every time you visit this website you will need to enable or disable cookies again.

Python Nested List

Nested lists in Python are lists that contain other lists as their elements. This structure allows you to create multi-dimensional data representations, which are particularly useful when working with matrices, tables, or other complex data arrangements.

Let’s learn more about nested lists in Python and explore various operations and techniques for working with them.

Creating a Nested List

A nested list can be created by placing lists within a list. Here are some basic examples:

Accessing Elements in a Nested List

To access elements in a nested list, you use multiple indices – one for each level of the list. The first index specifies which of the inner lists to access, and the subsequent indices specify the element within that inner list.

The indexes for the elements in a nested list are illustrated as below:

In this list, L[2] accesses the third element, which is itself a list: ['cc', 'dd', ['eee', 'fff']] . To get to ‘eee’, we need another index: L[2][2] gets us to the third element of this inner list, which is yet another list: ['eee', 'fff'] . Finally, L[2][2][0] gives us the first element of this innermost list, which is the string ‘eee’.

Negative List Indexing In a Nested List

In Python, negative indexing provides a convenient way to access elements from the end of a list. Just like positive indices start from 0 and count upwards, negative indices start from -1 and count downwards. So, -1 refers to the last element, -2 to the second-last, and so on.

This concept also applies to nested lists, where each level of nesting can be accessed with its own negative index.

The negative indexes for the elements in a nested list are illustrated as below:

Modifying Elements in a Nested List

Just like with regular lists, You can modify elements in nested lists by specifying the indices of the element you want to change:

Adding Elements to a Nested List

Nested lists in Python can be modified using the same list operations as regular lists. This means you can add elements to nested lists using methods like append() , insert() , and extend() .

To add a new element to the end of a nested list, you can use the append() method.

If you need to insert an element at a specific position within a nested list, the insert() method is the right tool.

Finally, the extend() method allows you to merge one list into another.

Removing Elements from a Nested List

There are different ways to remove elements from a nested list depending on your specific needs.

If you know the index of the element you want to remove, the pop() method is a good choice. This method not only removes the element at the specified index but also returns its value.

In cases where you don’t need the removed value, the del statement is a simple and efficient way to delete an element by its index.

If you don’t know the exact index but know the value of the element you want to remove, the remove() method is the way to go. This method searches the list and removes the first occurrence of the specified value.

Finding the Length of a Nested List

Determining the number of elements within a nested list is simple using Python’s built-in len() function. This function returns the length of a list, which is the number of elements it contains.

Iterating Through a Nested List

You can iterate through nested lists using nested loops. In this approach, an outer loop iterates over the sublists within the main list, while an inner loop iterates over the individual elements within each sublist.

Common Use Cases for Nested Lists

Nested lists provide a powerful and flexible way to organize and structure data in a hierarchical manner.

Matrices and 2D Arrays

One common use case is representing matrices and 2D arrays, which are useful in mathematical computations and data science.

Tables of Data

Nested lists are also used to represent tabular data; each inner list can act as a row, with elements representing the data within each column.

Graphs and Trees

Even in more complex scenarios, such as graph theory or data structures, nested lists can be useful. In graph representation, nested lists can store adjacency lists, where each inner list contains the neighbors of a particular node.

Working with Nested Lists in Python (5 Examples)

In Python, nested lists are lists that contain other lists as their elements. They can be useful for storing and manipulating complex data structures, such as matrices, graphs, or trees.

Creating Nested Lists

In order to create a nested list, you can simply use square brackets [] to enclose one or more lists inside another list.

Sometimes, list comprehension can also be used to construct a nested list:

The pprint() function from the pprint module helps us print big nested lists in a beautiful manner.

Accessing and Modifying Elements in a Nested List

When it comes to accessing or modifying the elements of a nested list, you can use two indices: the first one specifies the sublist, and the second one specifies the element within that sublist. The indices start from zero and can be positive or negative.

Iterating Over a Nested List

The way to iterate over the elements of a nested list is to use nested for loops. The outer loop iterates over the sublists and the inner loop iterates over the elements within each sublist.

In case you want to get both the indices and the elements of a nested list, the enumerate() function is the right choice.

That’s it. Happy coding!

Next Article: Python: How to Access Elements in a List

Previous Article: Python: Using type hints with map() function – Examples

Series: Python List Tutorials (Basic and Advanced)

Related Articles

• Python Warning: Secure coding is not enabled for restorable state
• Python TypeError: write() argument must be str, not bytes
• 4 ways to install Python modules on Windows without admin rights
• Python TypeError: object of type ‘NoneType’ has no len()
• Python: How to access command-line arguments (3 approaches)
• Understanding ‘Never’ type in Python 3.11+ (5 examples)
• Python: 3 Ways to Retrieve City/Country from IP Address
• Using Type Aliases in Python: A Practical Guide (with Examples)
• Python: Defining distinct types using NewType class
• Using Optional Type in Python (explained with examples)
• Python: How to Override Methods in Classes
• Python: Define Generic Types for Lists of Nested Dictionaries

Search tutorials, examples, and resources

• PHP programming
• Symfony & Doctrine
• Laravel & Eloquent
• Tailwind CSS
• Sequelize.js
• Mongoose.js

List Within a List in Python – How to Initialize a Nested List

By Shittu Olumide

Lists are a built-in data type in Python. And you can use them to store a collection of elements.

Lists are ordered, mutable, and contain elements of different data types, such as strings, integers, and other lists.

In Python, lists are a fundamental type of data structure that you'll use frequently whether you're a web developer, data scientist, or anything in between.

How to Create a List in Python

You can create a list in Python by separating the elements with commas and using square brackets [] . Let's create an example list:

From the example above, you can see that a list can contain several datatypes. In order to access these elements within a string, we use indexing. The first index is 0 , the second index is 1 , and so on.

Lists come with a wide range of methods such as:

• append() : adds an element to the end of the list.
• insert() : adds an element at a specified position in the list.
• remove() : removes the first occurrence of a specified element from the list.
• pop() : removes the element at a specified position in the list and returns it.
• sort() : sorts the elements in the list in ascending order.
• reverse() : reverses the order of the elements in the list.
• count() : returns the number of times a specified element appears in the list.
• index() : returns the index of the first occurrence of a specified element in the list.
• extend() : extends the list by appending elements from another iterable.

In Python, you can also have lists within a list. And that's what we'll discuss in the next section.

How a List within a List Works in Python

A list within another list is referred to as a nested list in Python. We can also say that a list that has other lists as its elements is a nested list.

When we want to keep several sets of connected data in a single list, this can be helpful.

Here is an illustration of a Python nested list:

Just like we said earlier, to access the elements in this nested list we use indexing. To access an element in one of the sublists, we use two indices – the index of the sublist and the index of the element within the sublist.

Let's use the example of the nested list above and access a particular sublist/element:

Let's have a look at how we can initialize a nested listed correctly in Python.

How to Initialize a Nested List in Python

We know that a nested list is a list inside of another list. But creating a list of lists in Python can be a little tricky because there are wrong ways and right ways to do it.

How NOT to initialize a nested list

Let's see one of the wrong ways of initializing a nested list (although it is the most basic and fastest way to initialize a nested list):

Initializing a nested list in this manner has the disadvantage that each entry in the list has the same ID , pointing to the same list object.

Let's verify this by looping through the list and printing the id of each sublist object.

Let's see why this is very bad. We will insert an element into the second sublist and then check the content of the main list.

The element was inserted into all the sublists, because they have the same ID. Therefore they are not different lists. So as you can see, this is an incorrect way to initialize a nested list.

How to initialize a nested list

Using list comprehension & range().

Using List Comprehension, we can create a sub-list and append it to the main list for each element of a sequence of numbers from 0 to n-1 that we generated using Python's range() function.

This creates a nested list that has 5 sublists. Now let's see if each sublist has a different ID. We'll also insert an element into a sublist.

As you can see, the element (7) is only inserted to the second sublist and other sublists are left empty because they all have different IDs or objects.

Using a for loop

Let's say we want to build a list that internally has four different sublists. To accomplish this, we will first create a new empty list, then use a for loop to iterate from 0 to 3. We'll append an empty list to the new list after each iteration.

To confirm if all sublists have different IDs, you can do this:

The distinct IDs of each sublist attest to the fact that these are distinct objects.

Using Numpy

Python's Numpy module includes a function called empty() that generates empty Numpy arrays of a specified shape. Using Numpy to initialize a nested list can be a practical way to build and work with 2-dimensional data structures in Python.

We now have 5 sublists – let's check their IDs.

This is another confirmation that all the sublists are different objects. So if we want to modify any sublist, the remaining sublists will not be affected.

We have come to the end of this article. The key takeaways are that initializing a nested list can be tricky - and there's an incorrect (and several correct) ways to do it.

There are many other ways that you can initialize a nested list in Python, but the ones above are the most popular and widely used.

Once we have created the nested list, we can access and modify its elements using indexing as you saw above.

Let's connect on Twitter and on LinkedIn . You can also subscribe to my YouTube channel.

Happy Coding!

If you read this far, thank the author to show them you care. Say Thanks

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

• Table of Contents
• Course Home
• Assignments
• Peer Instruction (Instructor)
• Peer Instruction (Student)
• Change Course
• Instructor's Page
• Progress Page
• Edit Profile
• Change Password
• Scratch ActiveCode
• Scratch Activecode
• Instructors Guide
• About Runestone
• Report A Problem
• 10.2 List Values
• 10.3 List Length
• 10.4 Accessing Elements
• 10.5 List Membership
• 10.6 Concatenation and Repetition
• 10.7 List Slices
• 10.8 Lists are Mutable
• 10.9 List Deletion
• 10.10 Objects and References
• 10.11 Aliasing
• 10.12 Cloning Lists
• 10.13 Repetition and References
• 10.14 List Methods
• 10.15 The Return of L-Systems
• 10.16 Append versus Concatenate
• 10.17 Lists and for loops
• 10.18 The Accumulator Pattern with Lists
• 10.19 Using Lists as Parameters
• 10.20 Pure Functions
• 10.21 Which is Better?
• 10.22 Functions that Produce Lists
• 10.23 List Comprehensions
• 10.24 Nested Lists
• 10.25 Strings and Lists
• 10.26 list Type Conversion Function
• 10.27 Tuples and Mutability
• 10.28 Tuple Assignment
• 10.29 Tuples as Return Values
• 10.30 Glossary
• 10.31 Exercises
• 10.23. List Comprehensions" data-toggle="tooltip">
• 10.25. Strings and Lists' data-toggle="tooltip" >

10.24. Nested Lists ¶

A nested list is a list that appears as an element in another list. In this list, the element with index 3 is a nested list. If we print( nested[3] ), we get [10, 20] . To extract an element from the nested list, we can proceed in two steps. First, extract the nested list, then extract the item of interest. It is also possible to combine those steps using bracket operators that evaluate from left to right.

Check your understanding

What is printed by the following statements?

• 6 is in the wrong list. alist[1] refers to the second item in alist, namely [888,999].
• 8 is in the wrong list. alist[1] refers to the second item in alist, namely [888,999].
• Yes, alist[0][1][0] is True and alist[1] is the second list, the first item is 888.
• alist[0][1][0] is True. Take another look at the if statement.

Python's list Data Type: A Deep Dive With Examples

Table of Contents

Getting Started With Python’s list Data Type

Creating lists through literals, using the list() constructor, building lists with list comprehensions, accessing items in a list: indexing, retrieving multiple items from a list: slicing, aliases of a list, shallow copies of a list, deep copies of a list, updating items in lists: index assignments, appending a single item at once: .append(), extending a list with multiple items at once: .extend(), inserting an item at a given position: .insert(), deleting items from a list, considering performance while growing lists, concatenating lists, repeating the content of a list, reversing a list: reversed() and .reverse(), sorting a list: sorted() and .sort(), using a for loop to iterate over a list, building new lists with comprehensions, processing lists with functional tools, finding items in a list, getting the length, maximum, and minimum of a list, comparing lists, common gotchas of python lists, subclassing the built-in list class, removing repeated items from a list, creating multidimensional lists, flattening multidimensional lists, splitting lists into chunks, using a list as a stack or queue, deciding whether to use lists.

The list class is a fundamental built-in data type in Python. It has an impressive and useful set of features, allowing you to efficiently organize and manipulate heterogeneous data. Knowing how to use lists is a must-have skill for you as a Python developer. Lists have many use cases, so you’ll frequently reach for them in real-world coding.

By working through this tutorial, you’ll dive deep into lists and get a solid understanding of their key features. This knowledge will allow you to write more effective code by taking advantage of lists.

In this tutorial, you’ll learn how to:

• Create new lists in Python
• Access the items in an existing list
• Copy , update , grow , shrink , and concatenate existing lists
• Sort , reverse , and traverse existing lists
• Use other features of Python lists

In addition, you’ll code some examples that showcase common use cases of lists in Python. They’ll help you understand how to better use lists in your code.

To get the most out of this tutorial, you should have a good understanding of core Python concepts, including variables , functions , and for loops . You’ll also benefit from familiarity with other built-in data types , such as strings , tuples , dictionaries , and sets .

Free Bonus: Click here to download the sample code that will make you an expert on Python’s list data type.

Python’s list is a flexible, versatile, powerful, and popular built-in data type . It allows you to create variable-length and mutable sequences of objects. In a list , you can store objects of any type. You can also mix objects of different types within the same list, although list elements often share the same type.

Note: Throughout this tutorial, you’ll use the terms items , elements , and values interchangeably to refer to the objects stored in a list.

Some of the more relevant characteristics of list objects include being:

• Ordered : They contain elements or items that are sequentially arranged according to their specific insertion order.
• Zero-based : They allow you to access their elements by indices that start from zero.
• Mutable : They support in-place mutations or changes to their contained elements.
• Heterogeneous : They can store objects of different types.
• Growable and dynamic : They can grow or shrink dynamically, which means that they support the addition, insertion, and removal of elements.
• Nestable : They can contain other lists, so you can have lists of lists.
• Iterable : They support iteration, so you can traverse them using a loop or comprehension while you perform operations on each of their elements.
• Sliceable : They support slicing operations, meaning that you can extract a series of elements from them.
• Combinable : They support concatenation operations, so you can combine two or more lists using the concatenation operators.
• Copyable : They allow you to make copies of their content using various techniques.

Lists are sequences of objects. They’re commonly called containers or collections because a single list can contain or collect an arbitrary number of other objects.

Note: In Python, lists support a rich set of operations that are common to all sequence types, including tuples , strings, and ranges . These operations are known as common sequence operations . Throughout this tutorial, you’ll learn about several operations that fall into this category.

In Python, lists are ordered, which means that they keep their elements in the order of insertion:

The items in this list are strings representing colors. If you access the list object, then you’ll see that the colors keep the same order in which you inserted them into the list. This order remains unchanged during the list’s lifetime unless you perform some mutations on it.

You can access an individual object in a list by its position or index in the sequence. Indices start from zero:

Positions are numbered from zero to the length of the list minus one. The element at index 0 is the first element in the list, the element at index 1 is the second, and so on.

Lists can contain objects of different types. That’s why lists are heterogeneous collections:

This list contains objects of different data types, including an integer number , string, Boolean value, dictionary , tuple, and another list. Even though this feature of lists may seem cool, in practice you’ll find that lists typically store homogeneous data.

Note: One of the most relevant characteristics of lists is that they’re mutable data types. This feature deeply impacts their behavior and use cases. For example, mutability implies that lists aren’t hashable , so you can’t use them as dictionary keys . You’ll learn a lot about how mutability affects lists throughout this tutorial. So, keep reading!

Okay! That’s enough for a first glance at Python lists. In the rest of this tutorial, you’ll dive deeper into all the above characteristics of lists and more. Are you ready? To kick things off, you’ll start by learning the different ways to create lists.

Constructing Lists in Python

First things first. If you want to use a list to store or collect some data in your code, then you need to create a list object. You’ll find several ways to create lists in Python. That’s one of the features that make lists so versatile and popular.

For example, you can create lists using one of the following tools:

• List literals
• The list() constructor
• A list comprehension

In the following sections, you’ll learn how to use the three tools listed above to create new lists in your code. You’ll start off with list literals.

List literals are probably the most popular way to create a list object in Python. These literals are fairly straightforward. They consist of a pair of square brackets enclosing a comma-separated series of objects.

Here’s the general syntax of a list literal:

This syntax creates a list of n items by listing the items in an enclosing pair of square brackets. Note that you don’t have to declare the items’ type or the list’s size beforehand. Remember that lists have a variable size and can store heterogeneous objects.

Here are a few examples of how to use the literal syntax to create new lists:

In these examples, you use the list literal syntax to create lists containing numbers, strings, other lists, dictionaries, and even function objects. As you already know, lists can store any type of object. They can also be empty, like the final list in the above code snippet.

Empty lists are useful in many situations. For example, maybe you want to create a list of objects resulting from computations that run in a loop. The loop will allow you to populate the empty list one element at a time.

Using a list literal is arguably the most common way to create lists. You’ll find these literals in many Python examples and codebases. They come in handy when you have a series of elements with closely related meanings, and you want to pack them into a single data structure.

Note that naming lists as plural nouns is a common practice that improves readability. However, there are situations where you can use collective nouns as well.

For example, you can have a list called people . In this case, every item will be a person . Another example would be a list that represents a table in a database. You can call the list table , and each item will be a row . You’ll find more examples like these in your walk-through of using lists.

Another tool that allows you to create list objects is the class constructor , list() . You can call this constructor with any iterable object, including other lists, tuples, sets, dictionaries and their components, strings, and many others. You can also call it without any arguments, in which case you’ll get an empty list back.

Here’s the general syntax:

To create a list, you need to call list() as you’d call any class constructor or function. Note that the square brackets around iterable mean that the argument is optional , so the brackets aren’t part of the syntax. Here are a few examples of how to use the constructor:

In these examples, you create different lists using the list() constructor, which accepts any type of iterable object, including tuples, dictionaries, strings, and many more. It even accepts sets, in which case you need to remember that sets are unordered data structures, so you won’t be able to predict the final order of items in the resulting list.

Calling list() without an argument creates and returns a new empty list. This way of creating empty lists is less common than using an empty pair of square brackets. However, in some situations, it can make your code more explicit by clearly communicating your intent: creating an empty list .

The list() constructor is especially useful when you need to create a list out of an iterator object. For example, say that you have a generator function that yields numbers from the Fibonacci sequence on demand, and you need to store the first ten numbers in a list.

In this case, you can use list() as in the code below:

Calling fibonacci_generator() directly returns a generator iterator object that allows you to iterate over the numbers in the Fibonacci sequence up to the index of your choice. However, you don’t need an iterator in your code. You need a list. A quick way to get that list is to wrap the iterator in a call to list() , as you did in the final example.

This technique comes in handy when you’re working with functions that return iterators, and you want to construct a list object out of the items that the iterator yields. The list() constructor will consume the iterator, build your list, and return it back to you.

Note: You can also use the literal syntax and the iterable unpacking operator ( * ) as an alternative to the list() constructor.

Here’s how:

In this example, the iterable unpacking operator consumes the iterator, and the square brackets build the final list of numbers. However, this technique is less readable and explicit than using list() .

As a side note, you’ll often find that built-in and third-party functions return iterators. Functions like reversed() , enumerate() , map() , and filter() are good examples of this practice. It’s less common to find functions that directly return list objects, but the built-in sorted() function is one example. It takes an iterable as an argument and returns a list of sorted items.

List comprehensions are one of the most distinctive features of Python. They’re quite popular in the Python community, so you’ll likely find them all around. List comprehensions allow you to quickly create and transform lists using a syntax that mimics a for loop but in a single line of code.

The core syntax of list comprehensions looks something like this:

Every list comprehension needs at least three components:

• expression() is a Python expression that returns a concrete value, and most of the time, that value depends on item . Note that it doesn’t have to be a function.
• item is the current object from iterable .
• iterable can be any Python iterable object, such as a list , tuple , set , string , or generator .

The for construct iterates over the items in iterable , while expression(item) provides the corresponding list item that results from running the comprehension.

To illustrate how list comprehensions allow you to create new lists out of existing iterables, say that you want to construct a list with the square values of the first ten integer numbers. In this case, you can write the following comprehension:

In this example, you use range() to get the first ten integer numbers. The comprehension iterates over them while computing the square and building the new list. This example is just a quick sample of what you can do with a list comprehension.

Note: To dive deeper into list comprehensions and how to use them, check out When to Use a List Comprehension in Python .

In general, you’ll use a list comprehension when you need to create a list of transformed values out of an existing iterable. Comprehensions are a great tool that you need to master as a Python developer. They’re optimized for performance and are quick to write.

You can access individual items from a list using the item’s associated index . What’s an item’s index? Each item in a list has an index that specifies its position in the list. Indices are integer numbers that start at 0 and go up to the number of items in the list minus 1 .

To access a list item through its index, you use the following syntax:

This construct is known as an indexing operation, and the [index] part is known as the indexing operator . It consists of a pair of square brackets enclosing the desired or target index. You can read this construct as from list_object give me the item at index .

Here’s how this syntax works in practice:

Indexing your list with different indices gives you direct access to the underlying items. If you use the Big O notation for time complexity , then you can say that indexing is an O(1) operation. This means that lists are quite good for those situations where you need to access random items from a series of items.

Here’s a more visual representation of how indices map to items in a list:

In any Python list, the index of the first item is 0 , the index of the second item is 1 , and so on. The index of the last item is the number of items minus 1 .

The number of items in a list is known as the list’s length . You can check the length of a list by using the built-in len() function:

So, the index of the last item in languages is 6 - 1 = 5 . That’s the index of the "Rust" item in your sample list. If you use an index greater than this number in an indexing operation, then you get an IndexError exception:

In this example, you try to retrieve the item at index 6 . Because this index is greater than 5 , you get an IndexError as a result. Using out-of-range indices can be an incredibly common issue when you work with lists, so keep an eye on your target indices.

Indexing operations are quite flexible in Python. For example, you can also use negative indices while indexing lists. This kind of index gives you access to the list items in backward order:

A negative index specifies an element’s position relative to the right end of the list, moving back to the beginning of the list. Here’s a representation of the process:

You can access the last item in a list using index -1 . Similarly, index -2 specifies the next-to-last item, and so forth. It’s important to note that negative indices don’t start from 0 because 0 already points to the first item. This may be confusing when you’re first learning about negative and positive indices, but you’ll get used to it. It just takes a bit of practice.

Note that if you use negative indices, then -len(languages) will be the first item in the list. If you use an index lower than that value, then you get an IndexError :

When you use an index lower than -len(languages) , you get an error telling you that the target index is out of range.

Using negative indices can be very convenient in many situations. For example, accessing the last item in a list is a fairly common operation. In Python, you can do this by using negative indices, like in languages[-1] , which is more readable and concise than doing something like languages[len(languages) - 1] .

Note: Negative indices also come in handy when you need to reverse a list, as you’ll learn in the section Reversing and Sorting Lists .

As you already know, lists can contain items of any type, including other lists and sequences. When you have a list containing other sequences, you can access the items in any nested sequence by chaining indexing operations. Consider the following list of employee records:

How can you access the individual pieces of data from any given employee? You can use the following indexing syntax:

The number at the end of each index represents the level of nesting for the list. For example, your employee list has one level of nesting. Therefore, to access Alice’s data, you can do something like this:

In this example, when you do employees[1][0] , index 1 refers to the second item in the employees list. That’s a nested list containing three items. The 0 refers to the first item in that nested list, which is "Alice" . As you can see, you can access items in the nested lists by applying multiple indexing operations in a row. This technique is extensible to lists with more than one level of nesting.

If the nested items are dictionaries, then you can access their data using keys:

In this example, you have a list of dictionaries. To access the data from one of the dictionaries, you need to use its index in the list, followed by the target key in square brackets.

Another common requirement when working with lists is to extract a portion, or slice , of a given list. You can do this with a slicing operation, which has the following syntax:

The [start:stop:step] part of this construct is known as the slicing operator . Its syntax consists of a pair of square brackets and three optional indices, start , stop , and step . The second colon is optional. You typically use it only in those cases where you need a step value different from 1 .

Note: Slicing is an operation that’s common to all Python sequence data types, including lists, tuples, strings, ranges, and others.

Here’s what the indices in the slicing operator mean:

• start specifies the index at which you want to start the slicing. The resulting slice includes the item at this index.
• stop specifies the index at which you want the slicing to stop extracting items. The resulting slice doesn’t include the item at this index.
• step provides an integer value representing how many items the slicing will skip on each step. The resulting slice won’t include the skipped items.

All the indices in the slicing operator are optional. They have the following default values:

The minimal working variation of the indexing operator is [:] . In this variation, you rely on the default values of all the indices and take advantage of the fact that the second colon is optional. The [::] variation of the slicing operator produces the same result as [:] . This time, you rely on the default value of the three indices.

Note: Both of the above variations of the slicing operator ( [:] and [::] ) allow you to create a shallow copy of your target list. You’ll learn more about this topic in the Shallow Copies of a List section.

Now it’s time for you to explore some examples of how slicing works:

In this example, you have a list of letters in uppercase and lowercase. You want to extract the uppercase letters into one list and the lowercase letters into another list. The [0::2] operator helps you with the first task, and [1::2] helps you with the second.

In both examples, you’ve set step to 2 because you want to retrieve every other letter from the original list. In the first slicing, you use a start of 0 because you want to start from the very beginning of the list. In the second slicing, you use a start of 1 because you need to jump over the first item and start extracting items from the second one.

You can use any variation of the slicing operator that fits your needs. In many situations, relying on the default indices is pretty helpful. In the examples above, you rely on the default value of stop , which is len(list_object) . This practice allows you to run the slicing all the way up to the last item of the target list.

Here are a few more examples of slicing:

In these examples, the variable names reflect the portion of the list that you’re extracting in every slicing operation. As you can conclude, the slicing operator is pretty flexible and versatile. It even allows you to use negative indices.

Every slicing operation uses a slice object internally. The built-in slice() function provides an alternative way to create slice objects that you can use to extract multiple items from a list. The signature of this built-in function is the following:

It takes three arguments with the same meaning as the indices in the slicing operator and returns a slice object equivalent to [start:stop:step] . To illustrate how slice() works, get back to the letters example and rewrite it using this function instead of the slicing operator. You’ll end up with something like the following:

Passing None to any arguments of slice() tells the function that you want to rely on its internal default value, which is the same as the equivalent index’s default in the slicing operator. In these examples, you pass None to stop , which tells slice() that you want to use len(letters) as the value for stop .

As an exercise, you can write the digits examples using slice() instead of the slicing operator. Go ahead and give it a try! This practice will help you better understand the intricacies of slicing operations in Python.

Finally, it’s important to note that out-of-range values for start and stop don’t cause slicing expressions to raise a TypeError exception. In general, you’ll observe the following behaviors:

• If start is before the beginning of the list, which can happen when you use negative indices, then Python will use 0 instead.
• If start is greater than stop , then the slicing will return an empty list.
• If stop is beyond the length of the list, then Python will use the length of the list instead.

Here are some examples that show these behaviors in action:

In these examples, your color list has seven items, so len(colors) returns 7 . In the first example, you use a negative value for start . The first item of colors is at index -7 . Because -8 < -7 , Python replaces your start value with 0 , which results in a slice that contains the items from 0 to the end of the list.

Note: In the examples above, you use only one colon in each slicing. In day-to-day coding, this is common practice. You’ll only use the second colon if you need to provide a step different from 1 . Here’s an example where step equals 2 :

In this example, you set step to 2 because you need a copy of colors that contains every other color. The slicing jumps over two colors in every step and gives you back a list of four colors.

In the second example, you use a start value that’s greater than the length of colors . Because there’s nothing to retrieve beyond the end of the list, Python returns an empty list. In the final example, you use a stop value that’s greater than the length of colors . In this case, Python retrieves all the items up to the end of the list.

Creating Copies of a List

Creating copies of an existing list is a common need in Python code. Having a copy ensures that when you change a given list, that change doesn’t affect the original data or the data in other copies.

Note: In Python, an object’s identity is a unique identifier that distinguishes it from other objects. You can use the built-in id() function to get the identity of any Python object. In Python’s CPython implementation , an object’s identity coincides with the memory address where the object is stored.

In Python, you’ll have two kinds of mechanisms to create copies of an existing list. You can create either:

• A shallow copy
• A deep copy

Both types of copies have specific characteristics that will directly impact their behavior. In the following sections, you’ll learn how to create shallow and deep copies of existing lists in Python. First, you’ll take a glance at aliases , a related concept that can cause some confusion and lead to issues and bugs.

In Python, you can create aliases of variables using the assignment operator ( = ). Assignments don’t create copies of objects in Python. Instead, they create bindings between the variable and the object involved in the assignment. Therefore, when you have several aliases of a given list, changes in an alias will affect the rest of the aliases.

To illustrate how you can create aliases and how they work, consider the following example:

In this code snippet, the first highlighted line creates nations as an alias of countries . Note how both variables point to the same object, which you know because the object’s identity is the same. In the second highlighted line, you update the object at index 0 in countries . This change reflects in the nations alias.

Assignment statements like the one in the first highlighted line above don’t create copies of the right-hand object. They just create aliases or variables that point to the same underlying object.

In general, aliases can come in handy in situations where you need to avoid name collisions in your code or when you need to adapt the names to specific naming patterns.

To illustrate, say that you have an app that uses your list of countries as countries in one part of the code. The app requires the same list in another part of the code, but there’s already a variable called countries with other content.

If you want both pieces of code to work on the same list, then you can use nations as an alias for countries . A handy way to do this would be to use the as keyword for creating the alias through an implicit assignment , for example, when you import the list from another module .

A shallow copy of an existing list is a new list containing references to the objects stored in the original list. In other words, when you create a shallow copy of a list, Python constructs a new list with a new identity. Then, it inserts references to the objects in the original list into the new list.

There are at least three different ways to create shallow copies of an existing list. You can use:

• The slicing operator, [:]
• The .copy() method
• The copy() function from the copy module

These three tools demonstrate equivalent behavior. So, to kick things off, you’ll start exploring the slicing operator:

The highlighted line creates nations as a shallow copy of countries by using the slicing operator with one colon only. This operation takes a slice from the beginning to the end of countries . In this case, nations and countries have different identities. They’re completely independent list objects.

However, the elements in nations are aliases of the elements in countries :

As you can see, items under the same index in both nations and countries share the same object identity. This means that you don’t have copies of the items. You’re really sharing them. This behavior allows you to save some memory when working with lists and their copies.

Now, how would this impact the behavior of both lists? If you changed an item in nations , would the change reflect in countries ? The code below will help you answer these questions:

On the first line of this piece of code, you update the item at index 0 in countries . This change doesn’t affect the item at index 0 in nations . Now the first items in the lists are completely different objects with their own identities. The rest of the items, however, continue to share the same identity. So, they’re the same object in each case.

Because making copies of a list is such a common operation, the list class has a dedicated method for it. The method is called .copy() , and it returns a shallow copy of the target list:

Calling .copy() on countries gets you a shallow copy of this list. Now you have two different lists. However, their elements are common to both. Again, if you change an element in one of the lists, then the change won’t reflect in the copy.

You’ll find yet another tool for creating shallow copies of a list. The copy() function from the copy module allows you to do just that:

When you feed copy() with a mutable container data type, such as a list, the function returns a shallow copy of the input object. This copy behaves the same as the previous shallow copies that you’ve built in this section.

Sometimes you may need to build a complete copy of an existing list. In other words, you want a copy that creates a new list object and also creates new copies of the contained elements. In these situations, you’ll have to construct what’s known as a deep copy .

When you create a deep copy of a list, Python constructs a new list object and then inserts copies of the objects from the original list recursively .

To create a deep copy of an existing list, you can use the deepcopy() function from the copy module. Here’s an example of how this function works:

In this example, you create a deep copy of your matrix list. Note how both the lists and their sibling items have different identities.

Why would you need to create a deep copy of matrix , anyway? For example, if you only create a shallow copy of matrix , then you can face some issues when trying to mutate the nested lists:

In this example, you create a shallow copy of matrix . If you change items in a nested list within matrix_copy , then those changes affect the original data in matrix . The way to avoid this behavior is to use a deep copy:

Now the changes in matrix_copy or any other deep copy don’t affect the content of matrix , as you can see on the highlighted lines.

Finally, it’s important to note that when you have a list containing immutable objects, such as numbers, strings, or tuples, the behavior of deepcopy() mimics what copy() does:

In this example, even though you use deepcopy() , the items in nations are aliases of the items in countries . That behavior makes sense because you can’t change immutable objects in place. Again, this behavior optimizes the memory consumption of your code when you’re working with multiple copies of a list.

Python lists are mutable data types. This means that you can change their elements without changing the identity of the underlying list. These kinds of changes are commonly known as in-place mutations . They allow you to update the value of one or more items in an existing list.

Note: To dive deeper into what mutable and immutable data types are and how they work in Python, check out Python’s Mutable vs Immutable Types: What’s the Difference?

To change the value of a given element in a list, you can use the following syntax:

The indexing operator gives you access to the target item through its index, while the assignment operator allows you to change its current value.

Here’s how this assignment works:

In this example, you’ve replaced all the numeric values in numbers with strings. To do that, you’ve used their indices and the assignment operator in what you can call index assignments . Note that negative indices also work.

What if you know an item’s value but don’t know its index in the list? How can you update the item’s value? In this case, you can use the .index() method as in the code below:

The .index() method takes a specific item as an argument and returns the index of the first occurrence of that item in the underlying list. You can take advantage of this behavior when you know the item that you want to update but not its index. However, note that if the target item isn’t present in the list, then you’ll get a ValueError .

You can also update the value of multiple list items in one go. To do that, you can access the items with the slicing operator and then use the assignment operator and an iterable of new values. This combination of operators can be called slice assignment for short.

In this syntax, the values from iterable replace the portion of list_object defined by the slicing operator. If iterable has the same number of elements as the target slice, then Python updates the elements one by one without altering the length of list_object .

To understand these behaviors, consider the following examples:

In this example, you update the items located from 1 to 4 , without including the last item. In this slice, you have three items, so you use a list of three new values to update them one by one.

If iterable has more or fewer elements than the target slice, then list_object will automatically grow or shrink accordingly:

Now the initial list of numbers only has four values. The values 1 , 2 , and 3 are missing. So, you use a slice to insert them starting at index 1 . In this case, the slice has a single index, while the list of values has three new values, so Python grows your list automatically to hold the new values.

You can also use a slice to shrink an existing list:

Here, the initial list has a bunch of zeros where it should have a 3 . Your slicing operator takes the portion filled with zeros and replaces it with a single 3 .

Using the slicing operator to update the value of several items in an existing list is a pretty useful technique that may be hard to grasp at first. Go ahead and practice a bit more to get a deeper understanding of how this technique works.

Growing and Shrinking Lists Dynamically

In Python lists, mutability goes beyond allowing you to modify the items in place. Because lists are mutable, you can change their length on the fly by adding or removing elements. So, lists are also variable-length containers, as you already learned.

Adding new items to a list or removing unneeded ones are everyday tasks. That’s why Python provides different efficient ways to perform these actions. Using the right tool for the job is an essential skill.

In the following sections, you’ll explore the different tools that Python offers to grow and shrink a list dynamically.

The .append() method is probably the most common tool that you’ll use to add items to an existing list. As its name suggests, this method allows you to append items to a list. The method takes one item at a time and adds it to the right end of the target list.

Here’s an example of how .append() works:

In these examples, every call to .append() adds a new pet at the end of your list. This behavior allows you to gradually populate an empty list or to add items to an existing list, as you did in the example.

Note: For a deep dive into how .append() works, check out Python’s .append() : Add Items to Your Lists in Place .

Using .append() is equivalent to doing the following slice assignment:

The slice assignment in this example grows your lists by appending a new item, "hawk" , after the current last item in pets . This technique works the same as .append() . However, using .append() leads to a more readable and explicit solution.

An important fact to keep in mind when using .append() is that this method adds only a single item at a time. That item could be of any data type, including another list:

Note how the last item in pets is a list of two pets rather than two new independent pets. This behavior may be a source of subtle errors. To avoid problems, you must remember that .append() takes and adds a single item each time.

If you need to add several items from an iterable at the end of an existing list, then you can use the .extend() method, which you’ll expore in the following section.

When you’re working with lists, you may face the need to add multiple items to the right end of a list at once. Because this is such a common requirement, Python’s list has a dedicated method for that task.

The method is called .extend() . It takes an iterable of objects and appends them as individual items to the end of the target list:

The .extend() method unpacks the items in the input iterable and adds them one by one to the right end of your target list. Now fruits has three more items on its end.

You should note that .extend() can take any iterable as an argument. So, you can use tuples, strings, dictionaries and their components, iterators, and even sets. However, remember that if you use a set as an argument to extend() , then you won’t know the final order of items beforehand.

Again, you must note that .extend() is equivalent to the following slice assignment:

In this example, you use a slice assignment to add three items after the end of your original fruits list. Note that the result is the same as when you use .extend() . However, the .extend() variation is more readable and explicit.

The .insert() method is another tool that you can use to add items to an existing list. This method is a bit different from .append() and .extend() . Instead of adding items at the right end of the list, .insert() allows you to decide where you want to put your item. That said, .insert() takes two arguments:

• index : the index at which you want to insert the item
• item : the item that you need to insert into the list

When you insert an item at a given index, Python moves all the following items one position to the right in order to make space for the new item, which will take the place of the old item at the target index:

In this example, you insert letters into specific positions in letters . You must insert one letter at a time because .insert() adds a single item in every call. To insert an item, the method shifts all the items starting from the target index to the right end of the list. This shifting makes space for the new item.

As an exercise, could you come up with a slice assignment that produces the same result as .insert() ? Click the collapsible section below for the solution:

Slice assignment equivalent to list_object.insert(index, item) Show/Hide

Here’s the equivalent slicing of an insert operation:

This statement takes an empty slice from list_object . Why empty? Well, the slicing starts at index and stops at index . Because of this, the slice doesn’t include any items.

Then the statement assigns a one-item list to the empty slice. This action results in item being inserted at index in list_object . Go ahead and give it a try!

Now that you’ve learned how to add items to an existing list using different tools and techniques, it’s time to learn how to remove unneeded items from a list, which is another common task.

Python also allows you to remove one or more items from an existing list. Again, deleting items from lists is such a common operation that the list class already has methods to help you with that. You’ll have the following methods:

The .remove() method comes in handy when you want to remove an item from a list, but you don’t know the item’s index. If you have several items with the same value, then you can remove all of them by calling .remove() as many times as the item occurs:

The first call to .remove() deletes the first instance of the number 42 . The second call removes the remaining instance of 42 . If you call .remove() with an item that’s not in the target list, then you get a ValueError .

The .pop() method allows you to remove and return a specific item using its index. If you call the method with no index, then it removes and returns the last item in the underlying list:

In these examples, the first call to .pop() removes and returns the last site in your list of sites to visit. The second call removes and returns the first site, which is the site at index 0 .

Finally, you use .pop() with -1 as an argument to emphasize that you can also use negative indices. This call removes and returns the last item. At the end of the process, your list of sites to visit is empty, pointing out that you’ve done all your planned visits.

Removing all the items from a list in one go can be another frequent task. In this case, Python also has you covered because list has a method called .clear() , which does exactly that. Consider the following example:

If you call .clear() on a non-empty list object, then you get the list content completely removed. This method can be useful when your lists work as a cache that you want to quickly clean for a restart.

The following slice assignment produces the same result as the .clear() method:

In this slice assignment, you assign an empty list to a slice that grabs the whole target list. Again, this syntax is less explicit and readable than using .clear() .

There’s still one more Python tool that you can use to remove one or more items from an existing list. Yes, that’s the del statement . You can combine del with an indexing or slicing operation to remove an item or multiple items, respectively:

With the first del statement, you remove the color at index 1 , which is "orange" . In the second del , you use a negative index of -1 to remove the last color, "violet" . Next, you use a slice to remove "green" and "blue" .

Note: To dive deeper into using the del statement, check out Python’s del : Remove References From Scopes and Containers .

In the final example, you use del and a slice to remove all the items from an existing list. That construct produces a result that’s equivalent to calling .clear() on your target list.

When you create a list, Python allocates enough space to store the provided items. It also allocates extra space to host future items. When you use the extra space by adding new items to that list with .append() , .extend() , or .insert() , Python automatically creates room for additional new items.

This process is known as resizing , and while it ensures that the list can accept new items, it requires extra CPU time and additional memory. Why? Well, to grow an existing list, Python creates a new one with room for your current data and the extra items. Then it moves the current items to the new list and adds the new item or items.

Consider the following code to explore how Python grows a list dynamically:

In this code snippet, you first import getsizeof() from the sys module. This function allows you to get the size of an object in bytes. Then you define numbers as an empty list.

Inside the for loop, you get and print your list object’s size in bytes. The first iteration shows that the size of your empty list is 56 bytes, which is the baseline size of every list in Python.

Next, the .append() method adds a new value to your list. Note how the size of numbers grows to 88 bytes. That’s the baseline size plus 32 additional bytes ( 56 + 4 × 8 = 88 ), which represent four 8-byte pointers or slots for future items. It means that Python went ahead and allocated space for four items when you added the first element.

As the loop goes, the size of numbers grows to 120 bytes, which is 88 + 4 × 8 = 120 . This step allocates space for four more items. That’s why you get 120 four times on your screen.

If you follow the loop’s output, then you’ll notice that the next steps add room for eight extra items, then for twelve, then for sixteen, and so on. Every time Python resizes the list, it has to move all the items to the new space, which takes considerable time.

In practice, if you’re working with small lists, then the overall impact of this internal behavior is negligible. However, in performance-critical situations or when your lists are large, you may want to use more efficient data types, such as collections.deque , for example.

Check out the time complexity Wiki page for a detailed summary of how time-efficient list operations are. For example, the .append() method has a time complexity of O(1) , which means that appending an item to a list takes constant time. However, when Python has to grow the list to make room for the new item, this performance will be a bit poorer.

Being aware of the time complexity of common list operations will significantly improve your ability to choose the right tool for the job, depending on your specific needs.

Concatenating and Repeating Lists

Another interesting and useful feature of Python’s list is that it supports the following two operations:

• Concatenation , which uses the plus operator ( + )
• Repetition , which uses the multiplication operator ( * )

In the following sections, you’ll learn how these two operations work on Python lists and how you can use them in your code.

Concatenation consists of joining two things together. In this case, you’d like to concatenate two lists, which you can do using the plus operator ( + ). In this context, this operator is known as the concatenation operator .

Here’s how it works:

In this example, you combine three list objects using the concatenation operator. Note how the operator creates a new list containing all the individual items from the three original lists.

Whenever you use the concatenation operator, you get a new list object as a result. Consider the following example. Keep an eye on the identity of digits :

In this example, you first create a list containing a few numbers. The id() function allows you to know the identity of this first list. Then you use a concatenation operation to complete your list of digits. Note how id() now returns a different value. This result confirms that the concatenation operator always creates a new list that joins its operands.

Note: You can only concatenate a list with another list. If you try to concatenate a list with something else, then you’ll get an exception:

Python’s concatenation operator raises a TypeError exception when you try to concatenate a list with a different data type, such as a tuple.

The concatenation operator has an augmented variation , which uses the += operator. Here’s how this operator works:

The augmented concatenation operator works on an existing list. It takes a second list and adds its items, one by one, to the end of the initial list. The operation is a shortcut to something like digits = digits + [6, 7, 8, 9] . However, it works a bit differently.

Unlike the regular concatenation operator, the augmented variation mutates the target list in place rather than creating a new list:

In this example, the id() function returns the same value in both calls, meaning that you have a single list object instead of two. The augmented concatenation mutates digits in place, so the whole process is more efficient in terms of memory and execution time than a plain concatenation would be.

Repetition consists of cloning the content of a given list a specific number of times. You can achieve this with the repetition operator ( * ), which takes two operands:

• The list whose content you want to repeat
• The number of times that you need to repeat the content

To understand how this operator works, consider the following example:

Here, you repeat the content of a list three times and get a new list as a result. In the first example, the left-hand operand is the target list, and the right-hand operand is an integer representing the number of times that you want to repeat the list’s content. In this second example, the operands are swapped, but the result is the same, as you’d expect in a multiplication operation.

The repetition operator also has an augmented variation that you’ll call the augmented repetition operator. This variation uses the *= operator. Here’s how it works:

In the highlighted expression, the left-hand operand is the target list, while the right-hand operand is the integer value. You can’t swap them.

Again, the regular repetition operator returns a new list object containing the repeated data. However, its augmented variation mutates the target list in place, which makes it more efficient. As an exercise, go ahead and use the id() function to confirm this statement.

Reversing and Sorting Lists

Reversing and specially sorting lists of values are commonplace tasks in programming. In Python, you’ll have the built-in reversed() and sorted() functions to perform these tasks. When you’re working with lists, then you also have the .reverse() and .sort() methods, which reverse and sort the target list in place.

In the following sections, you’ll learn how to reverse and sort lists using the tools that Python provides for these tasks.

The built-in reversed() function takes a sequence as an argument and returns an iterator that yields the values of that sequence in reverse order:

When you call reversed() with a list as an argument, you get a reverse iterator object. This iterator yields values from the input list in reverse order. In this example, you use the list() constructor to consume the iterator and get the reversed data as a list.

Note: To dive deeper into reversing lists in Python, check out Reverse Python Lists: Beyond .reverse() and reversed() .

The reversed() function doesn’t modify the input object. You’ll typically use reversed() in loops as a way to iterate over your data in reverse order. If you need to keep a reference to your data, then you can use list() and assign its return value to a new variable, which will be completely independent of your original sequence.

It’s important to note that reversed() retrieves items from the input sequence lazily. This means that if something changes in the input sequence during the reversing process, then those changes will reflect in the final result:

In this example, you use the built-in next() function to consume the iterator value by value. The first call to next() returns the last item from numbers . Then you update the value of the second item from 2 to 222 . When you call next() again, you get 222 instead of 2 . This is because reversed() doesn’t create a copy of the input iterable. Instead, it works with a reference to it.

The reversed() function is great when you want to iterate over a list in reverse order without altering the original list. What if you have a list, and for some reason, you need to reverse its content persistently? In that case, you can use the .reverse() method:

The .reverse() method reverses a list in place. This means that if you call .reverse() on an existing list, then the changes will reflect in the underlying list.

Keep in mind that while reversed() returns an iterator, the .reverse() method returns None . This behavior may be the source of subtle errors when you’re starting to use lists. Consider the following code:

In this example, reversed_digits doesn’t get a list of reversed digits. Instead, it gets None because .reverse() mutates the underlying list in place and has no fruitful return value.

Finally, slicing is another technique that you can use to get a reversed copy of an existing list. To do this, you can use the following slicing operation:

The [::-1] variation of the slicing operator does the magic in this code. With this operator, you create a reversed copy of the original list. But how does it work? The third index, step , is typically a positive number, which is why a normal slicing operation extracts the items from left to right.

By setting step to a negative number, such as -1 , you tell the slicing operator to extract the items from right to left. That’s why you get a reversed copy of digits in the example above.

When you need to sort a list of values without altering the original list, you can use the built-in sorted() function. This function takes an iterable of values and returns a list of sorted values:

When you pass a list to sorted() , you get a list of sorted values as a result. The function doesn’t alter the original data in your list.

Note: It’s important to note that sorted() returns a list rather than an iterator. This behavior differs from reversed() , which returns an iterator instead of a list.

As you can see in the above example, Python sorts numbers according to their specific values. When it comes to sorting strings, things can be a bit confusing. Consider the following example:

What? The sorted list isn’t in alphabetical order. Why? Python sorts strings character by character using each character’s Unicode code point . Because uppercase letters come before lowercase letters in Python’s default character set , UTF-8 , you end up with "Hello" in the first position and "am" in the last.

Note: To dive deeper into sorting tools, check out How to Use sorted() and .sort() in Python .

You can use the built-in ord() function to get the Unicode code point of a character in Python:

As you can confirm in this code snippet, the uppercase "H" comes before the lowercase "a" in the Unicode table. That’s why you get "Hello" before "am" in the above example.

By default, the sorted() function sorts the items of a list in ascending order. If you need to sort the items in descending order, then you can use the reverse keyword-only argument . This argument defaults to False . If you set it to True , then you get the data in descending order:

By setting the reverse argument to True , you tell sorted() to sort the input iterable in reverse order. Isn’t that neat?

Note: As you already learned, lists can store objects of different types. However, heterogeneous lists often don’t allow you to sort their content:

In practice, you won’t find heterogeneous lists in many use cases. Sequences of heterogeneous objects are like a database record with a few known and immutable fields. In those cases, using a tuple is a better way to go.

To illustrate how sorted() can help you in the real world, say that you want to calculate the median of a numeric dataset or sample. The median is the value that lies in the middle when you sort the data. In most cases, your data won’t be sorted, so sorting will be the first step. Then you just need to locate the value in the middle.

If the number of values in your dataset is even, then the median is the average of the two values in the middle. Here’s a Python function that allows you to compute the median of a sample of values:

Inside median() , you use sorted() to sort the samples in ascending order. Then you check if your list has an odd number of data points, in which case, you return the item in the middle directly. If the list has an even number of samples, then you compute the index of the two items in the middle, calculate their average, and return the resulting value.

The sorted() function also accepts another keyword-only argument called key . This argument allows you to specify a one-argument function that will extract a comparison key from each list item.

As an example of how to use key , say that you have a list of tuples where each tuple holds an employee’s data, including the employee’s name, age, position, and salary. Now imagine that you want to sort the employees by their age.

In that situation, you can do something like the following:

In this example, you pass a lambda function to the key argument. This lambda takes an employee tuple as an argument and returns the age value, which lives at index 1 . Then sorted() uses this value to sort the tuples.

The key argument is quite useful in practice because it allows you to fine-tune the sorting process by changing the sorting criteria according to your specific needs.

If you need to sort a list in place instead of getting a new list of sorted data, then you can use the .sort() method. This method is similar to the sorted() function:

The main difference between sorted() and .sort() is that the former returns a new list of sorted data, while the latter sorts the target list in place. Also, because .sort() is a method, you need to call it on a list object.

Like most list methods that run mutations, .sort() returns None . For example, in the code below, you run into a common mistake that can occur when working with lists:

The .sort() method sorts the list in place and returns None to remind users that it operates by side effect . You must keep this behavior in mind because it can lead to subtle bugs.

You can also use the reverse and key keyword-only arguments with .sort() . They have the same meaning and functionality as the equivalent arguments in the sorted() function. Go ahead and give them a try!

Traversing Lists

When you’re working with lists in Python, one of the most common tasks that you’ll have to perform is to traverse the list while you run some transformation on the data or use the data for other purposes.

To traverse a list, you’ll need a loop that goes over each element from the start to the end of the list. Python provides several constructs that allow you to do this. The most popular are for loops and list comprehensions. You can also use some of Python’s functional programming tools for traversing lists.

In the following sections, you’ll learn how to traverse an existing list using these tools. To kick things off, you’ll start with for loops.

The recommended way to iterate over a list is to use a for loop. This kind of loop is quite readable and straightforward in Python. Here’s how it goes:

To use a for loop with a list, you place the list after the in keyword and provide a suitable loop variable. Don’t you think this loop is beautiful? Its meaning is clear, and it reads like plain English. That’s great!

Python’s for loops are intrinsically ready to operate on any iterable input directly. In this example, you’re using a list, but it’d work the same with a tuple, string, set, or any other iterable.

In the above example, the target iterable is your colors list. The loop variable, color , holds the current color in each iteration, and you can process each color in the loop’s body as needed. Note that if your list has a plural noun as its name, then the loop variable can use the same name in singular. This tiny detail will improve your loop’s readability.

A coding pattern that you’ll usually notice in code by people who come from other programming languages is that they tend to iterate over lists using a for loop that looks something like this:

This loop iterates over a range of integer numbers from 0 up to the length of the target list. In each iteration, you use the current index to access the associated item in the underlying list. Even though this loop works, it’s not Pythonic and is considered bad practice.

You don’t have to use a range of indices to iterate over a list in a for loop. Just go ahead and use your list directly in the loop definition. Python will take care of the rest.

Some people will argue that, in many situations, you’ll need to know the index of the current item to be able to perform some computations. That’s right! It’s especially true when you’re dealing with complex algorithms that operate on indices. In those cases, Python has you covered as well. It offers you the built-in enumerate() function, which you can use as in the following example:

The enumerate() function takes an iterable and returns an iterator. This iterator yields two-item tuples on demand. Each tuple will contain an index and the associated item.

Note: The enumerate() function also takes a second argument called start , which is optional and defaults to 0 . This argument allows you to specify a different starting point for the item count. However, if you set this argument to something different from 0 , then the resulting values won’t match the items’ indices in the underlying list.

To learn more about enumerate() , check out Python enumerate() : Simplify Loops That Need Counters .

Python provides many other tools that you can use when you’re iterating through a list of values. For example, you can use reversed() to iterate over the list in reverse order:

In this loop, you take advantage of the reversed() function to traverse your list of colors in reverse order, which might be a common requirement in your code.

Another common need is to traverse the list in sorted order. In this situation, you can use your old friend sorted() as in the code below:

The sorted() function allows you to get a new list of sorted data from your original list. Then you iterate over the new sorted list as usual.

If you continue digging into the Python tool kit, then you’ll find many other tools that will allow you to traverse your lists in different ways. For example, you’ll have the zip() function, which allows you to iterate over multiple lists in parallel:

In this example, you use zip() to iterate over three lists in parallel. The zip() function returns an iterator of tuples. The elements of each tuple come from the input iterables. In this example, the tuples combine items from integers , letters , and floats .

Note: For a deep dive into using the built-in zip() function, check out Using the Python zip() Function for Parallel Iteration .

Up to this point, all your list-traversing examples iterate over a list without performing any modification on the list itself. Modifying a list during iteration can lead to unexpected behavior and bugs, so avoid this practice. As a rule of thumb, if you need to modify the content of a list in a loop, then take a copy of that list first.

Say that you have a list of numbers, and you want to remove only odd values. In this situation, you can try something like this as your first attempt:

Unfortunately, only 9 and 1 were removed, while 5 remained in your list. This unexpected and incorrect behavior happened because removing items from a list shifts their indices, which interferes with the indices inside a running for loop. You can avoid this problem in a few ways.

For example, you can iterate over a copy of the original list:

This time, the result is correct. You use the [:] operator to create a shallow copy of your list. This copy allows you to iterate over the original data in a safe way. Once you have the copy, then you feed it into the for loop, as before.

Alternatively, you can iterate over the list in reverse order:

When you remove only the last item from the right end of a list on each iteration, you change the list length, but the indexing remains unaffected. This lets you correctly map indices to the corresponding list elements.

Note that this was just an illustrative example that relied on cherry-picked data. Remember that calling .remove() deletes the first occurrence of the given value, starting from the left side of the list, instead of the last one. If you had duplicate values on the list, then list elements would be removed in a different order.

While modifying list elements during iteration is less of a problem than deleting them, it also isn’t considered a good practice. It’s usually more desirable to create a completely new list and populate it with the transformed values:

This example shows a pretty common pattern in Python. The pattern consists of creating an empty list and then populating it in a loop. You’ll find this pattern in several Python codebases all around. It provides an intuitive and readable way to populate a list from scratch. However, you’ll often find that you can replace this pattern with something even better, a list comprehension.

List comprehensions are another great, popular way to traverse your lists. Comprehensions are fundamentally a list transformation tool. They allow you to create lists with transformed data out of another list or iterable.

To understand how comprehensions can help you transform your lists, refer to the example where you have a list of numbers as strings and want to turn them into integers. You can solve this problem with the following comprehension:

This comprehension iterates over the values in your original list. The expression in the comprehension runs the conversion from string to integer. The final result is a new list object, which you assign back to the numbers variable.

Note that this comprehension is equivalent to a loop with the enumerate() function:

The loop is more verbose and complicated because you need to call enumerate() and declare an extra indexing variable, i . On the other hand, the loop modifies the original list in place, while the list comprehension creates a new list.

You can also use comprehensions to filter existing lists. For example, say that you have a list of integer values and want to create a new list containing only the even values out of your original list:

The if clause in this list comprehension works as a filter that selects only the even numbers from your original data. How would you write a similar comprehension to retrieve the odd numbers?

You can also take advantage of some Python functional programming tools, such as map() and filter() , to traverse a list of values. These functions have an internal loop that iterates over the items of an input iterable and returns a given result.

For example, the map() function takes a transformation function and an iterable as arguments. Then it returns an iterator that yields items that result from applying the function to every item in the iterable.

Using map() , you can convert your list of numbers to integers with the following code:

In this example, map() applies int() to every item in numbers in a loop. Because map() returns an iterator, you’ve used the list() constructor to consume the iterator and show the result as a list.

Note: For a deeper dive into using the map() function, check out Python’s map() : Processing Iterables Without a Loop .

If you need to filter values from an existing list, then you can use the built-in filter() function. This function takes two arguments: a predicate function and an iterable of data. Then it returns an iterator that yields items that meet a given condition, which the predicate function tests for.

Here’s how filter() works in practice:

In this example, you use filter() to traverse your integers list and extract those values that satisfy the condition of being even numbers.

Note: For a deeper dive into using the filter() function, check out Python’s filter() : Extract Values From Iterables .

In Python, you’ll find a few other built-in and standard-library functions that allow you to traverse a list of values and obtain a final result either as another list, an iterator, or even a single value. Some examples include reduce() , min() and max() , sum() , all() , and any() . Note that some of these functions aren’t really functional programming tools, but they internally iterate over the input list.

Exploring Other Features of Lists

Python’s list has an impressive set of features, making it a versatile, flexible, and powerful data structure. So far, you’ve learned about most of these features. You’ve learned to create lists, add and remove items from your lists, traverse existing lists in a loop or comprehension, and much more.

In the following sections, you’ll learn about some additional features that make lists even more powerful. You’ll learn how to find items in a list, determine the minimum and maximum values, and get the list’s length. You’ll also explore the details of how Python compares lists to each other.

Python has a few tools that allow you to search for values in an existing list. For example, if you only need to quickly determine whether a value is present in a list, but you don’t need to grab the value, then you can use the in or not in operator, which will run a membership test on your list.

Note: To learn more about the in and not in operators and how to perform membership tests, check out Python’s “in” and “not in” Operators: Check for Membership . These operators can be pretty useful when you need to check if a Python string contains a substring .

As its name suggests, a membership test is a Boolean test that allows you to find out whether an object is a member of a collection of values. The general syntax for membership tests on list objects looks something like this:

The first expression allows you to determine if item is in list_object . It returns True if it finds item in list_object or False otherwise. The second expression works in the opposite way, allowing you to check if item is not in list_object . In this case, you get True if item doesn’t appear in list_object .

Here’s how membership tests work in practice:

In this example, you have a list of users and want to determine whether some specific users are registered in your system.

The first test uses in to check whether the user linda is registered. You get False because that user isn’t registered. The second test uses the not in operator, which returns True as a confirmation that linda isn’t one of your users.

The .index() method is another tool that you can use to find a given value in an existing list. This method traverses a list looking for a specified value. If the value is in the list, then the method returns its index. Otherwise, it raises a ValueError exception:

In the first call to .index() , you get the index where you can find the user named "eve" . You can use this index later in your code to access the actual object as needed. In the second call, because the user "linda" isn’t in the list, you get a ValueError with an explanatory message.

Note that if your search’s target value appears several times in the list, then .index() will return the index of the first occurrence:

The .index() method returns as soon as it finds the input value in the underlying list. So, if the value occurs many times, then .index() always returns the index of the first occurrence.

Lists provide yet another method that you can use for searching purposes. The method is called .count() , and it allows you to check how many times a given value is present in a list:

The .count() method takes an item as an argument and returns the number of times the input item appears in the underlying list. If the item isn’t in the list, then you get 0 .

Searching for a specific value in a Python list isn’t a cheap operation. The time complexity of .index() , .count() , and membership tests on lists is O(n) . Such linear complexity may be okay if you don’t need to perform many lookups. However, it can negatively impact performance if you need to run many of these operations.

While working with Python lists, you’ll face the need to obtain descriptive information about a given list. For example, you may want to know the number of items in the list, which is known as the list’s length . You may also want to determine the greatest and lowest values in the list. In all these cases, Python has you covered.

To determine the length of a list, you’ll use the built-in len() function. In the following example, you use this function as an intermediate step to calculate the average grade of a student:

Here, you calculate the average grade of a student. To do this, you use the sum() function to get the total sum and len() to get the number of evaluated subjects, which is the length of your grades list.

It’s important to note that because lists keep track of their length, calling len() is pretty fast, with a time complexity of O(1) . So, in most cases, you don’t need to store the return value of len() in an intermediate variable as you did in the example above.

Note: To learn more about using the len() function, check out Using the len() Function in Python .

Another frequent task that you’ll perform on lists, especially on lists of numeric values, is to find the minimum and maximum values. To do this, you can take advantage of the built-in min() and max() functions:

In these examples, you call min() and max() with a list of integer numbers . The call to min() returns the smallest number in the input list, -5 . In contrast, the call to max() returns the largest number in the list, or 9 .

Note: For a deeper dive into using the built-in min() and max() functions, check out Python’s min() and max() : Find Smallest and Largest Values .

Overall, Python lists support the len() , min() , and max() functions. With len() , you get the length of a list. With min() and max() , you get the smallest and largest values in a list. All these values can be fairly useful when you’re working with lists in your code.

You can also face the need to compare lists. Fortunately, list objects support the standard comparison operators . All these operators work by making item-by-item comparisons within the two involved lists:

When you compare two lists, Python uses lexicographical ordering . It compares the first two items from each list. If they’re different, this difference determines the comparison result. If they’re equal, then Python compares the next two items, and so on, until either list is exhausted.

In these examples, you compare lists of numbers using the standard comparison operators. In the first expression above, Python compares 2 and 2 , which are equal. Then it compares 3 and 3 to conclude that both lists are equal.

In the second expression, Python compares 5 and 5 . They’re equal, so Python has to compare 6 and 6 . They’re equal too, so the final result is False .

In the rest of the expressions, Python follows the same pattern to figure out the comparison. In short, Python compares lists in an item-by-item manner using lexicographical comparison. The first difference determines the result.

You can also compare lists of different lengths:

In the first expression, you get True as a result because 5 is less than 8 . That fact is sufficient for Python to solve the evaluation. In the second example, you get False . This result makes sense because the lists don’t have the same length, so they can’t be equal.

As you can see, comparing lists can be tricky. It’s also an expensive operation that, in the worst case, requires traversing two entire lists. Things get more complex and expensive when you compare lists of strings. In this situation, Python will also have to compare the strings character by character, which adds cost to the operation.

If you’re new to Python and are starting with lists, then you’ll want to be on the lookout for a few gotchas that can cause subtle issues in your code. Up to this point, you’ve learned what you need in order to understand most of these gotchas, so here’s a summary of the most common ones:

• Confusing aliases of a list with copies : This can cause issues because changes to one alias affect others. Take a look at the Aliases of a List section for practical examples of this issue.
• Forgetting that most list methods mutate the list in place and return None rather than a new list : This commonly leads to issues when you assign the return value of a list method to a variable, thinking that you have a new list, but you really get None . Check out the Reversing and Sorting Lists section for practical examples of this gotcha.
• Confusing .append() with .extend() : This can cause issues because .append() adds a single item to the end of the list, while the .extend() method unpacks and adds multiple items. Have a look at the Growing and Shrinking Lists Dynamically section for details on how these methods work.
• Using an empty list as a default argument value in function definitions : This can lead to unexpected behaviors because default argument values get defined when Python first parses the function.

You already know the explanation of the first three bullet points in this list. So, you only have to dive deeper into the last point. Why should you avoid using an empty list—or a list in general—as a default argument value? To answer this question, consider the following toy function:

This function appends item to the end of target , which defaults to an empty list. At first glance, it may seem that consecutive calls to append_to() will return single-item lists like in the following hypothetical example:

But because Python defines the default argument value when it first parses the function and doesn’t overwrite it in every call, you’ll be working with the same list object in every call. Therefore, you don’t get the above behavior. Instead, you get the following:

The target list remembers the data between calls. This happens because you’re using the same list object that appears as the default value in the function’s definition.

To prevent this issue, you can use None as the default value:

Great! You’ve solved the issue. Now your function returns single-item lists as expected. That’s because the function doesn’t retain the state between calls.

Sometimes you may need to create a list-like class that either extends the features of list or customizes some of its standard behaviors. For a long time, it was impossible to inherit directly from built-in Python types implemented in C . Python 2.2 fixed this issue. Now you can subclass built-in types , including list .

To understand how to do this, say that you’re working on an application to process and report your students’ grades. You want to create a list-like object to store the grades. Your custom list should have a method that computes the average grade. In this situation, you can create a list subclass like the following:

In this code snippet, you inherit from list directly. You can instantiate GradeList with an iterable of grade values. Note that the class works as a regular list. You can use list methods, such as .append() and .extend() , do indexing and slicing, and so on.

Additionally, you have a new .average() method in the class. This method isn’t part of the standard functionality of a list. So, this method extends list with new functionality.

The above example is a relatively safe way to subclass list because it doesn’t touch on any standard behavior. In contrast, things get a bit trickier when you need to customize the standard list behaviors.

For example, say that you want to continue improving your GradeList class, and you’re thinking of adding some input validation functionality. You want your class to validate any input grade to make sure it’s a number between 1 and 100 .

In this situation, you need to make considerable changes to the standard functionality of list . You’ll need to modify all the methods that add new items to your lists. These methods include the following special methods :

• .__init__() , which initializes all the class’s new instances.
• .__setitem__() , which supports indexing operations.

You’ll also have to customize the .append() , .extend() , and .insert() methods. Furthermore, if you want your class to validate the input when you run concatenations, then you’ll have to update other special methods, including .__add__() , .__radd__() , and .__iadd__() .

Here’s a possible, yet minimal, update of your GradeList class:

This class extends all the standard methods that add items to a regular list. All of these methods use the ._validate() helper method to guarantee that the input grades are valid. The method checks whether the values are numbers. It also checks if they’re between 0 and 100 .

As you can conclude from the above code, modifying the standard behavior of a list in a subclass requires a lot of work, and it’s highly prone to errors.

Here are a few examples of how the above class works in practice:

Great! Your GradeList class works as expected. It raises an exception whenever you try to introduce an invalid grade using any of the regular operations that add items to an existing list.

Note: For a deeper dive into creating list-like classes, check out Custom Python Lists: Inheriting From list vs UserList .

Subclassing the built-in list class can be both useful and challenging. While you can extend a list with relatively little effort, customizing its standard behavior comes with important challenges, as you learned in this section. So, before making the decision to subclass list , consider whether other techniques, such as composition , might be a better solution.

Putting Lists Into Action

So far, you’ve learned a ton about Python lists, their features, and their functionalities. You’ve dived into how to create new lists, make copies of existing lists, add items to your lists, traverse existing lists in a loop or a similar tool, create custom list-like classes, and much more.

Now you have all the required knowledge about lists to effectively solve common practical Python coding problems with them. In the following sections, you’ll code a few examples to help you solidify your new knowledge and understand how to use lists in real life.

Removing repeated items from an existing list is often a requirement in Python. You’ll probably manage to figure out several approaches to this problem. Using a set object could be one of them because sets don’t allow repeated items. So, you can do something like this:

This solution works because you get a new list of unique values. However, Python sets don’t necessarily keep the contained items in order. So, you may want to use another technique that preserves the original insertion order.

Arguably, the safest way to tackle the problem of removing repeated items from a list is to create a new list with unique values out of the original list. You can do this in a function like the following:

In this function, you accept a list as an argument. Then you define a new empty list to store the function’s result. In the loop, you iterate over the items in the input list. The conditional checks if the current item is absent in result . If that’s the case, then you add the item using .append() . Once the loop has finished, you return the resulting list, which will contain unique values.

Note that using the not in operator on larger lists can be too slow due to its linear time complexity. If that’s the case, then you may want to introduce an additional helper variable to hold copies of the unique values in a Python set :

You use the set to quickly determine if the given value is already present. Sets implement the in and not in operators differently, making them much faster than their list counterparts. While this functions returns instantaneously, it requires twice as much memory because you’re now storing every value in two places.

Creating a multidimensional list, such as a matrix or a list of lists, might also be a common requirement in your code. Again, you can tackle this problem in many different ways, depending on your specific needs.

A quick and safe way to create a multidimensional list is using a for loop or a comprehension. For example, say that you want to create a five-by-five matrix of numeric values, and you want to initialize all the values to 0 . You can do something like this:

In this example, you first create an empty list to store your matrix. Then you start a for loop that will run five times. In each iteration, you add a new empty list. So, your matrix will have five rows. Next, you start a nested loop that runs five times too.

Each time, you add a 0 to the current row using .append() . As a result, you get a five-by-five matrix with all its values initialized to 0 .

Note: In Python, you commonly use an underscore ( _ ) as a placeholder variable when the syntax requires a variable, but your code doesn’t.

You can get the same result as in the example above with a list comprehension like the following:

In this example, you use a list comprehension whose expression is another list comprehension. The inner comprehension provides the nested lists, while the outer comprehension builds the matrix.

You can make the above comprehension even more concise and readable by taking advantage of the repetition operator ( * ) as in the following code:

This new version of your list comprehension is way more readable than the previous one. It takes advantage of the repetition operator to build the rows of your matrix. This example might it seem like the following would work:

This output looks like what you need. It’s a list containing five nested lists. However, this resulting matrix internally works pretty differently from all the previous solutions. If you change one value in a given row, then the change will reflect in all the other rows:

In this example, you try to change the value of the first item in the first nested list or row. However, you actually changed the first value in all the rows. When you pass a list as an argument to the repetition operator, you get aliases of the list instead of copies. So, all the rows in your matrix are actually the same list.

Sometimes, you may need to process data that comes as a list of nested lists. Flattening this data into a one-dimensional list may be a common requirement in those scenarios. By flattening a list, you convert a multidimensional list, such as a matrix, into a one-dimensional list.

Note: To dive deeper into how to flatten a list of lists, check out How to Flatten a List of Lists in Python .

For example, suppose that you have the following list of lists:

Processing this list may be annoying because of its nested structure. So you need to flatten the list and get the following list instead:

How would you do this in Python? You’ll find several solutions to this problem for sure. In the code snippet below, you have one of them:

In the for loop above, you iterate over the nested lists in matrix . Then you use the .extend() method to add the current sublist’s contents to flattened_list as independent items. This loop produces a flattened list as a result.

Another useful list-related skill is to split an existing list into a certain number of chunks. This skill comes in handy when you need to distribute the workload across multiple threads or processes for concurrent processing.

Note: For a complete walk-through of splitting a list or iterable into chunks, check out How to Split a Python List or Iterable Into Chunks .

Again, you’ll find multiple solutions to this problem. The code below shows just one of them. Note that you won’t be using any standard-library or third-party specialized tool. You’ll code the solution based on your knowledge about lists:

In this function, you take the list to split and the number of items in every resulting chunk. Then you define a new empty list to store the chunks. The for loop iterates over a range of indices that goes from 0 to the length of your input list. Every iteration jumps through the desired chunk size.

To extract the chunks, you use a slicing operation. The loop variable, start , defines the start index, while the stop variable provides the stop index. Then you append every chunk to your chunks list, and that’s it.

You can use a Python list to emulate a stack or queue data structure. The .append() and .pop() methods will help you in that task. For example, to mimic a stack, or last-in-first-out (LIFO) data structure, you can use .append() to push an item onto the top of the stack. Similarly, you can use .pop() with no arguments to pop items from the top of the stack:

In this example, you represent a stack using a list. The stack will hold actions that you can undo. You start by creating an empty list called stack . Then you push hypothetical actions onto the stack using .append() , which adds the actions to the right end of the list.

The .pop() method returns the actions so that you can redo them. This method also removes the actions from the right end of the list following the LIFO order that distinguishes a stack data structure.

Note: For a deep dive into what stacks are and how to create them in Python, check out How to Implement a Python Stack .

Alternatively, if you want to emulate a queue, or a first-in-first-out (FIFO) data structure, then you can use .append() to place items at the end of the list, which is known as an enqueue operation. Similarly, you can use .pop() with 0 as an argument to return and remove items from the left end of the queue, which is known as a dequeue :

This list simulates a queue of people who may be arriving at a place to get some service. The .append() method allows you to add people to the end of the queue as they arrive. The .pop() method with 0 as an argument allows you to process people from the beginning of the queue when it’s their turn to access the service. Overall, you’re following the FIFO principle that rules queues.

Note: Check out Python Stacks, Queues, and Priority Queues in Practice for a complete walk-through of stacks and queues in Python.

By using a Python list, you can quickly take advantage of the standard list functionality to provide basic stack and queue operations, such as push, pop, enqueue, and dequeue. However, keep in mind that even though lists can help you simulate stacks and queues, they aren’t optimized for these use cases. Using a list as a queue is especially bad because it can make the queue terribly slow .

As you’ve learned throughout this tutorial, lists are powerful, flexible, versatile, and full-featured data structures. Because of their characteristics, people tend to use and abuse them. Yes, they’re suitable for many use cases, but sometimes they aren’t the best available option.

In general, you should use lists when you need to:

• Keep your data ordered : Lists maintain the order of insertion of their items.
• Store a sequence of values : Lists are a great choice when you need to store a sequence of related values.
• Mutate your data : Lists are mutable data types that support multiple mutations.
• Access random values by index : Lists allow quick and easy access to elements based on their index.

In contrast, avoid using lists when you need to:

• Store immutable data : In this case, you should use a tuple. They’re immutable and more memory efficient.
• Represent database records: In this case, consider using a tuple or a data class .
• Store unique and unordered values : In this scenario, consider using a set or dictionary. Sets don’t allow duplicated values, and dictionaries can’t hold duplicated keys.
• Run many membership tests where item doesn’t matter : In this case, consider using a set . Sets are optimized for this type of operation.
• Run advanced array and matrix operations : In these situations, consider using NumPy’s specialized data structures.
• Manipulate your data as a stack or queue : In those cases, consider using deque from the collections module or Queue , LifoQueue , or PriorityQueue . These data types are thread-safe and optimized for fast inserting and removing on both ends.

Depending on your specific scenario, lists may or may not be the right tool for the job. Therefore, you must carefully evaluate your needs and consider advanced data structures like the ones listed above.

Now you have a deep, solid understanding of the core features and functionalities of Python lists . Lists are everywhere. They’re an important part of the language itself and are present in the standard library , third-party packages, and in just about every piece of Python code that you’ll find out there. So, learning about them is a fundamental skill that you must have under your belt.

In this tutorial, you’ve learned how to:

• Create new lists in Python using different approaches
• Access one or more items in an existing list
• Copy , update , grow , shrink , and concatenate existing Python lists
• Sort , reverse , and traverse existing lists using built-in functions and methods
• Use some other features of lists

With all this knowledge, you’re ready to write better, more effective code by taking advantage of Python lists. You’re also empowered to make informed decisions about when to use lists in your code.

🐍 Python Tricks 💌

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About Leodanis Pozo Ramos

Leodanis is an industrial engineer who loves Python and software development. He's a self-taught Python developer with 6+ years of experience. He's an avid technical writer with a growing number of articles published on Real Python and other sites.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal . Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session . Happy Pythoning!

Keep Learning

Related Topics: intermediate data-structures python

Related Tutorials:

• Dictionaries in Python
• Python's tuple Data Type: A Deep Dive With Examples
• Sets in Python
• Lists vs Tuples in Python
• Strings and Character Data in Python

Keep reading Real Python by creating a free account or signing in:

Already have an account? Sign-In

Almost there! Complete this form and click the button below to gain instant access:

Python's list Data Type: A Deep Dive With Examples (Sample Code)

🔒 No spam. We take your privacy seriously.

Python Programming

Practice Python Exercises and Challenges with Solutions

Free Coding Exercises for Python Developers. Exercises cover Python Basics , Data structure , to Data analytics . As of now, this page contains 18 Exercises.

What included in these Python Exercises?

Each exercise contains specific Python topic questions you need to practice and solve. These free exercises are nothing but Python assignments for the practice where you need to solve different programs and challenges.

• All exercises are tested on Python 3.
• Each exercise has 10-20 Questions.
• The solution is provided for every question.
• Practice each Exercise in Online Code Editor

These Python programming exercises are suitable for all Python developers. If you are a beginner, you will have a better understanding of Python after solving these exercises. Below is the list of exercises.

Select the exercise you want to solve .

Basic Exercise for Beginners

Practice and Quickly learn Python’s necessary skills by solving simple questions and problems.

Topics : Variables, Operators, Loops, String, Numbers, List

Python Input and Output Exercise

Solve input and output operations in Python. Also, we practice file handling.

Topics : print() and input() , File I/O

Python Loop Exercise

This Python loop exercise aims to help developers to practice branching and Looping techniques in Python.

Topics : If-else statements, loop, and while loop.

Python Functions Exercise

Practice how to create a function, nested functions, and use the function arguments effectively in Python by solving different questions.

Topics : Functions arguments, built-in functions.

Python String Exercise

Solve Python String exercise to learn and practice String operations and manipulations.

Python Data Structure Exercise

Practice widely used Python types such as List, Set, Dictionary, and Tuple operations in Python

Python List Exercise

This Python list exercise aims to help Python developers to learn and practice list operations.

Python Dictionary Exercise

This Python dictionary exercise aims to help Python developers to learn and practice dictionary operations.

Python Set Exercise

This exercise aims to help Python developers to learn and practice set operations.

Python Tuple Exercise

This exercise aims to help Python developers to learn and practice tuple operations.

Python Date and Time Exercise

This exercise aims to help Python developers to learn and practice DateTime and timestamp questions and problems.

Topics : Date, time, DateTime, Calendar.

Python OOP Exercise

This Python Object-oriented programming (OOP) exercise aims to help Python developers to learn and practice OOP concepts.

Topics : Object, Classes, Inheritance

Python JSON Exercise

Practice and Learn JSON creation, manipulation, Encoding, Decoding, and parsing using Python

Python NumPy Exercise

Practice NumPy questions such as Array manipulations, numeric ranges, Slicing, indexing, Searching, Sorting, and splitting, and more.

Python Pandas Exercise

Practice Data Analysis using Python Pandas. Practice Data-frame, Data selection, group-by, Series, sorting, searching, and statistics.

Python Matplotlib Exercise

Practice Data visualization using Python Matplotlib. Line plot, Style properties, multi-line plot, scatter plot, bar chart, histogram, Pie chart, Subplot, stack plot.

Random Data Generation Exercise

Practice and Learn the various techniques to generate random data in Python.

Topics : random module, secrets module, UUID module

Python Database Exercise

Practice Python database programming skills by solving the questions step by step.

Use any of the MySQL, PostgreSQL, SQLite to solve the exercise

Exercises for Intermediate developers

The following practice questions are for intermediate Python developers.

If you have not solved the above exercises, please complete them to understand and practice each topic in detail. After that, you can solve the below questions quickly.

Exercise 1: Reverse each word of a string

Expected Output

• Use the split() method to split a string into a list of words.
• Reverse each word from a list
• finally, use the join() function to convert a list into a string

Steps to solve this question :

• Split the given string into a list of words using the split() method
• Use a list comprehension to create a new list by reversing each word from a list.
• Use the join() function to convert the new list into a string
• Display the resultant string

Exercise 2: Read text file into a variable and replace all newlines with space

Given : Assume you have a following text file (sample.txt).

Expected Output :

• First, read a text file.
• Next, use string replace() function to replace all newlines ( \n ) with space ( ' ' ).

Steps to solve this question : -

• First, open the file in a read mode
• Next, read all content from a file using the read() function and assign it to a variable.
• Display final string

Exercise 3: Remove items from a list while iterating

Description :

In this question, You need to remove items from a list while iterating but without creating a different copy of a list.

Remove numbers greater than 50

Expected Output : -

• Get the list's size
• Iterate list using while loop
• Check if the number is greater than 50
• If yes, delete the item using a del keyword
• Reduce the list size

Solution 1: Using while loop

Solution 2: Using for loop and range()

Exercise 4: Reverse Dictionary mapping

Exercise 5: display all duplicate items from a list.

• Use the counter() method of the collection module.
• Create a dictionary that will maintain the count of each item of a list. Next, Fetch all keys whose value is greater than 2

Solution 1 : - Using collections.Counter()

Solution 2 : -

Exercise 6: Filter dictionary to contain keys present in the given list

Exercise 7: print the following number pattern.

Refer to Print patterns in Python to solve this question.

• Use two for loops
• The outer loop is reverse for loop from 5 to 0
• Increment value of x by 1 in each iteration of an outer loop
• The inner loop will iterate from 0 to the value of i of the outer loop
• Print value of x in each iteration of an inner loop
• Print newline at the end of each outer loop

Exercise 8: Create an inner function

Question description : -

• Create an outer function that will accept two strings, x and y . ( x= 'Emma' and y = 'Kelly' .
• Create an inner function inside an outer function that will concatenate x and y.
• At last, an outer function will join the word 'developer' to it.

Exercise 9: Modify the element of a nested list inside the following list

Change the element 35 to 3500

Exercise 10: Access the nested key increment from the following dictionary

Under Exercises: -

Python Object-Oriented Programming (OOP) Exercise: Classes and Objects Exercises

Updated on:  December 8, 2021 | 52 Comments

Python Date and Time Exercise with Solutions

Updated on:  December 8, 2021 | 10 Comments

Python Dictionary Exercise with Solutions

Updated on:  May 6, 2023 | 56 Comments

Python Tuple Exercise with Solutions

Updated on:  December 8, 2021 | 96 Comments

Python Set Exercise with Solutions

Updated on:  October 20, 2022 | 28 Comments

Python if else, for loop, and range() Exercises with Solutions

Updated on:  September 3, 2024 | 301 Comments

Updated on:  August 2, 2022 | 157 Comments

Updated on:  September 6, 2021 | 109 Comments

Python List Exercise with Solutions

Updated on:  December 8, 2021 | 203 Comments

Updated on:  December 8, 2021 | 7 Comments

Python Data Structure Exercise for Beginners

Updated on:  December 8, 2021 | 116 Comments

Python String Exercise with Solutions

Updated on:  October 6, 2021 | 221 Comments

Updated on:  March 9, 2021 | 24 Comments

Updated on:  March 9, 2021 | 52 Comments

Updated on:  July 20, 2021 | 29 Comments

Python Basic Exercise for Beginners

Updated on:  August 29, 2024 | 501 Comments

Useful Python Tips and Tricks Every Programmer Should Know

Updated on:  May 17, 2021 | 23 Comments

Python random Data generation Exercise

Updated on:  December 8, 2021 | 13 Comments

Python Database Programming Exercise

Updated on:  March 9, 2021 | 17 Comments

• Online Python Code Editor

Updated on:  June 1, 2022 |

About PYnative

PYnative.com is for Python lovers. Here, You can get Tutorials, Exercises, and Quizzes to practice and improve your Python skills .

Explore Python

• Learn Python
• Python Basics
• Python Databases
• Python Exercises
• Python Quizzes
• Python Tricks

To get New Python Tutorials, Exercises, and Quizzes

Legal Stuff

We use cookies to improve your experience. While using PYnative, you agree to have read and accepted our Terms Of Use , Cookie Policy , and Privacy Policy .

Copyright © 2018–2024 pynative.com

• Python Course
• Python Basics
• Interview Questions
• Python Quiz
• Popular Packages
• Python Projects
• Practice Python
• AI With Python
• Learn Python3
• Python Automation
• Python Web Dev
• DSA with Python
• Python OOPs
• Dictionaries

How to iterate through a nested List in Python?

In this article, we are going to see how to iterate through a nested List. A list can be used to store multiple Data types such as Integers, Strings, Objects, and also another List within itself . This sub-list which is within the list is what is commonly known as the Nested List.

Iterating through a Nested List

Lets us see how a typical nested list looks like :

There are multiple ways to iterate through a Nested List:

Method 1: Use of the index to iterate through the list

Use of Positive Index:

Use of Negative Index

Method 2: Use of loop to iterate through the list

Use of Temporary Variables inside a loop.

Method 3: Use of Slicing

Similar Reads

• python-list
• Python-list-of-lists

Please Login to comment...

• How to Underline in Discord
• How to Block Someone on Discord
• How to Report Someone on Discord
• How to add Bots to Discord Servers
• GeeksforGeeks Practice - Leading Online Coding Platform

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

CopyAssignment

We are Python language experts, a community to solve Python problems, we are a 1.2 Million community on Instagram, now here to help with our blogs.

Nested list Indexing Python

Problem statement:.

We are given a list of tuples. We need to ask the user to enter a number and then we need to search for that number inside the list of tuples. At last, we need to print the index of the tuple and the index of the number that matches the number.

For example tuplesList = [(8,2,3,7,0,7,0),(1,4,1,4,4,5),(7,4,6,57,68,9,4,3)] Input: Enter number: 4 Output:

Code for Nested list Indexing Python:

• Hyphenate Letters in Python
• Earthquake in Python | Easy Calculation
• Striped Rectangle in Python
• Perpendicular Words in Python
• Free shipping in Python
• Raj has ordered two electronic items Python | Assignment Expert
• Team Points in Python
• Ticket selling in Cricket Stadium using Python | Assignment Expert
• Split the sentence in Python
• String Slicing in JavaScript
• First and Last Digits in Python | Assignment Expert
• List Indexing in Python
• Date Format in Python | Assignment Expert
• New Year Countdown in Python
• Add Two Polynomials in Python
• Sum of even numbers in Python | Assignment Expert
• Evens and Odds in Python
• A Game of Letters in Python
• Sum of non-primes in Python
• Smallest Missing Number in Python
• String Rotation in Python
• Secret Message in Python
• Word Mix in Python
• Single Digit Number in Python
• Shift Numbers in Python | Assignment Expert
• Weekend in Python
• Temperature Conversion in Python
• Special Characters in Python
• Sum of Prime Numbers in the Input in Python

Author: Harry

Search….

Machine Learning

Data Structures and Algorithms(Python)

Python Turtle

Games with Python

All Blogs On-Site

Python Compiler(Interpreter)

Online Java Editor

Online C++ Editor

Online C Editor

All Editors

Services(Freelancing)

Recent Posts

• Most Underrated Database Trick | Life-Saving SQL Command
• Python List Methods
• Top 5 Free HTML Resume Templates in 2024 | With Source Code
• How to See Connected Wi-Fi Passwords in Windows?
• 2023 Merry Christmas using Python Turtle

© Copyright 2019-2024 www.copyassignment.com. All rights reserved. Developed by copyassignment

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

How to access the nested list items in python with out creating a new list?

Is there any way that i can access the items of nested list ?

• What exactly are you looking to do? Are you just trying to access the [3, 4] part of your list? It is at position "2" of your list, so a[2] will get you that part of the list. If you need to access the elements of the list from there then: a[2][0] will get you the first, and a[2][1] will get you the second. –  idjaw Commented Jun 24, 2017 at 3:54

4 Answers 4

you said without creating a new list

I would like to explain a bit about that for you. By declaring b=a[2] you are definitely not creating a new list. Check this out in your interpreter.

hex(id(your_variable)) just returns the address of the variable.

'0x7f1432fcd9c8' is the address of a[2] and b . Did you notice how they both are the same?

b=a[:] this only creates a fresh copy. Notice how addresses are different. But look at this one below.

Same addresses. What does this mean ? It means in Python only the reference (i.e address of memory of the value is assigned to variables. So remember not to forget this. Also

To access elements in your nested loops use subscripts.

Accessing elements this way is done in O(1) time so it is the fastest way possibile.

You can access it by providing two subscripts, like this:

Lists in python are indexed from 0, not 1.

Do this instead.

You can also access the nested list by using the following syntax:

As you concern seem to be that you are making a new list: stop worrying you are not.

both k and a[2] refer to the same list. Nothing new is created.

You can easily verify that by changing k[0] to something different than the element 3 it already has in that position:

which gives

If you wanted to create a new list you would have to explicitly do something like:

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged python list indexing or ask your own question .

• The Overflow Blog
• Where developers feel AI coding tools are working—and where they’re missing...
• He sold his first company for billions. Now he’s building a better developer...
• Featured on Meta
• User activation: Learnings and opportunities
• Preventing unauthorized automated access to the network
• Should low-scoring meta questions no longer be hidden on the Meta.SO home...
• Announcing the new Staging Ground Reviewer Stats Widget

Hot Network Questions

• Azure SQL Database CLR functions are working
• Harmonizing modes other than major and minor
• How can the doctor measure out a dose (dissolved in water) of exactly 10% of a tablet?
• How long have people been predicting the collapse of the family?
• Purpose of sleeve on sledge hammer handle
• Are there individual protons and neutrons in a nucleus?
• How can I draw a wedge of a cylinder?
• Does the Rogue's Evasion cost a reaction?
• Can a US president put a substantial tariff on cars made in Mexico, within the confines of USMCA?
• Could you compress chocolate such that it has the same density and shape as a real copper coin?
• Unable to re-use an old deleted Apple Account (aka Apple ID)
• Do early termination fees hold up in court?
• God and Law of Identity Paradox
• Tikz template for organization chart
• Thunderbird will not create profile in chosen folder on a different partition
• What is "illegal, immoral or improper" use in CPOL?
• Why the proper acceleration is zero during free fall?
• Were Soviet doctors and nurses actually as callous as "Voices from Chernobyl" portrays in the prologue?
• Player sprite becomes smaller during attack animation (Java)
• How do I avoid getting depressed after receiving edits?
• Does a ball fit in a pipe if they are exactly the same diameter?
• Why does Voyager use consumable hydrazine instead of reaction wheels that only rotate when moving the spacecraft?
• Easily unload sand/gravel from pickup truck
• Two parallel lines in a parabola with a ratio of 1/3