Summary
This chapter explains that strings are immutable and cannot be modified in place, and shows how to produce new string instances using methods like replace, concatenation, and other built-in operations.

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 wijzigen. Laten we een voorbeeld bekijken om te zien wat er gebeurt. We weten het resultaat pas als we het proberen. Daarom bekijken we dit voorbeeld.

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 wijzigingen te creëren. ondergaan soortgelijke wijzigingen.

De methode `replace()` is geïmplementeerd om dit probleem op te lossen. De syntaxis 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 kern-datatypen van Python en leer hoe u er effectief mee kunt werken. Ontdek getallen, booleans, strings en hoe u waarden veilig kunt converteren en vergelijken tussen verschillende typen. Bouw vertrouwen op in het uitvoeren van rekenkundige, logische en stringbewerkingen, en ontwikkel de basisvaardigheden die nodig zijn om schone, betrouwbare Python-code te schrijven.

Ontdek de basisprincipes van numerieke types in Python, van gehele getallen en kommagetallen tot rekenkundige bewerkingen en operatorprioriteit. Oefen met gehele deling, modulo en functies uit de math-module aan de hand van praktijkvoorbeelden zoals tijds- en budgetberekeningen.

Verkrijg een grondig begrip van het Booleaanse gegevenstype en hoe vergelijkingsoperatoren gelijkheid, identiteit en waarheidswaarden evalueren.
Toepassing van logische operatoren voor het opstellen van duidelijke, nauwkeurige condities in realistische programmeerscenario's.



Praktische ervaring met Python-strings, van het aanmaken en indexeren tot het slicen, zoeken en formatteren van tekst. Inzicht in de onveranderlijkheid van strings en het efficiënt opbouwen van nieuwe strings voor interactieve programma's.



Ontdek hoe u kunt converteren tussen de kern-datatypen van Python, strings betrouwbaar kunt vergelijken door hoofdletters en witruimte te normaliseren, en ontbrekende waarden kunt afhandelen met None. Leer wanneer u bytes en bytearray gebruikt voor ruwe binaire gegevens in praktijktoepassingen.



Uitdaging: Is String Muteerbaar?

Oplossing