python tuple support item assignment

CodeFatherTech

Learn to Code. Shape Your Future

Tuple Object Does Not Support Item Assignment. Why?

Have you ever seen the error “tuple object does not support item assignment” when working with tuples in Python? In this article we will learn why this error occurs and how to solve it.

The error “tuple object does not support item assignment” is raised in Python when you try to modify an element of a tuple. This error occurs because tuples are immutable data types. It’s possible to avoid this error by converting tuples to lists or by using the tuple slicing operator.

Let’s go through few examples that will show you in which circumstances this error occurs and what to do about it.

Let’s get started!

Explanation of the Error “Tuple Object Does Not Support Item Assignment”

Define a tuple called cities as shown below:

If you had a list you would be able to update any elements in the list .

But, here is what happens if we try to update one element of a tuple:

Tuples are immutable and that’s why we see this error.

There is a workaround to this, we can:

Convert the tuple into a list.
Update any elements in the list.
Convert the final list back to a tuple.

To convert the tuple into a list we will use the list() function :

Now, let’s update the element at index 1 in the same way we have tried to do before with the tuple:

You can see that the second element of the list has been updated.

Finally, let’s convert the list back to a tuple using the tuple() function :

Makes sense?

Avoid the “Tuple Object Does Not Support Item Assignment” Error with Slicing

The slicing operator also allows to avoid this error.

Let’s see how we can use slicing to create a tuple from our original tuple where only one element is updated.

We will use the following tuple and we will update the value of the element at index 2 to ‘Rome’.

Here is the result we want:

We can use slicing and concatenate the first two elements of the original tuple, the new value and the last two elements of the original tuple.

Here is the generic syntax of the slicing operator (in this case applied to a tuple).

This takes a slice of the tuple including the element at index n and excluding the element at index m .

Firstly, let’s see how to print the first two and last two elements of the tuple using slicing…

First two elements

We can also omit the first zero considering that the slice starts from the beginning of the tuple.

Last two elements

Notice that we have omitted index m considering that the slice includes up to the last element of the tuple.

Now we can create the new tuple starting from the original one using the following code:

(‘Rome’,) is a tuple with one element of type string.

Does “Tuple Object Does Not Support Item Assignment” Apply to a List inside a Tuple?

Let’s see what happens when one of the elements of a tuple is a list.

If we try to update the second element of the tuple we get the expected error:

If we try to assign a new list to the third element…

…once again we get back the error “‘ tuple’ object does not support item assignment “.

But if we append another number to the list inside the tuple, here is what happens:

The Python interpreter doesn’t raise any exceptions because the list is a mutable data type.

This concept is important for you to know when you work with data types in Python:

In Python, lists are mutable and tuples are immutable.

How to Solve This Error with a List of Tuples

Do we see this error also with a list of tuples?

Let’s say we have a list of tuples that is used in a game to store name and score for each user:

The user John has gained additional points and I want to update the points associated to his user:

When I try to update his points we get back the same error we have seen before when updating a tuple.

How can we get around this error?

Tuples are immutable but lists are mutable and we could use this concept to assign the new score to a new tuple in the list, at the same position of the original tuple in the list.

So, instead of updating the tuple at index 0 we will assign a new tuple to it.

Let’s see if it works…

It does work! Once again because a list is mutable .

And here is how we can make this code more generic?

Ok, this is a bit more generic because we didn’t have to provide the name of the user when updating his records.

This is just an example to show you how to address this TypeError , but in reality in this scenario I would prefer to use a dictionary instead.

It would allow us to access the details of each user from the name and to update the score without any issues.

Tuple Object Does Not Support Item Assignment Error With Values Returned by a Function

This error can also occur when a function returns multiple values and you try to directly modify the values returned by the function.

I create a function that returns two values: the number of users registered in our application and the number of users who have accessed our application in the last 30 days.

As you can see the two values are returned by the function as a tuple.

So, let’s assume there is a new registered user and because of that I try to update the value returned by the function directly.

I get the following error…

This can happen especially if I know that two values are returned by the function but I’m not aware that they are returned in a tuple.

Why Using Tuples If We Get This Error?

You might be thinking…

What is the point of using tuples if we get this error every time we try to update them?

Wouldn’t be a lot easier to always use lists instead?

We can see the fact that tuples are immutable as an added value for tuples when we have some data in our application that should never be modified.

Let’s say, for example, that our application integrates with an external system and it needs some configuration properties to connect to that system.

The tuple above contains two values: the API endpoint of the system we connect to and the port for their API.

We want to make sure this configuration is not modified by mistake in our application because it would break the integration with the external system.

So, if our code inadvertently updates one of the values, the following happens:

Remember, it’s not always good to have data structures you can update in your code whenever you want.

In this article we have seen when the error “tuple object does not support item assignment” occurs and how to avoid it.

You have learned how differently the tuple and list data types behave in Python and how you can use that in your programs.

If you have any questions feel free to post them in the comment below 🙂

Claudio Sabato - Codefather - Software Engineer and Programming Coach

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

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

Python TypeError: int object is not iterable: What To Do To Fix It?
Python Unexpected EOF While Parsing: The Way To Fix It
Python AttributeError: Fix This Built-in Exception
Understand the “str object is not callable” Python Error and Fix It!

TypeError: 'tuple' object does not support item assignment

Last updated: Apr 8, 2024 Reading time · 4 min

# TypeError: 'tuple' object does not support item assignment

The Python "TypeError: 'tuple' object does not support item assignment" occurs when we try to change the value of an item in a tuple.

To solve the error, convert the tuple to a list, change the item at the specific index and convert the list back to a tuple.

Here is an example of how the error occurs.

We tried to update an element in a tuple, but tuple objects are immutable which caused the error.

# Convert the tuple to a list to solve the error

We cannot assign a value to an individual item of a tuple.

Instead, we have to convert the tuple to a list.

convert tuple to list to solve the error

This is a three-step process:

