Logo
Python Introduction
Python Installation and Project Setup
Running Python Programs
Python Syntax and Indentation Rules
Python Variables
Python Comments
Python Data Types
Python Type Conversion and Type Checking
Python Input and Output Functions
Python Operators
Python Arithmetic Operators
Python Assignment Operators
Python Logical Operators
Python Comparison Operators
Python Bitwise Operators
Python Membership Operators
Python Identity Operators
Python Walrus Operator
Python Operator Precedence
Python Conditional Statements
Python if Statement
Python if else
Python if elif else
Python match case Statement
Python Loops
Python for Loop
Python for else Loop
Python while Loop
Python break statement
Python continue statement
Python pass statement
Python Strings
Python String Slicing
Python String Concatenation
Python String Formatting
Python Escape Characters
Python Lists
Python Access List Items
Python Add List Items
Python Change List Items
Python Remove List Items
Python Sort Lists
Python Copy Lists
Python Join Lists
Python List Methods
Python Tuples
Python Access Tuple Items
Python Update Tuples
Python Unpack Tuples
Python Loop Tuples
Python Join Tuples
Python Tuple Methods
Python Sets
Python Dictionaries
Python Functions
Python Lambda Functions
Python Higher Order Functions
Python Classes and Objects
Python OOP Principles
Python Magic Methods
Python Context Managers
Python Error Handling and Debugging
Python File Handling
Python Modules and Packages
Python Iterators and Generators

Python Change List Items

Python lists are mutable, which means you can change list items after creating them. Python change list items by assigning new values to specific index positions or by replacing entire sections using slice assignment. Understanding how to change items in a Python list is fundamental because it lets you update, correct, and transform your data without building a new list from scratch.

When you change list items in Python, the original list is modified directly in memory. No copy is created, and the list keeps the same identity. This in-place modification is one of the key features that makes Python lists different from immutable sequences like tuples and strings. Every method covered here changes the existing list rather than producing a new one.

Change a Single List Item

The most straightforward way to change list items in Python is by assigning a new value to a specific index. You reference the position of the element you want to change using square brackets and then use the assignment operator to set the new value.

fruits = ["apple", "banana", "cherry"]
fruits[0] = "mango"
print(fruits)

Output
['mango', 'banana', 'cherry']

The item at index 0 was originally apple, and it was replaced with mango. The list still has three elements, but the first one now holds a different value. This is the standard way to change a single list item by its index in Python.

You can change list items at any valid index position. Remember that Python uses zero-based indexing, so the first element is at index 0, the second at index 1, and so on.

colors = ["red", "green", "blue", "yellow"]
colors[2] = "purple"
print(colors)

Output
['red', 'green', 'purple', 'yellow']

The element at index 2 changed from blue to purple. The rest of the list remained exactly the same. Only the targeted position was affected when you change list items this way.

Change Items Using Negative Indexing

Python supports negative indexing, which lets you change list items by counting from the end. Index -1 refers to the last element, -2 to the second-to-last, and so on. This is useful when you want to change items near the end of a list without knowing its exact length.

animals = ["cat", "dog", "rabbit", "hamster"]
animals[-1] = "parrot"
print(animals)

Output
['cat', 'dog', 'rabbit', 'parrot']

The last item hamster was replaced with parrot using negative index -1. You did not need to calculate the length of the list or figure out that the last index was 3. Negative indexing makes it simple to change list items at the end of any Python list.

cities = ["London", "Paris", "Tokyo", "Sydney"]
cities[-2] = "Berlin"
print(cities)

Output
['London', 'Paris', 'Berlin', 'Sydney']

The second-to-last item Tokyo was changed to Berlin using index -2. Negative indexing works exactly like positive indexing for changing list items, just counted from the opposite direction.

Change a Range of Items Using Slicing

You can change multiple list items at once in Python by using slice assignment. A slice specifies a start and stop index, and you can assign a new list of values to that range. The items in the specified range get replaced with the new values.

numbers = [10, 20, 30, 40, 50]
numbers[1:3] = [200, 300]
print(numbers)

Output
[10, 200, 300, 40, 50]

The slice [1:3] selected the items at index 1 and index 2, which were 20 and 30. These two items were replaced with 200 and 300. The length of the list stayed the same because the replacement had the same number of elements as the slice. This is how you change a range of list items in Python using slicing.

You can also change list items by replacing a slice with more or fewer elements than the original range. Python adjusts the list size automatically.

letters = ["a", "b", "c", "d", "e"]
letters[1:4] = ["x", "y"]
print(letters)

Output
['a', 'x', 'y', 'e']

The slice [1:4] covered three elements (b, c, d), but the replacement only contained two elements (x, y). Python shrank the list from five elements to four. The list adjusted its size to accommodate the replacement values when you change list items using slice assignment.

