掌握文件和字符串的高效处理技巧是Python编程中的重要能力。以下是一些专业级的优化技巧和实践方法：

一、文件处理高效技巧

1. 文件读取优化

1.1 大文件逐行读取

# 标准方法（内存友好）
with open('large_file.txt', 'r', encoding='utf-8') as f:
    for line in f:  # 文件对象本身就是迭代器
        process(line)  # 逐行处理，不加载整个文件到内存

# 使用缓冲读取（处理二进制文件）
BUFFER_SIZE = 65536  # 64KB
with open('large_binary.bin', 'rb') as f:
    while chunk := f.read(BUFFER_SIZE):
        process_chunk(chunk)

1.2 高效读取方法对比

2. 文件写入优化

2.1 批量写入减少IO操作

# 低效方式（多次IO）
with open('output.txt', 'w') as f:
    for item in data:
        f.write(str(item) + '\n')

# 高效方式（单次IO）
with open('output.txt', 'w') as f:
    f.writelines(f"{item}\n" for item in data)  # 使用生成器表达式

2.2 追加写入模式

# 追加模式不会覆盖原有内容
with open('log.txt', 'a') as f:
    f.write(f"{datetime.now()}: New log entry\n")

3. 上下文管理器高级用法

3.1 同时处理多个文件

with open('input.txt', 'r') as fin, open('output.txt', 'w') as fout:
    for line in fin:
        fout.write(line.upper())

3.2 自定义上下文管理器

from contextlib import contextmanager

@contextmanager
def open_file(filename, mode):
    try:
        f = open(filename, mode)
        yield f
    finally:
        f.close()

with open_file('data.txt', 'r') as f:
    content = f.read()

二、字符串处理高效技巧

1. 字符串拼接优化

1.1 使用join代替+=

# 低效方式（每次拼接创建新对象）
result = ""
for s in string_list:
    result += s  # O(n^2)时间复杂度

# 高效方式
result = "".join(string_list)  # O(n)时间复杂度

1.2 格式化字符串性能对比

name = "Alice"; age = 25

# 方法1：f-string (Python 3.6+ 最快)
msg = f"My name is {name} and I'm {age} years old"

# 方法2：format方法
msg = "My name is {} and I'm {} years old".format(name, age)

# 方法3：%格式化 (Python2风格)
msg = "My name is %s and I'm %d years old" % (name, age)

2. 字符串查找与替换

2.1 高效查找方法

s = "Python programming is fun"

# 检查前缀/后缀
if s.startswith("Python"): ...
if s.endswith("fun"): ...

# 快速查找（返回索引）
idx = s.find("prog")  # 返回-1表示未找到
idx = s.index("prog")  # 找不到会抛出异常

2.2 多重替换

# 简单替换
s.replace("old", "new")

# 多重替换（使用str.translate最快）
trans_table = str.maketrans({'a': '1', 'b': '2'})
result = "abc".translate(trans_table)  # "12c"

# 正则表达式替换
import re
re.sub(r"\d+", "NUM", "123 abc")  # "NUM abc"

3. 字符串分割与连接

3.1 高效分割技巧

# 简单分割
parts = "a,b,c".split(",")  # ['a', 'b', 'c']

# 限制分割次数
"a b c d".split(" ", 2)  # ['a', 'b', 'c d']

# 保留分隔符（使用re.split）
import re
re.split(r"([,;])", "a,b;c")  # ['a', ',', 'b', ';', 'c']

3.2 多行字符串处理

text = """Line 1
Line 2
Line 3"""

# 按行分割（保持换行符）
lines = text.splitlines(keepends=True)

# 移除每行首尾空白
cleaned = [line.strip() for line in text.splitlines()]

4. 字符串性能优化

4.1 使用字符串缓存

import sys

# 小字符串会被自动驻留(interning)
a = "hello"
b = "hello"
print(a is b)  # True (相同对象)

# 强制驻留大字符串
big_str = sys.intern("very long string..." * 100)

4.2 避免不必要的字符串操作

# 不推荐：多次创建临时字符串
if s.lower().startswith("prefix").strip(): ...

# 推荐：分步处理
lower_s = s.lower()
stripped_s = lower_s.strip()
if stripped_s.startswith("prefix"): ..

三、文件与字符串结合处理

1. 高效日志处理

import re
from collections import defaultdict

log_pattern = re.compile(r'\[(.*?)\] (\w+): (.*)')

def process_log(file_path):
    stats = defaultdict(int)
    with open(file_path) as f:
        for line in f:
            if match := log_pattern.match(line):
                timestamp, level, message = match.groups()
                stats[level] += 1
                if level == 'ERROR':
                    log_error(message)
    return stats

2. CSV文件高效处理

import csv
from collections import namedtuple

# 使用命名元组处理CSV
with open('data.csv') as f:
    reader = csv.reader(f)
    headers = next(reader)
    Row = namedtuple('Row', headers)
    for row in map(Row._make, reader):
        process_row(row)

3. 内存映射文件处理大文件

import mmap

def search_in_large_file(filename, search_term):
    with open(filename, 'r+b') as f:
        # 内存映射文件
        with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
            # 像操作字符串一样操作文件内容
            if (pos := mm.find(search_term.encode())) != -1:
                return pos
    return -1

四、实用工具函数

1. 通用文件处理函数

def batch_process_files(file_pattern, processor, workers=4):
    """多进程批量处理文件"""
    from concurrent.futures import ProcessPoolExecutor
    import glob
    
    files = glob.glob(file_pattern)
    with ProcessPoolExecutor(max_workers=workers) as executor:
        executor.map(processor, files)

2. 字符串模板处理

from string import Template

template = Template("Hello $name! Your balance is $ $amount")
message = template.substitute(name="Alice", amount=100.5)
# Hello Alice! Your balance is $ 100.5

3. 高效多行日志解析

def parse_multiline_logs(file_obj):
    buffer = []
    for line in file_obj:
        if line.startswith('[') and buffer:
            yield ''.join(buffer)
            buffer = [line]
        else:
            buffer.append(line)
    if buffer:
        yield ''.join(buffer)

性能对比总结

记住这些原则：

1. 对于大文件，始终使用迭代方式而非全量读取
2. 字符串操作优先使用内置方法而非手动循环
3. 频繁操作考虑使用正则表达式预编译
4. 大量字符串处理时注意内存驻留和缓存

掌握这些技巧后，您的文件与字符串处理代码将更加高效和专业。