Summary  
This chapter explains that strings are immutable—once created, their characters cannot be changed in place—and shows how to modify text by using string methods (like replace, upper, lower) or concatenation to produce new string objects.  

General domain of usage  
Text processing

Vous vous souvenez peut-être de la notion de types de données mutables et immuables. **Immuable signifie qu'il ne peut pas être modifié**.

Watch this video to further explore why strings are immutable in Python and how methods like replace() allow you to work with strings effectively. You'll see practical demonstrations of string immutability and learn strategies for modifying string data using built-in methods.

Mais qu'en est-il des chaînes de caractères ? Elles sont immuables. Il n'est pas possible de modifier une chaîne directement. Observons un exemple pour voir ce qui se passe. Nous ne connaîtrons pas le résultat tant que nous n'aurons pas essayé. Examinons donc cet exemple.

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

string[0] = 'k'

La modification du contenu d'une chaîne de caractères est un besoin courant. Python propose la méthode `replace()` pour créer une nouvelle chaîne avec les modifications souhaitées. subir des modifications similaires.

La méthode `replace()` a été implémentée pour résoudre ce problème. Sa syntaxe est la suivante :

```python
string.replace(old_word, new_word)
```
Chaque méthode de chaîne crée une nouvelle chaîne — l'originale reste inchangée. Dans cet exemple, `replace()` remplace `"seafood"` par `"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 importlib
import unittest


class TestUserCode(unittest.TestCase):

    def _test_variable_equals_string(self, var_name, expected):
        # Force local import and reload to prevent module caching across runs
        import user_code

        importlib.reload(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 _assert_dynamic(self, var_name, expected):
        """Processes the validation and dynamically updates the test reporter name."""
        passed, result_text = self._test_variable_equals_string(
            var_name, expected
        )
        self._testMethodName = result_text
        self.assertTrue(passed, result_text)

    # --- Dynamic Test Cases ---

    def test_new_string1(self):
        self._assert_dynamic("new_string1", "Paris is the capital of France")

    def test_new_string2(self):
        self._assert_dynamic(
            "new_string2", "Brasilia is located in South America"
        )

    def test_new_string3(self):
        self._assert_dynamic("new_string3", "Monkeys eat bananas")


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

test_main.py

Acquérir une compréhension solide des principaux types de données de Python et apprendre à les manipuler efficacement. Explorer les nombres, les booléens et les chaînes de caractères à travers des exercices pratiques et des exemples concrets. Développer la confiance dans l'exécution des opérations de base et acquérir les compétences fondamentales nécessaires pour écrire un code Python propre et efficace.

Découvrez les principes fondamentaux des types de données numériques en Python et apprenez à manipuler les entiers et les nombres à virgule flottante. Maîtrise des opérations arithmétiques de base, exploration du concept d'immuabilité et mise en pratique avec les fonctions et outils intégrés de Python pour gérer efficacement les nombres dans des situations réelles.

Acquérir une compréhension claire du type de données booléen, un sous-type spécialisé des données numériques qui représente les valeurs de vérité. Bien qu'il puisse sembler difficile au début, la maîtrise des booléens est essentielle pour écrire des programmes logiques et efficaces. Cette section vous aidera à appliquer avec assurance la logique booléenne à des scénarios de programmation réels.

Les chaînes de caractères permettent de travailler avec du texte en Python, qu'il s'agisse d'afficher des messages ou de traiter des entrées utilisateur. Vous étudierez comment créer, modifier et manipuler efficacement les chaînes de caractères. La compréhension des chaînes de caractères est essentielle pour écrire des programmes interactifs et transmettre clairement des informations à travers votre code.

Apprenez à gérer efficacement les types de données afin d'assurer l'exactitude et la cohérence dans vos programmes. Convertissez les valeurs au type approprié, nettoyez le texte avant toute comparaison et séparez les opérations numériques du formatage du texte. Découvrez également comment gérer de manière délibérée les données manquantes et traiter différemment le texte lisible par l'humain des entrées brutes, pour obtenir des résultats fiables, cohérents et faciles à lire.

Une Chaîne Est-Elle Mutable ?

Solution