Rakennetaan sanakirja, joka edustaa kirjaa kirjastossa:

book = {"title": "Pride and Prejudice", "author": "Jane Austen", "year": 1813}
print(book)

Tämä sanakirja sisältää kolme avain-arvoparia:

Sanakirjassa voit hakea kohteen viittaamalla sen avaimen. Tässä on esimerkki kirjan julkaisuvuoden hakemisesta:

book = {"title": "Pride and Prejudice", "author": "Jane Austen", "year": 1813}

publication_year = book["year"]
print(publication_year)  # Output: 1813

Annetussa koodissa:

- Python etsii avainta `"year"` sanakirjasta book;
- Se hakee avainta vastaavan arvon (`1813`) ja määrittää sen muuttujalle `publication_year`.

Arvo tulostetaan sitten, mikä osoittaa, kuinka avaimet mahdollistavat nopean ja tarkan pääsyn sanakirjan arvoihin.

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)

class TestUserCode(unittest.TestCase):

    def test_authors_books_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'authors_books'),
            "The `authors_books` dictionary is declared.",
            "Expected `authors_books` dictionary to be declared."
        )

    def test_authors_books_is_dict(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.authors_books, dict),
            "The `authors_books` is of type `dict`.",
            "Expected `authors_books` to be of type `dict`."
        )

    def test_kings_books_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'kings_books'),
            "The `kings_books` list is declared.",
            "Expected `kings_books` to be declared."
        )

    def test_shekspeares_books_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'shekspeares_books'),
            "The `shekspeares_books` list is declared.",
            "Expected `shekspeares_books` to be declared."
        )

    def test_kings_books_is_list(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.kings_books, list),
            "The `kings_books` is of type `list`.",
            "Expected `kings_books` to be of type `list`."
        )

    def test_shekspeares_books_is_list(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.shekspeares_books, list),
            "The `shekspeares_books` is of type `list`.",
            "Expected `shekspeares_books` to be of type `list`."
        )

    def test_kings_books_correct_values(self):
        import user_code
        expected_books = ['It', 'The Shining', 'Carrie', 'Misery']
        _dynamic_test(
            self,
            user_code.kings_books == expected_books,
            "The `kings_books` list contains the correct books.",
            f"Expected `kings_books` to be {expected_books}, but got {user_code.kings_books}."
        )

    def test_shekspeares_books_correct_values(self):
        import user_code
        expected_books = ['Hamlet', 'Macbeth', 'Romeo and Juliet', 'Othello']
        _dynamic_test(
            self,
            user_code.shekspeares_books == expected_books,
            "The `shekspeares_books` list contains the correct books.",
            f"Expected `shekspeares_books` to be {expected_books}, but got {user_code.shekspeares_books}."
        )

    def test_books_are_retrieved_using_dict_indexing(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        
        _dynamic_test(
            self,
            "'Stephen King'" in user_code_source and "'William Shakespeare'" in user_code_source,
            "The books are retrieved using dictionary indexing.",
            "Expected the books to be retrieved using dictionary indexing."
        )

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


test_main.py

Tässä kurssissa tutustut Python-ohjelmointikielen perus tietorakenteisiin. Tutkimme Pythonin natiivien tietorakenteiden, kuten listojen, sanakirjojen, tuplien ja joukkojen, hyödyntämistä erilaisten haasteiden ratkaisemiseksi.

Mikä on lista? Lista on järjestetty kokoelma, jota voidaan muokata. Se sallii myös päällekkäiset elementit.

Mikä on sanakirja? Sanakirja on järjestetty kokoelma, jota voidaan muuttaa, mutta se ei salli päällekkäisiä merkintöjä. Se koostuu `key:value` pareista, joita käytetään sen rakenteen optimoimiseen.

Mikä on tuple? Tuple on järjestetty kokoelma, jota ei voi muuttaa. Se voi sisältää päällekkäisiä elementtejä. Vaikka se on samanlainen kuin lista, tuplen arvot voivat olla mitä tahansa tyyppiä ja ne indeksoidaan kokonaisluvuilla. Vaikka se ei ole pakollista, on yleistä sulkea tuplen arvot sulkuihin, mikä tekee niistä helpommin ymmärrettäviä Pythonissa.

Mikä on sarja? Pythonissa `set` on järjestämätön kokoelma, joka on sekä `iterable` että `muokattava`, ilman toistuvia elementtejä. Vaikka sarjan elementtien järjestys ei ole kiinteä, se voi sisältää monenlaisia elementtejä. Keskeinen etu sarjojen käytössä listoihin verrattuna on niiden erittäin tehokas menetelmä määrittää, onko elementti olemassa sarjassa.

Sanakirjan Arvojen Käsittely

Ratkaisu

Sanakirjan Arvojen Käsittely

Ratkaisu