Use the list() class to convert the tuple to a list.
Update the item at the specified index.
Use the tuple() class to convert the list back to a tuple.

Once we have a list, we can update the item at the specified index and optionally convert the result back to a tuple.

Python indexes are zero-based, so the first item in a tuple has an index of 0 , and the last item has an index of -1 or len(my_tuple) - 1 .

# Constructing a new tuple with the updated element

Alternatively, you can construct a new tuple that contains the updated element at the specified index.

construct new tuple with updated element

The get_updated_tuple function takes a tuple, an index and a new value and returns a new tuple with the updated value at the specified index.

The original tuple remains unchanged because tuples are immutable.

We updated the tuple element at index 1 , setting it to Z .

If you only have to do this once, you don't have to define a function.

The code sample achieves the same result without using a reusable function.

The values on the left and right-hand sides of the addition (+) operator have to all be tuples.

The syntax for tuple slicing is my_tuple[start:stop:step] .

The start index is inclusive and the stop index is exclusive (up to, but not including).

If the start index is omitted, it is considered to be 0 , if the stop index is omitted, the slice goes to the end of the tuple.

# Using a list instead of a tuple

Alternatively, you can declare a list from the beginning by wrapping the elements in square brackets (not parentheses).

Declaring a list from the beginning is much more efficient if you have to change the values in the collection often.

Tuples are intended to store values that never change.

# How tuples are constructed in Python

In case you declared a tuple by mistake, tuples are constructed in multiple ways:

Using a pair of parentheses () creates an empty tuple
Using a trailing comma - a, or (a,)
Separating items with commas - a, b or (a, b)
Using the tuple() constructor

# Checking if the value is a tuple

You can also handle the error by checking if the value is a tuple before the assignment.

If the variable stores a tuple, we set it to a list to be able to update the value at the specified index.

The isinstance() function returns True if the passed-in object is an instance or a subclass of the passed-in class.

If you aren't sure what type a variable stores, use the built-in type() class.

The type class returns the type of an object.

# Additional Resources

You can learn more about the related topics by checking out the following tutorials:

How to convert a Tuple to an Integer in Python
How to convert a Tuple to JSON in Python
Find Min and Max values in Tuple or List of Tuples in Python
Get the Nth element of a Tuple or List of Tuples in Python
Creating a Tuple or a Set from user Input in Python
How to Iterate through a List of Tuples in Python
Write a List of Tuples to a File in Python
AttributeError: 'tuple' object has no attribute X in Python
TypeError: 'tuple' object is not callable in Python [Fixed]

Borislav Hadzhiev

Web Developer

Explore your training options in 10 minutes Get Started

Graduate Stories
Partner Spotlights
Bootcamp Prep
Bootcamp Admissions
University Bootcamps
Coding Tools
Software Engineering
Web Development
Data Science
Tech Guides
Tech Resources
Career Advice
Online Learning
Internships
Apprenticeships
Tech Salaries
Associate Degree
Bachelor's Degree
Master's Degree
University Admissions
Best Schools
Certifications
Bootcamp Financing
Higher Ed Financing
Scholarships
Financial Aid
Best Coding Bootcamps
Best Online Bootcamps
Best Web Design Bootcamps
Best Data Science Bootcamps
Best Technology Sales Bootcamps
Best Data Analytics Bootcamps
Best Cybersecurity Bootcamps
Best Digital Marketing Bootcamps
Los Angeles
San Francisco
Browse All Locations
Digital Marketing
Machine Learning
See All Subjects
Bootcamps 101
Full-Stack Development
Career Changes
View all Career Discussions
Mobile App Development
Cybersecurity
Product Management
UX/UI Design
What is a Coding Bootcamp?
Are Coding Bootcamps Worth It?
How to Choose a Coding Bootcamp
Best Online Coding Bootcamps and Courses
Best Free Bootcamps and Coding Training
Coding Bootcamp vs. Community College
Coding Bootcamp vs. Self-Learning
Bootcamps vs. Certifications: Compared
What Is a Coding Bootcamp Job Guarantee?
How to Pay for Coding Bootcamp
Ultimate Guide to Coding Bootcamp Loans
Best Coding Bootcamp Scholarships and Grants
Education Stipends for Coding Bootcamps
Get Your Coding Bootcamp Sponsored by Your Employer
GI Bill and Coding Bootcamps
Tech Intevriews
Our Enterprise Solution
Connect With Us
Publication
Reskill America
Partner With Us

Resource Center
Bachelor’s Degree
Master’s Degree

Python typeerror: ‘tuple’ object does not support item assignment Solution

Tuples are immutable objects . “Immutable” means you cannot change the values inside a tuple. You can only remove them. If you try to assign a new value to an item in a variable, you’ll encounter the “typeerror: ‘tuple’ object does not support item assignment” error.

In this guide, we discuss what this error means and why you may experience it. We’ll walk through an example of this error so you can learn how to solve it in your code.

Find your bootcamp match

Typeerror: ‘tuple’ object does not support item assignment.

While tuples and lists both store sequences of data, they have a few distinctions. Whereas you can change the values in a list, the values inside a tuple cannot be changed. Also, tuples are stored within parenthesis whereas lists are declared between square brackets.

Because you cannot change values in a tuple, item assignment does not work.

Consider the following code snippet:

This code snippet lets us change the first value in the “honor_roll” list to Holly. This works because lists are mutable. You can change their values. The same code does not work with data that is stored in a tuple.

An Example Scenario

Let’s build a program that tracks the courses offered by a high school. Students in their senior year are allowed to choose from a class but a few classes are being replaced.

Start by creating a collection of class names:

We’ve created a tuple that stores the names of each class being offered.

The science department has notified the school that psychology is no longer being offered due to a lack of numbers in the class. We’re going to replace psychology with philosophy as the philosophy class has just opened up a few spaces.

To do this, we use the assignment operator:

