I denne utfordringen skal du sette ferdighetene dine på prøve ved å arbeide med et morsomt og enkelt offentlig API. Målet ditt er å bruke Cat Facts API for å hente og vise tre tilfeldige kattefakta. Denne øvelsen gir deg praktisk erfaring med å utføre HTTP-forespørsler ved hjelp av `requests`-biblioteket og håndtere JSON-data returnert fra et API. Du vil lære hvordan du trekker ut spesifikk informasjon fra svaret og presenterer det tydelig for brukeren. Etter å ha fullført denne oppgaven vil du ha styrket forståelsen din av grunnleggende samhandling med web-API-er i Python.


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

class TestTask(unittest.TestCase):
    def test_three_requests_and_output(self):
        import user_code
        importlib.reload(user_code)
        
        # Patch requests.get to count calls and simulate API responses
        import requests
        original_get = requests.get
        call_count = {'count': 0}
        facts = [
            {'fact': 'Cats have five toes on their front paws.'},
            {'fact': 'A group of cats is called a clowder.'},
            {'fact': 'Cats sleep for 70% of their lives.'}
        ]
        
        def fake_get(url, *args, **kwargs):
            call_count['count'] += 1
            class FakeResponse:
                def json(self_inner):
                    return facts[call_count['count']-1]
            return FakeResponse()
        
        requests.get = fake_get
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue().strip().split('\\n')
        requests.get = original_get
        
        _dynamic_test(
            self,
            call_count['count'] == 3,
            "Function makes three requests to the API",
            f"Expected 3 requests, got {call_count['count']}"
        )
        expected_facts = [fact['fact'] for fact in facts]
        _dynamic_test(
            self,
            len(output) == 3,
            "Function prints exactly three cat facts",
            f"Expected 3 lines of output, got {len(output)}: {output}"
        )
        for i in range(3):
            _dynamic_test(
                self,
                output[i] == expected_facts[i],
                f"Fact {i+1} matches expected output",
                f"Expected: '{expected_facts[i]}', got: '{output[i]}'"
            )
    
    def test_fact_extracted_from_json(self):
        import user_code
        importlib.reload(user_code)
        import requests
        original_get = requests.get
        call_args = []
        def fake_get(url, *args, **kwargs):
            call_args.append(url)
            class FakeResponse:
                def json(self_inner):
                    return {"fact": "Test fact extraction"}
            return FakeResponse()
        requests.get = fake_get
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue().strip().split('\\n')
        requests.get = original_get
        _dynamic_test(
            self,
            all(url == "https://catfact.ninja/fact" for url in call_args),
            "All requests made to correct API endpoint",
            f"Not all requests made to correct endpoint: {call_args}"
        )
        _dynamic_test(
            self,
            all(line == "Test fact extraction" for line in output),
            "Fact is extracted from 'fact' key in JSON response",
            f"Expected all lines to be 'Test fact extraction', got: {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

Lær hvordan du kan samhandle med åpne API-er ved hjelp av Python, behandle og analysere data fra virkelige nettjenester, og bygge praktiske applikasjoner uten behov for registrering eller betaling. Dette kurset er utviklet for viderekomne Python-brukere som ønsker å utvide ferdighetene sine innen datainnhenting og -behandling ved bruk av API-er.

Lær kjernebegrepene innen API-er, hvordan sende HTTP-forespørsler i Python, og hvordan håndtere svar fra åpne API-er.

Gå dypere inn i arbeidet med åpne API-er ved å hente og analysere offentlige data, som vær- og romfartsinformasjon.

Bruk avanserte teknikker for å arbeide med API-er, inkludert håndtering av spørringsparametere, behandling av lister med data og grunnleggende datavisualisering.

Utfordring: Hent og Vis Kattefakta

Løsning