import unittest
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 TestStringIndexing(unittest.TestCase):

    def test_test_str_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'test_str'),
            "The `test_str` variable is declared.",
            "Expected `test_str` variable to be declared."
        )

    def test_test_str_value_correct(self):
        import user_code
        expected_value = "This is string for learning"
        actual_value = user_code.test_str
        _dynamic_test(
            self,
            actual_value == expected_value,
            f"The `test_str` variable contains `{expected_value}`.",
            f"Expected `test_str` to be `{expected_value}`, but got `{actual_value}`."
        )

    def test_first_char_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'first_char'),
            "The `first_char` variable is declared.",
            "Expected `first_char` variable to be declared."
        )

    def test_first_char_value_correct(self):
        import user_code
        expected_value = user_code.test_str[0]
        actual_value = user_code.first_char
        _dynamic_test(
            self,
            actual_value == expected_value,
            f"The `first_char` variable contains `{expected_value}`.",
            f"Expected `first_char` to be `{expected_value}`, but got `{actual_value}`."
        )

    def test_last_char_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'last_char'),
            "The `last_char` variable is declared.",
            "Expected `last_char` variable to be declared."
        )

    def test_last_char_value_correct(self):
        import user_code
        expected_value = user_code.test_str[-1]
        actual_value = user_code.last_char
        _dynamic_test(
            self,
            actual_value == expected_value,
            f"The `last_char` variable contains `{expected_value}`.",
            f"Expected `last_char` to be `{expected_value}`, but got `{actual_value}`."
        )

    def test_highlighted_word_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'highlighted_word'),
            "The `highlighted_word` variable is declared.",
            "Expected `highlighted_word` variable to be declared."
        )

    def test_highlighted_word_value_correct(self):
        import user_code
        expected_value = "learning"
        actual_value = user_code.highlighted_word
        _dynamic_test(
            self,
            actual_value == expected_value,
            f"The `highlighted_word` variable contains `{expected_value}`.",
            f"Expected `highlighted_word` to be `{expected_value}`, but got `{actual_value}`."
        )

    def test_indexing_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'\[\d+\]', user_code_source) or re.search(r'\[-\d+\]', user_code_source),
            "Indexing is used to extract characters from the string.",
            "Expected indexing to be used to extract characters from the string."
        )

    def test_slicing_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'\[.*:.*\]', user_code_source),
            "String slicing is used to extract `learning`.",
            "Expected string slicing to be used to extract `learning`."
        )

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


test_main.py

Python on tulkattu korkean tason yleiskäyttöinen ohjelmointikieli. Toisin kuin HTML, CSS ja JavaScript, joita käytetään pääasiassa verkkokehityksessä, Python on monipuolinen ja sitä voidaan käyttää eri aloilla, mukaan lukien ohjelmistokehitys, datatiede ja taustakehitys. Tässä kurssissa tutustut Pythonin keskeisiin osa-alueisiin, ja lopuksi luot omia funktioitasi!

Sukella Pythonin perusteisiin, tutustu työtilaasi ja suorita yksinkertaisia matemaattisia operaatioita. Opi kirjoittamaan luettavaa koodia käyttämällä kommentteja ja käsittelemään sekä perus- että edistyneitä matemaattisia lausekkeita samalla kun näytät tuloksesi.

Opi tallentamaan ja hallitsemaan tietoja Pythonissa työskentelemällä numeroiden, tekstin ja muuttujien kanssa. Ymmärrä, kuinka arvoja annetaan, noudatetaan nimeämiskäytäntöjä ja tutkitaan erilaisia tietotyyppejä. Saa käytännön kokemusta merkkijono-operaatioista, indeksoinnista, viipaloinnista ja muistitekniikoista tekstin tehokkaaseen käsittelyyn Pythonissa.

Opi käyttämään vertailu- ja loogisia operaattoreita, työskentelemään ehdollisten lausekkeiden kanssa ja soveltamaan jäsenyys- ja tyyppivertailuja. Rakenna vahva perusta ohjelmien kirjoittamiseen, jotka reagoivat dynaamisesti erilaisiin ehtoihin käyttämällä if/else- ja if/elif/else-rakenteita.

Laajenna ymmärrystäsi tietotyypeistä oppimalla, kuinka ryhmitellä useita ominaisuuksia yhteen muuttujaan. Tutustu lists, tuples ja sanakirjoihin tehokkaasti tallentaaksesi ja hallitaksesi jäsenneltyä dataa sekä olennaisiin menetelmiin manipulointiin ja hakemiseen.

Hallitse silmukoiden kirjoittamisen taito Pythonissa—olennaiset rakenteet listojen, tuplien, sanakirjojen ja muiden tietorakenteiden läpikäymiseen. Opi käyttämään while- ja for-silmukoita tehokkaasti, tutustu range-funktioon ja työskentele sisäkkäisten silmukoiden kanssa monimutkaisten iteraatiomallien käsittelemiseksi.

Tutustu Pythonin olennaisiin sisäänrakennettuihin funktioihin ja ota seuraava askel luomalla omia. Opi määrittelemään funktioita, käyttämään ehdollista logiikkaa, muokkaamaan olemassa olevia funktioita ja työskentelemään lambda-lausekkeiden kanssa kirjoittaaksesi tehokasta, uudelleenkäytettävää koodia.

Mikä näistä on oikea tapa luoda muuttuja?

Kuinka tallennat tekstin `"Hello"` muuttujaan nimeltä `greeting`?

Mikä näistä muuttujien nimistä on kelvollinen Pythonissa?

Mikä on oikea tapa tulostaa `"c<>definity"` konsoliin?

Kuinka voit muuntaa merkkijonon `"123"` kokonaisluvuksi?

Mitä tapahtuu, kun seuraava koodi suoritetaan?

Haaste: Kirjainten Hakeminen Merkkijonosta

Ratkaisu

Haaste: Kirjainten Hakeminen Merkkijonosta

Ratkaisu