what is the benefit of using tuple assignment in python

Python Tuples: Usage, Benefits, and List Comparisons

Introduction to tuples in python.

Python tuples are an essential data structure that every developer should be familiar with. Tuples can store a collection of values similar to how a list does, but they are immutable, meaning their values cannot be changed after creation. This makes tuples a great choice when working with a sequence of values that must remain constant.

Properties and Usage of Tuples

A tuple is an ordered, immutable sequence of elements. These elements can be of any data type, including integers, floats, strings, and even other tuples. Once a tuple is created, its elements cannot be modified or removed, nor can new elements be added. This immutability often results in improved performance and enhanced security when working with data that should not change.

To create a tuple, you must enclose a comma-separated list of values within parentheses () :

You can also create a tuple using the tuple() function:

Tuples support standard indexing and slicing operations like lists, but their elements cannot be modified:

Simplified Real-life Example

A common use case for tuples is storing and representing coordinates in a two or three-dimensional space. Here’s an example of how to use tuples for representing a 3D point:

Complex Real-life Example

Let’s consider a more complex example where we use tuples to store student information, including test scores. We’ll create a function to calculate and display the average score for each student.

In this example, we use tuples to store each student’s data and their test scores. Notice that the scores are also a tuple. By using tuples, we ensure that this data remains immutable throughout our program.

Personal Tips

Remember tuples are immutable, so choose them over lists when dealing with data that must remain constant. This can help prevent accidental modifications and improve program stability.

When using a tuple with only one element, be sure to include a trailing comma after the element, like this: single_element_tuple = (42,) . Without the comma, Python will treat it as a regular integer instead of a tuple.

Tuples can be leveraged in multiple assignment situations, like when swapping two variables without the need for a temporary variable:

• Since tuples are hashable, they can be used as keys in dictionaries, unlike lists. This can be useful when working with complex data structures or performing advanced operations on sets.

With these tips in mind, you’ll be well-equipped to harness the advantages of tuples in your Python development projects.

Stay up to date with our latest content - No spam!

Related Posts

Appending data to csv files with python: a guide for developers.

Learn how to efficiently append data to a CSV file using Python, with examples and best practices for handling large datasets and complex structures.

Calculating the Sum of Elements in a Python List

Learn how to calculate the sum of elements in a Python list easily and efficiently using built-in methods and your own custom functions.

Comparing Multiple Lists in Python: Methods & Techniques

Compare multiple lists in Python efficiently with various techniques, including set operations, list comprehensions, and built-in functions.

Comparing Multiple Objects in Python: A Guide for Developers

Compare multiple objects in Python using built-in functions and custom solutions for efficient code. Boost your Python skills with this easy guide.

Python Tuple: How to Create, Use, and Convert

A Python tuple is one of Python’s three built-in sequence data types , the others being lists and range objects. A Python tuple shares a lot of properties with the more commonly known Python list :

• It can hold multiple values in a single variable
• It’s ordered: the order of items is preserved
• A tuple can have duplicate values
• It’s indexed: you can access items numerically
• A tuple can have an arbitrary length

But there are significant differences:

• A tuple is immutable; it can not be changed once you have defined it.
• A tuple is defined using optional parentheses () instead of square brackets []
• Since a tuple is immutable, it can be hashed, and thus it can act as the key in a dictionary

Table of Contents

• 1 Creating a Python tuple
• 2 Multiple assignment using a Python tuple
• 3 Indexed access
• 4 Append to a Python Tuple
• 5 Get tuple length
• 6 Python Tuple vs List
• 7 Python Tuple vs Set
• 8 Converting Python tuples

Creating a Python tuple

We create tuples from individual values using optional parentheses (round brackets) like this:

Like everything in Python, tuples are objects and have a class that defines them. We can also create a tuple by using the tuple() constructor from that class. It allows any Python iterable type as an argument. In the following example, we create a tuple from a list:

Now you know how to convert a Python list to a tuple as well!

Which method is best?

It’s not always easy for Python to infer if you’re using regular parentheses or if you’re trying to create a tuple. To demonstrate, let’s define a tuple holding only one item:

Python sees the number one, surrounded by useless parentheses on the first try, so Python strips down the expression to the number 1. However, we added a comma in the second try, explicitly signaling to Python that we are creating a tuple with just one element.

A tuple with just one item is useless for most use cases, but it demonstrates how Python recognizes a tuple: because of the comma.

If we can use tuple() , why is there a second method as well? The other notation is more concise, but it also has its value because you can use it to unpack multiple lists into a tuple in this way concisely:

The leading * operator unpacks the lists into individual elements. It’s as if you would have typed them individually at that spot. This unpacking trick works for all iterable types if you were wondering!

Multiple assignment using a Python tuple

You’ve seen something called tuple unpacking in the previous topic. There’s another way to unpack a tuple, called multiple assignment. It’s something that you see used a lot, especially when returning data from a function, so it’s worth taking a look at this.

Multiple assignment works like this:

Like using the *, this type of unpacking works for all iterable types in Python, including lists and strings.

As I explained in the Python trick on returning multiple values from a Python function, unpacking tuples works great in conjunction with a function that returns multiple values. It’s a neat way of returning more than one value without having to resort to data classes or dictionaries :

Indexed access

We can access a tuple using index numbers like [0] and [1] :

Append to a Python Tuple

Because a tuple is immutable, you can not append data to a tuple after creating it . For the same reason, you can’t remove data from a tuple either. You can, of course, create a new tuple from the old one and append the extra item(s) to it this way:

What we did was unpack t1 , create a new tuple with the unpacked values and two different strings and assign the result to t again.

Get tuple length

The len() function works on Python tuples just like it works on all other iterable types like lists and strings:

Python Tuple vs List

The most significant difference between a Python tuple and a Python list is that a List is mutable, while a tuple is not. After defining a tuple, you can not add or remove values. In contrast, a list allows you to add or remove values at will. This property can be an advantage; you can see it as write protection. If a piece of data is not meant to change, using a tuple can prevent errors. After all, six months from now, you might have forgotten that you should not change the data. Using a tuple prevents mistakes.

Another advantage is that tuples are faster, or at least that is what people say. I have not seen proof, but it makes sense. Since it’s an immutable data type, a tuple’s internal implementation can be simpler than lists. After all, they don’t need ways to grow larger or insert elements at random positions, which usually is implemented as a linked list . From what I understand, a tuple uses a simple array-like structure in the CPython implementation.

Python Tuple vs Set

The most significant difference between tuples and Python sets is that a tuple can have duplicates while a set can’t. The entire purpose of a set is its inability to contain duplicates. It’s an excellent tool for deduplicating your data.

Converting Python tuples

Convert tuple to list.

Python lists are mutable, while tuples are not. If you need to, you can convert a tuple to a list with one of the following methods.

The cleanest and most readable way is to use the list() constructor:

A more concise but less readable method is to use unpacking. This unpacking can sometimes come in handy because it allows you to unpack multiple tuples into one list or add some extra values otherwise:

Convert tuple to set

Analogous to the conversion to a list, we can use set() to convert a tuple to a set:

Here, too, we can use unpacking:

Convert tuple to string

Like most objects in Python, a tuple has a so-called dunder method, called __str__ , which converts the tuple into a string. When you want to print a tuple, you don’t need to do so explicitly. Python’s print function will call this method on any object that is not a string. In other cases, you can use the str() constructor to get the string representation of a tuple:

Get certified with our courses

Learn Python properly through small, easy-to-digest lessons, progress tracking, quizzes to test your knowledge, and practice sessions. Each course will earn you a downloadable course certificate.

Related articles

• Python Set: The Why And How With Example Code
• JSON in Python: How To Read, Write, and Parse
• Python List Comprehension: Tutorial With Examples
• Python List: How To Create, Sort, Append, Remove, And More

• Tuple Assignment

Introduction

Tuples are basically a data type in python . These tuples are an ordered collection of elements of different data types. Furthermore, we represent them by writing the elements inside the parenthesis separated by commas. We can also define tuples as lists that we cannot change. Therefore, we can call them immutable tuples. Moreover, we access elements by using the index starting from zero. We can create a tuple in various ways. Here, we will study tuple assignment which is a very useful feature in python.

In python, we can perform tuple assignment which is a quite useful feature. We can initialise or create a tuple in various ways. Besides tuple assignment is a special feature in python. We also call this feature unpacking of tuple.

The process of assigning values to a tuple is known as packing. While on the other hand, the unpacking or tuple assignment is the process that assigns the values on the right-hand side to the left-hand side variables. In unpacking, we basically extract the values of the tuple into a single variable.

Moreover, while performing tuple assignments we should keep in mind that the number of variables on the left-hand side and the number of values on the right-hand side should be equal. Or in other words, the number of variables on the left-hand side and the number of elements in the tuple should be equal. Let us look at a few examples of packing and unpacking.

Tuple Packing (Creating Tuples)

We can create a tuple in various ways by using different types of elements. Since a tuple can contain all elements of the same data type as well as of mixed data types as well. Therefore, we have multiple ways of creating tuples. Let us look at few examples of creating tuples in python which we consider as packing.

Example 1: Tuple with integers as elements

Example 2: Tuple with mixed data type

Example 3: Tuple with a tuple as an element

Example 4: Tuple with a list as an element

If there is only a single element in a tuple we should end it with a comma. Since writing, just the element inside the parenthesis will be considered as an integer.

For example,

Correct way of defining a tuple with single element is as follows:

Moreover, if you write any sequence separated by commas, python considers it as a tuple.

Browse more Topics Under Tuples and its Functions

• Immutable Tuples
• Creating Tuples
• Initialising and Accessing Elements in a Tuple
• Tuple Slicing
• Tuple Indexing
• Tuple Functions

Tuple Assignment (Unpacking)

Unpacking or tuple assignment is the process that assigns the values on the right-hand side to the left-hand side variables. In unpacking, we basically extract the values of the tuple into a single variable.

Frequently Asked Questions (FAQs)

Q1. State true or false:

Inserting elements in a tuple is unpacking.

Q2. What is the other name for tuple assignment?

A2. Unpacking

Q3. In unpacking what is the important condition?

A3. The number of variables on the left-hand side and the number of elements in the tuple should be equal.

Q4. Which error displays when the above condition fails?

A4. ValueError: not enough values to unpack

Customize your course in 30 seconds

Which class are you in.

• Initialising and Accessing Elements in Tuple

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Download the App

• How to Think Like a Computer Scientist: Learning with Python 3 »

9. Tuples ¶

9.1. tuples are used for grouping data ¶.

We saw earlier that we could group together pairs of values by surrounding with parentheses. Recall this example:

>>> year_born = ( "Paris Hilton" , 1981 )

This is an example of a data structure — a mechanism for grouping and organizing data to make it easier to use.

The pair is an example of a tuple . Generalizing this, a tuple can be used to group any number of items into a single compound value. Syntactically, a tuple is a comma-separated sequence of values. Although it is not necessary, it is conventional to enclose tuples in parentheses:

>>> julia = ( "Julia" , "Roberts" , 1967 , "Duplicity" , 2009 , "Actress" , "Atlanta, Georgia" )

Tuples are useful for representing what other languages often call records — some related information that belongs together, like your student record. There is no description of what each of these fields means, but we can guess. A tuple lets us “chunk” together related information and use it as a single thing.

Tuples support the same sequence operations as strings. The index operator selects an element from a tuple.

>>> julia [ 2 ] 1967

But if we try to use item assignment to modify one of the elements of the tuple, we get an error:

>>> julia [ 0 ] = "X" TypeError: 'tuple' object does not support item assignment

So like strings, tuples are immutable. Once Python has created a tuple in memory, it cannot be changed.

