Building on your understanding of **string manipulation** and **data type conversion**, you are now ready to tackle a practical challenge that brings together these skills. In real-world scenarios, you often receive data as strings, but you may need to process them as numbers. However, not every string will be a valid number, so your code must handle such cases gracefully. This exercise will help you develop a robust utility for converting lists of string values into numeric types, while skipping any entries that cannot be converted.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import math

class TestTask(unittest.TestCase):
    def test_valid_numeric_strings(self):
        import user_code
        importlib.reload(user_code)
        input_list = ["1.5", "2", "-3.0", "0.0", "4e2"]
        result = user_code.strings_to_floats(input_list)
        expected = [1.5, 2.0, -3.0, 0.0, 400.0]
        _dynamic_test(
            self,
            result == expected,
            "All valid numeric strings are converted to floats correctly.",
            f"Expected {expected}, got {result}.",
        )

    def test_skip_invalid_strings(self):
        import user_code
        importlib.reload(user_code)
        input_list = ["hello", "3.14", "abc", "2.71", "NaN", "xyz"]
        result = user_code.strings_to_floats(input_list)
        # float('NaN') is a valid float in Python, so it should be included
        expected = [3.14, 2.71, float('nan')]
        _dynamic_test(
            self,
            len(result) == 3 and math.isnan(result[2]) and result[0] == 3.14 and result[1] == 2.71,
            "Invalid strings are skipped; valid floats and NaN included.",
            f"Result does not match expected: {result}",
        )

    def test_empty_input_list(self):
        import user_code
        importlib.reload(user_code)
        input_list = []
        result = user_code.strings_to_floats(input_list)
        _dynamic_test(
            self,
            result == [],
            "Returns empty list for empty input.",
            f"Expected empty list, got {result}.",
        )

    def test_all_invalid_entries(self):
        import user_code
        importlib.reload(user_code)
        input_list = ["abc", "def", "ghi"]
        result = user_code.strings_to_floats(input_list)
        _dynamic_test(
            self,
            result == [],
            "Returns empty list when all entries are invalid.",
            f"Expected empty list, got {result}.",
        )

    def test_order_preserved(self):
        import user_code
        importlib.reload(user_code)
        input_list = ["10", "foo", "1.1", "bar", "2.2"]
        result = user_code.strings_to_floats(input_list)
        expected = [10.0, 1.1, 2.2]
        _dynamic_test(
            self,
            result == expected,
            "Order of valid floats is preserved in result.",
            f"Expected {expected}, got {result}.",
        )

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()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    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] = []
                    
                    return '\\n'.join(lines)
    return code

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


test_main.py

A beginner-friendly course focused on mastering string manipulation and handling various data formats in Python. Learn essential techniques for processing, formatting, and converting data, with hands-on practice and quizzes to reinforce your understanding.

Learn the core techniques for working with strings in Python, including slicing, searching, and modifying text.

Develop skills for formatting strings and converting between data types for effective data presentation and processing.

Gain practical experience handling structured data formats such as CSV and JSON using Python's built-in capabilities.

Challenge: Data Type Conversion Utility

Oplossing

Awesome!

Challenge: Data Type Conversion Utility

Oplossing