Python中字符串查找替换首选str.replace()处理固定内容，而复杂模式匹配和动态替换则使用re.sub()。前者简单高效，适用于明确的字符串替换；后者支持正则表达式、大小写不敏感操作及函数式动态替换，适合基于模式或条件的场景。性能方面，应优先用str.replace()，重复正则操作时预编译模式以提升效率，并避免循环中频繁拼接字符串，大文件宜分块处理以节省内存。
Python中查找和替换字符串内容，最直接、最常用的方法就是利用字符串自带的
replace()
re
re.sub()
在Python中处理字符串的查找和替换，主要有两种核心手段，它们各有侧重，理解它们的差异能帮助你更高效地解决问题。
1. str.replace()
这是最基础也最常用的方法，适用于当你明确知道要替换的“旧内容”和“新内容”是什么，并且它们都是固定字符串的情况。
立即学习“Python免费学习笔记（深入）”；
用法示例：
original_string = "Hello, world! Hello, Python!"
new_string = original_string.replace("Hello", "Hi")
print(new_string)
# 输出: Hi, world! Hi, Python!限制替换次数：
replace()
count
original_string = "apple, banana, apple, orange"
new_string_limited = original_string.replace("apple", "grape", 1) # 只替换第一个"apple"
print(new_string_limited)
# 输出: grape, banana, apple, orange核心特点：
replace()
replace()
2. re.sub()
当你的查找条件不再是固定字符串，而是某种模式（例如，所有数字、所有以特定字母开头的单词、特定格式的日期等），或者替换的内容需要根据匹配到的内容动态生成时，
re
re.sub()
基本用法：
re.sub(pattern, replacement, string, count=0, flags=0)
pattern
replacement
string
count
flags
re.IGNORECASE
用法示例（替换所有数字）：
import re text = "我有100个苹果和200个香蕉。" new_text = re.sub(r'\d+', '很多', text) # r'\d+' 匹配一个或多个数字 print(new_text) # 输出: 我有很多个苹果和很多个香蕉。
使用捕获组进行替换： 正则表达式的捕获组（用括号
()
import re text = "Name: John Doe, Age: 30" # 将 "Name: XXX" 替换为 "Full Name: XXX" new_text = re.sub(r'Name: (\w+ \w+)', r'Full Name: \1', text) print(new_text) # 输出: Full Name: John Doe, Age: 30
这里的
\1
John Doe
使用函数进行动态替换： 这是
re.sub()
replacement
match
import re
def double_number(match):
# match.group(0) 获取整个匹配到的字符串
num = int(match.group(0))
return str(num * 2)
text = "商品A价格10元，商品B价格25元。"
# 将所有数字替换为其两倍的值
new_text = re.sub(r'\d+', double_number, text)
print(new_text)
# 输出: 商品A价格20元，商品B价格50元。我个人觉得，字符串处理中大小写敏感性是个老生常谈的问题，也是初学者容易犯迷糊的地方。
str.replace()
re.sub()
对于
str.replace()
# str.replace() 模拟大小写不敏感（不推荐，会丢失原始大小写）
text = "Python is great. python is powerful."
# 假设我们想把所有的 "python" (不区分大小写) 替换成 "Java"
# 这种方法会把原始的 "Python" 变成 "java"
temp_lower_text = text.lower()
replaced_lower_text = temp_lower_text.replace("python", "java")
print(replaced_lower_text)
# 输出: java is great. java is powerful.
# 显然，这丢失了原始的 "Python" 的大写信息。相比之下，
re.sub()
flags=re.IGNORECASE
import re text = "Python is great. python is powerful." # 使用 re.IGNORECASE 标志进行大小写不敏感替换 new_text = re.sub(r'python', 'Java', text, flags=re.IGNORECASE) print(new_text) # 输出: Java is great. Java is powerful.
你看，这不仅完成了替换，还保留了替换后字符串的统一风格（这里是 "Java" 的首字母大写），避免了前面
str.replace()
有时候我们不光是想替换一个固定的字符串，还想根据匹配到的内容，或者一些外部条件，来动态地生成替换后的内容。这事儿，说起来简单，但里头门道不少，
re.sub()
replacement
当
replacement
re.sub()
match
match
举个例子，假设我们想把文本中的所有数字都乘以2。
import re
def multiply_by_two(match):
# match.group(0) 返回整个匹配到的字符串，这里是数字
number_str = match.group(0)
number = int(number_str)
return str(number * 2)
text = "我有10个苹果和25个香蕉，总共35个。"
new_text = re.sub(r'\d+', multiply_by_two, text)
print(new_text)
# 输出: 我有20个苹果和50个香蕉，总共70个。这里，
multiply_by_two
再来一个稍微复杂点的例子，假设我们想把一个字符串中所有
[[key]]
import re
data = {
"name": "Alice",
"city": "New York",
"age": "30"
}
def replace_placeholder(match):
key = match.group(1) # 获取第一个捕获组，即 [[ ]] 里面的内容
return data.get(key, f"[[{key}]]") # 如果字典里有，就替换，没有就原样返回
template = "Hello, my name is [[name]] and I live in [[city]]. I am [[age]] years old. My job is [[job]]."
filled_template = re.sub(r'\[\[(.*?)\]\]', replace_placeholder, template)
print(filled_template)
# 输出: Hello, my name is Alice and I live in New York. I am 30 years old. My job is [[job]].这个例子就充分体现了
re.sub()
处理大规模字符串查找替换，性能问题确实是个值得关注的点。我记得刚开始学Python的时候，就老是搞不清楚什么时候该用哪个，结果一不小心就写出了效率低下的代码。其实，这里面有一些经验和技巧可以分享。
1. str.replace()
re.sub()
str.replace()
re.sub()
re.sub()
re.sub()
2. 预编译正则表达式模式：re.compile()
re.compile()
import re
import time
# 不编译
start_time = time.time()
for _ in range(100000):
re.sub(r'\d+', 'NUM', "Text with 123 and 456 numbers.")
end_time = time.time()
print(f"Without compile: {end_time - start_time:.4f} seconds")
# 编译
pattern = re.compile(r'\d+')
start_time = time = time.time()
for _ in range(100000):
pattern.sub('NUM', "Text with 123 and 456 numbers.")
end_time = time.time()
print(f"With compile: {end_time - start_time:.4f} seconds")你会发现，对于重复操作，编译后的模式会显著提升性能。这是因为正则表达式引擎只需要解析和优化一次模式，后续直接使用编译好的模式进行匹配，省去了重复解析的开销。
3. 避免不必要的字符串拼接： 在循环中进行字符串拼接（比如
s = s + "new_part"
"".join(list_of_parts)
虽然
replace()
re.sub()
re.sub
4. 优化正则表达式本身： 一个设计糟糕的正则表达式可能会导致“回溯失控”（catastrophic backtracking），尤其是在处理长字符串时，这会导致性能急剧下降，甚至程序崩溃。
.
*
+
*?
+?
(?:...)
5. 分块处理大文件： 如果你的“大规模”指的是处理非常大的文件，那么不要一次性将整个文件读入内存。而应该逐行或分块读取文件，然后对每一行或每一块进行查找替换。这样可以大大减少内存占用，提高程序的健壮性。
# 示例：逐行处理文件
def process_large_file(input_filepath, output_filepath, pattern, replacement):
compiled_pattern = re.compile(pattern)
with open(input_filepath, 'r', encoding='utf-8') as infile, \
open(output_filepath, 'w', encoding='utf-8') as outfile:
for line in infile:
new_line = compiled_pattern.sub(replacement, line)
outfile.write(new_line)
# process_large_file('input.txt', 'output.txt', r'old_word', 'new_word')这些建议能帮助你在处理Python字符串查找替换时，不仅功能实现，还能兼顾性能，写出更健壮、更高效的代码。
以上就是python中怎么查找和替换字符串中的内容？的详细内容，更多请关注php中文网其它相关文章！
python怎么学习？python怎么入门？python在哪学？python怎么学才快？不用担心，这里为大家提供了python速学教程(入门到精通)，有需要的小伙伴保存下载就能学习啦！
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
326
收藏