Going the other direction, you can replace fewer items with more items, which causes the list to grow.

scores = [100, 200, 300]
scores[1:2] = [250, 260, 270, 280]
print(scores)

Output
[100, 250, 260, 270, 280, 300]

The single element at index 1 which was 200 got replaced with four new values. The list grew from three elements to six. Python handles this resizing seamlessly when you change list items through slice assignment.

Insert Items Without Removing Using Empty Slice

A clever use of slice assignment lets you insert new items into a list without removing any existing elements. You do this by assigning to an empty slice, where the start and stop index are the same position.

languages = ["Python", "Java", "Ruby"]
languages[1:1] = ["C++", "Go"]
print(languages)

Output
['Python', 'C++', 'Go', 'Java', 'Ruby']

The slice [1:1] is an empty range at position 1. Since no elements were selected for removal, the new items C++ and Go were inserted before index 1. The original items shifted to the right. This technique lets you change list items by adding new ones at any position without losing existing data.

Change All Items with a Loop

When you need to change list items based on a condition or transformation, you can iterate through the list using the index and modify each element. The enumerate function pairs each element with its index, making it easy to change list items in place.

prices = [10.5, 20.0, 35.75, 8.25]
for i in range(len(prices)):
    prices[i] = round(prices[i] * 1.1, 2)
print(prices)

Output
[11.55, 22.0, 39.33, 9.08]

Each price in the list was increased by 10 percent. The loop used range with len to get each valid index, then changed the list item at that position with the new calculated value. This pattern is common when you need to change list items by applying the same operation to every element in Python.

You can also use enumerate to change list items conditionally based on their current value.

grades = ["A", "C", "B", "F", "A", "D"]
for i, grade in enumerate(grades):
    if grade == "F":
        grades[i] = "Incomplete"
print(grades)

Output
['A', 'C', 'B', 'Incomplete', 'A', 'D']

Only the item that matched the condition was changed. The loop checked each element and only modified the one with value F, replacing it with Incomplete. This selective approach to changing list items in Python is powerful when you need to update specific values based on logic.

Change Items Using List Comprehension

List comprehension creates a new list based on transformations applied to each element. While it technically creates a new list rather than modifying the original, you can reassign it to the same variable to effectively change list items in Python.

temperatures_c = [0, 20, 37, 100]
temperatures_c = [t + 5 for t in temperatures_c]
print(temperatures_c)

Output
[5, 25, 42, 105]

Each temperature was increased by 5 degrees. The list comprehension built a new list with the modified values, and that new list was assigned back to the same variable name. This approach is clean and readable when you want to change all list items with a single expression.

You can combine list comprehension with conditional logic to change only certain list items while keeping others the same.

values = [15, -3, 42, -8, 7, -1]
values = [v if v >= 0 else 0 for v in values]
print(values)

Output
[15, 0, 42, 0, 7, 0]

All negative numbers were changed to zero while positive numbers stayed unchanged. The conditional expression inside the comprehension decided whether to keep the original value or replace it. This is an elegant way to change list items selectively in Python.

Full Working Example

This complete program demonstrates all the methods to change list items in Python, covering single index assignment, negative indexing, slice assignment, loop-based changes, and list comprehension.

students = ["Alice", "Bob", "Charlie", "Diana", "Eve"]

students[0] = "Alicia"
print("After changing index 0:", students)

students[-1] = "Evelyn"
print("After negative index change:", students)

students[1:3] = ["Bobby", "Charles"]
print("After slice replacement:", students)

students[2:2] = ["Clara"]
print("After empty slice insert:", students)

students[3:5] = ["Dana"]
print("After shrinking slice:", students)

scores = [55, 72, 88, 43, 91, 67]
for i in range(len(scores)):
    if scores[i] < 50:
        scores[i] = 50
print("After conditional loop change:", scores)

words = ["hello", "world", "python", "code"]
words = [w.upper() for w in words]
print("After comprehension change:", words)

mixed = [1, "two", 3, "four", 5]
mixed = [str(item) if isinstance(item, int) else item for item in mixed]
print("After type-based change:", mixed)

Output
After changing index 0: ['Alicia', 'Bob', 'Charlie', 'Diana', 'Eve']
After negative index change: ['Alicia', 'Bob', 'Charlie', 'Diana', 'Evelyn']
After slice replacement: ['Alicia', 'Bobby', 'Charles', 'Diana', 'Evelyn']
After empty slice insert: ['Alicia', 'Bobby', 'Clara', 'Charles', 'Diana', 'Evelyn']
After shrinking slice: ['Alicia', 'Bobby', 'Clara', 'Dana']
After conditional loop change: [55, 72, 88, 50, 91, 67]
After comprehension change: ['HELLO', 'WORLD', 'PYTHON', 'CODE']
After type-based change: ['1', 'two', '3', 'four', '5']