After learning how to extract features from signals, you are now ready to apply your knowledge to real-world signal data. In practical electrical engineering, it is essential to quickly summarize and interpret measurements using statistical tools. The most common statistics for signal analysis are **mean**, **RMS** (`root mean square`), and **peak-to-peak** values. The **mean** gives you the average voltage level, the **RMS** provides a measure of the signal’s effective power, and the **peak-to-peak** value shows the total voltage swing. Interpreting these statistics helps you understand the nature of the signal, such as whether it is centered around zero, has significant fluctuations, or contains high energy.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        self.signal = np.array([2.0, 3.5, 4.1, 2.8, 3.9, 5.0, 4.6, 3.3, 2.7, 3.8])
        self.mean = np.mean(self.signal)
        self.rms = np.sqrt(np.mean(np.square(self.signal)))
        self.ptp = np.ptp(self.signal)

    def test_mean_value_correct(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_signal(self.signal)
        output = f.getvalue()
        _dynamic_test(
            self,
            f"Mean value:" in output and f"{self.mean}"[:6] in output.replace(" ", ""),
            "Mean value is correctly calculated and printed.",
            f"Expected mean value {self.mean} labeled, got output: {output}",
        )

    def test_rms_value_correct(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_signal(self.signal)
        output = f.getvalue()
        _dynamic_test(
            self,
            "RMS value:" in output and f"{self.rms}"[:6] in output.replace(" ", ""),
            "RMS value is correctly calculated and printed.",
            f"Expected RMS value {self.rms} labeled, got output: {output}",
        )

    def test_peak_to_peak_value_correct(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_signal(self.signal)
        output = f.getvalue()
        _dynamic_test(
            self,
            "Peak-to-peak value:" in output and f"{self.ptp}"[:6] in output.replace(" ", ""),
            "Peak-to-peak value is correctly calculated and printed.",
            f"Expected peak-to-peak value {self.ptp} labeled, got output: {output}",
        )

    def test_comments_present(self):
        with open("user_code.py", "r") as f:
            code = f.read()
        mean_comment = "mean" in code.lower() and "average" in code.lower()
        rms_comment = "rms" in code.lower() and ("effective" in code.lower() or "power" in code.lower())
        ptp_comment = ("peak-to-peak" in code.lower() or "peak to peak" in code.lower()) and ("range" in code.lower() or "maximum" in code.lower() or "minimum" in code.lower())
        _dynamic_test(
            self,
            mean_comment and rms_comment and ptp_comment,
            "Code contains comments explaining the meaning of each statistic.",
            "Missing or incomplete comments explaining statistics.",
        )

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: Analyze Real-World Signal Data

Solution