Of course, even if we can’t modify the elements of a tuple, we can always make the julia variable reference a new tuple holding different information. To construct the new tuple, it is convenient that we can slice parts of the old tuple and join up the bits to make the new tuple. So if julia has a new recent film, we could change her variable to reference a new tuple that used some information from the old one:

>>> julia = julia [: 3 ] + ( "Eat Pray Love" , 2010 ) + julia [ 5 :] >>> julia ("Julia", "Roberts", 1967, "Eat Pray Love", 2010, "Actress", "Atlanta, Georgia")

To create a tuple with a single element (but you’re probably not likely to do that too often), we have to include the final comma, because without the final comma, Python treats the (5) below as an integer in parentheses:

>>> tup = ( 5 ,) >>> type ( tup ) <class 'tuple'> >>> x = ( 5 ) >>> type ( x ) <class 'int'>

9.2. Tuple assignment ¶

Python has a very powerful tuple assignment feature that allows a tuple of variables on the left of an assignment to be assigned values from a tuple on the right of the assignment. (We already saw this used for pairs, but it generalizes.)

( name , surname , b_year , movie , m_year , profession , b_place ) = julia

This does the equivalent of seven assignment statements, all on one easy line. One requirement is that the number of variables on the left must match the number of elements in the tuple.

One way to think of tuple assignment is as tuple packing/unpacking.

In tuple packing, the values on the left are ‘packed’ together in a tuple:

>>> b = ( "Bob" , 19 , "CS" ) # tuple packing

In tuple unpacking, the values in a tuple on the right are ‘unpacked’ into the variables/names on the right:

>>> b = ( "Bob" , 19 , "CS" ) >>> ( name , age , studies ) = b # tuple unpacking >>> name 'Bob' >>> age 19 >>> studies 'CS'

Once in a while, it is useful to swap the values of two variables. With conventional assignment statements, we have to use a temporary variable. For example, to swap a and b :

1 2 3 temp = a a = b b = temp

Tuple assignment solves this problem neatly:

1 ( a , b ) = ( b , a )

The left side is a tuple of variables; the right side is a tuple of values. Each value is assigned to its respective variable. All the expressions on the right side are evaluated before any of the assignments. This feature makes tuple assignment quite versatile.

Naturally, the number of variables on the left and the number of values on the right have to be the same:

>>> ( a , b , c , d ) = ( 1 , 2 , 3 ) ValueError: need more than 3 values to unpack

9.3. Tuples as return values ¶

Functions can always only return a single value, but by making that value a tuple, we can effectively group together as many values as we like, and return them together. This is very useful — we often want to know some batsman’s highest and lowest score, or we want to find the mean and the standard deviation, or we want to know the year, the month, and the day, or if we’re doing some some ecological modelling we may want to know the number of rabbits and the number of wolves on an island at a given time.

For example, we could write a function that returns both the area and the circumference of a circle of radius r:

1 2 3 4 5 def f ( r ): """ Return (circumference, area) of a circle of radius r """ c = 2 * math . pi * r a = math . pi * r * r return ( c , a )

9.4. Composability of Data Structures ¶

We saw in an earlier chapter that we could make a list of pairs, and we had an example where one of the items in the tuple was itself a list:

students = [ ( "John" , [ "CompSci" , "Physics" ]), ( "Vusi" , [ "Maths" , "CompSci" , "Stats" ]), ( "Jess" , [ "CompSci" , "Accounting" , "Economics" , "Management" ]), ( "Sarah" , [ "InfSys" , "Accounting" , "Economics" , "CommLaw" ]), ( "Zuki" , [ "Sociology" , "Economics" , "Law" , "Stats" , "Music" ])]

Tuples items can themselves be other tuples. For example, we could improve the information about our movie stars to hold the full date of birth rather than just the year, and we could have a list of some of her movies and dates that they were made, and so on:

julia_more_info = ( ( "Julia" , "Roberts" ), ( 8 , "October" , 1967 ), "Actress" , ( "Atlanta" , "Georgia" ), [ ( "Duplicity" , 2009 ), ( "Notting Hill" , 1999 ), ( "Pretty Woman" , 1990 ), ( "Erin Brockovich" , 2000 ), ( "Eat Pray Love" , 2010 ), ( "Mona Lisa Smile" , 2003 ), ( "Oceans Twelve" , 2004 ) ])

Notice in this case that the tuple has just five elements — but each of those in turn can be another tuple, a list, a string, or any other kind of Python value. This property is known as being heterogeneous , meaning that it can be composed of elements of different types.

9.5. Glossary ¶

9.6. exercises ¶.

• We’ve said nothing in this chapter about whether you can pass tuples as arguments to a function. Construct a small Python example to test whether this is possible, and write up your findings.
• Is a pair a generalization of a tuple, or is a tuple a generalization of a pair?
• Is a pair a kind of tuple, or is a tuple a kind of pair?

• Learn Python
• Python Lists
• Python Dictionaries
• Python Strings
• Python Functions
• Learn Pandas & NumPy
• Pandas Tutorials
• Numpy Tutorials
• Learn Data Visualization
• Python Seaborn
• Python Matplotlib

Python Tuples: A Complete Overview

• January 4, 2022 December 15, 2022

In this tutorial, you’ll learn all you need to know to get started with Python tuples . You’ll learn what tuples are and how they’re different from Python lists. You’ll learn how to create tuples and access data within them using indexing and slicing. You’ll also learn how tuples methods work to allow you to understand their data better.

Table of Contents

What are Python Tuples

Python tuples are a collection data type, meaning that, like Python lists, you can use them as containers for other values. There’s no clearly define way to pronounce the term. Sometimes it’s pronounced as “two-ple” and other times as “tuh-ple”.

Let’s take a look at the main attributes of Python tuples:

• Ordered : Python tuples are an ordered collection of objects. This means that the order that the object has matters and will remain the same.
• Indexable : You can access the items in a Python tuple using their index positions. Because tuples are ordered, the index remains the same.
• Heterogeneous : Python tuples can contain different types of objects, including other tuples! For example, you can use tuples to store information about user information for a website, such as login, name, age, gender, etc.
• Immutable : Python tuples are immutable, meaning that once they are created, they cannot be changed. This means that if you wanted to, say, sort a tuple, you’d need to create a new one.

If you’re familiar with Python lists, tuples may seem incredibly similar. In the next section, you’ll learn some of the key similarities and differences between Python lists and tuples.

Differences Between Python Lists and Tuples

On the surface, Python tuples and lists sound quite similar! And, really, there are a lot of differences. However, there are some notable differences as well! The table below breaks down the similarities and differences between Python tuples and lists:

You can see that, really, the only difference mentioned is that Python lists are mutable, while Python tuples are immutable. This means that once a tuple has been created, a tuple cannot be changed!

Why Use Tuples Over Lists in Python

At this point, you might be wondering, “why even bother with tuples?”. There are two primary reasons for using tuples over lists:

• Immutability : there may be times when you have some values that you simply don’t want to change (especially, accidentally). This is where tuples may are a better choice over lists.
• Memory efficiency : Because Python tuples are immutable, they are significantly more memory-efficient. When a Python list is created, Python doesn’t know how much space to allocate for it in memory. Because of this, some space is reserved. Meanwhile, when a tuple is created, the exact size of that tuple is known!

How To Create a Tuple in Python

A Python tuple is created using regular parentheses, separating items by commas. Let’s take a look at creating your first tuple:

Let’s take a look at the type of this tuple, data , using the built-in type() function:

Now, let’s try something else. Let’s create a tuple with a single item:

Let’s check the type of this new object:

This is odd! It’s actually the comma that creates the tuple, not the parentheses! It may feel a bit odd, but if you need to create a tuple with only a single item, it needs to have a trailing comma:

What is even more interesting is that the parentheses are actually optional! It really is only the comma that makes the tuple. Writing the code below also produces a tuple:

Now that you know how to create tuples in Python, let’s take a look at how you can access data in tuples.

Accessing Items in Python Tuples

There are a number of easy ways to access items within Tuples. Similar to Python lists, you can access items using indexing and slicing. In the next two sections, you’ll learn how to use both these methods.

Accessing Items with Indexing

Because Python tuples are ordered, you can access individual items using their index position. Python is a 0-based indexed language, meaning that the first item has an index position of 0. Using the index operator [] , you can pass in an integer to access that item.

Let’s load a tuple and see how you can access items in that tuple using indexing.

When you try to access an item beyond the tuples range, an IndexError is returned. Remember, because Python indices start at 0, the last item will have an index of the length of the tuple minus one. If you tried to access index 4, Python would raise an IndexError :

Python indices can also be accessed using negative indexing. Negative indices begin at the last item with the value of -1 . Let’s see how you can access the last item in the tuple:

Accessing Items with Slicing

There are often times you need to access multiple items in a Python tuple. You can access a range of items using slicing. Slicing is done using the [] indexing operator, but selecting a range of values using a colon : . The slice accepts integer values and includes the left value and goes up to (but doesn’t include) the right value. Let’s access the first through second item:

The values on either side of the colon are optional. If either side (or both sides) are omitted, then all values to that end are included. For example, the example above could be rewritten as shown below:

Iterating Over Tuples in Python

Because Python tuples are sequence data types, you can iterate over them. For example, you can iterate over a tuple using a simple for loop. Let’s use a for loop to print out every item in the tuple defined above:

Iterating over tuples is incredibly straightforward! Similarly, you could build in if-else conditions to skip over certain items if a condition isn’t met.

Changing Tuples in Python

Python tuples are immutable. This means that they cannot be changed. While with lists, you could append items or modify items using direct assignment, this isn’t possible with tuples. Let’s try this out and see what happens:

By attempting to modify a tuple’s value, a TypeError is raised. One thing that’s interesting, however, is that if an item in a tuple is a mutable time, such as a list, a direct assignment works. This is because the reference to the place in memory where that item is stored remains the same!

Concatenating and Repeating Tuples in Python

You can also easily concatenate tuples in Python by using the + operator. When you do this, a brand new tuple is created. Let’s see how you can concatenate two tuples together:

Similarly, you can repeat a tuple by using the * operator in Python.

Something important to note here is that the code above makes it look like the tuple was mutated. However, the first instance of a_tuple was destroyed and a new one was created. You can verify this by using the id() function which returns the space in memory the object is using. Let’s confirm this now:

Python Tuple Methods

Python tuples have fewer methods available than mutable types, such as lists. Since you can’t append or modify items in tuples, these methods, of course, don’t exist. However, you can count an element in the tuple and return the index position of an item in a tuple. Let’s see how you can count items using the .count() method:

Now, let’s see how you can find the first index of an item in a tuple using the .index() method:

One thing to keep in mind is that if an item doesn’t exist, Python will raise a ValueError .

It’s time to check your learning! Try and complete the exercises below. If you need a hint or want to check your answer, simply toggle the question to check a solution:

You can delete a tuple using the `del` keyword. Try creating a tuple and then delete it.

What are some advantages of using a tuple?

• Tuples are immutable. Because of this, if you don’t want an item to change, a tuple is a good option.
• Tuples are significantly more memory efficient than other container types, because Python knows how much space to allocate to them.
• Because tuples are immutable, they can be used as keys in Python dictionaries.

Given a tuple a_tuple = (1,2,3,4,5) , what would a_tuple[:-1] return?

This would return the entire tuple, except for the last item.

Conclusion and Recap

In this tutorial, you learned everything about the Python tuple, an important container data type. The section below provides a recap of what you learned:

• Tuples are an immutable, iterable, and heterogeneous data type
• Tuples are created using regular parantheses (). A singleton (a tuple with only one item), requires a trailing comma.
• You can access items in a tuple using indexing and slicing
• You can use tuple methods to count items in a tuple and find the first index position of an item

