Summary  
This chapter covers using the string method index() to locate the first occurrence of a substring and notes that it raises an exception if the substring isn’t found.

General domain of usage  
Text processing

Hallo, het is belangrijk om te vermelden dat er een andere functie is die dezelfde actie uitvoert als `find()`, namelijk `index()`.

Net als `find()` geeft deze de index van het eerste voorkomen van een substring terug:

string = "I can manage everything"

manage = string.index('manage')
everything = string.index('everything')

print("The index of the word manage is", manage)
print("The index of the word everything is", everything)

De functie `index()` heeft de volgende syntaxis:
```python
string.index('word')
```

De functie `index()` geeft het **eerste voorkomen van het woord** in de string terug, en een belangrijk punt is dat **er een uitzondering wordt opgegooid als het woord niet wordt gevonden**.

Definitie

import importlib
import sys
from io import StringIO
import unittest


class TestUserCode(unittest.TestCase):

    def _test_variable_equals_value(self, var_name, expected):
        # Force local import and reload to prevent persistent module caching issues
        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_value(
            var_name, expected
        )
        self._testMethodName = result_text
        self.assertTrue(passed, result_text)

    # --- Dynamic Test Cases ---

    def test_burning(self):
        self._assert_dynamic("burning", 21)

    def test_desire(self):
        self._assert_dynamic("desire", 29)

    def test_studying(self):
        self._assert_dynamic("studying", 40)


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: Vind de Woordindex

Oplossing