In dieser Aufgabe vertiefen Sie Ihre Fähigkeiten im Umgang mit APIs und der Textverarbeitung in Python. Sie verwenden die Cat Facts API, um eine Liste von 10 Fakten über Katzen abzurufen. Ihr Ziel ist es, diese Fakten zu analysieren und zu bestimmen, wie viele davon das Wort "cat" enthalten, unabhängig von der Groß- und Kleinschreibung. Dies hilft Ihnen, sowohl API-Anfragen als auch grundlegende String-Suchoperationen mit realen Daten zu üben.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout
import requests

class TestTask(unittest.TestCase):
    def test_count_cat_in_facts(self):
        url = "https://catfact.ninja/facts?limit=10"
        response = requests.get(url)
        data = response.json()
        facts = data["data"]
        expected_count = sum(1 for fact in facts if "cat" in fact["fact"].lower())
        f = io.StringIO()
        with redirect_stdout(f):
            import user_code
            importlib.reload(user_code)
        output = f.getvalue().strip()
        try:
            actual_count = int(output)
            _dynamic_test(
                self,
                actual_count == expected_count,
                "Correct count of facts containing 'cat' is printed",
                f"Expected count {expected_count}, got {actual_count}"
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "Output is a valid integer",
                f"Output is not a valid integer: {output}"
            )

    def test_output_is_integer(self):
        f = io.StringIO()
        with redirect_stdout(f):
            import user_code
            importlib.reload(user_code)
        output = f.getvalue().strip()
        try:
            value = int(output)
            _dynamic_test(
                self,
                isinstance(value, int),
                "Output is an integer",
                f"Output is not an integer: {output}"
            )
        except Exception:
            _dynamic_test(
                self,
                False,
                "Output is an integer",
                f"Output is not an integer: {output}"
            )

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

Erlernen Sie den Umgang mit offenen APIs in Python, die Verarbeitung und Analyse von Daten aus realen Webdiensten sowie die Entwicklung praxisnaher Anwendungen ohne Registrierung oder Bezahlung. Dieser Kurs richtet sich an fortgeschrittene Python-Anwender, die ihre Fähigkeiten in der Datenabfrage und -verarbeitung mittels APIs erweitern möchten.

Erlernen Sie die grundlegenden Konzepte von APIs, das Senden von HTTP-Anfragen in Python sowie die Verarbeitung von Antworten offener APIs.

Vertiefte Arbeit mit offenen APIs durch Abrufen und Analysieren öffentlicher Daten, wie Wetter- und Weltrauminformationen.

Anwendung fortgeschrittener Techniken für die Arbeit mit APIs, einschließlich der Handhabung von Abfrageparametern, Verarbeitung von Datenlisten und grundlegender Datenvisualisierung.

Herausforderung: Cat-Fact-Analyzer

Lösung