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

    def test_prices_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'prices'),
            "The `prices` tuple is declared.",
            "Expected `prices` to be declared."
        )

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

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

    def test_final_prices_correct_values(self):
        import user_code
        expected_final_prices = [round(price, 2) for price in user_code.prices]
        _dynamic_test(
            self,
            user_code.final_prices == expected_final_prices,
            "The `final_prices` list contains correctly rounded values (to 2 decimal places).",
            f"Expected `final_prices` to be `{expected_final_prices}`, but got `{user_code.final_prices}`."
        )

    def test_rounded_prices_correct_values(self):
        import user_code
        expected_rounded_prices = [round(price) for price in user_code.prices]
        _dynamic_test(
            self,
            user_code.rounded_prices == expected_rounded_prices,
            "The `rounded_prices` list contains correctly rounded values (to nearest whole number).",
            f"Expected `rounded_prices` to be `{expected_rounded_prices}`, but got `{user_code.rounded_prices}`."
        )

    def test_for_loop_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'for', user_code_source),
            "The `for` loop is used to iterate over `prices`.",
            "Expected a `for` loop iterating over `prices`."
        )

    def test_round_function_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'round\(\s*\w+\s*,\s*2\s*\)', user_code_source) and re.search(r'round\(\s*\w+\s*\)', user_code_source),
            "The `round()` function is used for both rounding methods.",
            "Expected `round()` to be used for rounding prices to 2 decimal places and to the nearest whole number."
        )

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


test_main.py

Python är ett tolkat högnivå allmänt programmeringsspråk. Till skillnad från HTML, CSS och JavaScript, som främst används för webbutveckling, är Python mångsidigt och kan användas inom olika områden, inklusive mjukvaruutveckling, datavetenskap och back-end utveckling. I den här kursen kommer du att utforska de grundläggande aspekterna av Python, och i slutet kommer du att skapa dina egna funktioner!

Dyk in i grunderna i Python, utforska din arbetsyta och utför enkla matematiska operationer. Lär dig hur du skriver läsbar kod med hjälp av kommentarer och hanterar både grundläggande och avancerade matematiska uttryck samtidigt som du visar dina resultat.

Lär dig hur du lagrar och hanterar data i Python genom att arbeta med siffror, text och variabler. Förstå hur du tilldelar värden, följer namngivningskonventioner och utforskar olika datatyper. Få praktisk erfarenhet av strängoperationer, indexering, skivning och minnesåterkallningstekniker för att effektivt manipulera text i Python.

Lär dig hur du använder jämförelse- och logiska operatorer, arbetar med villkorsuttryck och tillämpar medlemskap och typjämförelser. Bygg en stark grund i att skriva program som svarar dynamiskt på olika villkor med hjälp av if/else och if/elif/else-strukturer.

Utöka din förståelse för datatyper genom att lära dig hur man grupperar flera attribut inom en enda variabel. Utforska lists, tuples och dictionaries för att effektivt lagra och hantera strukturerad data, tillsammans med viktiga metoder för manipulation och hämtning.

Bemästra konsten att skriva loopar i Python—väsentliga konstruktioner för att iterera över listor, tupler, ordböcker och andra datastrukturer. Lär dig använda while- och for-loopar effektivt, utforska range-funktionen och arbeta med nästlade loopar för att hantera komplexa iterationsmönster.

Utforska viktiga inbyggda funktioner i Python och ta nästa steg genom att skapa dina egna. Lär dig hur du definierar funktioner, använder villkorslogik, modifierar befintliga funktioner och arbetar med lambda-uttryck för att skriva effektiv, återanvändbar kod.

Utmaning: Konvertera Heights

Lösning

Utmaning: Konvertera Heights

Lösning