Additional Resources

To learn more about related topics, check out the tutorials below:

• Python Dictionaries: All You Need to Know
• Python Lists: An Overview
• Python Conditionals, Booleans, and Comparisons

Nik Piepenbreier

Nik is the author of datagy.io and has over a decade of experience working with data analytics, data science, and Python. He specializes in teaching developers how to use Python for data science using hands-on tutorials. View Author posts

6 thoughts on “Python Tuples: A Complete Overview”

Hello, at the end of the exercises, it doesn’t return the whole tuple? (1,2,3,4)?

Thanks so much for catching that! I have fixed the post.

“Given a tuple a_tuple = (1,2,3,4,5), what would a_tuple[:-1] return?”

It returns a 5. The answer should be changed on question 3 (:

love these lessons thank you

Hey there! Thanks for your comment! Since we’re using a colon to slice the tuple, it returns everything up to the last value.

Day 8, done. Excelent tutorial. Thanks!!

Well done, Flávio!

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

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

Guide to Tuples in Python

• Introduction

As a Python programmer, you might already be familiar with lists, dictionaries, and sets - but don't overlook tuples! They are often overshadowed by more popular data types, but tuples can be incredibly useful in many situations.

In this guide, we'll take a deep dive into Python tuples and explore everything you need to know to use tuples in Python. We'll cover the basics of creating and accessing tuples, as well as more advanced topics like tuple operations, methods, and unpacking.

• How to Create Tuples in Python

In Python, tuples can be created in several different ways. The simplest one is by enclosing a comma-separated sequence of values inside of parentheses:

Alternatively, you can create a tuple using the built-in tuple() function, which takes an iterable as an argument and returns a tuple:

This method is a bit more explicit and might be easier to read for Python novices.

You can also create an empty tuple by simply using the parentheses:

It's worth noting that even a tuple with a single element must include a trailing comma :

Note: Without the trailing comma, Python will interpret the parentheses as simply grouping the expression, rather than creating a tuple.

With the basics out of the way, we can take a look at how to access elements within a tuple.

• How to Access Tuple Elements in Python

Once you have created a tuple in Python, you can access its elements using indexing, slicing, or looping . Let's take a closer look at each of these methods.

You can access a specific element of a tuple using its index. In Python, indexing starts at 0 , so the first element of a tuple has an index of 0 , the second element has an index of 1 , and so on:

If you try to access an element that is outside the bounds of the tuple, you'll get an IndexError :

Another interesting way you can access an element from the tuple is by using negative indices . That way, you are effectively indexing a tuple in reversed order, from the last element to the first:

Note: Negative indexing starts with -1 . The last element is accessed by the -1 index, the second-to-last by the -2 , and so on.

You can also access a range of elements within a tuple using slicing. Slicing works by specifying a start index and an end index, separated by a colon. The resulting slice includes all elements from the start index up to (but not including) the end index:

You can also use negative indices to slice from the end of the tuple:

Advice: If you want to learn more about slicing in Python, you should definitely take a look at our article "Python: Slice Notation on List" .

• Looping Through Tuples

Finally, you can simply loop through all the elements of a tuple using a for loop:

This will give us:

In the next section, we'll explore the immutability of tuples and how to work around it.

• Can I Modify Tuples in Python?

One of the defining characteristics of tuples in Python is their immutability . Once you have created a tuple, you cannot modify its contents . This means that you cannot add, remove, or change elements within a tuple. Let's look at some examples to see this in action:

As you can see, attempting to modify a tuple raises appropriate errors - TypeError or AttributeError . So what can you do if you need to change the contents of a tuple?

Note: It's important to note that all of the methods demonstrated below are simply workarounds. There is no direct way to modify a tuple in Python, and the methods discussed here effectively create new objects that simulate the modification of tuples.

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!

One approach is to convert the tuple to a mutable data type, such as a list, make the desired modifications, and then convert it back to a tuple:

This approach allows you to make modifications to the contents of the tuple, but it comes with a trade-off - the conversion between the tuple and list can be expensive in terms of time and memory. So use this technique sparingly, and only when absolutely necessary.

Another approach is to use tuple concatenation to create a new tuple that includes the desired modifications:

In this example, we used tuple concatenation to create a new tuple that includes the modified element (4,) followed by the remaining elements of the original tuple. This approach is less efficient than modifying a list, but it can be useful when you only need to make a small number of modifications.

Remember, tuples are immutable, and examples shown in this section are just (very inefficient) workarounds, so always be careful when modifying tuples. More specifically, if you find yourself in need of changing a tuple in Python, you probably shouldn't be using a tuple in the first place.

• What Operations Can I Use on Tuples in Python?

Even though tuples are immutable, there are still a number of operations that you can perform on them. Here are some of the most commonly used tuple operations in Python:

• Tuple Concatenation

You can concatenate two or more tuples using the + operator. The result is a new tuple that contains all of the elements from the original tuples:

• Tuple Repetition

You can repeat a tuple a certain number of times using the * operator. The result is a new tuple that contains the original tuple repeated the specified number of times:

• Tuple Membership

You can check if an element is present in a tuple using the in operator. The result is a Boolean value ( True or False ) indicating whether or not the element is in the tuple:

• Tuple Comparison

You can compare two tuples using the standard comparison operators ( < , <= , > , >= , == , and != ). The comparison is performed element-wise, and the result is a Boolean value indicating whether or not the comparison is true:

• Tuple Unpacking

You can unpack a tuple into multiple variables using the assignment operator ( = ). The number of variables must match the number of elements in the tuple, otherwise a ValueError will be raised. Here's an example:

• Tuple Methods

In addition to the basic operations that you can perform on tuples, there are also several built-in methods that are available for working with tuples in Python. In this section, we'll take a look at some of the most commonly used tuple methods.

The count() method returns the number of times a specified element appears in a tuple:

The index() method returns the index of the first occurrence of a specified element in a tuple. If the element is not found, a ValueError is raised:

The len() function returns the number of elements in a tuple:

The sorted() function returns a new sorted list containing all elements from the tuple:

Note: The sorted() function returns a list, which is then converted back to a tuple using the tuple() constructor.

• min() and max()

The min() and max() functions return the smallest and largest elements in a tuple, respectively:

These are just a few examples of the methods that are available for working with tuples in Python. By combining these methods with the various operations available for tuples, you can perform a wide variety of tasks with these versatile data types.

One of the interesting features of tuples in Python that we've discussed is that you can "unpack" them into multiple variables at once. This means that you can assign each element of a tuple to a separate variable in a single line of code. This can be a convenient way to work with tuples when you need to access individual elements or perform operations on them separately.

Let's recall the example from the previous section:

In this example, we created a tuple my_tuple with three elements. Then, we "unpack" the tuple by assigning each element to a separate variables a , b , and c in a single line of code. Finally, we verified that the tuple has been correctly unpacked.

One interesting use case of tuple unpacking is that we can use it to swap the values of two variables, without needing a temporary variable :

Here, we use tuple unpacking to swap the values of a and b . The expression a, b = b, a creates a tuple with the values of b and a , which is then unpacked into the variables a and b in a single line of code.

Another useful application of tuple unpacking is unpacking a tuple into another tuple . This can be helpful when you have a tuple with multiple elements, and you want to group some of those elements together into a separate tuple:

We have a tuple my_tuple with five elements. We use tuple unpacking to assign the first two elements to the variables a and b , and the remaining elements to the variable c using the * operator. The * operator is used to "unpack" the remaining elements of the tuple into a new tuple, which is assigned to the variable c .

This is also an interesting way to return multiple values/variables from a function, allowing the caller to then decide how the return values should be unpacked and assigned from their end.

Tuples are one of fundamental data types in Python. They allow you to store a collection of values in a single container. They're similar to lists, but with a few important differences - tuples are immutable, and they're usually used to store a fixed set of values that belong together.

In this guide, we've covered the basics of working with tuples in Python, including creating tuples, accessing their elements, modifying them, and performing operations on them. We've also explored some of the more advanced features of tuples, such as tuple unpacking.

Tuples may not be the most glamorous data type in Python, but they're certainly effective when you know how and when to use them. So the next time you're working on a Python project, remember to give tuples a try. Who knows, they may just become your new favorite data type!

You might also like...

• Hidden Features of Python
• Python Docstrings
• Handling Unix Signals in Python
• The Best Machine Learning Libraries in Python
• Guide to Sending HTTP Requests in Python with urllib3

Improve your dev skills!

Get tutorials, guides, and dev jobs in your inbox.

No spam ever. Unsubscribe at any time. Read our Privacy Policy.

In this article

Monitor with Ping Bot

Reliable monitoring for your app, databases, infrastructure, and the vendors they rely on. Ping Bot is a powerful uptime and performance monitoring tool that helps notify you and resolve issues before they affect your customers.

Vendor Alerts with Ping Bot

Get detailed incident alerts about the status of your favorite vendors. Don't learn about downtime from your customers, be the first to know with Ping Bot.

© 2013- 2024 Stack Abuse. All rights reserved.

• 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
• Mixed-Up Code Questions
• Write Code Questions
• Peer Instruction: Tuples Multiple Choice Questions
• 11.1 Tuples are Immutable
• 11.2 Comparing Tuples
• 11.3 Tuple Assignment
• 11.4 Dictionaries and Tuples
• 11.5 Multiple Assignment with Dictionaries
• 11.6 The Most Common Words
• 11.7 Using Tuples as Keys in Dictionaries
• 11.8 Sequences: Strings, Lists, and Tuples - Oh My!
• 11.9 Debugging
• 11.10 Glossary
• 11.11 Multiple Choice Questions
• 11.12 Tuples Mixed-Up Code Questions
• 11.13 Write Code Questions
• 11.2. Comparing Tuples" data-toggle="tooltip">
• 11.4. Dictionaries and Tuples' data-toggle="tooltip" >

11.3. Tuple Assignment ¶

One of the unique syntactic features of Python is the ability to have a tuple on the left side of an assignment statement. This allows you to assign more than one variable at a time when the left side is a sequence.

In this example we have a two-element list (which is a sequence) and assign the first and second elements of the sequence to the variables x and y in a single statement.

This isn’t magic! Python roughly translates the tuple assignment syntax to the following:

It’s worth noting that Python does not translate the syntax literally. For example, if you try this with a dictionary, it won’t work as you might expect.

Stylistically, when we use a tuple on the left side of the assignment statement, we omit the parentheses, but the following is an equally valid syntax:

11-9-4: What is associated with the variable ‘x’ once the following code is run?

• Incorrect! The values in random_list are strings, not lists. Try again.
• Incorrect! x is listed before y in the tuple on the left side of the assignment statement, so the first value in random_list should be assigned to x. Try again.
• Correct! This properly assigns the first element of the list to 'x'.

A particularly clever application of tuple assignment allows us to swap the values of two variables in a single statement:

Both sides of this statement are tuples, but Python interprets the left side to be a tuple of variables and the right side to be a tuple of expressions. All of the expressions on the right side are evaluated before any of the assignments. This means that the values of b and a on the right side are evaluated, then a and b on the left side take on their values.

The number of variables on the left and the number of values on the right must be the same:

Write code to swap the values of tuple t.

More generally, the right side can be any kind of sequence (string, list, or tuple). For example, to split an email address into a username and a domain, you could write:

The return value from split() is a list with two elements; the first element is assigned to uname , the second to domain .

11-9-6: What is associated with the variable ‘domain’ once the following code is run?

• hotmail.com
• Correct! The split() method splits the email address at '@'.
• @hotmail.com
• Incorrect! The split() method doesn't include its parameter in any of the elements of its returned list. Try again.
• ['hotmail.com']
• Incorrect! The split() method returns a list of strings, not a list of lists. Try again.

Previous Index Next

A tuple is a sequence of values much like a list. The values stored in a tuple can be any type, and each item has an index indicating its position in the list. The first item in a tuple is at index 0, the second at index 1, and so on. The important difference between list and tuple is that tuples are immutable.

A tuple is a comma-separated list of values inside parentheses (). The parentheses are optional.

Empty Tuple

There are two ways to construct an empty tuple. You can construct an empty tuple by having () with no values in them

To construct an empty tuple you can also use the built-in function tuple like this

Tuple with a single element

To create a tuple with a single element, you have to include the final comma:

Without the comma Python treats ('a') as an expression with a string in parentheses that evaluates to a string:

Another way to construct a tuple is the built-in function tuple.

Operations on tuples

Most list operators also work on tuples. The bracket operator indexes an element:

And the slice operator selects a range of elements.

But if you try to modify one of the elements of the tuple, you get an error:

Concatenating Tuples

The + operator concatenates tuples:

The Repetition Operator

The * operator repeats a tuple a given number of times:

Iterating over a Tuple with the for Loop

You can use for loop to iterate over a tuple. Here are some examples:

Program (forloop1.py)

Program (forloop2.py)

Tuple Methods and Useful Built-in Functions

The function len returns the length of a tuple.

Returns the largest item in a tuple.

Returns the smallest item in a tuple.

Returns a sorted list of the specified tuple.

Returns the number of times a specified value occurs in a tuple

Searches the tuple for a specified value and returns the position of where it was found

Tuple assignment

One of the unique syntactic features of the Python language is the ability to have a tuple on the left side of an assignment statement. This allows you to assign more than one variable at a time when the left side is a sequence.

In this example we have a two-element list and assign the first and second elements of the sequence to the variables x and y in a single statement.

Stylistically when we use a tuple on the left side of the assignment statement, we omit the parentheses, but the following is an equally valid syntax:

A particularly clever application of tuple assignment allows us to swap the values of two variables in a single statement:

Converting Between Lists and Tuples

You can use the built-in list() function to convert a tuple to a list and the built-in tuple() function to convert a list to a tuple.

Tuple Assignment Python [With Examples]

Tuple assignment is a feature that allows you to assign multiple variables simultaneously by unpacking the values from a tuple (or other iterable) into those variables.

Tuple assignment is a concise and powerful way to assign values to multiple variables in a single line of code.

Here’s how it works:

In this example, the values from the my_tuple tuple are unpacked and assigned to the variables a , b , and c in the same order as they appear in the tuple.

Tuple assignment is not limited to tuples; it can also work with other iterable types like lists:

Tuple assignment can be used to swap the values of two variables without needing a temporary variable:

Tuple assignment is a versatile feature in Python and is often used when you want to work with multiple values at once, making your code more readable and concise.

Tuple Assignment Python Example

Here are some examples of tuple assignment in Python:

Example 1: Basic Tuple Assignment

Example 2: Multiple Variables Assigned at Once

Example 3: Swapping Values

Example 4: Unpacking a Tuple Inside a Loop

Example 5: Ignoring Unwanted Values

These examples demonstrate various uses of tuple assignment in Python, from basic variable assignment to more advanced scenarios like swapping values or ignoring unwanted elements in the tuple. Tuple assignment is a powerful tool for working with structured data in Python.

• Python Tuple Vs List Performance
• Subprocess Python Stdout
• Python Subprocess Stderr
• Python Asyncio Subprocess [Asynchronous Subprocesses]
• Subprocess.popen And Subprocess.run
• Python Subprocess.popen
•  Difference Between Subprocess Popen And Call
• 5 Tuple Methods in Python [Explained]
• Python List to Tuple
• Python Tuple Append
• Python Unpack Tuple Into Arguments
• Python Concatenate Tuples

Aniket Singh holds a B.Tech in Computer Science & Engineering from Oriental University. He is a skilled programmer with a strong coding background, having hands-on experience in developing advanced projects, particularly in Python and the Django framework. Aniket has worked on various real-world industry projects and has a solid command of Python, Django, REST API, PostgreSQL, as well as proficiency in C and C++. He is eager to collaborate with experienced professionals to further enhance his skills.

Leave a Comment Cancel reply

Join us and get access to thousands of tutorials and a community of expert Pythonistas.

This lesson is for members only. Join us and get access to thousands of tutorials and a community of expert Pythonistas.

Tuple Assignment, Packing, and Unpacking

• Discussion (4)

In this lesson, you’ll learn about tuple assignment, packing, and unpacking. A literal tuple containing several items can be assigned to a single object. Assigning the packed object to a new tuple unpacks the individual items into the objects in the new tuple:

00:00 In this video, I’m going to show you tuple assignment through packing and unpacking. A literal tuple containing several items can be assigned to a single object, such as the example object here, t .

00:16 Assigning that packed object to a new tuple, unpacks the individual items into the objects in that new tuple. When unpacking, the number of variables on the left have to match the number of values that are inside of the tuple.

00:33 Let me have you explore that with some code. As you saw in the previous video, you can create a tuple just by typing the objects into the set of parentheses, and that will pack them all in there, into that single object. Again, you can access them via index.

00:56 Here’s an interesting idea. You can create another tuple of objects—in this case, (s1, s2, s3, s4) , and you could assign it to the tuple that you created a moment ago, t .

01:13 Now, s1 , s2 , s3 , and s4 will have unpacked that tuple during that assignment and placed them into the appropriate objects. It’s pretty neat!

01:27 Now, it’s important that they have the same number on both sides of that assignment. If you tried to assign it to (s1, s2, s3) = t , you are going to raise an exception here, a ValueError . There’s too many values to unpack.

01:41 It was expecting three on this side and t , as you know, has four. So again, here’s t . And what if you went with too many? Well, in this case, it was expecting to get five, but t only provided four. Packing and unpacking could be done into one statement if you wanted to.

02:12 And here they all are. Again, the two sides have to be equal.

02:23 Here, again, too many values. When doing assignments like this, there’s a handful of situations where Python’s going to allow you to skip the parentheses.

02:41 And the same with the unpacking.

02:50 You can even do something like this, where both sides don’t have parentheses.

03:02 Even creating that singleton. It works the same whether the parentheses are included or not, so if you have any doubt as to whether they’re needed, go ahead and include them.

03:14 This tuple assignment allows for a bit of idiomatic Python. Frequently when programming, you have two variables whose values you need to swap. In most programming languages, it’s necessary to store one of the values into a temporary variable while the swap occurs. It would look something like this.

03:48 So you create a variable temp , assign a into it, assign b into a , and then say b = temp . And there—you’ve swapped the two.

03:58 So again, you’re making a temporary variable that holds a , taking b , assigning it into a , and then b pulling that temp back into it by reassigning it again.

04:08 That’s the swap. But in Python, the swap can be done with just a single tuple assignment.

04:24 Here you’re going to say a, b = b, a . And you can see that the swap has occurred. It brings me to this kind of cool example that I saw from python.org. In teaching a little bit about programming they showed this example that I liked a lot about the Fibonacci series.

04:47 Here, we’re assigning the first two, 0 and 1 , and then creating a while loop. And then inside the while loop, you’re doing something very similar, just modifying it a little bit by assigning a on the left to b .

05:05 But you’re taking b and you’re saying that now equals a+b . Pretty neat! Next step is the conclusion and the course review.

reb24 on May 8, 2020

If I run this:

I can’t see any magic happening or reason to use temp variable to accomplish the swap

Dan Bader RP Team on May 8, 2020

The “magic” is that with Python you can do the swap without using an extra temporary variable. Many other programming languages would require the use of a temporary variable. Hope that clarifies it :)