This code will replace the value at the index position 3 in our list of classes with “Philosophy”. Next, we print our list of classes to the console so that the user can see what classes are being actively offered:

Use a for loop to print out each class in our tuple to the console. Let’s run our code and see what happens:

Our code returns an error.

The Solution

We’ve tried to use the assignment operator to change a subject in our list. Tuples are immutable so we cannot change their values. This is why our code returns an error.

To solve this problem, we convert our “classes” tuple into a list . This will let us change the values in our sequence of class names.

Do this using the list() method:

We use the list() method to convert the value of “classes” to a list. We assign this new list to the variable “as_list”. Now that we have our list of classes stored as a list, we can change existing classes in the list.

Let’s run our code:

Our code successfully changes the “Psychology” class to “Philosophy”. Our code then prints out the list of classes to the console.

If we need to store our data as a tuple, we can always convert our list back to a tuple once we have changed the values we want to change. We can do this using the tuple() method:

This code converts “as_list” to a tuple and prints the value of our tuple to the console:

We could use this tuple later in our code if we needed our class names stored as a tuple.

The “typeerror: ‘tuple’ object does not support item assignment” error is raised when you try to change a value in a tuple using item assignment.

To solve this error, convert a tuple to a list before you change the values in a sequence. Optionally, you can then convert the list back to a tuple.

Now you’re ready to fix this error in your code like a pro !

About us: Career Karma is a platform designed to help job seekers find, research, and connect with job training programs to advance their careers. Learn about the CK publication .

"Career Karma entered my life when I needed it most and quickly helped me match with a bootcamp. Two months after graduating, I found my dream job that aligned with my values and goals in life!"

Venus, Software Engineer at Rockbot

What's Next?

Get matched with top bootcamps

Ask a question to our community, take our careers quiz.

Solve Python TypeError: 'tuple' object does not support item assignment

by Nathan Sebhastian

Posted on Dec 26, 2022

Reading time: 2 minutes

In Python, tuples are immutable sequences that cannot be modified once they are created. This means that you cannot change, add, or delete elements from a tuple.

When you try to modify a tuple using the square brackets and the assignment operator, you will get the “TypeError: ’tuple’ object does not support item assignment” error.

Consider the example below:

The above code tries to change the first element of the tuple from “Orange” to “Mango”.

But since a tuple is immutable, Python will respond with the following error:

There are two solutions you can use to edit a tuple in Python.

Solution #1: Change the tuple to list first

When you need to modify the elements of a tuple, you can convert the tuple to a list first using the list() function.

Lists are mutable sequences that allow you to change, add, and delete elements.

Once you have made the changes to the list, you can convert it back to a tuple using the tuple() function:

By converting a tuple into a list, you can modify its elements. Once done, convert it back to a tuple.

Solution #2: Create a new tuple

When you only need to modify a single element of a tuple, you can create a new tuple with the modified element.

To access a range of elements from a tuple, you can use the slice operator.

For example, the following code creates a new tuple by adding a slice of elements from an existing tuple:

The code fruits[1:] means you are slicing the fruits tuple to return the second element to the last.

Creating a new tuple is more efficient than converting the entire tuple to a list and back as it requires only one line of code.

But this solution doesn’t work when you need a complex modification.

The Python TypeError: tuple object does not support item assignment issue occurs when you try to modify a tuple using the square brackets (i.e., [] ) and the assignment operator (i.e., = ).

A tuple is immutable, so you need a creative way to change, add, or remove its elements.

This tutorial shows you two easy solutions on how to change the tuple object element(s) and avoid the TypeError.

Thanks for reading. I hope this helps! 🙏

Take your skills to the next level ⚡️

I'm sending out an occasional email with the latest tutorials on programming, web development, and statistics. Drop your email in the box below and I'll send new stuff straight into your inbox!

Hello! This website is dedicated to help you learn tech and data science skills with its step-by-step, beginner-friendly tutorials. Learn statistics, JavaScript and other programming languages using clear examples written for people.

Learn more about this website

Connect with me on Twitter

Or LinkedIn

Type the keyword below and hit enter

Click to see all tutorials tagged with:

How to Solve ‘Tuple’ Object Does Not Support Item Assignment (Python)

Here’s everything about TypeError: ‘Tuple’ Object Does Not Support Item Assignment in Python.

You’ll learn:

The specifics of the tuple data type
The difference between immutable and mutable data types
How to change immutable data types

So if you want to understand this error in Python and how to solve it, then you’re in the right place.

Let’s jump right in!

IndentationError: Unexpected Unindent in Python
How to Solve ImportError: Attempted Relative Import With No Known Parent Package (Python)
SyntaxError: Invalid Character in Identifier: How to Solve? (Python)
3 Ways to Solve Series Objects Are Mutable and Cannot be Hashed (Python)
9 Examples of Unexpected Character After Line Continuation Character (Python)

Mutable, or Immutable? That Is the Question

Data types in Python are mutable or immutable .

All data types that are numeric , for example, are immutable .

You can write something like this:

Have you changed the variable a ?

Not really: When you write a = 1 , you put the object 1 in memory and told the name a to refer to this literal.

Next, when you write a = a + 1 , Python evaluates the expression on the right:

Python takes the object referred by a (the 1 ) and then adds 1 to it.

You get a new object, a 2 . This object goes right into the memory and a references instead of object 1 .

The value of object 1 has not changed—it would be weird if 1 would out of a sudden a 2 , for example, wouldn’t it? So instead of overwriting an object ( 1 ), a new object ( 2 ) is created and assigned to the variable ( a ).

Mutable Data Types

More complex data types in Python are sequences such as:

Byte Arrays

Sequences contain several values, which can be accessed by index.

Software developer standing near his desk while working in a hurry.

However, some sequences are mutable (byte arrays, lists) , while others are immutable (tuples) .

You can create a tuple and access its elements like this:

Yet if you try to change one of the elements, you get an error:

Notice that the item in the tuple at index 2 is a list. You can change the list without changing the tuple:

The object stored in the tuple remains the same, but its contents have changed. But what if you still need to change the element in the tuple?

You can do this by converting the tuple to a list. Then you change the element, and then convert the list to a tuple again:

For large amounts of data, conversion operations can take quite a long time:

As you can see, for a list of 100 million float numbers, this operation takes about a second. This is not a long time for most tasks, but it is still worth considering if you are dealing with large amounts of data.

However, there is another way to “change” a tuple element—you can rebuild a tuple using slicing and concatenation:

Note that it is necessary to put a comma in parentheses to create a tuple of one element. If you use just parentheses, then (‘uno’) is not a tuple, but a string in parentheses .

Concatenating a string with a tuple is not possible:

Interestingly, you can use shorthand operators on a tuple, like this:

Or even like this:

3 Examples of TypeError: ‘Tuple’ Object Does Not Support Item Assignment in Python

Let’s look at some practical examples of when this error can occur. The simplest is when you initially enter the sequence incorrectly:

In this example, the name list1 refers to a tuple despite the list in the name. The name does not affect the type of variable. To fix this error, simply change the parentheses to square brackets in the constructor:

Perhaps you have a list with some values, such as the student’s name and grade point average:

Alice did a poor job this semester, and her GPA dropped to 90:

Unfortunately, you cannot just change the average score in such a list. You already know that you can convert a tuple to a list, or form a new tuple. For example, like this:

However, if you need to change values regularly, it makes sense to switch from a list of tuples to a dictionary. Dictionaries are a perfect fit for such tasks. You can do this easily with the dict() constructor:

Now you can change the average by student name:

#1 Real World Example of TypeError: ‘Tuple’ Object Does Not Support Item Assignment in Python

An interesting example of a novice programmer trying to enter values in a list from the keyboard using the eval() function:

This method is not very reliable by itself.

Even if the user enters the correct sequence separated by commas—for example, 3, 2, 4, 1 —it will be evaluated in a tuple.

Naturally, an attempt to assign a new value to a tuple element in the line list[i +1] = list[i] raises a TypeError: ‘tuple’ object does not support item assignment .

Here, you see another mistake—which, by the way, may even be invisible during program execution.

The my_sort function uses the list data type name as the argument name. This is not only the name of the data type, but also the list constructor.

Python will not throw an error while executing this code, but if you try to create a list using the constructor inside the my_sort function, you will have big problems.

Programmer trying to solve problems with the code he's working on.

In this case, to enter elements into the list, it would be more correct to read the entire string and then split it using the split() method. If you need integer values, you can also apply the map() function, then convert the resulting map object into a list:

The construction looks a little cumbersome, but it does its job. You can also enter list items through a list comprehension:

You can choose the design that you like best.

#2 Real World Example of TypeError: ‘Tuple’ Object Does Not Support Item Assignment in Python

Another example of when a TypeError: ‘tuple’ object does not support item assignment may occur is the use of various libraries.

If you have not studied the documentation well enough, you may not always clearly understand which data type will be returned in a given situation. In this example, the author tries to make the picture redder by adding 20 to the red color component:

This produces an error on the line pixel[0] = pixel[0] + 20 . How?

You are converting pixels to a list in line of code 3 . Indeed, if you check the type of the pixels variable, you get a list:

However, in the loop, you iterate over the pixels list elements, and they already have a different type. Check the type of the pixels list element with index 0 :

And this is a tuple!

So, you can solve this problem by converting lists to tuples inside a loop, for example.

However, in this case, you will need to slightly adjust the iterable value. This is because you will need the pixel color values and the index to write the new values into the original array.

For this, use the enumerate() function:

The program will work successfully with that version of a loop, and you will get a redder image at the output. It would be more correct to trim values above 255 , for example:

But if the program consists only of this transformation, then Python will already truncate the values when saving the image.

Here’s more Python support:

9 Examples of Unexpected Character After Line Continuation Character
3 Ways to Solve Series Objects Are Mutable and Cannot be Hashed
How to Solve SyntaxError: Invalid Character in Identifier
ImportError: Attempted Relative Import With No Known Parent Package
IndentationError: Unexpected Unindent in Python (and 3 More)

Tech entrepreneur and founder of Tech Medic, who has become a prominent advocate for the Right to Repair movement. She has testified before the US Federal Trade Commission and been featured on CBS Sunday Morning, helping influence change within the tech industry.

How to Solve Python TypeError: ‘tuple’ object does not support item assignment

by Suf | Programming , Python , Tips

Tuples are immutable objects, which means you cannot change them once created. If you try to change a tuple in place using the indexing operator [], you will raise the TypeError: ‘tuple’ object does not support item assignment.

To solve this error, you can convert the tuple to a list, perform an index assignment then convert the list back to a tuple.

This tutorial will go through how to solve this error and solve it with the help of code examples.

Typeerror: ‘tuple’ object does not support item assignment.

Let’s break up the error message to understand what the error means. TypeError occurs whenever you attempt to use an illegal operation for a specific data type.

The part 'tuple' object tells us that the error concerns an illegal operation for tuples.

The part does not support item assignment tells us that item assignment is the illegal operation we are attempting.

Tuples are immutable objects, which means we cannot change them once created. We have to convert the tuple to a list, a mutable data type suitable for item assignment.

Let’s look at an example of assigning items to a list. We will iterate over a list and check if each item is even. If the number is even, we will assign the square of that number in place at that index position.

Let’s run the code to see the result:

We can successfully do item assignments on a list.

Let’s see what happens when we try to change a tuple using item assignment:

We throw the TypeError because the tuple object is immutable.

To solve this error, we need to convert the tuple to a list then perform the item assignment. We will then convert the list back to a tuple. However, you can leave the object as a list if you do not need a tuple.

Let’s run the code to see the updated tuple:

Congratulations on reading to the end of this tutorial. The TypeError: ‘tuple’ object does not support item assignment occurs when you try to change a tuple in-place using the indexing operator [] . You cannot modify a tuple once you create it. To solve this error, you need to convert the tuple to a list, update it, then convert it back to a tuple.

