Summary  
This chapter explains how to access individual characters in a string using positive and negative indexing and how to determine the length of a string using the len() function.

General domain of usage  
Grocery store data management (e.g., accessing product names and calculating string lengths)

**Merkkijonot Pythonissa** ovat merkkien jonoja, joissa jokaiselle merkille, mukaan lukien välilyönnit, annetaan **tietty sijainti eli indeksi**.
Merkkien käsittely indeksoinnin avulla sekä merkkijonojen pituuden selvittäminen `len()`-funktiolla ovat perustaitoja Pythonissa.

Katso seuraava video, jossa Alex havainnollistaa, miten **indeksointia** ja `len()`-funktiota voidaan käyttää tehokkaasti merkkijonojen kanssa.



Pythonissa indeksointi alkaa arvosta `0`, joten merkkijonon ensimmäinen merkki on indeksissä `0`, toinen indeksissä `1` ja niin edelleen. Tätä kutsutaan usein `n-1`-säännöksi, missä `n` on merkkijonon merkkien määrä. Havainnollistetaan tätä merkkijonolla `"Apple"`:

## Negatiivinen indeksointi

Vastaavasti **negatiivinen indeksointi** mahdollistaa **merkkien laskemisen lopusta alkaen** merkkijonossa alkuperäisen sijaan.

Tämä menetelmä on erityisen hyödyllinen, kun halutaan **päästä käsiksi merkkijonon viimeisiin merkkeihin** tietämättä sen tarkkaa pituutta. Merkkijonon viimeinen merkki on indeksissä `-1`, toiseksi viimeinen indeksissä `-2` ja niin edelleen.

Tarkastellaan samaa merkkijonoa, `"Apple"`, **käyttäen negatiivisia indeksejä** havainnollistaaksemme, miten jokainen merkki voidaan hakea lopusta käsin:


## Esimerkkisovellus

Aloitetaan **merkkijonojen indeksoinnin perusteista**.
Käytä tätä esimerkkiä **tulostaaksesi eri merkkejä** merkkijonosta. Voit kokeilla myös negatiivista indeksointia.


grocery_item = "Milk"

# Accessing the first and last character using indexing
first_character = grocery_item[0]  # 'M'
last_character = grocery_item[-1]  # 'k', using negative indexing for the last character

print("First character:", first_character)
print("Last character:", last_character)

Seuraavaksi tarkastellaan **välilyöntejä sisältävää merkkijonoa** ja käytetään `len()`-funktiota nähdäksemme, **miten välilyönnit lasketaan merkeiksi**.

Sen ymmärtäminen, että välilyönnit lasketaan merkeiksi Pythonissa, auttaa käsittelemään merkkijonoja tarkasti, erityisesti kun ne ovat osa dataa.

store_name = "Green Valley Market"

# Find the length of the string, which includes spaces
length_of_name = len(store_name)  # Includes spaces in the count

# Accessing a character in a position after a space
character_after_space = store_name[6]  # 'V'

print("Length of store name:", length_of_name)
print("Character after the space:", character_after_space)

import unittest
import user_code
from io import StringIO
from contextlib import redirect_stdout
import importlib
import re

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)

