Summary  
This chapter covers how to use Python’s built-in enumerate function to iterate over a sequence while automatically retrieving both each element’s index and its value, and demonstrates how to customize the starting index.  

General domain of usage  
Generating numbered lists of items in output.

Get a clear, visual walkthrough of the `enumerate()` function in Python. This video covers what `enumerate()` does, how it works with lists, and why it is useful for accessing both indexes and values in a loop. See the syntax in action, watch a step-by-step example labeling a travel list, and get guidance for completing the hands-on task that follows. Perfect for understanding how to combine indexes and values efficiently in your Python code.

`enumerate()`-funktio on erittäin hyödyllinen, kun tarvitsee käyttää sekä arvon että sen indeksin tietoja jossain sekvenssissä, kuten listassa tai merkkijonossa. Tämän avulla voit käsitellä alkioita ja samalla seurata niiden sijaintia sekvenssissä.

Pythonissa listat ovat järjestettyjä tietorakenteita, eli jokaisella alkiolla on yksilöllinen indeksi. `enumerate()`-funktio helpottaa sekä indeksin että arvon saamista samanaikaisesti.



`enumerate()`-funktion syntaksi on:

``` python
for index, value in enumerate(sequence):
    # Your code here
```

- `index`: viittaa alkion sijaintiin listassa. Python käyttää nollapohjaista indeksointia, eli ensimmäisen alkion indeksi on 0;
- `value`: viittaa varsinaiseen arvoon annetussa indeksissä.

Käytetään `enumerate()`-funktiota `travel_list`-listaan, jotta voidaan tulostaa jokainen kaupunki ja sen indeksi:

travel_list = ['Monako', 'Luxemburg', 'Liverpool', 'Barcelona', 'Munchen']

# Printing all cities with their indexes
for index, city in enumerate(travel_list, start=1):
    print(str(index) + ' ' + city)

Voit käyttää `str()`-funktiota muuntaaksesi numeron tekstiksi ennen sen yhdistämistä merkkijonoon.

Huomio

import unittest
import importlib

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def _short_preview(lst, max_items=3):
    """Show only the first few items of a list."""
    if isinstance(lst, list):
        preview = lst[:max_items]
        return preview + (["..."] if len(lst) > max_items else [])
    return lst

class TestUserCode(unittest.TestCase):
    def setUp(self):
        try:
            self.user_code = importlib.import_module("user_code")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_travel_rankings_is_declared(self):
        try:
            _ = self.user_code.travel_rankings
            _dynamic_test(self, True, "The `travel_rankings` list is declared.", "")
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `travel_rankings` to be declared.")

    def test_travel_rankings_is_list(self):
        _dynamic_test(
            self,
            isinstance(self.user_code.travel_rankings, list),
            "`travel_rankings` is a list.",
            "`travel_rankings` must be a list."
        )

    def test_travel_rankings_has_correct_length(self):
        _dynamic_test(
            self,
            len(self.user_code.travel_rankings) == len(self.user_code.countries),
            "`travel_rankings` has the same length as `countries`.",
            f"`travel_rankings` should have {len(self.user_code.countries)} elements, "
            f"found {len(self.user_code.travel_rankings)}."
        )

    def test_travel_rankings_correct_format(self):
        expected = [f"Destination {i + 1}: {country}" for i, country in enumerate(self.user_code.countries)]
        _dynamic_test(
            self,
            self.user_code.travel_rankings == expected,
            "`travel_rankings` elements follow the correct format.",
            (
                "The numbering or format of destinations seems incorrect. "
                f"Expected first 3 examples: {_short_preview(expected)} "
                f"But your list starts as: {_short_preview(self.user_code.travel_rankings)}. "
                "Hint: Make sure destination numbering starts at 1, not 0."
            )
        )

    def test_first_and_last_items(self):
        try:
            expected_first = f"Destination 1: {self.user_code.countries[0]}"
            expected_last = f"Destination {len(self.user_code.countries)}: {self.user_code.countries[-1]}"
            actual_first = self.user_code.travel_rankings[0]
            actual_last = self.user_code.travel_rankings[-1]
            _dynamic_test(
                self,
                actual_first == expected_first and actual_last == expected_last,
                "First and last items in `travel_rankings` are correct.",
                (
                    "Incorrect numbering or formatting detected at the start or end of the list. "
                    f"Expected first: '{expected_first}', got '{actual_first}'. "
                    f"Expected last: '{expected_last}', got '{actual_last}'. "
                    "Hint: Ensure numbering starts at 1 and increments correctly through the list."
                )
            )
        except IndexError:
            self.fail("`travel_rankings` or `countries` list is empty.")

    def test_travel_rankings_contains_correct_values(self):
        try:
            expected_rankings = [f"Destination {i + 1}: {country}" for i, country in enumerate(self.user_code.countries)]
            _dynamic_test(
                self,
                self.user_code.travel_rankings == expected_rankings,
                "The `travel_rankings` list contains the correct formatted values.",
                (
                    "The list elements do not match the expected pattern. "
                    f"Expected first 3 examples: {_short_preview(expected_rankings)} "
                    f"But your list starts as: {_short_preview(self.user_code.travel_rankings)}. "
                    "Hint: Check your string formatting and numbering."
                )
            )
        except AttributeError as e:
            _dynamic_test(self, False, "", f"Missing variable: {e}")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

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

test_main.py

Rakenna varmuutta Python-silmukoiden hallinnassa! Aloita for- ja while-silmukoiden perusteista ja etene edistyneisiin aiheisiin, kuten sisäkkäisiin silmukoihin, ohjausrakenteisiin ja dynaamisiin ehtoihin. Käytännön harjoitusten ja tosielämän esimerkkien avulla opit kirjoittamaan tehokasta, selkeää ja vaikuttavaa koodia. Sopii aloittelijoille ja kaikille, jotka haluavat syventää Python-osaamistaan!

Hallitse sekvenssien läpikäynti for-silmukalla, käytä range()-funktiota tehokkaasti, tutki ehtoja if/else-rakenteilla sekä ohjaa silmukoita break- ja continue-komennoilla. Valmistaudu kirjoittamaan tehokasta, selkeää ja käytännöllistä koodia ratkoessasi mielenkiintoisia haasteita.

Käytännön kokemusta while-silmukasta. Ehtojen käsittely, äärettömien silmukoiden välttäminen, ohjaus break- ja continue-lauseilla sekä else-lauseen yhdistäminen silmukoihin. Ymmärrys siitä, milloin while-silmukkaa kannattaa käyttää todellisissa tilanteissa, ja ongelmanratkaisutaitojen kehittäminen.

Opi yhdistämään silmukoita tehokkaasti, käyttämään if/else-ehtoja sekä hallitsemaan break- ja continue-lauseita ohjaamaan ohjelman kulkua. Kurssin lopussa pystyt ratkaisemaan monimutkaisia ongelmia vaivattomasti ja tarkasti.

Tehosta Python-koodiasi lista- ja sanakirjakehitelmillä. Opiskele, kuinka luoda listoja ja sanakirjoja tiiviisti ja elegantisti samalla parantaen luettavuutta ja suorituskykyä. Hallitse käytännön esimerkit ja opi yksinkertaistamaan monimutkaisia tehtäviä, kuten tietojen suodattamista ja muuntamista, kaikki yhdellä koodirivillä.

Enumerate()-funktio

Ratkaisu