For further reading on TypeErrors, go to the article:

How to Solve Python TypeError: ‘str’ object does not support item assignment

To learn more about Python for data science and machine learning, go to the online courses page on Python for the most comprehensive courses available.

Have fun and happy researching!

Python Tuple does not support item assignment

5 minute read

Introduction

In Python, tuples are immutable, meaning that their elements cannot be modified once they have been assigned. This means that attempting to assign a value to an element in a tuple will result in the following error:

TypeError: ‘tuple’ object does not support item assignment

This error can be frustrating, but there are a few ways to work around it and achieve the desired outcome. In this article, we will explore three different ways to fix this error and give an in-depth explanation of how each method works.

Error and Cause

When attempting to reassign an item in a tuple using the indexing operator, such as:

Python will raise a TypeError, indicating that the tuple object does not support item assignment. This is because, as previously mentioned, tuples are immutable , and their elements cannot be modified once they have been assigned.

Python’s tuple is a built-in data structure that can store multiple values in a single object. This makes it useful for situations where you need to store multiple related values together.

Tuples are defined by enclosing the values in parentheses and separating them with commas. For example, the following code creates a tuple with three integers:

This tuple object, as stated before, is immutable, which means that once it is created, its elements cannot be modified. This means that you cannot add, remove, or change the values of the elements in a tuple.

This is why when you try to reassign a value to an element in the tuple using the indexing operator, such as my_tuple[0] = 4, python will raise a TypeError, indicating that the tuple object does not support item assignment.

Fix 1: Convert Tuple to List

One way to fix this error is to convert the tuple to a list, make the desired changes, and then convert it back to a tuple.

In the above example, we first convert the tuple to a list using the built-in list() function. Once the tuple is converted to a list, we can use the indexing operator to reassign the value at index 0 to 4.

Since lists are mutable, this operation is allowed. Once the desired changes have been made, we convert the list back to a tuple using the built-in tuple() function. The original tuple object is now replaced by the new tuple object which has the desired value at index 0.

It’s important to note that the original tuple remains unchanged, and the new tuple is created with the modified values. This method is useful when you want to make changes to the tuple and need to keep the original tuple object intact.

Fix 2: Using Slicing

Another way to change the values in a tuple is by using slicing. You can create a new tuple with the desired values by slicing the original tuple and concatenating the new values.

In this example, we use slicing to create a new tuple. The my_tuple[:0] slice returns an empty tuple, the (4,) creates a new tuple with the value 4, and the my_tuple[1:] slice returns a new tuple with all elements of the original tuple except the first element.

We then concatenate these three tuples using the + operator to create a new tuple with the desired values.

It’s important to note that the original tuple remains unchanged, and the new tuple is created with the modified values.

This method is useful when you want to make changes to the tuple and need to keep the original tuple object intact.

It is also worth noting that this method is the most efficient one of the three, as it only uses slicing which has O(k) time complexity where k is the number of elements in the slice.

Fix 3: Creating a new Tuple

The last fix is creating a new tuple with the desired values.

This method works similarly to the previous method, but instead of using slicing and concatenation, we create a new tuple with the desired value and concatenate it with the rest of the elements of the original tuple using the + operator.

While tuples are immutable in Python, there are a few ways to work around the ‘tuple’ object does not support item assignment error. By converting the tuple to a list, using slicing, or creating a new tuple, you can achieve the desired outcome.

We hope this article was useful.

You may also enjoy

Python’s Default dict explained

4 minute read

In this article, we will explain how to use default dicts in the Python programming language. Find examples and more

C++ Undefined reference to std::cout

3 minute read

How to fix the undefined reference to std::cout in the C++ programming language. This error is usually caused by a dependency problem in the gcc compiler.

C++ Length of an Array With Examples (3 easy ways)

In this article, we will use sizeof() operator, for loop method and the std::size function to determine the length of any C++ array. We will provide examples

C++ Convert Int to String

1 minute read

How to convert an int to a string in C++, we will be using the to_string, stringstream and sprintf functions from the std library. Easiest methods to convert

We Love Servers.

WHY IOFLOOD?
BARE METAL CLOUD
DEDICATED SERVERS

Python Tuple | Data Type Usage Guide (With Examples)

Python script demonstrating tuple creation and manipulation with tuple structure symbols and element markers

Ever felt like you’re wrestling with a locked suitcase when trying to grasp the concept of tuples in Python? You’re not alone.

Tuples, just like a tightly locked suitcase, are immutable in Python, meaning once you’ve packed them, you can’t change what’s inside. They can hold a collection of items, but once created, they remain constant.

So, why use them, and how? This comprehensive guide will walk you through everything you need to know about Python tuples, from basic use to advanced techniques. So, let’s unlock the suitcase and dive into the fascinating world of Python tuples.

TL;DR: What is a Tuple in Python?

A tuple in Python is an immutable sequence type. It’s like a list that cannot be changed once created. Here’s a simple example of a tuple:

In the example above, we created a tuple named ‘my_tuple’ with three elements. Once created, you can’t add or remove elements from ‘my_tuple’ or change the existing elements. This immutability makes tuples a useful tool in Python programming, especially when you want to ensure certain data remains constant.

If you’re intrigued and want to unlock more about tuples, including their advanced usage, keep reading!

Table of Contents

Getting Started with Python Tuples

Advanced tuple techniques, exploring alternatives to tuples, navigating tuple troubles, delving into python immutability, expanding tuple usage in larger projects, further resources and readings, python tuples: a quick recap.

Tuples in Python are incredibly straightforward to create. You simply define your tuple by enclosing your items, separated by commas, within parentheses () . Here’s an example of a basic Python tuple:

In the above code, we’ve created a tuple named fruit_tuple that contains three elements. When we print fruit_tuple , we get the output ('apple', 'banana', 'cherry') , which is the tuple we defined.

