Summary  
Demonstrates implementing code to generate prime numbers by iteratively checking divisibility with loops and conditionals, including optimizations such as limiting checks to the square root of each candidate.

General domain of usage  
Cryptography


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

class TestTask(unittest.TestCase):
    def test_primes_up_to_10(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.primes_up_to(10)
        result = list(gen)
        expected = [2, 3, 5, 7]
        _dynamic_test(
            self,
            result == expected,
            f"Yields correct primes up to 10: {expected}",
            f"Expected primes up to 10: {expected}, got: {result}"
        )

    def test_primes_up_to_20(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.primes_up_to(20)
        result = list(gen)
        expected = [2, 3, 5, 7, 11, 13, 17, 19]
        _dynamic_test(
            self,
            result == expected,
            f"Yields correct primes up to 20: {expected}",
            f"Expected primes up to 20: {expected}, got: {result}"
        )

    def test_primes_up_to_prime_n(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.primes_up_to(13)
        result = list(gen)
        expected = [2, 3, 5, 7, 11, 13]
        _dynamic_test(
            self,
            result == expected,
            f"Yields all primes including n if n is prime (n=13)",
            f"Expected primes up to 13: {expected}, got: {result}"
        )

    def test_primes_up_to_less_than_2(self):
        import user_code
        importlib.reload(user_code)
        for n in [1, 0, -5]:
            gen = user_code.primes_up_to(n)
            result = list(gen)
            _dynamic_test(
                self,
                result == [],
                f"Yields nothing for n < 2 (n={n})",
                f"Expected empty list for n < 2 (n={n}), got: {result}"
            )

    def test_no_primes_greater_than_n(self):
        import user_code
        importlib.reload(user_code)
        n = 17
        gen = user_code.primes_up_to(n)
        result = list(gen)
        _dynamic_test(
            self,
            all(x <= n for x in result),
            "No primes yielded greater than n",
            f"Found primes greater than {n}: {result}"
        )

    def test_ascending_order(self):
        import user_code
        importlib.reload(user_code)
        n = 30
        gen = user_code.primes_up_to(n)
        result = list(gen)
        _dynamic_test(
            self,
            result == sorted(result),
            "Primes yielded in ascending order",
            f"Primes not in ascending order: {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()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    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] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Master the art of efficient iteration in Python by learning about iterators and generators. This course covers the creation, use, and advanced techniques of generators and iterators, with hands-on tasks and conceptual quizzes to reinforce your understanding.

Explore the fundamentals of Python's iteration protocol and learn how to create and use custom iterators.

Learn how to use generator functions and expressions for efficient, lazy iteration.

Master advanced generator features such as delegation, state management, and practical applications.

Challenge: Prime Number Generator

Solution

Challenge: Prime Number Generator

Solution