In your previous studies, you learned how to create signals in Python and analyze their frequency content using the Fast Fourier Transform (FFT). This is a fundamental skill for electrical engineers, as it enables you to identify the frequency components present in real-world signals. When you generate a signal by summing two sine waves of different frequencies, their combined waveform contains both frequency components. By applying the FFT, you can decompose this signal and determine which frequencies are most prominent.

import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_dominant_frequencies_identified(self):
        import user_code
        importlib.reload(user_code)
        result_str = getattr(user_code, 'result', None)
        _dynamic_test(
            self,
            isinstance(result_str, str) and ("50.0 hz" in normalize_text(result_str) and "120.0 hz" in normalize_text(result_str)),
            "Result string contains both dominant frequencies 50.0 Hz and 120.0 Hz",
            f"Expected result string to contain both 50.0 Hz and 120.0 Hz. Got: {result_str}"
        )

    def test_frequencies_are_sorted(self):
        import user_code
        importlib.reload(user_code)
        result_str = getattr(user_code, 'result', None)
        sorted_expected = normalize_text("Dominant frequencies: 50.0 Hz, 120.0 Hz")
        _dynamic_test(
            self,
            isinstance(result_str, str) and sorted_expected in normalize_text(result_str),
            "Dominant frequencies are sorted in ascending order",
            f"Expected sorted frequencies in result string. Got: {result_str}"
        )

    def test_no_false_frequency(self):
        import user_code
        importlib.reload(user_code)
        result_str = getattr(user_code, 'result', None)
        _dynamic_test(
            self,
            isinstance(result_str, str) and ("60.0 hz" not in normalize_text(result_str) and "100.0 hz" not in normalize_text(result_str) and "10.0 hz" not in normalize_text(result_str)),
            "No false dominant frequencies are reported",
            f"False frequency found in result string: {result_str}"
        )

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

Explore how Python empowers electrical engineers to analyze circuits, process signals, and model systems. This course blends practical coding with real-world electrical engineering scenarios, using Python and its scientific libraries to solve authentic engineering problems.

Learn how Python can be used to analyze electrical circuits, calculate parameters, and visualize circuit behavior.

Discover how Python can be used to analyze, visualize, and process electrical signals relevant to engineering applications.

Use Python to model, simulate, and visualize electrical systems and their dynamic behavior.

Challenge: Signal Frequency Identification

Ratkaisu