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

Je herinnert je misschien iets over mutabele en onveranderlijke datatypes. **Onveranderlijk kan niet worden gewijzigd**.

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.

Maar hoe zit het met strings? Deze zijn onveranderlijk. Je kunt een string niet direct aanpassen. Laten we naar een voorbeeld kijken om te zien wat er gebeurt. We weten pas wat het resultaat is als we het proberen. Laten we daarom dit voorbeeld bekijken.

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

string[0] = 'k'

Het wijzigen van de inhoud van een string is een veelvoorkomende behoefte. Python biedt de methode `replace()` om een nieuwe string met de gewenste aanpassingen te creëren. vergelijkbare wijzigingen ondergaan.

De methode `replace()` is geïmplementeerd om dit probleem op te lossen. De syntax is als volgt: 

```python
string.replace(old_word, new_word)
```
Elke stringmethode creëert een nieuwe string — het origineel blijft ongewijzigd. In dit voorbeeld verandert `replace()` `"seafood"` in `"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

Verkrijg een grondig begrip van de kerngegevenstypen van Python en leer hoe u er effectief mee kunt werken. Ontdek getallen, booleans en strings aan de hand van praktische oefeningen en voorbeelden. Bouw vertrouwen op in het uitvoeren van basisbewerkingen en ontwikkel de fundamentele vaardigheden die nodig zijn om schone en efficiënte Python-code te schrijven.

Ontdek de basisprincipes van numerieke gegevenstypen in Python en leer werken met gehele getallen en drijvende-kommagetallen. Beheers elementaire rekenkundige bewerkingen, verken het concept van onveranderlijkheid en doe praktische ervaring op met de ingebouwde functies en hulpmiddelen van Python om efficiënt met getallen om te gaan in realistische situaties.

Krijg een duidelijk begrip van het Booleaanse gegevenstype, een gespecialiseerde subcategorie van numerieke gegevens die waarheidswaarden weergeeft. Hoewel het in het begin lastig kan lijken, is het beheersen van Booleans essentieel voor het schrijven van logische en efficiënte programma's. Deze sectie helpt u om Booleaanse logica met vertrouwen toe te passen in praktische programmeersituaties.

Strings stellen je in staat om met tekst te werken in Python, van het weergeven van berichten tot het verwerken van gebruikersinvoer. Je leert hoe je strings effectief kunt aanmaken, aanpassen en manipuleren. Inzicht in strings is essentieel voor het schrijven van interactieve programma's en het duidelijk overbrengen van informatie via je code.

Leer hoe u effectief met gegevenstypen omgaat om nauwkeurigheid en consistentie in uw programma's te waarborgen. Waarden omzetten naar het juiste type. Tekst opschonen vóór vergelijking. Numerieke bewerkingen scheiden van tekstopmaak. Ook ontdekt u hoe u ontbrekende gegevens doelbewust beheert en mensleesbare tekst anders behandelt dan ruwe invoer, voor betrouwbare, consistente en goed leesbare resultaten.

Is String Muteerbaar?

Oplossing