Summary  
This chapter covers selecting and manipulating paragraph elements in the DOM, including updating their text content and styling programmatically.

General domain of usage  
Web development (client-side)

import unittest
import io
import sys


def _dynamic_test(test_case, condition, success, fail):
    if condition:
        test_case._testMethodName = success
        test_case.assertTrue(True)
    else:
        test_case._testMethodName = fail
        test_case.fail(fail)


class TestUserCode(unittest.TestCase):

    # -------- 1. Check import --------
    def test_beautifulsoup_imported(self):
        with open("user_code.py", "r") as f:
            src = f.read()

        condition = "from bs4 import BeautifulSoup" in src

        _dynamic_test(
            self,
            condition,
            "The `BeautifulSoup` class is imported.",
            "Expected `from bs4 import BeautifulSoup` import."
        )

    # -------- 2. soup exists --------
    def test_soup_declared(self):
        import user_code

        condition = hasattr(user_code, "soup")

        _dynamic_test(
            self,
            condition,
            "`soup` variable is declared.",
            "`soup` variable is missing."
        )

    # -------- 3. soup is BeautifulSoup --------
    def test_soup_is_beautifulsoup(self):
        import user_code
        from bs4 import BeautifulSoup

        try:
            s = user_code.soup
            condition = isinstance(s, BeautifulSoup)
            fail_msg = "`soup` must be a BeautifulSoup instance."
        except:
            condition = False
            fail_msg = "`soup` is missing or invalid."

        _dynamic_test(
            self,
            condition,
            "`soup` is a valid BeautifulSoup object.",
            fail_msg
        )

    # -------- 4. html is decoded string --------
    def test_html_is_string(self):
        import user_code

        try:
            h = user_code.html
            condition = isinstance(h, str)
            fail_msg = f"`html` must be str, got `{type(h).__name__}`."
        except:
            condition = False
            fail_msg = "`html` variable missing."

        _dynamic_test(
            self,
            condition,
            "`html` contains decoded HTML.",
            fail_msg
        )

    # -------- 5. p is correct list of <p> elements --------
    def test_p_is_correct(self):
        import user_code

        try:
            p_val = user_code.p
            is_list = isinstance(p_val, list)
        except:
            is_list = False

        _dynamic_test(
            self,
            is_list,
            "`p` is a list of `<p>` elements.",
            "`p` must be a list returned by `soup.find_all('p')`."
        )

    # -------- 6. printed output matches p and len(p) --------
    def test_printed_output(self):
        import user_code
        import importlib

        # Capture stdout
        captured = io.StringIO()
        sys.stdout = captured

        importlib.reload(user_code)

        sys.stdout = sys.__stdout__

        output = captured.getvalue().splitlines()

        if len(output) < 2:
            _dynamic_test(
                self,
                False,
                "",
                "Expected two printed lines: list of `<p>` elements and its length."
            )
            return

        printed_list = output[0].strip()
        printed_len = output[1].strip()

        # Expected values
        expected_list = str(user_code.p)
        expected_len = str(len(user_code.p))

        cond_list = printed_list == expected_list
        cond_len = printed_len == expected_len

        if not cond_list:
            _dynamic_test(
                self,
                False,
                "",
                f"Expected printed list `{expected_list}`, got `{printed_list}`."
            )
            return

        if not cond_len:
            _dynamic_test(
                self,
                False,
                "",
                f"Expected printed length `{expected_len}`, got `{printed_len}`."
            )
            return

        _dynamic_test(
            self,
            True,
            "The list of `<p>` elements and its length are printed correctly.",
            ""
        )


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


test_code.py

Erlernen Sie das automatische Extrahieren wertvoller Daten von Websites. Beherrschen Sie Techniken zur effizienten Informationsgewinnung, um fundierte Analysen durchzuführen, datenbasierte Entscheidungen zu treffen und neue Erkenntnisse aus der Fülle an Online-Informationen zu gewinnen.

Untersuchung der Struktur einer HTML-Datei, effizientes Laden sowie Erwerb praktischer Fähigkeiten im Umgang mit den enthaltenen Daten.

Grundlagen von Beautiful Soup zur Extraktion von Daten aus HTML-Dokumenten. Struktur von HTML analysieren, gezielte Elemente ansprechen und mit deren Kindelementen arbeiten, um eine solide Basis im Web Scraping zu schaffen.

Beherrschen Sie den Umgang mit Elementattributen und -inhalten unter Verwendung von Beautiful Soup. Erwerben Sie die Fähigkeiten, spezifische Informationen zu extrahieren, Elemente anhand von Attributwerten zu suchen und fortgeschrittene Techniken zur effizienten Analyse und Auswertung von HTML-Daten anzuwenden.

Arbeiten mit Absatz-Elementen

Lösung

Arbeiten mit Absatz-Elementen

Lösung