处理大文本文件是程序员经常遇到的挑战。特别是当我们需要把一个几百MB甚至几个GB的TXT文件分割成小块时，手动操作显然不现实。今天我们就来聊聊如何用Python自动完成这个任务，特别是如何精确控制每个分割文件的大小为4KB。

为什么需要分割TXT文件

在实际开发中，我们可能会遇到这些情况：

• 某些老旧系统只能处理小体积文本文件
  
• 需要将日志文件分割后上传到云存储
  
• 进行分布式处理时需要将数据分片
  
• 调试时需要用小文件快速测试
  

4KB是个很常用的分割尺寸，因为它正好是很多系统默认的内存页大小，处理起来效率很高。那么问题来了：怎么用Python实现这个需求呢？

基础版：按行分割

我们先来看一个最简单的实现方式：

1. def split_by_line(input_file, output_prefix, chunk_size=4000):
   
2.     with open(input_file, 'r', encoding='utf-8') as f:
   
3.         file_count = 1
   
4.         current_size = 0
   
5.         output_file = None
   
6.         
   
7.         for line in f:
   
8.             line_size = len(line.encode('utf-8'))
   
9.             
   
10.             if current_size + line_size > chunk_size:
    
11.                 if output_file:
    
12.                     output_file.close()
    
13.                 output_file = open(f"{output_prefix}_{file_count}.txt", 'w', encoding='utf-8')
    
14.                 file_count += 1
    
15.                 current_size = 0
    
16.                
    
17.             if not output_file:
    
18.                 output_file = open(f"{output_prefix}_{file_count}.txt", 'w', encoding='utf-8')
    
19.                 file_count += 1
    
20.                
    
21.             output_file.write(line)
    
22.             current_size += line_size
    
23.             
    
24.         if output_file:
    
25.             output_file.close()

复制代码

这个脚本可以按行分割文件，尽量保证每个文件不超过指定大小。但是有个问题：它不能精确控制文件大小正好是4KB，特别是当某一行特别长时，单个文件可能会超过限制。

进阶版：精确控制文件大小

要实现更精确的控制，我们需要按字节而不是按行来处理：

1. def split_by_size(input_file, output_prefix, chunk_size=4096):
   
2.     with open(input_file, 'rb') as f:
   
3.         file_count = 1
   
4.         while True:
   
5.             chunk = f.read(chunk_size)
   
6.             if not chunk:
   
7.                 break
   
8.             with open(f"{output_prefix}_{file_count}.txt", 'wb') as out_file:
   
9.                 out_file.write(chunk)
   
10.             file_count += 1

复制代码

注意！ 这里我们用二进制模式(‘rb’)打开文件，这样可以精确控制读取的字节数。但是这样可能会在UTF-8编码的中文文件中出现乱码，因为一个中文字符可能被从中间截断。

完美解决方案：支持UTF-8编码

为了解决中文乱码问题，我们需要更智能的处理方式：

1. def split_utf8_safely(input_file, output_prefix, chunk_size=4096):
   
2.     buffer = ""
   
3.     file_count = 1
   
4.     current_size = 0
   
5.    
   
6.     with open(input_file, 'r', encoding='utf-8') as f:
   
7.         while True:
   
8.             char = f.read(1)
   
9.             if not char:
   
10.                 if buffer:
    
11.                     with open(f"{output_prefix}_{file_count}.txt", 'w', encoding='utf-8') as out_file:
    
12.                         out_file.write(buffer)
    
13.                 break
    
14.                
    
15.             char_size = len(char.encode('utf-8'))
    
16.             if current_size + char_size > chunk_size:
    
17.                 with open(f"{output_prefix}_{file_count}.txt", 'w', encoding='utf-8') as out_file:
    
18.                     out_file.write(buffer)
    
19.                 file_count += 1
    
20.                 buffer = ""
    
21.                 current_size = 0
    
22.                
    
23.             buffer += char
    
24.             current_size += char_size

复制代码

这个方法逐个字符读取文件，确保不会截断多字节字符。虽然速度会慢一些，但能保证分割后的文件都能正常显示中文内容。