class TestUserCode(unittest.TestCase):
    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        return text.strip()

    def test_grocery_item_defined(self):
        try:
            _dynamic_test(
                self,
                hasattr(user_code, 'grocery_item'),
                'grocery_item is defined',
                'Expected grocery_item to be defined.'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_length_of_item_defined(self):
        try:
            expected = len(user_code.grocery_item)
            actual = getattr(user_code, 'length_of_item', None)
            _dynamic_test(
                self,
                actual == expected,
                f'length_of_item is correct: {expected}',
                f'Expected length_of_item to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_first_char_defined_and_correct(self):
        try:
            expected = user_code.grocery_item[0]
            actual = getattr(user_code, 'first_char', None)
            _dynamic_test(
                self,
                actual == expected,
                f'first_char is correct: {expected}',
                f'Expected first_char to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_second_char_defined_and_correct(self):
        try:
            second_word_start = user_code.grocery_item.find(' ') + 1
            expected = user_code.grocery_item[second_word_start]
            actual = getattr(user_code, 'second_char', None)
            _dynamic_test(
                self,
                actual == expected,
                f'second_char is correct: {expected}',
                f'Expected second_char to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_third_char_defined_and_correct(self):
        try:
            second_word_start = user_code.grocery_item.find(' ') + 1
            third_word_start = user_code.grocery_item.find(' ', second_word_start) + 1
            expected = user_code.grocery_item[third_word_start]
            actual = getattr(user_code, 'third_char', None)
            _dynamic_test(
                self,
                actual == expected,
                f'third_char is correct: {expected}',
                f'Expected third_char to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_last_char1_defined_and_correct(self):
        try:
            expected = user_code.grocery_item[-1]
            actual = getattr(user_code, 'last_char1', None)
            _dynamic_test(
                self,
                actual == expected,
                f'last_char1 is correct: {expected}',
                f'Expected last_char1 to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_last_char2_defined_and_correct(self):
        try:
            second_word_end = user_code.grocery_item.find(' ', user_code.grocery_item.find(' ') + 1) - 1
            expected = user_code.grocery_item[second_word_end]
            actual = getattr(user_code, 'last_char2', None)
            _dynamic_test(
                self,
                actual == expected,
                f'last_char2 is correct: {expected}',
                f'Expected last_char2 to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_last_char3_defined_and_correct(self):
        try:
            first_word_end = user_code.grocery_item.find(' ') - 1
            expected = user_code.grocery_item[first_word_end]
            actual = getattr(user_code, 'last_char3', None)
            _dynamic_test(
                self,
                actual == expected,
                f'last_char3 is correct: {expected}',
                f'Expected last_char3 to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

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

test_main.py

Python on korkean tason, tulkattava, yleiskäyttöinen ohjelmointikieli. Toisin kuin HTML, CSS ja JavaScript, joita käytetään pääasiassa web-kehityksessä, Python on monipuolinen ja soveltuu useille eri aloille, kuten ohjelmistokehitykseen, datatieteeseen ja taustajärjestelmäkehitykseen. Tämä kurssi johdattaa sinut Pythonin peruskäsitteisiin ja antaa valmiudet omien funktioiden luomiseen kurssin loppuun mennessä.

Tässä osiossa tutustutaan Pythonin perusteisiin, perehdytään työtilaan, suoritetaan yksinkertaisia laskutoimituksia ja esitetään tulokset.

Tässä osiossa opit, kuinka tallentaa tietoja, kuten numeroita ja tekstiä, tietokoneen muistiin ja hakea niitä nimen perusteella. Lisäksi saat johdannon tekstin käsittelyyn Pythonissa.

Tässä osiossa perehdyt boolean-tietotyyppiin ja opit, miten sitä käytetään ohjelmien kehittämisessä, jotka reagoivat tiettyihin ehtoihin.

Tässä osiossa jatkat tietotyyppien opiskelua ja opit, miten erilaisia ominaisuuksia voidaan järjestää yhteen muuttujaan käyttämällä listoja, tupleja ja sanakirjoja.

Tässä osiossa opit luomaan silmukoita Pythonissa — olennainen taito listojen, tuplien ja sanakirjojen läpikäymiseen.

Tämän johdantokurssin lopuksi tutustut joihinkin sisäänrakennettuihin funktioihin ja alat kehittää omiasi.

Mikä seuraavista on oikea tapa luoda muuttuja?

Annetulla merkkijonolla `"Banana"`, millä koodilla saadaan sen ensimmäinen merkki?

Merkkijonon Indeksointi ja Pituus

Negatiivinen indeksointi

Esimerkkisovellus

Ratkaisu