Summary  
This chapter explains how to use the step parameter in string slicing to select characters at defined intervals or in reverse order by specifying start, end, and step (including negative steps).

General domain of usage  
Parsing structured string data.

Viipalointia voidaan tehostaa askel-argumentilla, jonka avulla voit poimia merkkejä tietyin välein.

Tämä on hyödyllistä, kun haluat valita joka toisen merkin, ohittaa kirjaimia tai poimia kuvioita rakenteisesta datasta, kuten laskun numeroista, tapahtumakoodeista tai raporteista.

```python
string[start : end : step]
```
- `start`: indeksi, josta viipalointi alkaa (mukana)
- `end`: indeksi, johon viipalointi päättyy (ei mukana)
- `step`: väli (esim. 2 tarkoittaa joka toista merkkiä)

Voit myös **jättää pois** yhden tai useamman arvon:

- `string[::2]` ottaa joka toisen merkin alusta loppuun;
- `string[5::3]` alkaa indeksistä 5 ja ottaa joka kolmannen merkin;
- `string[:-2:2]` ottaa joka toisen merkin alusta aina toiseksi viimeiseen merkkiin asti (ei sisällä sitä).

## Esimerkki


Watch this video to see visual demonstrations of string slicing in Python using the step argument. You'll learn how to extract every second or third character from a string, and see real-world examples — like pulling control codes from report filenames. This will help you understand how the start, end, and step values work together to select specific characters in a string.

code = "TXN-2024-INV-0007"
sliced = code[0:13:5]
print(sliced)  # Output: T0N

- Aloita indeksistä `0`
- Lopeta indeksiin `13` (ei mukana)
- Käytä askelta `5`, eli ota joka viides merkki

Indekseissä `0`, `5` ja `10` olevat merkit ovat `'T'`, `'0'` ja `'N'`, joten tulos on `'T0N'`.

Tällaista viipalointia voidaan käyttää esimerkiksi nimikirjainten tai ohjauskoodien poimimiseen rakenteisista merkkijonoista talous- tai asiakirjajärjestelmissä.

import ast
import csv
import importlib
import re
import unittest


# Global Helper Function for Dynamic Feedback
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        # Overwrite the test method name so the test runner displays the success message
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        # Overwrite the test method name so the test runner displays the failure message
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):

    def _test_variable_equals_string(self, var_name, expected):
        # Local import to prevent caching issues across test runs
        import user_code
        importlib.reload(user_code)

        if not hasattr(user_code, var_name):
            return (False, f"Expected variable '{var_name}' to be defined.")

        value = getattr(user_code, var_name)
        if str(value) != str(expected):
            return (
                False,
                f"Expected variable '{var_name}' to equal '{expected}', but got '{value}'.",
            )

        return (True, f"The variable '{var_name}' equals '{expected}'.")

    def test_year_code_value(self):
        passed, result_text = self._test_variable_equals_string(
            "year_code", "22"
        )

        # Route the results dynamically
        _dynamic_test(
            test_case=self,
            condition=passed,
            success_message="The variable 'year_code' equals '22'.",
            failure_message=result_text,
        )


# Additional Source Code Manipulation Helpers (Preserved for your platform)
def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()


def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False

    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(
            isinstance(target, ast.Name) and target.id == var_name
            for target in node.targets
        )
    ]

    if not assign_nodes:
        return code

    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = "" * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i + 1 :]:
            if hasattr(next_node, "lineno"):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line + 1 : next_line] = []
        changed = True

    return "\\n".join(lines) if changed else code


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

test_main.py

Hanki vankka ymmärrys Pythonin keskeisistä tietotyypeistä ja opi työskentelemään niiden kanssa tehokkaasti. Tutustu numeroihin, totuusarvoihin ja merkkijonoihin käytännön harjoitusten ja esimerkkien avulla. Rakenna varmuutta perusoperaatioiden suorittamisessa ja kehitä perustaidot, joita tarvitaan selkeän ja tehokkaan Python-koodin kirjoittamiseen.

Tutustu Pythonin numeeristen tietotyyppien perusteisiin ja opi käsittelemään kokonais- ja liukulukuja. Hallitse peruslaskutoimitukset, perehdy muuttumattomuuden käsitteeseen ja saa käytännön kokemusta Pythonin sisäänrakennettujen funktioiden ja työkalujen hyödyntämisestä numeroiden tehokkaaseen käsittelyyn todellisissa tilanteissa.

Saat selkeän käsityksen Boolean-tietotyypistä, joka on numeerisen datan erikoistyyppi ja edustaa totuusarvoja. Vaikka aihe voi aluksi vaikuttaa haastavalta, Booleanien hallinta on olennaista loogisten ja tehokkaiden ohjelmien kirjoittamisessa. Tämä osio auttaa sinua soveltamaan Boolean-logiikkaa luottavaisesti todellisissa ohjelmointitilanteissa.

Merkkijonot mahdollistavat tekstin käsittelyn Pythonissa, viestien näyttämisestä käyttäjän syötteen käsittelyyn. Tässä osiossa perehdytään merkkijonojen luomiseen, muokkaamiseen ja käsittelyyn tehokkaasti. Merkkijonojen ymmärtäminen on olennaista vuorovaikutteisten ohjelmien kirjoittamisessa ja tiedon selkeässä välittämisessä koodin kautta.

Opi käsittelemään tietotyyppejä tehokkaasti varmistaaksesi ohjelmiesi tarkkuuden ja johdonmukaisuuden. Muunna arvot sopivaan tietotyyppiin, puhdista teksti ennen vertailua ja erottele numeeriset laskutoimitukset tekstin muotoilusta. Opit myös hallitsemaan puuttuvia tietoja tarkoituksellisesti sekä käsittelemään ihmisen luettavaa tekstiä eri tavalla kuin raakadataa, saavuttaen luotettavia, johdonmukaisia ja helposti luettavia tuloksia.

Viipalointitehtävä

Esimerkki

Ratkaisu