One of the key characteristics of tuples is their immutability, i.e., once a tuple is created, you cannot change its content. This is advantageous when you have a set of data that should not be altered.

However, this immutability can also be a pitfall if you’re not careful. For instance, if you try to change an item in the tuple like this:

You’ll encounter a TypeError . Python is telling us that tuples do not support item assignment, which is a fancy way of saying you can’t change their content once they’re created.

Python tuples offer more than just a static collection of items. They can be used in more complex ways, such as tuple unpacking, nested tuples, and as dictionary keys. Let’s explore these advanced uses.

Tuple Unpacking

Tuple unpacking allows you to assign the elements of a tuple to different variables. This can be handy when you want to extract values from a tuple in a single line. Here’s how it works:

In the above code, we’ve assigned each item in the fruit_tuple to a separate variable ( fruit1 , fruit2 , fruit3 ). When we print these variables, we get the individual elements of the tuple.

Nested Tuples

Tuples can hold other tuples within them, creating what we call ‘nested tuples’. This is useful when you want to group related data together. Here’s an example:

In this example, nested_tuple contains two tuples, each with two elements.

Tuples as Dictionary Keys

Because of their immutability, tuples can be used as keys in Python dictionaries, unlike lists. This is advantageous when you need a composite key, i.e., a key that is made up of multiple parts. Here’s an example:

Here, we’ve used tuples as keys in our fruit_colors dictionary. When we print the value associated with the key ('apple', 'banana') , we get ‘yellow’.

While tuples are powerful and versatile data structures in Python, they aren’t the only game in town. Python offers other data structures such as lists and dictionaries. Understanding these alternatives can help you make informed decisions about which data structure to use based on your specific needs.

Lists: The Mutable Alternative

Lists in Python are similar to tuples, but unlike tuples, they are mutable. This means you can add, remove, or change elements in a list after it’s created. Here’s an example of a Python list:

In the above code, we created a list and then changed the first element from ‘apple’ to ‘orange’. This would not be possible with a tuple. While this mutability provides flexibility, it may not be ideal when you want to ensure certain data remains constant.

Dictionaries: Key-Value Pairs

Dictionaries in Python are a collection of key-value pairs. They are mutable like lists but provide a way to associate pieces of related information. Here’s an example:

In the above code, we created a dictionary where each fruit (key) is associated with a color (value). This association is something unique to dictionaries and can’t be achieved with tuples or lists.

While tuples, lists, and dictionaries each have their own advantages, the best choice depends on your specific needs. If you need immutability, go with tuples. If you need to change the data, lists are your best bet. And if you need to associate values, dictionaries are the way to go.

While working with Python tuples, you may encounter some common errors or obstacles. Let’s explore these issues and their solutions, along with some best practices for optimization.

Attempting to Modify a Tuple

One of the most common errors when working with tuples is trying to modify them. Remember, tuples are immutable. Let’s see what happens when we try to change a tuple:

The above code returns a TypeError because we’re trying to change a tuple, which is not allowed in Python. If you need a collection of items that can be modified, consider using a list instead.

Unpacking a Tuple Incorrectly

Another common issue arises when trying to unpack more or fewer variables than the tuple contains. Here’s an example:

In this case, Python throws a ValueError because we’re trying to unpack a three-item tuple into only two variables. To solve this, ensure the number of variables matches the number of items in the tuple.

Best Practices and Optimization

When working with tuples, it’s good practice to use them for collections of items that are not meant to change. This clearly signals to anyone reading your code that those values should remain constant. For larger collections of items, tuples can be more memory-efficient than lists, making your programs more optimized. Remember, the right data structure can make your code both easier to read and more efficient.

Immutability is a fundamental concept in Python that directly impacts how we work with tuples. But what does it really mean for a data structure to be immutable, and why is it so important?

In Python, an immutable object is an object whose state cannot be changed after it’s created. This means that once you’ve defined an immutable object, such as a tuple, you can’t add, remove, or change its elements. Let’s see this in action:

In the above code, Python throws a TypeError when we try to change an element in the tuple. This is Python’s way of enforcing immutability.

The Importance of Immutability

Immutability is important for a couple of reasons. First, it provides a degree of safety. When you define a tuple, you can be sure its data will remain constant throughout the program, preventing accidental modifications.

Second, immutability makes Python tuples hashable, meaning they can be used as dictionary keys, unlike lists. This is a powerful feature when you need a composite key, i.e., a key made up of multiple parts.

Beyond Tuples: Other Immutable Types

Tuples aren’t the only immutable objects in Python. Other immutable types include integers, floats, strings, and frozensets. Like tuples, these types can’t be changed after they’re created, providing the same benefits of safety and hashability.

Python tuples, with their immutability and ability to hold multiple data types, can be incredibly useful in larger scripts or projects. For instance, they can be used to group related data together, making your code cleaner and more organized.

Consider a scenario where you’re building a script to manage a database of students. Each student could be represented as a tuple, with elements for their name, age, and grade level.

In this example, the tuple student holds related pieces of data together in a logical and organized way.

Complementary Data Structures

Tuples often work hand-in-hand with other data structures. For instance, lists of tuples are a common sight in Python code. This combination allows you to have an ordered collection of immutable data.

In this example, students is a list of tuples, each representing a different student.

For more advanced usage, you can explore how tuples interact with dictionaries, sets, and other Python data structures.

For a deeper dive into the previously mentioned topics, and more, check out the following guides:

Python Data Types Logic: Simplified – Explore boolean data type usage in Python to enhance your logical reasoning skills.

Python Set Intersection: Usage Guide with Examples – Dive into set intersection operations in Python for finding common elements between sets.

Exploring Bisect Module in Python – Learn how to use bisect in Python for binary search and insertion into sorted collections.

Python Sets – Detailed guides on Python sets by Real Python.

Python’s Official Data Structures Documentation – Understanding Python’s data structures from official sources.

