Python String Immutability means that once a string is created, its contents cannot be changed directly. Python strings are used to store text such as names, messages, and sentences, so understanding this property is important when working with and modifying strings.
When a change is needed, Python creates a new string instead of changing the existing one. This affects how Python string modification works and helps avoid common errors when working with strings.
In this section, we will explore four practical approaches commonly used for string modification.
Real-World Analogy
A Python string is like a printed name badge. Once the name is printed, it cannot be edited. To change the name, a new badge must be created.
String Immutability in Python
In Python, strings are immutable, which means their characters cannot be changed after the string is created.
For example, suppose a string contains the word "Python". You cannot replace one of its characters by assigning a new value to its index.
Example: Attempting to Modify a String Directly
message = "Python"
# Attempt to change the first character
message[0] = "J"
print(message)
# Output:
TypeError: 'str' object does not support item assignment
Explanation: The code tries to replace the character "P" with "J". Python does not allow item assignment for strings because strings are immutable. The original string cannot be changed directly.
The same rule applies when trying to replace a slice of a string.
Example: Attempting to Modify a String Slice
message = "Learn Python"
# Attempt to replace part of the string
message[6:] = "Programming"
# Output:
TypeError: 'str' object does not support item assignment
Explanation: The code tries to replace "Python" with "Programming". Since strings do not support direct item or slice assignment, Python raises a TypeError.
How Python String Modification Works
Since a string cannot be changed directly, Python string modification creates a new string containing the required change.
There are several ways to do this. The simplest approaches include:
- joining strings with concatenation
- using string methods such as
replace(),upper(), andlower() - converting a string into a mutable structure such as a list when individual characters need to be changed
The following examples introduce two simple approaches. A separate guide covers more string conversion and editing techniques in detail.
Using String Concatenation for Python String Modification
String concatenation joins two or more strings to create a new string. It does not change either of the original strings.
Example: Creating a Modified String with Concatenation
text = "Hello"
modified = text + " World"
print("Original:", text)
print("Modified:", modified)
# Output:
Original: Hello
Modified: Hello World
Explanation: The + operator joins "Hello" and " World" and creates a new string. The original text remains unchanged, while the new string is stored in modified.
Modifying a Python String Using a List
A list is mutable, so it allows individual characters to be changed. This makes a list useful when a specific character in a string needs to be replaced.
Example: Changing a Character Using a List
# Convert the string into a list
s = list("PYTHON")
# Change the second character
s[1] = "A"
# Convert the list back into a string
modified = "".join(s)
print("Original:", "PYTHON")
print("Modified:", modified)
# Output:
Original: PYTHON
Modified: PATHON
Explanation: The string is first converted into a list of characters. The character at index 1 is changed from "Y" to "A". The list is then joined to create a new string stored in modified.
This approach is useful for simple character-level changes. It does not change the original string.
String Methods for Creating Modified Strings
Many built-in string methods can also produce a new string. For example, replace() can replace text without changing the original string.
Example: Using replace()
text = "I like Java"
modified = text.replace("Java", "Python")
print("Original:", text)
print("Modified:", modified)
# Output:
Original: I like Java
Modified: I like Python
Explanation: The replace() method returns a new string containing the replacement. The original text remains unchanged.
Key Takeaways
The main points about Python string immutability and modification are summarized below.
- Python strings are immutable.
- You cannot change a string character or slice directly using assignment.
- Python creates a new string when a string modification is required.
- Concatenation can create a new string by joining existing strings.
- A list can be used when individual characters need to be changed.
- String methods such as
replace()return new strings instead of changing the original string.
What’s Next?
In this guide, you learned why Python strings are immutable and how Python creates a new string when a change is needed. You also saw basic approaches such as concatenation, string methods, and converting a string into a list for character-level changes.
When different types of string editing or conversion are needed, other approaches can be useful. The next guide compares techniques such as lists, split(), the array module, and StringIO, and explains when each approach is useful.
The difference is simple: this guide explains how string immutability affects modification, while the next guide focuses on comparing different techniques and when to use them.
Python String Modification: Comparison of Techniques & When to Use Each