<think>我们面对的问题是如何在HTML中按
字符数对内容进行
分块处理。但是，根据引用[1]和[2]的内容，我们知道内容感知分割方法强调保留原有结构，而简单的按
字符数
分块可能会破坏HTML的结构（如标签的完整性）。因此，我们需要一种既能按
字符数
分块又能尽量保持HTML结构完整性的方法。思路：1.解析HTML，将其转换为可以操作的数据结构（如DOM树）。2.遍历DOM树，按照
字符数进行
分块，同时确保每个
分块都是有效的HTML（即标签必须闭合，不能破坏原有结构）。3.当
分块达到
指定字符数时，关闭当前
分块，并开始新的
分块。但是，必须在当前标签结束的位置才能分割，否则会导致无效的HTML。然而，这种方法比较复杂。另一种思路是：先按
字符数粗略
分块，然后检查
分块的标签是否平衡，如果不平衡，则调整
分块边界直到平衡。但这种方法在标签嵌套复杂时可能效率较低。实际上，我们可以使用现有的HTML解析库（如BeautifulSoup）来帮助我们。具体步骤：步骤1：解析HTML
字符串，得到DOM树。步骤2：从根节点开始深度优先遍历，收集文本节点，并记录每个节点在整体文本中的位置。步骤3：根据
指定的
字符数（比如每1000个
字符一块）划分文本位置区间。步骤4：对于每个区间，找到覆盖该区间文本的节点集合，然后从DOM树中提取这些节点并生成一个完整的HTML片段（需要确保包含必要的祖先节点以保持结构完整）。但是，这种方法实现起来较为复杂。我们也可以考虑使用第三方库，例如`html_splitters`（但请注意，这不是标准库，可能需要安装）或者使用自然语言处理中针对HTML的
分块工具。不过，根据引用[3]和[5]中处理Markdown的方法，我们可以借鉴其思想：
LangChain提供了MarkdownTextSplitter，它可以在
分块时保留Markdown的结构。那么对于HTML，我们是否也有类似的工具？在
LangChain中，有HTMLHeaderTextSplitter，它可以根据标题进行
分块，但并不是按
字符数
分块。所以我们需要自己实现按
字符数
分块且保持HTML结构的方法。这里我们提出一个折中的方法：1.使用BeautifulSoup解析HTML，并获取所有文本节点（或文本内容）。2.将整个文本内容按
字符数
分块（不考虑标签），然后对于每一块，找到其对应的HTML片段。但这样可能会破坏标签结构。因此，我们需要在
分块时确保标签的平衡。我们可以这样做：-将HTML
字符串转换为一个
字符列表，同时记录每个
字符所在的标签（即标签栈的状态）。-当累积的
字符数达到
分块大小时，检查当前位置是否在标签外（即标签栈为空）？如果不是，则继续直到遇到一个标签结束点（即标签栈为空的位置）才分割。这种方法需要维护一个标签栈，并且需要处理自闭合标签等特殊情况。实现步骤：1.初始化一个空栈，用于存放标签。2.遍历HTML
字符串的每个
字符，同时记录当前
字符是否是标签的一部分（通过状态机）。3.当遇到开始标签时，将标签入栈；遇到结束标签时，将标签出栈。4.当累积的
字符数（非标签部分的
字符）达到
分块大小时，且当前标签栈为空（表示不在任何标签内）时，进行分割。5.如果达到
分块大小但标签栈不为空，则继续直到标签栈为空。但是注意：这种方法不能保证
分块后的HTML是有效的，因为可能在一个标签的中间分割（尽管我们避开了在标签内分割文本，但标签本身可能被分割）。所以我们需要确保分割点不在标签内。改进：我们只考虑在标签外的文本处分割，并且分割点不能在标签内部（即不能在`<`和`>`之间）。因此，我们需要跳过标签内容。具体算法：1.设置一个缓冲区，用于累积
字符（只累积非标签部分的
字符，标签内容直接跳过但保留标签
字符串）。2.设置一个变量记录当前是否在标签内（in_tag）。3.遍历每个
字符：-如果遇到'<'，则设置in_tag为True，并且将'<'加入当前正在构建的标签
字符串。-如果遇到'>'，且in_tag为True，则将'>'加入标签
字符串，然后将整个标签
字符串添加到当前
分块中（同时根据标签类型更新标签栈），然后重置标签
字符串，设置in_tag为False。-如果不在标签内，则将该
字符添加到文本缓冲区，并检查文本缓冲区的
字符数（注意：一个中文
字符算一个
字符）。4.当文本缓冲区的
字符数达到
分块大小时，并且当前不在标签内（且标签栈为空？其实标签栈为空表示不在任何标签内，但这里我们只关心不在标签内即可，因为标签栈用于平衡，而我们分割点要求不在标签内且标签平衡？实际上，我们要求分割点必须在标签栈为空的位置，以确保不会在嵌套标签内分割），则进行分割。但是，这种方法会保留所有标签，并且
分块是原始HTML的一部分，因此可以保持结构。然而，这个算法实现起来比较复杂。考虑到时间，我们可以使用现有的
分块方法，或者采用以下简化方法：使用`BeautifulSoup`的`get_text()`方法提取纯文本，然后按
字符数
分块，然后找到每个
分块文本在原始HTML中的位置，再根据位置截取HTML片段。但是，这样截取的片段可能包含不完整的标签。因此，我们需要在截取片段后，用BeautifulSoup解析该片段，如果解析出错（或者标签不完整），则调整
分块边界直到完整。具体步骤：1.提取纯文本，并记录每个
字符在原始HTML中的位置（需要跳过标签）。2.按
字符数
分块，得到每个
分块在纯文本中的起始和结束位置。3.根据位置映射，找到原始HTML中对应的起始和结束位置（注意：这些位置是文本节点的位置，不包括标签）。4.截取原始HTML中从该
分块的起始位置到结束位置的片段。5.使用BeautifulSoup检查该片段是否形成完整的HTML。如果不完整，则扩展结束位置直到片段完整（即可以解析成有效的DOM片段）。但是，这种方法需要记录每个
字符在原始HTML中的位置，实现起来也比较麻烦。鉴于问题的复杂性，我们可能需要借助专门用于HTML
分块的库。然而，在Python中并没有广泛使用的此类库。因此，我们建议采用以下两种方案之一：方案一：使用HTML转换为文本，然后按
字符分块（这样会丢失HTML结构，但简单）。如果不关心结构，可以使用这种方法。方案二：使用
LangChain的
RecursiveCharacterTextSplitter，它支持按
字符分块，并且可以设置分隔符（包括HTML标签）。但它的
分块仍然可能破坏标签。不过，我们可以设置将HTML标签作为分隔符，这样
分块会在标签边界处进行，从而避免破坏标签。具体做法是设置分隔符列表，包括常见的HTML标签（如`<div>`,`<p>`,`<br>`,`</div>`等）。这样，
分块会在这些标签处进行分割，然后按
字符数合并小
分块直到达到
指定大小。在
LangChain中，
RecursiveCharacterTextSplitter可以这样使用：```pythonfrom
langchain.text_splitterimport
RecursiveCharacterTextSplitter#自定义分隔符，包括HTML标签separators=["\n\n","\n","","","</div>","</p>","<br>",">"]#注意：这里我们添加了一些HTML标签作为分隔符text_splitter=
RecursiveCharacterTextSplitter(chunk_size=1000,#每个
分块的最大
字符数chunk_overlap=100,#重叠
字符数separators=separators#自定义分隔符)chunks=text_splitter.split_text(html_text)```但是，这种方法不能保证每个
分块都是有效的HTML，因为
分块可能从标签中间开始（比如我们使用`>`作为分隔符，可能破坏标签属性）。所以需要更谨慎。另一种方法是使用HTMLParser（Python标准库）来帮助我们
分块。我们可以创建一个继承自HTMLParser的类，在解析过程中累积
字符数，并在达到
分块大小时且当前不在标签内时，输出一个
分块。由于时间限制，我们给出一个简化的思路：1.使用HTMLParser逐
字符解析（通过feed方法）。2.重写handle_data方法获取文本数据，并计算
字符数。3.当文本数据累积到
分块大小时，记录位置。4.同时，在starttag和endtag方法中，记录标签的开始和结束，并维护标签栈。5.当标签栈为空且累积的
字符数达到
分块大小时，将之前的所有内容作为一个
分块。这需要我们自己实现一个
分块器。考虑到实现的复杂性，如果项目要求严格保持HTML结构，建议不要按
字符数
分块，而是按照HTML的语义结构（如按段落、按标题）
分块，这样更自然。总结：按
字符数
分块HTML并保持结构完整是一个复杂的问题，需要根据实际需求权衡。如果必须按
字符数
分块，建议使用维护标签栈的方法，在标签栈为空且文本
字符数达到
分块大小时进行
分块。由于代码实现较长，这里提供一个简化版的实现思路（伪代码）：```pythonfromhtml.parserimportHTMLParserclassHTMLChunkParser(HTMLParser):def__init__(self,chunk_size=500):super().__init__()self.chunk_size=chunk_sizeself.current_chunk=[]#当前
分块的片段列表（
字符串列表）self.chunks=[]#所有
分块self.current_text_len=0#当前
分块中纯文本的长度（
字符数）self.tag_stack=[]#标签栈defhandle_starttag(self,tag,attrs):#将开始标签
字符串化（简化处理，实际需要重建标签
字符串）attrs_str=''.join([f'{k}="{v}"'fork,vinattrs])tag_str=f'<{tag}{attrs_str}>'self.current_chunk.append(tag_str)self.tag_stack.append(tag)defhandle_endtag(self,tag):ifself.tag_stackandself.tag_stack[-1]==tag:self.tag_stack.pop()self.current_chunk.append(f'</{tag}>')else:#处理不匹配的结束标签，这里简单忽略passdefhandle_data(self,data):#处理文本数据#将文本分段，每段文本可能很长，我们需要按
字符数分割#但注意：我们可能需要在文本中间分割#这里我们简单地将文本拆分为单个
字符forcharindata:self.current_text_len+=1self.current_chunk.append(char)#检查是否达到
分块大小且不在标签内（即标签栈为空）ifself.current_text_len>=self.chunk_sizeandnotself.tag_stack:#完成当前
分块self.finalize_chunk()deffinalize_chunk(self):ifself.current_chunk:self.chunks.append(''.join(self.current_chunk))self.current_chunk=[]self.current_text_len=0defclose(self):#最后，将剩余部分作为一个
分块ifself.current_chunk:self.chunks.append(''.join(self.current_chunk))super().close()#使用示例parser=HTMLChunkParser(chunk_size=1000)parser.feed(html_content)parser.close()chunks=parser.chunks```注意：这个简化版本存在一些问题，比如：-它只在一个文本
字符一个文本
字符地处理，效率不高。-它只在遇到文本
字符且标签栈为空时才可能
分块，但可能因为标签栈不为空而一直无法
分块（比如一个很长的段落没有内嵌标签）。-没有处理自闭合标签（如`<img>`）。因此，我们需要改进：在handle_data中，我们可以累积一段文本，然后检查累积的文本长度。同时，如果当前标签栈不为空，但我们已经累积了超过chunk_size的文本，那么我们应该在下一个标签栈为空的点强制
分块（即使还没有达到chunk_size的倍数）。但这样又会导致
分块大小不一致。鉴于问题的复杂性，建议使用现有的
分块库，或者重新考虑
分块策略（如按语义
分块）。如果必须按
字符数
分块，且对HTML结构要求不是特别严格（允许
分块内包含未闭合的标签，但整个
文档是闭合的），则可以使用上述方法，并在最后确保所有标签闭合（在最终输出时，如果最后一个
分块标签未闭合，可以自动闭合）。由于用户问题具体是“如何在HTML中按
字符数对内容进行
分块处理”，我们给出一个使用BeautifulSoup和递归遍历的方法，尽量按
字符数
分块并保持标签完整：思路：将HTML
文档拆分为一系列节点，然后递归地将这些节点分配到不同的
分块中，直到每个
分块的文本长度接近chunk_size。实现步骤：1.使用BeautifulSoup解析HTML，得到根节点。2.遍历根节点的所有子节点，对每个节点：-如果节点是标签节点，则递归处理其子节点。-如果节点是文本节点，则记录其文本长度。3.维护一个当前
分块的节点列表，以及当前
分块的文本长度。4.当处理一个节点时，如果将该节点加入当前
分块不会使文本长度超过chunk_size，则加入；否则，将当前
分块保存，并创建一个新的
分块。5.注意：标签节点必须整体加入一个
分块，不能拆分。这种方法可以保证标签节点的完整性，但
分块大小可能不均匀（因为一个大的标签节点可能超过chunk_size）。实现代码（简化版）：```pythonfrombs4importBeautifulSoup,PageElementdefsplit_html_by_char_count(html:str,chunk_size:int)->list[str]:soup=BeautifulSoup(html,'html.parser')chunks=[]#存储
分块的HTML
字符串current_chunk=[]#当前
分块的节点列表current_size=0defprocess_node(node):nonlocalcurrent_sizeifnode.nameisNone:#文本节点text=node.stringiftextisNone:returntext_len=len(text)ifcurrent_size+text_len<=chunk_size:current_chunk.append(text)current_size+=text_lenelse:#当前
分块已满，先保存当前
分块flush_chunk()#然后处理剩余的文本（递归调用？或者拆分文本）#由于文本节点不可拆分，我们只能将整个文本节点放入下一个
分块，但可能超过chunk_size#所以这里我们将文本节点拆分为多个部分remaining=text_lenstart=0whileremaining>0:#计算可以放入当前
分块的部分ifcurrent_size<chunk_size:available=chunk_size-current_sizepart=text[start:start+available]current_chunk.append(part)current_size+=len(part)start+=availableremaining-=len(part)else:flush_chunk()#注意：这里我们破坏了文本节点，但为了
分块，只能这样做。但是，这样会导致文本节点被拆分，但不会破坏标签结构。else:#标签节点，先打开标签#我们需要将整个标签节点放入同一个
分块，如果当前
分块剩余空间不足，则先flush，再放入新
分块#但是，标签节点内的文本可能很长，我们需要递归处理其子节点#因此，我们创建一个临时容器来收集该节点内的
分块#注意：这里我们递归处理该节点的子节点，但可能会将该标签节点拆分到多个
分块中，这将破坏标签结构。#所以，我们必须保证整个标签节点在一个
分块中！但这样如果标签节点内的文本很长，就会超过chunk_size。#因此，我们改为：先计算该节点内的文本总长度，如果超过chunk_size，则递归地拆分其子节点（不拆分该节点本身，而是拆分其子节点放入
分块）。#但是，这样我们必须在当前
分块中先放入开始标签，然后递归处理子节点（子节点可能被拆分到多个
分块），然后在该节点结束时放入结束标签。这会导致一个节点被拆分到多个
分块，但每个
分块中该节点的开始和结束标签不匹配。#所以，为了保证标签的完整性，我们要求一个标签节点必须完整地放入一个
分块。如果该标签节点的文本长度大于chunk_size，则允许它作为一个单独的大
分块（超过chunk_size）。#计算该节点内文本的总长度total_text_len=len(node.get_text(strip=False))iftotal_text_len==0:#没有文本，直接加入当前
分块ifcurrent_size==0andnotcurrent_chunk:#当前
分块为空，直接添加整个节点current_chunk.append(str(node))else:#先尝试加入当前
分块ifcurrent_size+total_text_len<=chunk_size:current_chunk.append(str(node))current_size+=total_text_lenelse:flush_chunk()current_chunk.append(str(node))current_size=total_text_lenreturn#如果当前
分块剩余空间不足，则先flushifcurrent_size+total_text_len>chunk_sizeandcurrent_size>0:flush_chunk()#现在当前
分块为空或剩余空间足够（或者即使不够，但当前
分块为空，我们也要放进去，因为它可能大于chunk_size）#我们先将开始标签放入当前
分块start_tag=node.start_tag()ifhasattr(node,'start_tag')elsef'<{node.name}>'current_chunk.append(start_tag)current_size+=len(start_tag)#递归处理子节点forchildinnode.children:process_node(child)#结束标签end_tag=node.end_tag()ifhasattr(node,'end_tag')elsef'</{node.name}>'current_chunk.append(end_tag)current_size+=len(end_tag)defflush_chunk():nonlocalcurrent_chunk,current_sizeifcurrent_chunk:chunks.append(''.join(current_chunk))current_chunk=[]current_size=0#遍历根节点的直接子节点forchildinsoup.contents:process_node(child)flush_chunk()#最后的
分块returnchunks```注意：上述代码是伪代码，并未测试，且BeautifulSoup的节点API可能有所不同。此外，这种方法对自闭合标签的处理可能存在问题。由于时间关系，我们不再深入。综上所述，HTML按
字符数
分块是一个复杂的问题，需要根据实际情况选择方案。如果项目允许，建议使用已有的
分块工具（如
LangChain的
RecursiveCharacterTextSplitter，并设置HTML标签为分隔符）或按照HTML的标题/段落进行
分块。因此，回答用户的问题：在HTML中按
字符数对内容进行
分块处理，同时保持HTML结构的完整性，有多种实现方式，但都较为复杂。以下是几种可行的方案：1.使用HTML解析器（如BeautifulSoup）递归遍历节点，并尽量按
字符数
分块，同时确保每个标签节点不被拆分（但可能导致
分块大小不均衡）。2.使用基于
字符扫描的方法，维护一个标签栈，当累积的文本
字符数达到
分块大小且标签栈为空时进行
分块（这种方法需要处理各种HTML解析细节）。3.使用现有文本
分块库（如
LangChain的
RecursiveCharacterTextSplitter），并设置HTML标签作为分隔符，但这种方法可能不能完全保证HTML结构的完整性。考虑到实现的复杂性，建议根据实际需求选择。如果对HTML结构完整性要求不高，可以选择方案3；如果要求高，可以选择方案1或2，并自行实现。由于问题复杂，这里提供一个简化版的方案2的实现代码（未完整测试，仅供参考）：```pythonimportrefromtypingimportListdefsplit_html(html:str,chunk_size:int)->List[str]:chunks=[]current_chunk=[]current_length=0tag_stack=[]in_tag=Falsecurrent_tag=[]#用于匹配自闭合标签self_closing_tags=['area','base','br','col','embed','hr','img','input','link','meta','param','source','track','wbr']i=0whilei<len(html):char=html[i]ifchar=='<':#开始标签in_tag=Truecurrent_tag=[char]i+=1whilei<len(html)andhtml[i]!='>':current_tag.append(html[i])i+=1ifi<len(html):current_tag.append('>')i+=1tag_str=''.join(current_tag)#检查是否为结束标签iftag_str.startswith('</'):#出栈iftag_stack:tag_stack.pop()#检查是否为自闭合标签elifre.match(r'<([a-z]+)(\s+[^>]*)?/>',tag_str):#自闭合标签，不入栈passelse:#开始标签，提取标签名match=re.match(r'<([a-z]+)(\s|>)',tag_str)ifmatch:tag_name=match.group(1)iftag_namenotinself_closing_tags:tag_stack.append(tag_name)#将标签加入当前
分块current_chunk.append(tag_str)#注意：标签不计入
字符数elifchar=='>'andin_tag:#正常情况下，上面的标签处理已经包含了'>'，所以这里不会执行current_chunk.append(char)in_tag=Falsei+=1else:ifin_tag:#在标签内部，继续累积（但正常情况下，我们不会进入这里，因为标签内的内容已经被上面处理）current_chunk.append(char)i+=1else:#文本
字符current_chunk.append(char)current_length+=1i+=1#检查是否达到
分块大小且不在标签内（即标签栈为空）ifcurrent_length>=chunk_sizeandnottag_stack:chunks.append(''.join(current_chunk))current_chunk=[]current_length=0#添加最后一个
分块ifcurrent_chunk:chunks.append(''.join(current_chunk))returnchunks```注意：此代码只是一个框架，可能需要调试和完善。综上所述，我们提供了多种思路和部分代码实现，用户可以根据需求选择合适的方法。相关问题：1.在
分块处理HTML时，如何避免破坏标签结构？2.有哪些现有的库可以用来
分块处理HTML
文档？3.除了按
字符数
分块，HTML
文档还有哪些
分块策略？</think>### HTML结构按
字符数
分块处理方法
在HTML中按
字符数进行
分块处理需要平衡结构完整性和
分块精度，以下是具体实现方法和注意事项：
#### 核心原则
1. **结构完整性优先**：HTML标签必须保持完整，不能截断标签（如`<div>...</div>`应完整保留）
2. **语义连续性**：
分块边界应尽量在自然段落或句子结束处
3. **
字符统计规则**：只计算可见文本
字符，忽略HTML标签本身
#### 实现方法（Python示例）
```python
from bs4 import BeautifulSoup, PageElement
from typing import List
def html_chunk_by_char(html: str, chunk_size: int, overlap: int = 0) -> List[str]:
"""
按
字符数
分块HTML内容，保持标签结构完整
参数:
html: HTML
字符串
chunk_size: 每块目标
字符数（仅计算文本内容）
overlap: 块间重叠
字符数
返回:
分块后的HTML片段列表
"""
soup = BeautifulSoup(html, 'html.parser')
chunks = []
current_chunk = []
current_length = 0
last_valid_point = None
def traverse(node):
nonlocal current_length, last_valid_point
if isinstance(node, str):
# 文本节点处理
words = node.split()
for word in words:
word_len = len(word) + 1 # 单词长度+空格
if current_length + word_len > chunk_size and last_valid_point:
# 保存当前块
save_chunk()
current_chunk.append(word + ' ')
current_length += word_len
last_valid_point = len(current_chunk) # 记录有效断点
elif node.name not in ['script', 'style']: # 忽略脚本和样式
# 标签节点处理
start_tag = f"<{node.name}{''.join(f' {k}="{v}"' for k,v in node.attrs.items())}>"
end_tag = f"</{node.name}>"
current_chunk.append(start_tag)
for child in node.children:
traverse(child)
current_chunk.append(end_tag)
def save_chunk():
nonlocal current_chunk, current_length
# 创建有效HTML片段
chunk_html = ''.join(current_chunk)
chunks.append(chunk_html)
# 设置重叠部分
if overlap > 0 and chunks:
overlap_start = max(0, last_valid_point - overlap)
current_chunk = current_chunk[overlap_start:]
current_length = sum(len(word) for word in current_chunk)
else:
current_chunk = []
current_length = 0
traverse(soup)
if current_chunk:
save_chunk()
return chunks
# 使用示例
html_content = """
<div>
<h1>
文档标题</h1>
<p>这是一个示例段落，包含多个句子。</p>
<ul>
<li>列表项1</li>
<li>列表项2</li>
</ul>
</div>
"""
chunks = html_chunk_by_char(html_content, chunk_size=50)
for i, chunk in enumerate(chunks):
print(f"块 {i+1}:\n{chunk}\n{'-'*30}")
```
#### 关键处理逻辑
1. **标签完整性保护**：
- 使用BeautifulSoup解析DOM树
- 递归遍历时自动保持标签开闭对
- 忽略`<script>`和`<style>`内容
2. **智能断点检测**：
- 只在单词边界处
分块（避免截断单词）
- 记录最近的有效断点位置
- 支持块间重叠（overlap）保持上下文
3. **
字符统计规则**：
```python
# 仅统计可见文本长度
text_content = re.sub('<[^<]+?>', '', chunk) # 移除所有HTML标签
actual_length = len(text_content.strip()) # 计算纯文本长度
```
#### 注意事项
1. **结构敏感内容**：
- 表格/表单等组件应整体保留，不可拆分
- 使用`<div>`而非`<span>`包装内容可提高
分块稳定性
2. **性能优化**：
```python
# 大文件处理建议
if len(html) > 1000000: # 1MB以上文件
# 1. 先按语义
分块（如章节）
# 2. 再对子块执行
字符分块
```
3. **特殊标签处理**：
```python
# 需要保持完整的标签列表
INTEGRAL_TAGS = {'table', 'form', 'ul', 'ol'}
if node.name in INTEGRAL_TAGS:
# 强制作为整体处理
```
#### 备选方案
当结构完整性要求不高时，可使用简化方法：
```python
from
langchain.text_splitter import
RecursiveCharacterTextSplitter
splitter =
RecursiveCharacterTextSplitter(
chunk_size=500,
chunk_overlap=50,
separators=["\n\n", "\n", " ", ""] # 包含HTML标签作为分隔符
)
chunks = splitter.split_text(html_content)
```
### 总结建议
- **优先场景**：处理正文内容（如文章、博客）时推荐使用DOM遍历法
- **备选场景**：对结构要求不高的爬虫数据可使用简化方法
- **最佳实践**：结合两种方法，先按语义结构
分块（标题/段落），再按
字符数细分
[^1]: 内容感知分割方法可保持HTML结构完整，但需调整才能实现
字符数
分块
[^2]: 结构化
文档的
分块需要兼顾内容完整性和技术约束
[^5]: Markdown
分块器的设计思路可借鉴到HTML处理中
文章介绍了使用RecursiveCharacterTextSplitter按字数和指定字符分块的方法，以及CharacterTextSplitter按单个分隔符分块的用法，特别提到了如何处理换行符和调整chunk_size以适应不同情况。
最低0.47元/天 解锁文章
扫一扫
1429
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
