Automating the calculation of molecular weight for multiple protein sequences is a practical task in protein characterization studies. By processing a batch of sequences at once, you can quickly compare molecular properties and identify outliers or patterns relevant to biological research. In this challenge, you will build on your understanding of amino acid weights and sequence analysis to create a function that efficiently handles lists of protein sequences, reporting their molecular weights while managing any unknown amino acids that might appear.


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

class TestTask(unittest.TestCase):
    def test_returns_list_with_one_weight_per_sequence(self):
        import user_code
        importlib.reload(user_code)
        seqs = ["ACDE", "GGG", "MSTQ"]
        result = user_code.calculate_molecular_weights(seqs)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == len(seqs),
            "Returns a list with one molecular weight per input sequence",
            f"Expected {len(seqs)} results, got {result}"
        )

    def test_correct_weights_known_amino_acids(self):
        import user_code
        importlib.reload(user_code)
        seqs = ["ACD", "GGG"]
        # A:89.09, C:121.15, D:133.10 = 343.34
        # G:75.07*3 = 225.21
        expected = [343.34, 225.21]
        result = user_code.calculate_molecular_weights(seqs)
        _dynamic_test(
            self,
            isinstance(result, list) and all(abs(r-e)<0.01 for r,e in zip(result,expected)),
            "Correctly sums weights for sequences with only known amino acids",
            f"Expected {expected}, got {result}"
        )

    def test_skips_unknown_amino_acids(self):
        import user_code
        importlib.reload(user_code)
        seqs = ["AXYZ", "CDEFG"]
        # A:89.09, X,Z unknown, Y:181.19 (known): 89.09+181.19 = 270.28
        # C:121.15, D:133.10, E:147.13, F:165.19, G:75.07 = 641.64
        expected = [270.28, 641.64]
        result = user_code.calculate_molecular_weights(seqs)
        _dynamic_test(
            self,
            isinstance(result, list) and all(abs(r-e)<0.01 for r,e in zip(result,expected)),
            "Skips unknown amino acids in a sequence without error",
            f"Expected {expected}, got {result}"
        )

    def test_sequences_with_only_unknown_amino_acids(self):
        import user_code
        importlib.reload(user_code)
        seqs = ["XYZ", "QWERTY", ""]
        # XYZ: X,Z unknown, Y:181.19 (known) => 181.19
        # QWERTY: Q,W,E,R,T,Y are all known
        # Q:146.15, W:204.23, E:147.13, R:174.20, T:119.12, Y:181.19 = 972.02
        # empty string: 0.0
        expected = [181.19, 972.02, 0.0]
        result = user_code.calculate_molecular_weights(seqs)
        _dynamic_test(
            self,
            isinstance(result, list) and all(abs(r-e)<0.01 for r,e in zip(result,expected)),
            "Handles sequences with only unknown amino acids by returning zero for those sequences",
            f"Expected {expected}, got {result}"
        )

    def test_empty_input_list(self):
        import user_code
        importlib.reload(user_code)
        seqs = []
        result = user_code.calculate_molecular_weights(seqs)
        _dynamic_test(
            self,
            result == [],
            "Returns an empty list if given an empty input list",
            f"Expected empty list, 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: Protein Molecular Weight for Multiple Sequences

Ratkaisu

Challenge: Protein Molecular Weight for Multiple Sequences

Ratkaisu