メニュー
Parse, search, and modify HTML/XML documents by building a navigable tree of tags and text.
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/diegosouzapw/awesome-omni-skill --skill beautifulsoup4コマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
Token-efficient tracking for AI orchestration. CLI-first for status updates (~50 tokens), agent fallback for complex ops (~1KB). Use when: updating task status, querying blockers, creating progress files, validating phases.
AshAi extension guidelines for integrating AI capabilities with Ash Framework. Use when implementing vectorization/embeddings, exposing Ash actions as LLM tools, creating prompt-backed actions, or setting up MCP servers. Covers semantic search, LangChain integration, and structured outputs.
This skill should be used when solving hard questions, complex architectural problems, or debugging issues that benefit from GPT-5 Pro or GPT-5.1 thinking models with large file context. Use when standard Claude analysis needs deeper reasoning or extended context windows.
SKILL.md を表示中
SOC 職業分類に基づく
| name | beautifulsoup4 |
| description | Parse, search, and modify HTML/XML documents by building a navigable tree of tags and text. |
| version | 4.14.3 |
| ecosystem | python |
| license | MIT License |
| generated_with | gpt-5.2 |
import bs4
from bs4 import BeautifulSoup, Tag, Comment
from bs4.exceptions import FeatureNotFound, ParserRejectedMarkup
from bs4.dammit import UnicodeDammit
from __future__ import annotations
from bs4 import BeautifulSoup
html_doc = "<html><body><p class='body strikeout'>Hello</p></body></html>"
# Always choose the parser explicitly for consistent behavior across environments.
soup = BeautifulSoup(html_doc, "html.parser")
p = soup.find("p")
assert p is not None
print(p.name) # "p"
print(p.get_text()) # "Hello"
BeautifulSoup(markup, "html.parser"), "lxml", "html5lib", or "xml"/"lxml-xml" depending on your needs; different parsers can produce different trees for invalid documents.from __future__ import annotations
from pathlib import Path
from bs4 import BeautifulSoup
path = Path("example.html")
path.write_text("<html><body><a href='/x'>Link</a></body></html>", encoding="utf-8")
with path.open("r", encoding="utf-8") as fp:
soup = BeautifulSoup(fp, "html.parser")
a = soup.find("a")
assert a is not None
print(a.get("href")) # "/x"
BeautifulSoup to let the builder stream/handle encodings appropriately.from __future__ import annotations
from typing import Optional
from bs4 import BeautifulSoup, Tag
html_doc = """
<div id="root">
<h1>Title</h1>
<p>First</p>
<p>Second <span>inner</span></p>
</div>
"""
soup = BeautifulSoup(html_doc, "html.parser")
root: Optional[Tag] = soup.find(id="root")
assert root is not None
h1: Optional[Tag] = root.find("h1")
assert h1 is not None
# Navigate
second_p: Optional[Tag] = h1.find_next("p")
assert second_p is not None
print(second_p.get_text(strip=True)) # "First"
all_ps = root.find_all("p")
print([p.get_text(" ", strip=True) for p in all_ps]) # ["First", "Second inner"]
find, find_all, and the find_next* / find_previous* / sibling / parent variants for tree navigation.class) ✅ Currentfrom __future__ import annotations
from bs4 import BeautifulSoup, Tag
soup = BeautifulSoup("<p id='x' class='body strikeout'></p>", "html.parser")
p = soup.find("p")
assert isinstance(p, Tag)
# Dict-like access
print(p["id"]) # "x"
print(p.get("id")) # "x"
# Multi-valued HTML attributes like class are lists by default.
print(p["class"]) # ["body", "strikeout"]
# If you always want a list (even for non-multivalued attrs), use get_attribute_list.
print(p.get_attribute_list("id")) # ["x"]
print(p.get_attribute_list("class")) # ["body", "strikeout"]
# Mutation
p["data-role"] = "demo"
del p["id"]
print(p.attrs) # {'class': ['body', 'strikeout'], 'data-role': 'demo'}
class, rel, etc. are typically stored as list[str]. Use Tag.get_attribute_list(name) to normalize to a list.from __future__ import annotations
from bs4 import BeautifulSoup, Comment
from bs4.element import NavigableString
soup = BeautifulSoup("<p>Hello<!--secret--></p>", "html.parser")
p = soup.find("p")
assert p is not None
# Comments are special text nodes.
comment = p.find(string=lambda s: isinstance(s, Comment))
assert isinstance(comment, Comment)
print(comment) # "secret"
# NavigableString is immutable; replace the node instead of editing in place.
text = p.find(string=lambda s: isinstance(s, NavigableString) and not isinstance(s, Comment))
assert isinstance(text, NavigableString)
text.replace_with("Hi")
print(p.get_text()) # "Hi"
NavigableString as immutable; use replace_with(...) to change text.features):
"html.parser": built-in, decent baseline."lxml": fast (requires lxml)."html5lib": most lenient (slow; requires html5lib)."xml" / "lxml-xml": XML parsing mode (attribute handling differs from HTML).parse_only: pass a SoupStrainer (not covered here) to parse only parts of a document for speed/memory.from_encoding / exclude_encodings: hint or restrict encoding detection when input is bytes.huge_tree=True to BeautifulSoup(...) to avoid lxml security limits truncating the parse.class/rel etc. become lists.BeautifulSoup(markup, "html.parser", multi_valued_attributes=None)multi_valued_attributes={'*': 'class'}.from bs4 import BeautifulSoup
html_doc = "<p><b>badly nested</p></b>"
soup = BeautifulSoup(html_doc) # parser not specified
print(soup.find("b"))
from bs4 import BeautifulSoup
html_doc = "<p><b>badly nested</p></b>"
soup = BeautifulSoup(html_doc, "html.parser")
print(soup.find("b"))
class as a string in HTML modefrom bs4 import BeautifulSoup
soup = BeautifulSoup("<p class='body strikeout'></p>", "html.parser")
# In HTML mode, soup.p["class"] is a list, so this fails.
classes = soup.p["class"].split() # type: ignore[attr-defined]
print(classes)
get_attribute_list)from bs4 import BeautifulSoup
soup = BeautifulSoup("<p class='body strikeout'></p>", "html.parser")
classes = soup.p["class"]
print(classes) # ["body", "strikeout"]
ids = soup.p.get_attribute_list("id")
print(ids) # []
from bs4 import BeautifulSoup
soup = BeautifulSoup("<p class='body strikeout'></p>", "xml")
# In XML mode, "class" is a string by default; indexing returns a character.
first = soup.p["class"][0]
print(first) # "b" (not "body")
from bs4 import BeautifulSoup
class_is_multi = {"*": "class"}
soup = BeautifulSoup("<p class='body strikeout'></p>", "xml", multi_valued_attributes=class_is_multi)
first = soup.p["class"][0]
print(first) # "body"
NavigableString “in place”from bs4 import BeautifulSoup
from bs4.element import NavigableString
soup = BeautifulSoup("<p>Hello</p>", "html.parser")
text = soup.p.string
assert isinstance(text, NavigableString)
# Strings are immutable; this does not update the parse tree.
text = NavigableString("Hi")
print(soup.p.get_text()) # still "Hello"
replace_withfrom bs4 import BeautifulSoup
from bs4.element import NavigableString
soup = BeautifulSoup("<p>Hello</p>", "html.parser")
text = soup.p.string
assert isinstance(text, NavigableString)
text.replace_with("Hi")
print(soup.p.get_text()) # "Hi"
huge_tree=True)from bs4 import BeautifulSoup
# If this markup contains a single >10,000,000 byte text node, lxml may stop early.
markup_with_huge_text = "<root>" + ("x" * 11_000_000) + "</root>"
soup = BeautifulSoup(markup_with_huge_text, "lxml")
print(soup.find("root") is not None)
from bs4 import BeautifulSoup
markup_with_huge_text = "<root>" + ("x" * 11_000_000) + "</root>"
soup = BeautifulSoup(markup_with_huge_text, "lxml", huge_tree=True)
print(soup.find("root") is not None)
find_* methods gained overloads to improve type safety.
Optional[Tag], Optional[NavigableString], Sequence[Tag], etc.find_all("a", string="...") may still confuse type checkers; refactor or use typing.cast.from __future__ import annotations
from typing import Optional, Sequence, cast
from bs4 import BeautifulSoup, Tag
soup = BeautifulSoup("<a>b</a>", "html.parser")
# Preferred: reflect optionality
a: Optional[Tag] = soup.find("a")
# Edge case: mixed filters may require a cast for static type checkers
tags = cast(Sequence[Tag], soup.find_all("a", string="b"))
print([t.get_text() for t in tags])
ResultSet typing churn across 4.14.x: inheritance changed in 4.14.0/4.14.1/4.14.2; avoid depending on specific ABC inheritance.
results = list(soup.find_all(...)).lxml huge text nodes (4.14.3 note): if using an lxml builder and expecting extremely large text nodes, pass huge_tree=True.
features (parser) explicitly.Tag | None); supports tag name, attrs, and other filters.list(...) if you need a stable container type."a", "p").