Python Dictionaries Tutorial – Comprehensive guide to Python dictionaries by W3Schools.

Python tuples, with their immutability and ability to hold multiple data types, are a powerful tool in Python’s data structure toolkit. They provide safety and efficiency, especially when working with data that should remain constant.

Here’s a quick comparison of tuples with other Python data structures:

To summarize, tuples are best used when you need to group related data that should remain constant. They can be used in more advanced ways, such as tuple unpacking, nested tuples, and as dictionary keys. However, when you need to change the data or associate values, lists and dictionaries may be more suitable.

Remember, Python will throw a TypeError if you try to modify a tuple, and a ValueError if you try to unpack more or fewer variables than the tuple contains. To avoid these issues, ensure you understand the concept of immutability and use the right number of variables when unpacking a tuple.

Tuples often work hand-in-hand with other data structures, particularly in larger scripts or projects. To expand your knowledge, explore how tuples interact with dictionaries, sets, and other Python data structures.

About Author

Gabriel Ramuglia

Gabriel is the owner and founder of IOFLOOD.com , an unmanaged dedicated server hosting company operating since 2010.Gabriel loves all things servers, bandwidth, and computer programming and enjoys sharing his experience on these topics with readers of the IOFLOOD blog.

java_initialize_declare_array_hands_laptop_coding

Learn Python practically and Get Certified .

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 tuple()

Python Tuple index()

Python Tuple count()

Python Lists Vs Tuples

Python del Statement

Python Dictionary items()

A tuple is a collection similar to a Python list . The primary difference is that we cannot modify a tuple once it is created.

Create a Python Tuple

We create a tuple by placing items inside parentheses () . For example,

More on Tuple Creation

We can also create a tuple using a tuple() constructor. For example,

Here are the different types of tuples we can create in Python.

Empty Tuple

Tuple of different data types

Tuple of mixed data types

Tuple Characteristics

Tuples are:

Ordered - They maintain the order of elements.
Immutable - They cannot be changed after creation.
Allow duplicates - They can contain duplicate values.
Access Tuple Items

Each item in a tuple is associated with a number, known as a index .

The index always starts from 0 , meaning the first item of a tuple is at index 0 , the second item is at index 1, and so on.

Access Items Using Index

We use index numbers to access tuple items. For example,

Tuple Cannot be Modified

Python tuples are immutable (unchangeable). We cannot add, change, or delete items of a tuple.

If we try to modify a tuple, we will get an error. For example,

Python Tuple Length

We use the len() function to find the number of items present in a tuple. For example,

Iterate Through a Tuple

We use the for loop to iterate over the items of a tuple. For example,

Video: Python Lists and Tuples

Sorry about that.

TypeError: ‘tuple’ object does not support item assignment ( Solved )

Tuples, lists, maps are data structures in python. All of them are used for creating multiple items in a single variable. But they have different features. Some support item assignment and some not. In this entire tutorial you will know how to solve the TypeError ‘tuple’ object does not support item assignment.

What are tuples ?

Tuples are used to create multiple elements in a single variable. It is just like list but instead of the square bracket it uses round brackets. Once the tuple is created you cannot change the value of the elements. Therefore it is immutable.

The syntax for the list is the below.

What cause ‘tuple’ object does not support item assignment error

In case you are manipulating the tuple object and you are getting the tuple’ object item assignment error. Then most of the case it is due to that you are changing the elements of the tuple.

Lets take an example and creat this error.

Suppose I have tuple with name of the three students in it. I want to change the name of the third student. And if I use the below lines of code then I will get the ‘tuple’ object does not support item assignment error.

Solution for ‘tuple’ object does not support item assignment error

There is a trick for solving this error. As you already know the tuple object is immutable. Once the elements for the tuples are defined, you can’t change it. But list object elements can be changed.

Therefore if you want to change any elements of the tuples then you have to first convert it into list. After that change the element of the lists. Finally if you want to again get the tuple then you have to change the list to the tuple.

Execute the below lines of code to change the element of the tuple.

‘tuple’ object does not support item assignment is a TypeError that you will get when you try to change the element of the tuple object. As tuple is immutable, before changing elements you have to first convert it into list and then change the elements.

The above method works without giving you error and change the element of tuple.

If you have any query then you can contact us for more help.

Join our list

Subscribe to our mailing list and get interesting stuff and updates to your email inbox.

We respect your privacy and take protecting it seriously

Thank you for signup. A Confirmation Email has been sent to your Email Address.

Something went wrong.

Python TypeError: 'tuple' object does not support item assignment Solution

Posted in PROGRAMMING LANGUAGE / PYTHON

Vinay Khatri Last updated on May 24, 2024

Table of Content

In Python, we have a built-in data structure " tuple " which is similar to a Python list and stores elements in sequential order. The only difference between a Python list and a tuple is that the tuple is an immutable data structure, which means once a tuple object is defined, we can not change its elements. If we try to change the tuple elements using indexing and assignment operator, we will receive the TypeError: 'tuple' object does not support item assignment Error.

In this Python guide, we will discuss this error in detail and learn how to debug it. We will also walk through a common example to demonstrate this error. So without further ado, let's get started with the Error statement.

Python Error: TypeError: 'tuple' object does not support item assignment

The Error Statement TypeError: 'tuple' object does not support item assignment is divided into two parts Exception Type and Error Message.

TypeError (Exception Type)
'tuple' object does not support item assignment (Error Message)

1. TypeError

TypeError is a standard Python exception. It is raised in a Python program when we try to perform an invalid or unsupported operation on a Python object.

2. 'tuple' object does not support item assignment

This error message tells us that the tuple object does not support new value assignment to its elements. You will only encounter this error message when you try to change the values of a tuple element using indexing.

Although we can use indexing to access the individual tuple elements, we can not use indexing to change tuple element values.

