
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_rectangle_area(self):
        import user_code
        importlib.reload(user_code)
        Rectangle = getattr(user_code, 'Rectangle', None)
        _dynamic_test(
            self,
            Rectangle is not None and callable(Rectangle),
            "Rectangle class is defined",
            "Rectangle class is not defined or not callable",
        )
        rect = Rectangle(4, 5)
        area_method = getattr(rect, 'area', None)
        _dynamic_test(
            self,
            area_method is not None and callable(area_method),
            "area method is defined",
            "area method is not defined or not callable",
        )
        area = rect.area()
        _dynamic_test(
            self,
            area == 20,
            "area method returns correct value for (4, 5)",
            f"Expected area 20, got {area}",
        )

    def test_rectangle_perimeter(self):
        import user_code
        importlib.reload(user_code)
        Rectangle = getattr(user_code, 'Rectangle', None)
        rect = Rectangle(4, 5)
        perimeter_method = getattr(rect, 'perimeter', None)
        _dynamic_test(
            self,
            perimeter_method is not None and callable(perimeter_method),
            "perimeter method is defined",
            "perimeter method is not defined or not callable",
        )
        perimeter = rect.perimeter()
        _dynamic_test(
            self,
            perimeter == 18,
            "perimeter method returns correct value for (4, 5)",
            f"Expected perimeter 18, got {perimeter}",
        )

    def test_rectangle_other_values(self):
        import user_code
        importlib.reload(user_code)
        Rectangle = getattr(user_code, 'Rectangle', None)
        rect = Rectangle(7, 3)
        area = rect.area()
        perimeter = rect.perimeter()
        _dynamic_test(
            self,
            area == 21,
            "area method returns correct value for (7, 3)",
            f"Expected area 21, got {area}",
        )
        _dynamic_test(
            self,
            perimeter == 20,
            "perimeter method returns correct value for (7, 3)",
            f"Expected perimeter 20, got {perimeter}",
        )

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)

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
    # Collect all assignment nodes to modify
    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 nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    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

Erlernen Sie den Aufbau sauberer, sicherer und skalierbarer Anwendungen mit objektorientierter Programmierung in Python. Behandelt werden die Grundlagen von Klassen und Objekten sowie fortgeschrittene Konzepte wie Vererbung, Komposition, Polymorphismus und Kapselung. Durch klare Erklärungen und praxisnahe Beispiele erwerben Sie die Fähigkeit, Python-Programme zu entwerfen, die leistungsfähig, wartbar und für den praktischen Einsatz geeignet sind.

Erlernen Sie die grundlegenden Bausteine der objektorientierten Programmierung in Python. Dieser Abschnitt behandelt Klassen, Objekte, Methoden und Variablen und vermittelt Ihnen eine solide Grundlage, um zu verstehen, wie OOP Code organisiert und strukturiert.

Herausforderung: Methoden Erstellen und Verwenden

Lösung