Ah Ok !!! Thanks Dan

kiran on July 25, 2020

Multiple Assignment (n, m = 300, 400) also called Tuple packing & unpacking?

Source: Multiple Assignment

Become a Member to join the conversation.

• 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

Python Lists

• Get a list as input from user in Python
• Python | Create list of numbers with given range
• How to add Elements to a List in Python

Python List Access/Iteration Operations

• Iterate over a list in Python
• How to iterate through a nested List in Python?
• Python | Iterate over multiple lists simultaneously
• Iterate Over a List of Lists in Python
• Python Program to Accessing index and value in list
• Python | Accessing all elements at given list of indexes
• Check if element exists in list in Python
• Python | Check if any element in list satisfies a condition

Python List Search Operations

• How To Find the Length of a List in Python
• Python | Find elements of a list by indices
• Python program to find the String in a List
• Python | Ways to find indices of value in list
• Python | Find most frequent element in a list

Python List Remove Operations

• How to Remove an Item from the List in Python
• Python | Remove given element from the list
• Ways to remove particular List element in Python
• Remove multiple elements from a list in Python

Python List Concatenation Operations

• Python | Concatenate two lists element-wise
• Merge Two Lists in Python
• Python - Concatenate two list of lists Row-wise
• Python program to concatenate every elements across lists
• Python program to Concatenate all Elements of a List into a String
• Python | Concatenate All Records
• Python | Merge list elements
• Python | Concatenate N consecutive elements in String list
• Python | Merge two lists alternatively
• Python | Union of two or more Lists

Python List Sorting and Comparison

• Python | Sort a List according to the Length of the Elements
• Python | Element repetition in list
• Python - Repeat Alternate Elements in list
• Python | Difference between two lists
• Python | Check if two lists are identical
• Python | Combining two sorted lists
• Python | Cloning or Copying a list
• Sort the values of first list using second list in Python

Python List Comprehension Operations

• Python List Slicing
• Python - List Comprehension
• Python List Comprehension and Slicing

Python List Reverse Operations

• Python List reverse()
• Reversing a List in Python

Python Nested Lists

• Nested List Comprehensions in Python
• Python | Test for nested list
• Python | How to copy a nested list
• Python | Convert given list into nested list
• Python | Split nested list into two lists
• Python - Nested List to single value Tuple
• Python | Column wise sum of nested list
• Python | Intersection of two nested list
• Python | Check if a nested list is a subset of another nested list

Python List Flatten Operation

• Python - Flatten List to individual elements
• Python | Convert a nested list into a flat list
• Python Program to Flatten a List without using Recursion
• Python | Sort Flatten list of list
• Flatten A List of Lists in Python
• Python | Split flatten String List
• Python | Flatten given list of dictionaries
• Python | Grouped Flattening of list
• Python | Ways to flatten a 2D list

Python List Methods and Exercises

• Find size of a list in Python
• Python - Elements Lengths in List
• Python List Exercise
• Python List methods

Python Lists are just like dynamically sized arrays, declared in other languages (vector in C++ and ArrayList in Java). In simple language, a list is a collection of things, enclosed in [ ] and separated by commas. 

The list is a sequence data type which is used to store the collection of data. Tuples and String are other types of sequence data types.

Example of the list in Python

Here we are creating a Python List using [].

Lists are the simplest containers that are an integral part of the Python language. Lists need not be homogeneous always which makes it the most powerful tool in Python . A single list may contain DataTypes like Integers, Strings, as well as Objects. Lists are mutable, and hence, they can be altered even after their creation.

Creating a List in Python

Lists in Python can be created by just placing the sequence inside the square brackets[]. Unlike Sets , a list doesn’t need a built-in function for its creation of a list. 

Note: Unlike Sets, the list may contain mutable elements.  

Example 1: Creating a list in Python

Complexities for creating lists.

Time Complexity: O(1)

Space Complexity: O(n)

Example 2:  Creating a list with multiple distinct or duplicate elements

A list may contain duplicate values with their distinct positions and hence, multiple distinct or duplicate values can be passed as a sequence at the time of list creation.

Accessing elements from the List

In order to access the list items refer to the index number. Use the index operator [ ] to access an item in a list. The index must be an integer. Nested lists are accessed using nested indexing. 

