The **Fibonacci sequence** is a famous series of numbers in which each term after the first two is the sum of the two preceding terms. Starting with `0` and `1`, the sequence continues as `0, 1, 1, 2, 3, 5, 8, 13, 21, 34`, and so on. The Fibonacci sequence appears in various areas of **mathematics**, such as number theory and combinatorics, and is also observed in nature, including the arrangement of leaves, the pattern of seeds in a sunflower, and the spiral shells of certain mollusks. Understanding how to generate and analyze this sequence using Python will help you apply programming to mathematical patterns and explore their properties.


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

class TestTask(unittest.TestCase):
    def test_fibonacci_sequence_length_and_values(self):
        import user_code
        importlib.reload(user_code)
        fn = getattr(user_code, 'generate_fibonacci', None)
        _dynamic_test(
            self,
            callable(fn),
            "Function 'generate_fibonacci' is defined.",
            "Function 'generate_fibonacci' is not defined.",
        )
        # Test n = 10
        result = fn(10) if fn else None
        expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Function returns correct Fibonacci sequence for n=10.",
            f"Expected {expected}, got {result}",
        )
        # Test n = 1
        result1 = fn(1) if fn else None
        _dynamic_test(
            self,
            isinstance(result1, list) and result1 == [0],
            "Function returns correct Fibonacci sequence for n=1.",
            f"Expected [0], got {result1}",
        )
        # Test n = 0 (edge case)
        result0 = fn(0) if fn else None
        _dynamic_test(
            self,
            isinstance(result0, list) and result0 == [],
            "Function returns empty list for n=0.",
            f"Expected [], got {result0}",
        )

    def test_sequence_sum(self):
        import user_code
        importlib.reload(user_code)
        fib_sequence = getattr(user_code, 'fib_sequence', None)
        sequence_sum = getattr(user_code, 'sequence_sum', None)
        _dynamic_test(
            self,
            isinstance(fib_sequence, list) and sequence_sum is not None,
            "Variables 'fib_sequence' and 'sequence_sum' are defined.",
            f"fib_sequence: {fib_sequence}, sequence_sum: {sequence_sum}",
        )
        expected_sum = sum([0, 1, 1, 2, 3, 5, 8, 13, 21, 34])
        _dynamic_test(
            self,
            sequence_sum == expected_sum,
            "'sequence_sum' is correct for n=10.",
            f"Expected sum {expected_sum}, got {sequence_sum}",
        )

    def test_sequence_average(self):
        import user_code
        importlib.reload(user_code)
        fib_sequence = getattr(user_code, 'fib_sequence', None)
        sequence_sum = getattr(user_code, 'sequence_sum', None)
        sequence_average = getattr(user_code, 'sequence_average', None)
        _dynamic_test(
            self,
            isinstance(fib_sequence, list) and sequence_sum is not None and sequence_average is not None,
            "Variables for average calculation are defined.",
            f"fib_sequence: {fib_sequence}, sequence_sum: {sequence_sum}, sequence_average: {sequence_average}",
        )
        expected_avg = sum([0, 1, 1, 2, 3, 5, 8, 13, 21, 34]) / 10
        _dynamic_test(
            self,
            abs(sequence_average - expected_avg) < 1e-8,
            "'sequence_average' is correct for n=10.",
            f"Expected average {expected_avg}, got {sequence_average}",
        )

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

A practical course designed for math students to harness the power of Python for solving mathematical problems, visualizing data, and applying computational thinking to real-world scenarios. Each section blends engaging theory with hands-on challenges, focusing on mathematical applications and problem-solving. 

Explore how Python can be used to perform numerical calculations, solve algebraic equations, and automate mathematical processes.

Learn how to visualize mathematical data and functions using Python, and apply these skills to real-world mathematical problems.

Apply Python to probability, statistics, and simulation, enabling students to model uncertainty and analyze data in mathematical contexts.

Challenge: Generate and Analyze a Fibonacci Sequence

Oplossing

Challenge: Generate and Analyze a Fibonacci Sequence

Oplossing