Automating the search for motifs across multiple DNA sequences is a fundamental task in regulatory genomics, where you often need to locate short, recurring patterns in large datasets. By developing a Python function to systematically scan each sequence for a given motif, you can quickly identify all positions where the motif occurs, including overlapping matches. This approach streamlines analyses such as promoter scanning, transcription factor binding site mapping, or any scenario where motif detection in DNA is required.


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

class TestTask(unittest.TestCase):
    def test_returns_dict_with_correct_positions(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'find_motif_positions', None)
        _dynamic_test(
            self,
            callable(func),
            "Function 'find_motif_positions' is defined.",
            "Function 'find_motif_positions' is not defined."
        )
        sequences = ["ATGCGATATCG", "GATATATGCATATACTT"]
        motif = "ATAT"
        result = func(sequences, motif) if func else None
        expected = {
            "ATGCGATATCG": [5],
            "GATATATGCATATACTT": [1, 3, 9]
        }
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Returns correct dictionary mapping for sample input.",
            f"Expected {expected}, got {result}."
        )

    def test_includes_overlapping_motifs(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'find_motif_positions', None)
        seqs = ["AAAAA"]
        motif = "AA"
        result = func(seqs, motif) if func else None
        expected = {"AAAAA": [0,1,2,3]}
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Overlapping motifs are detected correctly.",
            f"Expected {expected}, got {result}."
        )

    def test_handles_motif_any_length(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'find_motif_positions', None)
        seqs = ["ACGTACGTGACGTA"]
        motif = "ACGTA"
        result = func(seqs, motif) if func else None
        expected = {"ACGTACGTGACGTA": [0, 9]}
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Handles motifs of any length correctly.",
            f"Expected {expected}, got {result}."
        )


    def test_empty_list_when_motif_not_found(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'find_motif_positions', None)
        seqs = ["GGGG", "TTTT"]
        motif = "AA"
        result = func(seqs, motif) if func else None
        expected = {"GGGG": [], "TTTT": []}
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Returns empty lists when motif not found.",
            f"Expected {expected}, got {result}."
        )

    def test_empty_input_list(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'find_motif_positions', None)
        seqs = []
        motif = "A"
        result = func(seqs, motif) if func else None
        expected = {}
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Returns empty dictionary for empty sequence list.",
            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()
    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

Learn how Python is used in biology for analyzing DNA sequences, processing biological data, and visualizing research results. Includes hands-on examples with bioinformatics libraries.

Explore how Python can be used to analyze DNA and other biological sequences, including searching for motifs, calculating GC content, and basic sequence manipulations.

Delve into protein sequences, amino acid composition, and basic protein analysis using Python.

Learn how to visualize biological data using Python, including plotting sequence statistics and creating informative charts for research.

Challenge: Motif Search in Multiple Sequences

解答