Example 1: Accessing elements from list

Example 2: Accessing elements from a multi-dimensional list

Negative indexing

In Python, negative sequence indexes represent positions from the end of the List. Instead of having to compute the offset as in List[len(List)-3], it is enough to just write List[-3]. Negative indexing means beginning from the end, -1 refers to the last item, -2 refers to the second-last item, etc.

Complexities for Accessing elements in a Lists:

Space Complexity: O(1)

Getting the size of Python list

Python len() is used to get the length of the list.

Taking Input of a Python List

We can take the input of a list of elements as string, integer, float, etc. But the default one is a string.

Example 1: 

To know more see this .

Adding Elements to a Python List

Method 1: using append() method.

Elements can be added to the List by using the built-in append() function. Only one element at a time can be added to the list by using the append() method, for the addition of multiple elements with the append() method, loops are used. Tuples can also be added to the list with the use of the append method because tuples are immutable. Unlike Sets, Lists can also be added to the existing list with the use of the append() method.

Complexities for Adding elements in a Lists(append() method):

S pace Complexity: O(1)

Method 2: Using insert() method

append() method only works for the addition of elements at the end of the List, for the addition of elements at the desired position, insert() method is used. Unlike append() which takes only one argument, the insert() method requires two arguments(position, value). 

Complexities for Adding elements in a Lists(insert() method):

Time Complexity: O(n)

Method 3: Using extend() method

Other than append() and insert() methods, there’s one more method for the Addition of elements, extend() , this method is used to add multiple elements at the same time at the end of the list.

Note: append() and extend() methods can only add elements at the end.

Complexities for Adding elements in a Lists(extend() method):

Reversing a list, method 1:  a list can be reversed by using the reverse() method in python ., method 2: using the reversed() function:.

The reversed() function returns a reverse iterator, which can be converted to a list using the list() function.

Removing Elements from the List

Method 1: using remove() method.

Elements can be removed from the List by using the built-in remove() function but an Error arises if the element doesn’t exist in the list. Remove() method only removes one element at a time, to remove a range of elements, the iterator is used. The remove() method removes the specified item.

Note: Remove method in List will only remove the first occurrence of the searched element.

Complexities for Deleting elements in a Lists(remove() method):

Method 2: using pop() method.

pop() function can also be used to remove and return an element from the list, but by default it removes only the last element of the list, to remove an element from a specific position of the List, the index of the element is passed as an argument to the pop() method.

Complexities for Deleting elements in a Lists(pop() method):

Time Complexity: O(1)/O(n) (O(1) for removing the last element, O(n) for removing the first and middle elements)

Slicing of a List

We can get substrings and sublists using a slice. In Python List, there are multiple ways to print the whole list with all the elements, but to print a specific range of elements from the list, we use the Slice operation . 

Slice operation is performed on Lists with the use of a colon(:). 

To print elements from beginning to a range use:

To print elements from end-use:

To print elements from a specific Index till the end use 

To print the whole list in reverse order, use 

Note – To print elements of List from rear-end, use Negative Indexes. 

UNDERSTANDING SLICING OF LISTS:

• pr[0] accesses the first item, 2.
• pr[-4] accesses the fourth item from the end, 5.
• pr[2:] accesses [5, 7, 11, 13], a list of items from third to last.
• pr[:4] accesses [2, 3, 5, 7], a list of items from first to fourth.
• pr[2:4] accesses [5, 7], a list of items from third to fifth.
• pr[1::2] accesses [3, 7, 13], alternate items, starting from the second item.

Negative index List slicing

List comprehension.

Python List comprehensions are used for creating new lists from other iterables like tuples, strings, arrays, lists, etc. A list comprehension consists of brackets containing the expression, which is executed for each element along with the for loop to iterate over each element. 

newList = [ expression(element) for element in oldList if condition ]

For better understanding, the above code is similar to as follows: 

Refer to the below articles to get detailed information about List Comprehension.

• List comprehension and ord() in Python

Basic Example on Python List

• Python program to interchange first and last elements in a list
• Python program to swap two elements in a list
• Python – Swap elements in String list
• Python | Ways to find length of list
• Maximum of two numbers in Python
• Minimum of two numbers in Python

To Practice the basic list operation, please read this article – Python List of program

List Methods

To know more refer to this article – Python List methods

The operations mentioned above modify the list Itself.

Built-in functions with List

Do go through recent articles on Lists

Useful Links:  

• Recent Articles on Python List
• Python Tutorials
• Multiple Choice Questions
• All articles in Python Category

Please Login to comment...

Similar reads.

• python-list

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

• school Campus Bookshelves
• menu_book Bookshelves
• perm_media Learning Objects
• login Login
• how_to_reg Request Instructor Account
• hub Instructor Commons

Margin Size

• Download Page (PDF)
• Download Full Book (PDF)
• Periodic Table
• Physics Constants
• Scientific Calculator
• Reference & Cite
• Tools expand_more
• Readability

selected template will load here

This action is not available.

10.3: Tuple Assignment

• Last updated
• Save as PDF
• Page ID 3172

• Chuck Severance
• University of Michigan

\( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

\( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

\( \newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\)

( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\)

\( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

\( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\)

\( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

\( \newcommand{\Span}{\mathrm{span}}\)

\( \newcommand{\id}{\mathrm{id}}\)

\( \newcommand{\kernel}{\mathrm{null}\,}\)

\( \newcommand{\range}{\mathrm{range}\,}\)

\( \newcommand{\RealPart}{\mathrm{Re}}\)

\( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

\( \newcommand{\Argument}{\mathrm{Arg}}\)

\( \newcommand{\norm}[1]{\| #1 \|}\)

\( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\AA}{\unicode[.8,0]{x212B}}\)

\( \newcommand{\vectorA}[1]{\vec{#1}}      % arrow\)

\( \newcommand{\vectorAt}[1]{\vec{\text{#1}}}      % arrow\)

\( \newcommand{\vectorB}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

\( \newcommand{\vectorC}[1]{\textbf{#1}} \)

\( \newcommand{\vectorD}[1]{\overrightarrow{#1}} \)

\( \newcommand{\vectorDt}[1]{\overrightarrow{\text{#1}}} \)

\( \newcommand{\vectE}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash{\mathbf {#1}}}} \)

One of the unique syntactic features of the Python language is the ability to have a tuple on the left side of an assignment statement. This allows you to assign more than one variable at a time when the left side is a sequence.

In this example we have a two-element list (which is a sequence) and assign the first and second elements of the sequence to the variables x and y in a single statement.

It is not magic, Python roughly translates the tuple assignment syntax to be the following: 2

Stylistically when we use a tuple on the left side of the assignment statement, we omit the parentheses, but the following is an equally valid syntax:

A particularly clever application of tuple assignment allows us to swap the values of two variables in a single statement:

Both sides of this statement are tuples, but the left side is a tuple of variables; the right side is a tuple of expressions. Each value on the right side is assigned to its respective variable on the left side. All the expressions on the right side are evaluated before any of the assignments.

The number of variables on the left and the number of values on the right must be the same:

More generally, the right side can be any kind of sequence (string, list, or tuple). For example, to split an email address into a user name and a domain, you could write:

The return value from split is a list with two elements; the first element is assigned to uname , the second to domain .

• Python »
• 3.12.4 Documentation »
• The Python Tutorial »
• 5. Data Structures
• Theme Auto Light Dark |

5. Data Structures ¶

This chapter describes some things you’ve learned about already in more detail, and adds some new things as well.

5.1. More on Lists ¶

The list data type has some more methods. Here are all of the methods of list objects:

Add an item to the end of the list. Equivalent to a[len(a):] = [x] .

Extend the list by appending all the items from the iterable. Equivalent to a[len(a):] = iterable .

Insert an item at a given position. The first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x) .

Remove the first item from the list whose value is equal to x . It raises a ValueError if there is no such item.

Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list. It raises an IndexError if the list is empty or the index is outside the list range.

Remove all items from the list. Equivalent to del a[:] .

Return zero-based index in the list of the first item whose value is equal to x . Raises a ValueError if there is no such item.

The optional arguments start and end are interpreted as in the slice notation and are used to limit the search to a particular subsequence of the list. The returned index is computed relative to the beginning of the full sequence rather than the start argument.

Return the number of times x appears in the list.

Sort the items of the list in place (the arguments can be used for sort customization, see sorted() for their explanation).

Reverse the elements of the list in place.

Return a shallow copy of the list. Equivalent to a[:] .

An example that uses most of the list methods:

You might have noticed that methods like insert , remove or sort that only modify the list have no return value printed – they return the default None . [ 1 ] This is a design principle for all mutable data structures in Python.

Another thing you might notice is that not all data can be sorted or compared. For instance, [None, 'hello', 10] doesn’t sort because integers can’t be compared to strings and None can’t be compared to other types. Also, there are some types that don’t have a defined ordering relation. For example, 3+4j < 5+7j isn’t a valid comparison.

5.1.1. Using Lists as Stacks ¶

The list methods make it very easy to use a list as a stack, where the last element added is the first element retrieved (“last-in, first-out”). To add an item to the top of the stack, use append() . To retrieve an item from the top of the stack, use pop() without an explicit index. For example:

5.1.2. Using Lists as Queues ¶

It is also possible to use a list as a queue, where the first element added is the first element retrieved (“first-in, first-out”); however, lists are not efficient for this purpose. While appends and pops from the end of list are fast, doing inserts or pops from the beginning of a list is slow (because all of the other elements have to be shifted by one).

To implement a queue, use collections.deque which was designed to have fast appends and pops from both ends. For example:

5.1.3. List Comprehensions ¶

List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.

For example, assume we want to create a list of squares, like:

Note that this creates (or overwrites) a variable named x that still exists after the loop completes. We can calculate the list of squares without any side effects using:

or, equivalently:

which is more concise and readable.

A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The result will be a new list resulting from evaluating the expression in the context of the for and if clauses which follow it. For example, this listcomp combines the elements of two lists if they are not equal:

and it’s equivalent to:

Note how the order of the for and if statements is the same in both these snippets.

If the expression is a tuple (e.g. the (x, y) in the previous example), it must be parenthesized.

List comprehensions can contain complex expressions and nested functions:

5.1.4. Nested List Comprehensions ¶

The initial expression in a list comprehension can be any arbitrary expression, including another list comprehension.

Consider the following example of a 3x4 matrix implemented as a list of 3 lists of length 4:

The following list comprehension will transpose rows and columns:

As we saw in the previous section, the inner list comprehension is evaluated in the context of the for that follows it, so this example is equivalent to:

which, in turn, is the same as:

In the real world, you should prefer built-in functions to complex flow statements. The zip() function would do a great job for this use case:

See Unpacking Argument Lists for details on the asterisk in this line.

5.2. The del statement ¶

There is a way to remove an item from a list given its index instead of its value: the del statement. This differs from the pop() method which returns a value. The del statement can also be used to remove slices from a list or clear the entire list (which we did earlier by assignment of an empty list to the slice). For example:

del can also be used to delete entire variables:

Referencing the name a hereafter is an error (at least until another value is assigned to it). We’ll find other uses for del later.

5.3. Tuples and Sequences ¶

We saw that lists and strings have many common properties, such as indexing and slicing operations. They are two examples of sequence data types (see Sequence Types — list, tuple, range ). Since Python is an evolving language, other sequence data types may be added. There is also another standard sequence data type: the tuple .

A tuple consists of a number of values separated by commas, for instance:

As you see, on output tuples are always enclosed in parentheses, so that nested tuples are interpreted correctly; they may be input with or without surrounding parentheses, although often parentheses are necessary anyway (if the tuple is part of a larger expression). It is not possible to assign to the individual items of a tuple, however it is possible to create tuples which contain mutable objects, such as lists.

Though tuples may seem similar to lists, they are often used in different situations and for different purposes. Tuples are immutable , and usually contain a heterogeneous sequence of elements that are accessed via unpacking (see later in this section) or indexing (or even by attribute in the case of namedtuples ). Lists are mutable , and their elements are usually homogeneous and are accessed by iterating over the list.

A special problem is the construction of tuples containing 0 or 1 items: the syntax has some extra quirks to accommodate these. Empty tuples are constructed by an empty pair of parentheses; a tuple with one item is constructed by following a value with a comma (it is not sufficient to enclose a single value in parentheses). Ugly, but effective. For example:

The statement t = 12345, 54321, 'hello!' is an example of tuple packing : the values 12345 , 54321 and 'hello!' are packed together in a tuple. The reverse operation is also possible:

This is called, appropriately enough, sequence unpacking and works for any sequence on the right-hand side. Sequence unpacking requires that there are as many variables on the left side of the equals sign as there are elements in the sequence. Note that multiple assignment is really just a combination of tuple packing and sequence unpacking.

5.4. Sets ¶

Python also includes a data type for sets . A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.

Curly braces or the set() function can be used to create sets. Note: to create an empty set you have to use set() , not {} ; the latter creates an empty dictionary, a data structure that we discuss in the next section.

Here is a brief demonstration:

Similarly to list comprehensions , set comprehensions are also supported:

5.5. Dictionaries ¶

Another useful data type built into Python is the dictionary (see Mapping Types — dict ). Dictionaries are sometimes found in other languages as “associative memories” or “associative arrays”. Unlike sequences, which are indexed by a range of numbers, dictionaries are indexed by keys , which can be any immutable type; strings and numbers can always be keys. Tuples can be used as keys if they contain only strings, numbers, or tuples; if a tuple contains any mutable object either directly or indirectly, it cannot be used as a key. You can’t use lists as keys, since lists can be modified in place using index assignments, slice assignments, or methods like append() and extend() .

It is best to think of a dictionary as a set of key: value pairs, with the requirement that the keys are unique (within one dictionary). A pair of braces creates an empty dictionary: {} . Placing a comma-separated list of key:value pairs within the braces adds initial key:value pairs to the dictionary; this is also the way dictionaries are written on output.

The main operations on a dictionary are storing a value with some key and extracting the value given the key. It is also possible to delete a key:value pair with del . If you store using a key that is already in use, the old value associated with that key is forgotten. It is an error to extract a value using a non-existent key.

Performing list(d) on a dictionary returns a list of all the keys used in the dictionary, in insertion order (if you want it sorted, just use sorted(d) instead). To check whether a single key is in the dictionary, use the in keyword.

Here is a small example using a dictionary:

The dict() constructor builds dictionaries directly from sequences of key-value pairs:

In addition, dict comprehensions can be used to create dictionaries from arbitrary key and value expressions:

When the keys are simple strings, it is sometimes easier to specify pairs using keyword arguments:

5.6. Looping Techniques ¶

When looping through dictionaries, the key and corresponding value can be retrieved at the same time using the items() method.

When looping through a sequence, the position index and corresponding value can be retrieved at the same time using the enumerate() function.

To loop over two or more sequences at the same time, the entries can be paired with the zip() function.

To loop over a sequence in reverse, first specify the sequence in a forward direction and then call the reversed() function.

To loop over a sequence in sorted order, use the sorted() function which returns a new sorted list while leaving the source unaltered.

Using set() on a sequence eliminates duplicate elements. The use of sorted() in combination with set() over a sequence is an idiomatic way to loop over unique elements of the sequence in sorted order.

It is sometimes tempting to change a list while you are looping over it; however, it is often simpler and safer to create a new list instead.

5.7. More on Conditions ¶

The conditions used in while and if statements can contain any operators, not just comparisons.

The comparison operators in and not in are membership tests that determine whether a value is in (or not in) a container. The operators is and is not compare whether two objects are really the same object. All comparison operators have the same priority, which is lower than that of all numerical operators.

Comparisons can be chained. For example, a < b == c tests whether a is less than b and moreover b equals c .

Comparisons may be combined using the Boolean operators and and or , and the outcome of a comparison (or of any other Boolean expression) may be negated with not . These have lower priorities than comparison operators; between them, not has the highest priority and or the lowest, so that A and not B or C is equivalent to (A and (not B)) or C . As always, parentheses can be used to express the desired composition.

The Boolean operators and and or are so-called short-circuit operators: their arguments are evaluated from left to right, and evaluation stops as soon as the outcome is determined. For example, if A and C are true but B is false, A and B and C does not evaluate the expression C . When used as a general value and not as a Boolean, the return value of a short-circuit operator is the last evaluated argument.

It is possible to assign the result of a comparison or other Boolean expression to a variable. For example,

Note that in Python, unlike C, assignment inside expressions must be done explicitly with the walrus operator := . This avoids a common class of problems encountered in C programs: typing = in an expression when == was intended.

5.8. Comparing Sequences and Other Types ¶

Sequence objects typically may be compared to other objects with the same sequence type. The comparison uses lexicographical ordering: first the first two items are compared, and if they differ this determines the outcome of the comparison; if they are equal, the next two items are compared, and so on, until either sequence is exhausted. If two items to be compared are themselves sequences of the same type, the lexicographical comparison is carried out recursively. If all items of two sequences compare equal, the sequences are considered equal. If one sequence is an initial sub-sequence of the other, the shorter sequence is the smaller (lesser) one. Lexicographical ordering for strings uses the Unicode code point number to order individual characters. Some examples of comparisons between sequences of the same type:

Note that comparing objects of different types with < or > is legal provided that the objects have appropriate comparison methods. For example, mixed numeric types are compared according to their numeric value, so 0 equals 0.0, etc. Otherwise, rather than providing an arbitrary ordering, the interpreter will raise a TypeError exception.

Table of Contents

• 5.1.1. Using Lists as Stacks
• 5.1.2. Using Lists as Queues
• 5.1.3. List Comprehensions
• 5.1.4. Nested List Comprehensions
• 5.2. The del statement
• 5.3. Tuples and Sequences
• 5.5. Dictionaries
• 5.6. Looping Techniques
• 5.7. More on Conditions
• 5.8. Comparing Sequences and Other Types

Previous topic

4. More Control Flow Tools

• Report a Bug
• Show Source

Learn Python practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn python interactively, python introduction.

• Get Started With Python
• Your First Python Program
• Python Comments

Python Fundamentals

• Python Variables and Literals
• Python Type Conversion
• Python Basic Input and Output

Python Operators

Python flow control.

Python if...else Statement

• Python for Loop
• Python while Loop
• Python break and continue
• Python pass Statement

Python Data types

• Python Numbers and Mathematics
• Python List
• Python Tuple
• Python String
• Python Sets
• Python Dictionary
• Python Functions
• Python Function Arguments
• Python Variable Scope
• Python Global Keyword
• Python Recursion
• Python Modules
• Python Package
• Python Main function

Python Files

• Python Directory and Files Management
• Python CSV: Read and Write CSV files
• Reading CSV files in Python
• Writing CSV files in Python
• Python Exception Handling
• Python Exceptions
• Python Custom Exceptions

Python Object & Class

• Python Objects and Classes
• Python Inheritance
• Python Multiple Inheritance
• Polymorphism in Python

Python Operator Overloading

Python Advanced Topics

• List comprehension
• Python Lambda/Anonymous Function
• Python Iterators
• Python Generators
• Python Namespace and Scope
• Python Closures
• Python Decorators
• Python @property decorator
• Python RegEx

Python Date and Time

• Python datetime
• Python strftime()
• Python strptime()
• How to get current date and time in Python?
• Python Get Current Time
• Python timestamp to datetime and vice-versa
• Python time Module
• Python sleep()

Additional Topic

Precedence and Associativity of Operators in Python

• Python Keywords and Identifiers
• Python Asserts
• Python Json
• Python *args and **kwargs

Python Tutorials

Python 3 Tutorial

• Python Strings
• Python any()

Operators are special symbols that perform operations on variables and values. For example,

Here, + is an operator that adds two numbers: 5 and 6 .

• Types of Python Operators

Here's a list of different types of Python operators that we will learn in this tutorial.

• Arithmetic Operators
• Assignment Operators
• Comparison Operators
• Logical Operators
• Bitwise Operators
• Special Operators

1. Python Arithmetic Operators

Arithmetic operators are used to perform mathematical operations like addition, subtraction, multiplication, etc. For example,

Here, - is an arithmetic operator that subtracts two values or variables.

Example 1: Arithmetic Operators in Python

In the above example, we have used multiple arithmetic operators,

• + to add a and b
• - to subtract b from a
• * to multiply a and b
• / to divide a by b
• // to floor divide a by b
• % to get the remainder
• ** to get a to the power b

2. Python Assignment Operators

Assignment operators are used to assign values to variables. For example,

Here, = is an assignment operator that assigns 5 to x .

Here's a list of different assignment operators available in Python.

Example 2: Assignment Operators

Here, we have used the += operator to assign the sum of a and b to a .

Similarly, we can use any other assignment operators as per our needs.

3. Python Comparison Operators

Comparison operators compare two values/variables and return a boolean result: True or False . For example,

Here, the > comparison operator is used to compare whether a is greater than b or not.

Example 3: Comparison Operators

Note: Comparison operators are used in decision-making and loops . We'll discuss more of the comparison operator and decision-making in later tutorials.

4. Python Logical Operators

Logical operators are used to check whether an expression is True or False . They are used in decision-making. For example,

Here, and is the logical operator AND . Since both a > 2 and b >= 6 are True , the result is True .

Example 4: Logical Operators

Note : Here is the truth table for these logical operators.

5. Python Bitwise operators

Bitwise operators act on operands as if they were strings of binary digits. They operate bit by bit, hence the name.

For example, 2 is 10 in binary, and 7 is 111 .

In the table below: Let x = 10 ( 0000 1010 in binary) and y = 4 ( 0000 0100 in binary)

6. Python Special operators

Python language offers some special types of operators like the identity operator and the membership operator. They are described below with examples.

• Identity operators

In Python, is and is not are used to check if two values are located at the same memory location.

It's important to note that having two variables with equal values doesn't necessarily mean they are identical.

Example 4: Identity operators in Python

Here, we see that x1 and y1 are integers of the same values, so they are equal as well as identical. The same is the case with x2 and y2 (strings).

But x3 and y3 are lists. They are equal but not identical. It is because the interpreter locates them separately in memory, although they are equal.

• Membership operators

In Python, in and not in are the membership operators. They are used to test whether a value or variable is found in a sequence ( string , list , tuple , set and dictionary ).

In a dictionary, we can only test for the presence of a key, not the value.

Example 5: Membership operators in Python

Here, 'H' is in message , but 'hello' is not present in message (remember, Python is case-sensitive).

Similarly, 1 is key, and 'a' is the value in dictionary dict1 . Hence, 'a' in y returns False .

• Precedence and Associativity of operators in Python

Table of Contents

• Introduction
• Python Arithmetic Operators
• Python Assignment Operators
• Python Comparison Operators
• Python Logical Operators
• Python Bitwise operators
• Python Special operators

Write a function to split the restaurant bill among friends.

• Take the subtotal of the bill and the number of friends as inputs.
• Calculate the total bill by adding 20% tax to the subtotal and then divide it by the number of friends.
• Return the amount each friend has to pay, rounded off to two decimal places.

Video: Operators in Python

Sorry about that.

Related Tutorials

Python Tutorial

• Stack Overflow Public questions & answers
• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Talent Build your employer brand
• Advertising Reach developers & technologists worldwide
• Labs The future of collective knowledge sharing
• About the company

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.

Item assignment to tuples

I am trying to change the value of a particular element of a tuple of tuples. Here is the code:

I understand that Tuples are immutable objects. “Immutable” means you cannot change the values inside a tuple. You can only remove them. I was wondering if there is a workaround? I cannot create a list of lists for y because I am using y as a key in a dictionary later.

• Does this answer your question? List vs tuple, when to use each? –  Mateen Ulhaq Commented Mar 19, 2022 at 22:53
• @MateenUlhaq I mean I understand the difference between lists and tuples. But I am wondering if there is a data structure that can be used for assignment and also be hashed in dictionaries. A tuple does not allow assignment but can be hashed. On the other hand, lists allow assignment but cannot be hashed. So is there a way to do both? –  Garfield Commented Mar 19, 2022 at 22:55
• 1 Do you expect the modified value of y to refer to the same entry in the dictionary? –  Nick Commented Mar 19, 2022 at 23:01
• stackoverflow.com/questions/24217647/… –  Nick Commented Mar 19, 2022 at 23:01
• 1 Is there a reason you want to modify y instead of just assigning it a new value? –  John Gordon Commented Mar 19, 2022 at 23:15

3 Answers 3

If you don't expect the modified value of y to point to the same dictionary entry, you could convert to a list of lists, modify that and then convert back to tuples. For example:

The workaround would be to convert it to the list, make changes, and then convert to the tuple again, if you need to use the tuple later as a key to a dictionary. There is no way to directly change the values.

You can't change the values of tuples because they are constant. But, you can convert it back to a list to be changed.

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 or ask your own question .

• Featured on Meta
• Upcoming sign-up experiments related to tags
• Policy: Generative AI (e.g., ChatGPT) is banned
• The return of Staging Ground to Stack Overflow
• The 2024 Developer Survey Is Live

Hot Network Questions

• Can castanets play this fast?
• Convergence/Divergence of Recursive Sequence
• Do abandoned buildings count as broken rooms for the purposes of downtime rules?
• Problems with \dot and \hbar in sfmath following an update
• Binding to an IP address on an interface that comes and goes
• Aligning surveyed point layers in QGIS
• Confusion with treatment of unit vectors in electrostatics
• How to calculate velocity of air behind a propeller?
• Is there a way knowledge checks can be done without an Intelligence trait?
• Scheme interpreter in C
• intersection points, line and contour
• "The Puzzle benchmark" source?
• Is it possible to cast a bonus action spell and then use the Ready action to activate a magic item and cast another spell off-turn with your reaction?
• Tips on removing solder stuck in very small hole
• *Friendly* coloring of a digraph
• What is the difference between NP=EXP and ETH, and what does the community believe about their truth?
• Are these labels or stickers?
• How can photons interact with nuclei?
• Why does setting a variable readonly in the outer scope prevents defining a local variable with the same name?
• Round Cake Pan with Parchment Paper
• End Punctuation Checking using LuaLaTeX (like Reg-Ex)
• What is the story about Merlin, which includes Gorlois' captain Brithael?
• Why aren't the plains people conquering the city people?
• How do I efficiently update myself on what's expected of me as a postdoc?

Advisory boards aren’t only for executives. Join the LogRocket Content Advisory Board today →

• Product Management
• Solve User-Reported Issues
• Find Issues Faster
• Optimize Conversion and Adoption
• Start Monitoring for Free

Understanding type annotation in Python

Python is highly recognized for being a dynamically typed language, which implies that the datatype of a variable is determined at runtime. In other words, as a Python developer, you are not mandated to declare the data type of the value that a variable accepts because Python realizes the data type of this variable based on the current value it holds.

The flexibility of this feature, however, comes with some disadvantages that you typically would not experience when using a statically typed language like Java or C++:

• More errors will be detected at runtime that could have been avoided at the development time
• Absence of compilation could lead to poor performing codes
• Verbose variables make codes harder to read
• Incorrect assumptions about the behavior of specific functions
• Errors due to type mismatch

Python 3.5 introduced type hints , which you can add to your code using the type annotations introduced in Python 3.0. With type hints, you can annotate variables and functions with datatypes. Tools like mypy , pyright , pytypes , or pyre perform the functions of static type-checking and provide hints or warnings when these types are used inconsistently.

This tutorial will explore type hints and how you can add them to your Python code. It will focus on the mypy static type-checking tool and its operations in your code. You’ll learn how to annotate variables, functions, lists, dictionaries, and tuples. You’ll also learn how to work with the Protocol class, function overloading, and annotating constants.

What is static type checking?

Adding type hints to variables.

• Adding type hints to functions
• The Any  type

Configuring mypy for type checking

Adding type hints to functions without return statements, adding union type hints in function parameters, when to use the iterable type to annotate function parameters, when to use the sequence type, when to use the mapping class, using the mutablemapping class as a type hint, using the typeddict class as a type hint.

• Adding type hints to tuples

Creating and using protocols

Annotating overloaded functions, annotating constants with final, dealing with type-checking in third-party packages, before you begin.

To get the most out of this tutorial, you should have:

• Python ≥3.10 installed
• Knowledge of how to write functions, f-strings , and running Python code
• Knowledge of how to use the command-line

We recommend Python ≥3.10, as those versions have new and better type-hinting features. If you’re using Python ≤3.9, Python provides an alternatives type-hint syntax that I’ll demonstrate in the tutorial.

When declaring a variable in statically-typed languages like C and Java, you are mandated to declare the data type of the variable. As a result, you cannot assign a value that does not conform to the data type you specified for the variable. For example, if you declare a variable to be an integer, you can’t assign a string value to it at any point in time.

In statically-typed languages, a compiler monitors the code as it is written and strictly ensures that the developer abides by the rules of the language. If no issues are found, the program can be run.

Using static type-checkers has numerous advantages; some of which include:

• Detecting type errors
• Preventing bugs
• Documenting your code — anyone who wants to use an annotated function will know the type of parameters it accepts and the return value type at a glance
• Additionally, IDEs understand your code much better and offer good autocompletion suggestions

Static typing in Python is optional and can be introduced gradually (this is known as gradual typing). With gradual typing, you can choose to specify the portion of your code that should be dynamically or statically typed. The static type-checkers will ignore the dynamically-typed portions of your code and will not give out warnings on code that does not have type hints nor prevents inconsistent types from compiling during runtime.

What is mypy?

Since Python is by default, a dynamically-typed language, tools like mypy were created to give you the benefits of a statically-typed environment. mypy is a optional static type checker created by Jukka Lehtosalo. It checks for annotated code in Python and emits warnings if annotated types are used inconsistently.

mypy also checks the code syntax and issues syntax errors when it encounters invalid syntax. Additionally, supports gradual typing, allowing you to add type hints in your code slowly at your own pace.

In Python, you can define a variable with a type hint using the following syntax:

Let’s look at the following variable:

You assign a string value "rocket" to the name variable.

To annotate the variable, you need to append a colon ( : ) after the variable name, and declare a type str :

In Python, you can read the type hints defined on variables using the __annotations__ dictionary:

The __annotations__ dictionary will show you the type hints on all global variables.

Over 200k developers use LogRocket to create better digital experiences

As mentioned earlier, the Python interpreter does not enforce types, so defining a variable with a wrong type won’t trigger an error:

On the other hand, a static type checker like mypy will flag this as an error:

Declaring type hints for other data types follows the same syntax. The following are some of the simple types you can use to annotate variables:

• float : float values, such as 3.10
• int : integers, such as 3 , 7
• str : strings, such as 'hello'
• bool : boolean value, which can be True or False
• bytes : represents byte values, such as b'hello'

Annotating variables with simple types like int , or str may not be necessary because mypy can infer the type. However, when working with complex datatypes like lists, dictionary or tuples, it is important that you declare type hints to the corresponding variables because mypy may struggle to infer types on those variables.

Adding types hints to functions

To annotate a function, declare the annotation after each parameter and the return value:

Let’s annotate the following function that returns a message:

The function accepts a string as the first parameter, a float as the second parameter, and returns a string. To annotate the function parameters, we will append a colon( : ) after each parameter and follow it with the parameter type:

• language: str
• version: float

To annotate return value type, add -> immediately after closing the parameter parentheses, just before the function definition colon( : ):

The function now has type hints showing that it receives str and float arguments, and returns str .

When you invoke the function, the output should be similar to what is obtained as follows:

Although our code has type hints, the Python interpreter won’t provide warnings if you invoke the function with wrong arguments:

The function executes successfully, even when you passed a Boolean True as the first argument , and a string "Python" as the second argument. To receive warnings about these mistakes, we need to use a static type-checker like mypy.

Static type-checking with mypy

We will now begin our tutorial on static type-checking with mypy to get warnings about type errors in our code.

Create a directory called type_hints and move it into the directory:

Create and activate the virtual environment:

Install the latest version of mypy with pip :

With mypy installed, create a file called announcement.py and enter the following code:

Save the file and exit. We’re going to reuse the same function from the previous section.

Next, run the file with mypy:

As you can see, mypy does not emit any warnings. Static typing in Python is optional, and with gradual typing, you should not receive any warnings unless you opt in by adding type hints to functions. This allows you to annotate your code slowly.

Let’s now understand why mypy doesn’t show us any warnings.

More great articles from LogRocket:

• Don't miss a moment with The Replay , a curated newsletter from LogRocket
• Learn how LogRocket's Galileo cuts through the noise to proactively resolve issues in your app
• Use React's useEffect to optimize your application's performance
• Switch between multiple versions of Node
• Discover how to use the React children prop with TypeScript
• Explore creating a custom mouse cursor with CSS
• Advisory boards aren’t just for executives. Join LogRocket’s Content Advisory Board. You’ll help inform the type of content we create and get access to exclusive meetups, social accreditation, and swag.

The Any type

As we noted, mypy ignores code with no type hints. This is because it assumes the Any type on code without hints.

The following is how mypy sees the function:

The Any type is a dynamic type that’s compatible with, well, any type. So mypy will not complain whether the function argument types are bool , int , bytes , etc.

Now that we know why mypy doesn’t always issue warnings, let’s configure it to do that.

mypy can be configured to suit your workflow and code practices. You can run mypy in strict mode, using the --strict option to flag any code without type hints:

The --strict option is the most restrictive option and doesn’t support gradual typing. Most of the time, you won’t need to be this strict. Instead, adopt gradual typing to add the type hints in phases.

mypy also provides a --disallow-incomplete-defs option. This option flags functions that don’t have all of their parameters and return values annotated. This option is so handy when you forget to annotate a return value or a newly added parameter, causing mypy to warn you. You can think of this as your compiler that reminds you to abide by the rules of static typing in your code development.

To understand this, add the type hints to the parameters only and omit the return value types (pretending you forgot):

Run the file with mypy without any command-line option:

As you can see, mypy does not warn us that we forgot to annotate the return type. It assumes the Any type on the return value. If the function was large, it would be difficult to figure out the type of value it returns. To know the type, we would have to inspect the return value, which is time-consuming.

To protect ourselves from these issues, pass the --disallow-incomplete-defs option to mypy:

Now run the file again with the --disallow-incomplete-defs option enabled:

Not only does the --disallow-incomplete-defs option warn you about missing type hint, it also flags any datatype-value mismatch. Consider the example below where bool and str values are passed as arguments to a function that accepts str and float respectively:

Let’s see if mypy will warn us about this now:

Great! mypy warns us that we passed the wrong arguments to the function.

Now, let’s eliminate the need to type mypy with the --disallow-incomplete-defs option.

mypy allows you save the options in a mypy.ini file. When running mypy , it will check the file and run with the options saved in the file.

You don’t necessarily need to add the --disallow-incomplete-defs  option each time you run the file using mypy. Mypy gives you an alternative of adding this configuration in a mypy.ini file where you can add some mypy configurations.

Create the mypy.ini file in your project root directory and enter the following code:

In the mypy.ini file, we tell mypy that we are using Python 3.10 and that we want to disallow incomplete function definitions.

Save the file in your project, and next time you can run mypy without any command-line options:

mypy has many options you can add in the mypy file. I recommend referring to the mypy command line documentation to learn more.

Not all functions have a return statement. When you create a function with no return statement, it still returns a None value:

The None value isn’t totally useful as you may not be able to perform an operation with it. It only shows that the function was executed successfully. You can hint that a function has no return type by annotating the return value with None :

When a function accepts a parameter of more than one type, you can use the union character ( | ) to separate the types.

For example, the following function accepts a parameter that can be either str or int :

You can invoke the function show_type  with a string or an integer, and the output depends on the data type of the argument it receives.

To annotate the parameter, we will use the union character | , which was introduced in Python 3.10, to separate the types as follows:

The union | now shows that the parameter num is either str or int .

If you’re using Python ≤3.9, you need to import Union from the typing module. The parameter can be annotated as follows:

Adding type hints to optional function parameters

Not all parameters in a function are required; some are optional. Here’s an example of a function that takes an optional parameter:

The second parameter title is an optional parameter that has a default value of None if it receives no argument at the point of invoking the function. The typing module provides the Optional[<datatype>] annotation to annotate this optional parameter with a type hint:

Below is an example of how you can perform this annotation:

Adding type hints to lists

Python lists are annotated based on the types of the elements they have or expect to have. Starting with Python ≥3.9, to annotate a list, you use the list type, followed by [] . [] contains the element’s type data type.

For example, a list of strings can be annotated as follows:

If you’re using Python ≤3.8, you need to import List from the typing module:

In function definitions, the Python documentation recommends that the list type should be used to annotate the return types:

However, for function parameters, the documentation recommends using these abstract collection types:

The Iterable type should be used when the function takes an iterable and iterates over it.

An iterable is an object that can return one item at a time. Examples range from lists, tuples, and strings to anything that implements the __iter__ method.

You can annotate an Iterable as follows, in Python ≥3.9:

In the function, we define the items parameter and assign it an Iterable[int] type hint, which specifies that the Iterable contains int elements.

The Iterable type hint accepts anything that has the __iter__ method implemented. Lists and tuples have the method implemented, so you can invoke the double_elements function with a list or a tuple, and the function will iterate over them.

To use Iterable in Python ≤3.8, you have to import it from the typing module:

Using Iterable in parameters is more flexible than if we had a list type hint or any other objects that implements the __iter__ method. This is because you wouldn’t need to convert a tuple for example, or any other iterable to a list before passing it into the function.

A sequence is a collection of elements that allows you to access an item or compute its length.

A Sequence type hint can accept a list, string, or tuple. This is because they have special methods: __getitem__ and __len__ . When you access an item from a sequence using  items[index] , the __getitem__ method is used. When getting the length of the sequence len(items) , the __len__ method is used.

In the following example, we use the Sequence[int] type to accept a sequence that has integer items:

This function accepts a sequence and access the last element from it with data[-1] . This uses the __getitem__ method on the sequence to access the last element.

As you can see, we can call the function with a tuple or list and the function works properly. We don’t have to limit parameters to list if all the function does is get an item.

For Python ≤3.8, you need to import Sequence from the typing module:

Adding type hints to dictionaries

To add type hints to dictionaries, you use the dict type followed by [key_type, value_type] :

For example, the following dictionary has both the key and the value as a string:

You can annotate it as follows:

The dict type specifies that the person dictionary keys are of type str and values are of type str .

If you’re using Python ≤3.8, you need to import Dict from the typing module.

In function definitions, the documentation recommends using dict as a return type:

For function parameters, it recommends using these abstract base classes:

• MutableMapping

In function parameters, when you use the dict type hints, you limit the arguments the function can take to only dict , defaultDict , or OrderedDict . But, there are many dictionary subtypes, such as UserDict and ChainMap , that can be used similarly.

You can access an element and iterate or compute their length like you can with a dictionary. This is because they implement:

• __getitem__ : for accessing an element
• __iter__ : for iterating
• __len__ : computing the length

So instead of limiting the structures the parameter accepts, you can use a more generic type Mapping since it accepts:

• defaultdict
• OrderedDict

Another benefit of the Mapping type is that it specifies that you are only reading the dictionary and not mutating it.

The following example is a function that access items values from a dictionary:

The Mapping type hint in the above function has the [str, str] depiction that specifies that the student data structure has keys and values both of type str .

If you’re using Python ≤3.8, import Mapping from the typing module:

Use MutableMapping as a type hint in a parameter when the function needs to mutate the dictionary or its subtypes. Examples of mutation are deleting items or changing item values.

The MutableMapping class accepts any instance that implements the following special methods:

• __getitem__
• __setitem__
• __delitem__

The __delitem__ and __setitem__ methods are used for mutation, and these are methods that separate Mapping type from the MutableMapping type.

In the following example, the function accepts a dictionary and mutates it:

In the function body, the value in the first_name variable is assigned to the dictionary and replaces the value paired to the first_name key. Changing a dictionary key value invokes the __setitem__ method.

If you are on Python ≤3.8, import MutableMapping from the typing module.

So far, we have looked at how to annotate dictionaries with dict , Mapping , and MutableMapping , but most of the dictionaries have only one type: str . However, dictionaries can contain a combination of other data types.

Here is an example of a dictionary whose keys are of different types:

The dictionary values range from str , int , and list . To annotate the dictionary, we will use a TypedDict that was introduced in Python 3.8. It allows us to annotate the value types for each property with a class-like syntax:

We define a class StudentDict that inherits from TypedDict . Inside the class, we define each field and its expected type.

With the TypedDict defined, you can use it to annotate a dictionary variable as follows:

You can also use it to annotate a function parameter that expects a dictionary as follows:

If the dictionary argument doesn’t match StudentDict , mypy will show a warning.

Adding type hints to tuples

A tuple stores a fixed number of elements. To add type hints to it, you use the tuple type, followed by [] , which takes the types for each elements.

The following is an example of how to annotate a tuple with two elements:

Regardless of the number of elements the tuple contains, you’re required to declare the type for each one of them.

The tuple type can be used as a type hint for a parameter or return type value:

If your tuple is expected to have an unknown amount of elements of a similar type, you can use tuple[type, ...] to annotate them:

To annotate a named tuple, you need to define a class that inherits from NamedTuple . The class fields define the elements and their types:

If you have a function that takes a named tuple as a parameter, you can annotate the parameter with the named tuple:

There are times when you don’t care about the argument a function takes. You only care if it has the method you want.

To implement this behavior, you’d use a protocol. A protocol is a class that inherits from the Protocol class in the typing module. In the protocol class, you define one or more methods that the static type checker should look for anywhere the protocol type is used.

Any object that implements the methods on the protocol class will be accepted. You can think of a protocol as an interface found in programming languages such as Java, or TypeScript. Python provides predefined protocols, a good example of this is the Sequence type. It doesn’t matter what kind of object it is, as long as it implements the __getitem__ and __len__ methods, it accepts them.

Let’s consider the following code snippets. Here is an example of a function that calculates age by subtracting the birth year from the current year:

The function takes two parameters: current_year , an integer, and data , an object. Within the function body, we find the difference between the current_year and the value returned from get_birthyear() method.

Here is an example of a class that implements the get_birthyear method:

This is one example of such a class, but there could be other classes such as Dog or Cat that implements the get_birthyear method. Annotating all the possible types would be cumbersome.

Since we only care about the get_birthyear() method. To implement this behavior, let’s create our protocol:

The class HasBirthYear inherits from Protocol , which is part of the typing module. To make the Protocol aware about the get_birthyear method, we will redefine the method exactly as it is done in the Person class example we saw earlier. The only exception would be the function body, where we have to replace the body with an ellipsis ( ... ).

With the Protocol defined, we can use it on the calc_age function to add a type hint to the data parameter:

Now the data parameter has been annotated with the HasBirthYear Protocol. The function can now accept any object as long it has the get_birthyear method.

Here is the full implementation of the code using Protocol :

Running the code with mypy will give you no issues.

Some functions produce different outputs based on the inputs you give them. For example, let’s look at the following function:

When you call the function with an integer as the first argument, it returns an integer. If you invoke the function with a list as the first argument, it returns a list with each element added with the second argument value.

Now, how can we annotate this function? Based on what we know so far, our first instinct would be to use the union syntax:

However, this could be misleading due to its ambiguity. The above code describes a function that accepts an integer as the first argument, and the function returns either a list or an int . Similarly, when you pass a list as the first argument, the function will return either a list or an int .

You can implement function overloading to properly annotate this function. With function overloading, you get to define multiple definitions of the same function without the body, add type hints to them, and place them before the main function implementations.

To do this, annotate the function with the overload decorator from the typing module. Let’s define two overloads before the add_number function implementation:

We define two overloads before the main function add_number . The overloads parameters are annotated with the appropriate types and their return value types. Their function bodies contains an ellipsis ( ... ).

The first overload shows that if you pass int as the first argument, the function will return int .

The second overload shows that if you pass a list as the first argument, the function will return a list .

Finally, the main add_number implementation does not have any type hints.

As you can now see, the overloads annotate the function behavior much better than using unions.

At the time of writing, Python does not have an inbuilt way of defining constants . Starting with Python 3.10, you can use the Final type from the typing module. This will mean mypy will emit warnings if there are attempts to change the variable value.

Running the code with mypy with issue a warning:

This is because we are trying to modify the MIN variable value to MIN = MIN + 3 .

Note that, without mypy or any static file-checker, Python won’t enforce this and the code will run without any issues:

As you can see, during runtime you can change the variable value MIN any time. To enforce a constant variable in your codebase, you have to depend on mypy.

While you may be able to add annotations to your code, the third-party modules you use may not have any type hints. As a result, mypy will warn you.

If you receive those warnings, you can use a type comment that will ignore the third-party module code:

You also have the option of adding type hints with stubs. To learn how to use stubs, see Stub files in the mypy documentation.

This tutorial explored the differences between statically typed and dynamically typed codes. You learned the different approaches you can use to add type hints to your functions and classes. You also learned about static type-checking with mypy and how to add type hints to variables, functions, lists, dictionaries, and tuples as well as working with Protocols, function overloading, and how to annotate constants.

To continue building your knowledge, visit typing — Support for type hints . To learn more about mypy, visit the mypy documentation .

Get set up with LogRocket's modern error tracking in minutes:

• Visit https://logrocket.com/signup/ to get an app ID

Install LogRocket via npm or script tag. LogRocket.init() must be called client-side, not server-side

Share this:

• Click to share on Twitter (Opens in new window)
• Click to share on Reddit (Opens in new window)
• Click to share on LinkedIn (Opens in new window)
• Click to share on Facebook (Opens in new window)

Stop guessing about your digital experience with LogRocket

Recent posts:.

7 TUI libraries for creating interactive terminal apps

When writing applications, a good user interface is just as important as the actual app’s functionality. A good user interface […]

Expo Router adoption guide: Overview, examples, and alternatives

Expo Router provides an excellent file-based routing solution with crucial features such as deep linking and native support.

Superglue vs. Hotwire for modern frontend development

Explore how Superglue and Hotwire revolutionize frontend development with HTML over the wire, enhancing performance, flexibility, and ease of use.

Using PocketBase to build a full-stack application

PocketBase is a performant Go-based tool that comes with essential features like user auth, file uploads, access control rules, and more.

Leave a Reply Cancel reply