Summary  
This chapter explains how to use the step parameter in string slicing to select characters at regular intervals (including omitting start/end values and using negative steps to reverse the selection).

General domain of usage  
Parsing structured identifiers such as invoice numbers or transaction codes.

Viipalointia voidaan tehostaa askelargumentilla, 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 kontrollikoodien 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, merkkijonoihin sekä siihen, miten arvoja muunnetaan ja verrataan turvallisesti eri tyyppien välillä. Kehitä varmuutta aritmeettisten, loogisten ja merkkijono-operaatioiden suorittamisessa sekä perusosaamista, jota tarvitaan selkeän ja luotettavan Python-koodin kirjoittamiseen.

Tutustu Pythonin numeeristen tietotyyppien perusteisiin, kuten kokonaislukuihin ja liukulukuihin, sekä aritmetiikkaan ja operaattorien etusijajärjestykseen. Harjoittele lattiakertolaskua, jakojäännöstä ja math-moduulin funktioita käytännön ajan- ja budjettilaskelmien avulla.

Perusteellinen ymmärrys Boolean-tietotyypistä sekä siitä, miten vertailuoperaattorit arvioivat yhtäsuuruutta, identiteettiä ja totuusarvoja. Loogisten operaattoreiden hyödyntäminen selkeiden ja tarkkojen ehtojen rakentamiseen ohjelmointitilanteissa.

Saat käytännön kokemusta Python-merkkijonoista, niiden luomisesta ja indeksoinnista aina viipalointiin, hakemiseen ja tekstin muotoiluun asti. Ymmärrä, miksi merkkijonot ovat muuttumattomia ja kuinka rakentaa uusia merkkijonoja tehokkaasti vuorovaikutteisia ohjelmia varten.



Opi muuntamaan Pythonin ydintietotyyppejä, vertailemaan merkkijonoja luotettavasti normalisoimalla kirjainkoko ja välilyönnit sekä käsittelemään puuttuvia arvoja None-arvon avulla.
Ymmärrä, milloin käyttää bytes- ja bytearray-tyyppejä raakadatan käsittelyyn käytännön ohjelmissa.



Haaste: Viipalointitehtävä

Esimerkki

Ratkaisu