Before solving a real-world circuit problem, it is helpful to recall the core principles for analyzing resistors in series and parallel, as well as how current divides in such circuits. When resistors are in series, their resistances simply add: the total resistance is the sum of the individual resistances. For resistors in parallel, the reciprocal of the total resistance equals the sum of the reciprocals of each resistor's resistance. Current division principles tell you that in parallel branches, the current splits inversely proportional to the resistance of each branch, while in series the current is the same through all resistors. These foundational concepts allow you to analyze more complex circuits by breaking them down into simpler series and parallel combinations.


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_total_resistance(self):
        import user_code
        importlib.reload(user_code)
        # Capture printed output
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_circuit(100, 200, 300, 12)
        output = f.getvalue()
        # Calculate expected total resistance
        Rs = 100 + 200
        Rp = 1 / (1/Rs + 1/300)
        expected = f"Total resistance (Ohms): {Rp}"
        _dynamic_test(
            self,
            normalize_text(expected) in normalize_text(output),
            "Correct total resistance calculated and printed.",
            f"Expected total resistance line: '{expected}' not found in output: {output}",
        )

    def test_total_current(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_circuit(100, 200, 300, 12)
        output = f.getvalue()
        Rs = 100 + 200
        Rp = 1 / (1/Rs + 1/300)
        total_current = 12 / Rp
        expected = f"Total current (A): {total_current}"
        _dynamic_test(
            self,
            normalize_text(expected) in normalize_text(output),
            "Correct total current calculated and printed.",
            f"Expected total current line: '{expected}' not found in output: {output}",
        )

    def test_current_through_R1_R2(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_circuit(100, 200, 300, 12)
        output = f.getvalue()
        Rs = 100 + 200
        V = 12
        current_Rs = V / Rs
        expected_R1 = f"Current through R1 (A): {current_Rs}"
        expected_R2 = f"Current through R2 (A): {current_Rs}"
        _dynamic_test(
            self,
            normalize_text(expected_R1) in normalize_text(output),
            "Current through R1 correctly calculated and printed.",
            f"Expected current through R1 line: '{expected_R1}' not found in output: {output}",
        )
        _dynamic_test(
            self,
            normalize_text(expected_R2) in normalize_text(output),
            "Current through R2 correctly calculated and printed.",
            f"Expected current through R2 line: '{expected_R2}' not found in output: {output}",
        )

    def test_current_through_R3(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_circuit(100, 200, 300, 12)
        output = f.getvalue()
        V = 12
        current_R3 = V / 300
        expected = f"Current through R3 (A): {current_R3}"
        _dynamic_test(
            self,
            normalize_text(expected) in normalize_text(output),
            "Current through R3 correctly calculated and printed.",
            f"Expected current through R3 line: '{expected}' not found in output: {output}",
        )

    def test_currents_R3_vs_R1(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_circuit(100, 200, 100, 12)
        output = f.getvalue()
        Rs = 100 + 200
        V = 12
        current_Rs = V / Rs
        current_R3 = V / 100
        _dynamic_test(
            self,
            current_R3 > current_Rs,
            "Current through R3 is greater than current through R1/R2, as expected for parallel branches.",
            f"Current through R3 ({current_R3}) should be greater than through R1/R2 ({current_Rs})",
        )

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 a Simple Circuit

Ratkaisu

Challenge: Analyze a Simple Circuit

Ratkaisu