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

Du husker kanskje noe om mutable og immutable datatyper. **Immutable kan ikke endres**.

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.

Men hva med strenger? De er immutable. Du kan ikke endre en streng direkte. La oss se på et eksempel for å se hva som skjer. Vi vil ikke vite utfallet før vi prøver. Derfor skal vi undersøke dette eksempelet.

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

string[0] = 'k'

Å endre innholdet i en streng er et vanlig behov. Python tilbyr metoden `replace()` for å opprette en ny streng med ønskede endringer. gjennomgår lignende endringer.

Metoden `replace()` ble implementert for å løse dette problemet. Den har følgende syntaks: 

```python
string.replace(old_word, new_word)
```
Hver strengmetode oppretter en ny streng — originalen forblir uendret. I dette eksemplet endrer `replace()` `"seafood"` til `"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

Få en solid forståelse av Pythons grunnleggende datatyper og lær hvordan du arbeider effektivt med dem. Utforsk tall, boolske verdier og strenger gjennom praktiske øvelser og eksempler. Bygg selvtillit i å utføre grunnleggende operasjoner og utvikle de nødvendige ferdighetene for å skrive ren og effektiv Python-kode.

Utforsk det grunnleggende om numeriske datatyper i Python og lær hvordan man arbeider med heltall og flyttall. Få oversikt over grunnleggende aritmetiske operasjoner, undersøk begrepet uforanderlighet, og få praktisk erfaring med Pythons innebygde funksjoner og verktøy for effektiv håndtering av tall i virkelige situasjoner.

Få en klar forståelse av datatypen boolsk, en spesialisert undergruppe av numeriske data som representerer sannhetsverdier. Selv om det kan virke utfordrende i starten, er det avgjørende å beherske boolske verdier for å skrive logiske og effektive programmer. Denne delen vil hjelpe deg å anvende boolsk logikk trygt i virkelige programmeringssituasjoner.

Strenger gjør det mulig å arbeide med tekst i Python, fra å vise meldinger til å behandle brukerinput. Du vil utforske hvordan du kan opprette, endre og manipulere strenger på en effektiv måte. Å forstå strenger er avgjørende for å skrive interaktive programmer og formidle informasjon tydelig gjennom koden din.

Lær hvordan du håndterer datatyper effektivt for å sikre nøyaktighet og konsistens i programmene dine. Konverter verdier til riktig type, rens tekst før sammenligning, og skill mellom numeriske operasjoner og tekstformatering. Du vil også oppdage hvordan du bevisst håndterer manglende data og behandler lesbar tekst annerledes enn rå input, for å oppnå pålitelige, konsistente og lettleste resultater.

Er Streng Muterbar?

Løsning