Summary  
This chapter explains that strings are immutable—attempting to modify them directly raises an error—and shows how methods like `replace()` create and return a new string with desired changes.  

General domain of usage  
Text processing

You may recall something about mutable and immutable data types.  **Immutable cannot be changed** .

But what about strings? They are immutable. We cannot change a string directly, only with special operations. We will not have knowledge of the outcome unless we make an attempt. Therefore, let us examine this example.

string = "What does it really take to be first past the post?"

string[0] = 'k'

It is difficult to disagree with the assertion that modifying strings is essential. Just as individuals can alter their viewpoints, we should permit strings to undergo similar changes.

The `replace()` method was implemented to solve this problem. It has the following syntax: 

```python
string.replace(old_word, new_word)
```
By the way, each method that can be implemented for string just creates new string because the current one cannot be modified. Look at the example in which I want to **change seafood to fish**:

string = "I would like to order seafood"
# I changed my mind and want to order fish now
new_string = string.replace('seafood','fish')

# The previous order
print(string)
# The current order
print(new_string)

import unittest


class TestUserCode(unittest.TestCase):
    def _test_variable_equals_string(self, var_name, expected):
        import user_code
        if not hasattr(user_code, var_name):
            return (False, f"Expected '{var_name}' variable to be defined.")
        var = getattr(user_code, var_name)
        if var != expected:
            return (False, f"Expected '{var_name}' to equal '{expected}', but got '{var}'.")
        return (True, f'The variable {var_name} equals "{expected}"')

    def test_new_string1(self):
        passed, result_text = self._test_variable_equals_string(
            'new_string1', 'Paris is the capital of France')
        self._testMethodName = result_text
        self.assertTrue(passed, result_text)

    def test_new_string2(self):
        passed, result_text = self._test_variable_equals_string(
            'new_string2', 'Brasilia is located in South America')
        self._testMethodName = result_text
        self.assertTrue(passed, result_text)

    def test_new_string3(self):
        passed, result_text = self._test_variable_equals_string(
            'new_string3', 'Monkeys eat bananas')
        self._testMethodName = result_text
        self.assertTrue(passed, result_text)


if __name__ == '__main__':
    unittest.main()


test_main.py

Gain a solid understanding of Python's core data types and learn how to work with them effectively. Explore numbers, booleans, and strings through hands-on exercises and practical examples. Build confidence in performing basic operations and develop the foundational skills needed to write clean and efficient Python code.

Discover the essentials of numerical data types in Python and learn how to work with integers and floating-point numbers. Master basic arithmetic operations, explore the concept of immutability, and get hands-on experience using Python's built-in functions and tools to handle numbers efficiently in real-world scenarios.

Gain a clear understanding of the Boolean data type, a specialized subtype of numeric data that represents truth values. Although it may seem challenging at first, mastering Booleans is essential for writing logical and efficient programs. This section will help you confidently apply Boolean logic to real-world programming scenarios.

Strings allow you to work with text in Python, from displaying messages to processing user input. You'll explore how to create, modify, and manipulate strings effectively. Understanding strings is essential for writing interactive programs and communicating information clearly through your code.

Learn how to handle data types effectively to ensure accuracy and consistency in your programs. Convert values to the appropriate type, clean text before comparison, and separate numeric operations from text formatting. You'll also discover how to manage missing data deliberately and handle human-readable text differently from raw input, achieving reliable, consistent, and easy-to-read results.

Is String Mutable?

解答