Here we are getting this error because in line 5, we are trying to assign a new value to the tuple " letters ". As tuple does not support element change operation, it throws the error when we try to assign a new value to the tuple element. Now let's discuss a common scenario example, and in the solution, we will see an alternative way to debug this problem and add and change the value of a tuple element using some logic.

Common Example Scenario

Tuples are faster as compared to the Python list. That's why many Python developers use tuples to store items or element values. Although tuple supports element access using indexing, it throws an error when changing its elements. This is also one of the main reasons why many pythoneer use tuples instead of lists when they do not want to change the elements of the container throughout the program.

But let's say you come across a situation when you want to change the element value of a tuple, then what would you do?

Here we will discuss an example where we first try to change one of the values of a tuple using indexing. Then in the solution, we will discuss how we can achieve it.

Break the code

The error statement is quite expected. We know that when we try to change the tuple element value using indexing, we get the error. In line 5, we tried to change the first element of the tuple " sem_1_subjects " from "Java" to "Python" , which is the cause of this error statement.

When we use the tuple element as a container to store elements, we think of that container as intact throughout the program. But in the case when we come across a situation where we need to change the value of the tuple elements, there we first need to convert that tuple object to a list using list() function. Then only we can change its values. After changing the value, we can convert back the list object to the tuple using tuple() function.

Example solution

In this Python tutorial, we discussed the "TypeError: 'tuple' object does not support item assignment" Error in detail. This error raises in a Python program when we try to change the value of a tuple element using the assignment operator. A tuple is an immutable data structure, and once we define all its elements, we can not change them. To change its elements, first, need to convert the tuple object to a list, and then only we can change its values.

If you are still getting this error in your Python program, you can share your code in the comment section. We will try to help you in debugging.

People are also reading:

Python typeerror: ‘str’ object is not callable Solution
Python SyntaxError: can’t assign to function call Solution
Python TypeError: ‘method’ object is not subscriptable Solution
Python typeerror: list indices must be integers or slices, not str Solution
Python NameError name is not defined Solution
Python typeerror: ‘list’ object is not callable Solution
Python IndexError: tuple index out of range Solution
Python AttributeError: 'numpy.ndarray' object has no attribute 'append' Solution
Python typeerror: string indices must be integers Solution
Python TypeError: ‘float’ object is not callable Solution

Vinay Khatri I am a Full Stack Developer with a Bachelor's Degree in Computer Science, who also loves to write technical articles that can help fellow developers.

Related Blogs

7 Most Common Programming Errors Every Programmer Should Know

Every programmer encounters programming errors while writing and dealing with computer code. They m…

Carbon Programming Language - A Successor to C++

A programming language is a computer language that developers or programmers leverage to …

Introduction to Elixir Programming Language

We know that website development is at its tipping point, as most businesses aim to go digital nowa…

Proposal: Annotate types in multiple assignment

In the latest version of Python (3.12.3), type annotation for single variable assignment is available:

However, in some scenarios like when we want to annotate the tuple of variables in return, the syntax of type annotation is invalid:

In this case, I propose two new syntaxes to support this feature:

Annotate directly after each variable:
Annotate the tuple of return:

In other programming languages, as I know, Julia and Rust support this feature in there approaches:

I’m pretty sure this has already been suggested. Did you go through the mailing list and searched for topics here? Without doing that, there’s nothing to discuss here. (Besides linking to them).

Secondly, try to not edit posts, but post a followup. Some people read these topics in mailing list mode and don’t see your edits.

https://mail.python.org
https://mail.python.org/archives

For reference, PEP 526 has a note about this in the “Rejected/Postponed Proposals” section:

Allow type annotations for tuple unpacking: This causes ambiguity: it’s not clear what this statement means: x, y: T Are x and y both of type T , or do we expect T to be a tuple type of two items that are distributed over x and y , or perhaps x has type Any and y has type T ? (The latter is what this would mean if this occurred in a function signature.) Rather than leave the (human) reader guessing, we forbid this, at least for now.

Personally I think the meaning of this is rather clear, especially when combined with an assignment, and I would like to see this.

Thank you for your valuable response, both regarding the discussion convention for Python development and the history of this feature.

I have found a related topic here: https://mail.python.org/archives/list/[email protected]/thread/5NZNHBDWK6EP67HSK4VNDTZNIVUOXMRS/

Here’s the part I find unconvincing:

Under what circumstances will fun() be hard to annotate, but a, b will be easy?

It’s better to annotate function arguments and return values, not variables. The preferred scenario is that fun() has a well-defined return type, and the type of a, b can be inferred (there is no reason to annotate it). This idea is presupposing there are cases where that’s difficult, but I’d like to see some examples where that applies.

Does this not work?

You don’t need from __future__ as of… 3.9, I think?

3.10 if you want A | B too: PEP 604 , although I’m not sure which version the OP is using and 3.9 hasn’t reached end of life yet.

We can’t always infer it, so annotating a variable is sometimes necessary or useful. But if the function’s return type is annotated then a, b = fun() allows type-checkers to infer the types of a and b . This stuff isn’t built in to Python and is evolving as typing changes, so what was inferred in the past might be better in the future.

So my question above was: are there any scenarios where annotating the function is difficult, but annotating the results would be easy? That seems like the motivating use case.

Would it be a solution to put it on the line above? And not allow assigning on the same line? Then it better mirrors function definitions.

It’s a long thread, so it might have been suggested already.

Actually, in cases where the called function differs from the user-defined function, we should declare the types when assignment unpacking.

Here is a simplified MWE:

NOTE: In PyTorch, the __call__ function is internally wrapped from forward .

Can’t you write this? That’s shorter than writing the type annotations.

This is the kind of example I was asking for, thanks. Is the problem that typing tools don’t trace the return type through the call because the wrapping isn’t in python?

I still suggest to read the thread you linked, like I’m doing right now.

The __call__ function is not the same as forward . There might be many other preprocessing and postprocessing steps involved inside it.

Yeah, quite a bit of pre-processing in fact… unless you don’t have hooks by the looks of it: