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

Impara a estrarre dati preziosi dai siti web in modo automatico. Apprendi tecniche per raccogliere informazioni in modo efficiente, consentendo analisi approfondite, decisioni basate sui dati e la scoperta di nuove informazioni dal vasto oceano di dati online.

Esplora la struttura di un file HTML, apprendi come caricarlo in modo efficiente e acquisisci competenze pratiche nell'elaborazione dei dati in esso contenuti.

Esplora le basi di Beautiful Soup per estrarre dati da documenti HTML. Scopri come navigare nella struttura dell'HTML, accedere a elementi specifici e lavorare con i loro elementi figli per costruire una solida base nello scraping web.

Padroneggiare la gestione degli attributi e dei contenuti degli elementi utilizzando Beautiful Soup. Acquisire competenze nell'estrazione di informazioni specifiche, nella ricerca di elementi tramite valori di attributo e nell'utilizzo di tecniche avanzate per analizzare e interpretare in modo efficiente i dati HTML.

Lavorare con gli Elementi Paragrafo

Soluzione