性能优化：使用缓冲区

处理大文件时，逐个字符读取效率太低。我们可以用缓冲区来提升性能：

1. def split_with_buffer(input_file, output_prefix, chunk_size=4096, buffer_size=1024):
   
2.     buffer = ""
   
3.     file_count = 1
   
4.     current_size = 0
   
5.    
   
6.     with open(input_file, 'r', encoding='utf-8') as f:
   
7.         while True:
   
8.             chunk = f.read(buffer_size)
   
9.             if not chunk:
   
10.                 if buffer:
    
11.                     with open(f"{output_prefix}_{file_count}.txt", 'w', encoding='utf-8') as out_file:
    
12.                         out_file.write(buffer)
    
13.                 break
    
14.                
    
15.             buffer += chunk
    
16.             while len(buffer.encode('utf-8')) >= chunk_size:
    
17.                 # 找到不超过chunk_size的最大子串
    
18.                 split_pos = 0
    
19.                 for i in range(1, len(buffer)+1):
    
20.                     if len(buffer[:i].encode('utf-8')) <= chunk_size:
    
21.                         split_pos = i
    
22.                     else:
    
23.                         break
    
24.                         
    
25.                 with open(f"{output_prefix}_{file_count}.txt", 'w', encoding='utf-8') as out_file:
    
26.                     out_file.write(buffer[:split_pos])
    
27.                 file_count += 1
    
28.                 buffer = buffer[split_pos:]
    
29.                 current_size = 0

复制代码

处理特殊情况

实际应用中我们还需要考虑一些特殊情况：

• 文件头处理：如果需要保留原文件的头信息到每个分割文件
  
• 行完整性：某些场景下需要保持行的完整性
  
• 内存限制：处理超大文件时的内存优化
  
• 进度显示：添加进度条让长时间运行的任务更友好
  

这里给出一个保留文件头的实现示例：

1. def split_with_header(input_file, output_prefix, chunk_size=4096, header_lines=1):
   
2.     # 先读取文件头
   
3.     with open(input_file, 'r', encoding='utf-8') as f:
   
4.         header = [next(f) for _ in range(header_lines)]
   
5.    
   
6.     buffer = ""
   
7.     file_count = 1
   
8.     current_size = len(''.join(header).encode('utf-8'))
   
9.    
   
10.     with open(input_file, 'r', encoding='utf-8') as f:
    
11.         # 跳过已经读取的文件头
    
12.         for _ in range(header_lines):
    
13.             next(f)
    
14.             
    
15.         while True:
    
16.             char = f.read(1)
    
17.             if not char:
    
18.                 if buffer:
    
19.                     with open(f"{output_prefix}_{file_count}.txt", 'w', encoding='utf-8') as out_file:
    
20.                         out_file.writelines(header)
    
21.                         out_file.write(buffer)
    
22.                 break
    
23.                
    
24.             char_size = len(char.encode('utf-8'))
    
25.             if current_size + char_size > chunk_size:
    
26.                 with open(f"{output_prefix}_{file_count}.txt", 'w', encoding='utf-8') as out_file:
    
27.                     out_file.writelines(header)
    
28.                     out_file.write(buffer)
    
29.                 file_count += 1
    
30.                 buffer = ""
    
31.                 current_size = len(''.join(header).encode('utf-8'))
    
32.                
    
33.             buffer += char
    
34.             current_size += char_size

复制代码

总结

我们介绍了多种Python分割TXT文件的方法：
简单的按行分割适合行结构明显的文件
按字节分割效率最高但不支持UTF-8
带UTF-8支持的版本适合中文文本
缓冲区的版本在性能和准确性之间取得平衡
特殊需求如保留文件头需要额外处理
记住！ 选择哪种方法取决于你的具体需求。如果是处理GB级别的大文件，建议使用缓冲区方案并考虑内存映射等高级技术。希望这篇指南能帮你解决文件分割的问题！
到此这篇关于Python如何将大TXT文件分割成4KB小文件的文章就介绍到这了,更多相关Python大文件分割内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：https://www.jb51.net/python/339664vgj.htm
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！