共计 6408 个字符，预计需要花费 17 分钟才能阅读完成。
上周帮同事 review 代码时，发现不少同学在处理字符串时还在用比较“原始”的方式，比如 + 号拼接，或者使用老旧的 % 格式化语法。特别是一些需要频繁拼接动态内容的场景，代码写起来不仅啰嗦，可读性也差，还容易埋下性能隐患。作为一名摸爬滚打十年的老兵，我深知这种细节对项目维护和效率的影响。今天，咱们就来系统地聊聊 Python 字符串格式化的“进化史”，从古老的 % 到现在主流的 f-string，并通过实战对比，看看它们各自的优缺点，帮助大家在不同场景下做出最优选择，让你的代码更优雅、更高效！
一、回顾经典：% 格式化——时代的眼泪？
如果你是 Python 老鸟，或者接触过 C/C++ 等语言，对 % 这种格式化方式一定不陌生。它是 Python 语言早期（直到 Python 2.x 时代都是主流）就支持的一种字符串格式化方法，语法上与 C 语言的 printf 家族非常相似。
实操步骤 1：基础用法
name = "Alice"
age = 30
salary = 98765.4321
# 使用 %s 格式化字符串，%d 格式化整数
message_percent = "Hello, %s! You are %d years old." % (name, age)
print(message_percent)
# 输出: Hello, Alice! You are 30 years old.
# 格式化浮点数，%.2f 表示保留两位小数
price = 19.998
formatted_price = "The price is $%.2f." % price
print(formatted_price)
# 输出: The price is $20.00. (这里会四舍五入)
# 提醒下：当你需要格式化的参数只有一个时，可以直接放变量，不用元组。# 但为了代码一致性，我个人习惯即使只有一个参数也用元组，减少出错概率。item = "Laptop"
single_param_example = "You chose %s." % item
print(single_param_example)小提醒：% 格式化的常见痛点
% 格式化在处理多个或不同类型的参数时，很容易因为类型不匹配（比如把字符串当成整数格式化）或者参数顺序错乱导致运行时错误。当年刚学 Python 时，我可没少在这上面踩坑，特别是调试那些长长的字符串模板，一个个 %s、%d 对应过去简直是噩梦。它要求你严格按照占位符的顺序和类型提供参数，灵活性较差。
二、步入现代：.format() 方法——更灵活的中间站
随着 Python 2.6 的发布，字符串的 .format() 方法横空出世，极大地改善了格式化字符串的体验。它提供了更强的灵活性和可读性，允许你通过位置、命名或者混合方式来传递参数。
实操步骤 1：位置参数格式化
这是最简单的用法，{} 作为占位符，按照 .format() 方法中参数的顺序进行填充。
name = "Bob"
age = 25
message_format_pos = "Hello, {}! You are {} years old.".format(name, age)
print(message_format_pos)
# 输出: Hello, Bob! You are 25 years old.
# 小提醒：可以指定索引来改变顺序，但如果参数很多，这种方式会显得比较笨重。message_format_index = "Hello, {1}! You are {0} years old.".format(age, name)
print(message_format_index)
# 输出: Hello, Bob! You are 25 years old.实操步骤 2：命名参数格式化
这是 .format() 方法的亮点之一，你可以给占位符起名字，然后在 .format() 方法中以关键字参数的形式传递值，这极大地提高了代码的可读性和维护性。
city = "Beijing"
weather = "Sunny"
temperature = 28.5
# 使用命名参数，可读性更好
message_format_named = "Today in {city}, the weather is {weather} with a temperature of {temp:.1f}°C.".format(city=city, weather=weather, temp=temperature)
print(message_format_named)
# 输出: Today in Beijing, the weather is Sunny with a temperature of 28.5°C.
# 提醒下：如果你有很多参数，并且这些参数本身就是字典里的键值对，# 可以直接使用字典解包（**kwargs）的方式传递，非常优雅。person_info = {"name": "Charlie", "age": 40}
message_from_dict = "My name is {name} and I am {age} years old.".format(**person_info)
print(message_from_dict)
# 输出: My name is Charlie and I am 40 years old.小提醒：.format() 的优点
.format() 方法通过 {} 占位符及其内部的灵活语法，解决了 % 格式化在可读性和参数传递上的痛点。特别是命名参数和字典解包，让处理复杂数据结构时的字符串格式化变得非常清晰。在 f-string 出现之前，它一直是我的首选。
三、性能与优雅的巅峰：f-string——Python 3.6+ 的杀手锏
如果你正在使用 Python 3.6 或更高版本，那么恭喜你，f-string (格式化字符串字面值，Formatted String Literals) 绝对是你最应该掌握和使用的字符串格式化方式。它以 f 或 F 作为字符串前缀，允许你在字符串字面值内嵌入表达式，极大地简化了语法，并且在性能上也表现出色。
实操步骤 1：基础用法
直接在字符串中嵌入变量或表达式，Python 会自动替换它们。
product = "Smartphone"
price = 699.99
discount = 0.15
final_price = price * (1 - discount)
# f-string 直接嵌入变量，简洁明了
message_fstring_simple = f"You bought a {product} for ${price:.2f}."
print(message_fstring_simple)
# 输出: You bought a Smartphone for $700.00. (这里四舍五入)
# 嵌入表达式：可以在花括号内直接进行计算
message_fstring_expr = f"After a {discount:.0%} discount, the final price is ${final_price:.2f}."
print(message_fstring_expr)
# 输出: After a 15% discount, the final price is $594.99.
# 小提醒：f-string 还可以方便地用于调试！在变量名后加上 `= `，# 它会自动打印出变量名和它的值，省去了手动写 print(f"{var=}") 的麻烦。debug_variable = "test_value"
print(f"{debug_variable=}")
# 输出: debug_variable='test_value' (这个特性在 Python 3.8+ 才支持哦！)实操步骤 2：高级用法
f-string 不仅可以嵌入变量和表达式，还能调用函数、访问对象属性等等，几乎所有能在代码中运行的表达式都可以在 f-string 中使用。
class User:
def __init__(self, name, email):
self.name = name
self.email = email
def get_greeting(self):
return f"Hello, {self.name}!"
my_user = User("David", "[email protected]")
# 嵌入对象方法调用
user_greeting = f"{my_user.get_greeting()} Your email is {my_user.email}."
print(user_greeting)
# 输出: Hello, David! Your email is [email protected].
# 结合列表推导式或字典推导式 (虽然通常不推荐在 f-string 内做太复杂的逻辑，但功能上是支持的)
items = ["apple", "banana", "cherry"]
listed_items = f"Your items: {', '.join(item.capitalize() for item in items)}."
print(listed_items)
# 输出: Your items: Apple, Banana, Cherry.
# 提醒下：虽然 f-string 很强大，但别在里面写太复杂的逻辑，容易降低可读性。# 复杂计算最好先在外面完成，再把结果放到 f-string 里。小提醒：f-string 的优势
f-string 最大的优点是简洁、直观，并且由于是在解析时直接编译成字符串操作，性能也非常好。它使得格式化字符串的代码看起来就像普通的字符串，大大提升了开发效率和可读性。我个人在所有新项目中都会优先使用 f-string，除非有兼容旧 Python 版本的特殊要求。
四、实战对比：性能究竟谁更胜一筹？
光说不练假把式，我们用 timeit 模块来实际测试一下这三种方法的性能差异。在处理大量字符串格式化任务时，性能优势会更加明显。
实操步骤 1：定义测试函数
我们将分别定义三个函数，每个函数使用一种格式化方法来生成相同内容的字符串。
import timeit
def format_with_percent(name, age):
return "Hello, %s! You are %d years old." % (name, age)
def format_with_format_method(name, age):
return "Hello, {}! You are {} years old.".format(name, age)
def format_with_fstring(name, age):
return f"Hello, {name}! You are {age} years old."
# 准备测试数据
test_name = "Pythonista"
test_age = 10
number_of_runs = 1000000 # 进行一百万次操作，放大差异
print(f"进行 {number_of_runs} 次字符串格式化操作性能测试：")实操步骤 2：运行性能测试并分析
# 测试 % 格式化
time_percent = timeit.timeit(lambda: format_with_percent(test_name, test_age),
number=number_of_runs
)
print(f"百分号 (%) 格式化耗时: {time_percent:.4f} 秒")
# 测试 .format() 方法
time_format = timeit.timeit(lambda: format_with_format_method(test_name, test_age),
number=number_of_runs
)
print(f".format() 方法耗时: {time_format:.4f} 秒")
# 测试 f-string
time_fstring = timeit.timeit(lambda: format_with_fstring(test_name, test_age),
number=number_of_runs
)
print(f"f-string 格式化耗时: {time_fstring:.4f} 秒")
# 简单分析
# 亲测有效：通常 f-string 会是最快的，其次是 .format()，% 格式化最慢。# 这主要是因为 f-string 在编译阶段就完成了大部分工作，而 .format() 和 % 需要在运行时解析。小提醒：性能测试结果解读
在我本地的测试环境中，f-string 的性能优势通常非常明显，尤其是在字符串格式化操作非常频繁的场景下（比如日志记录、大量数据导出等），这一点点时间差异累计起来就非常可观。format() 方法也比 % 格式化快不少。所以在追求极致性能时，f-string 绝对是你的首选。当然，对于大多数不那么性能敏感的应用，这三种方法在可读性和维护性上的考量可能更重要。
五、常见误区与避坑指南
作为踩过无数坑的老兵，我给大家总结几个字符串格式化时常犯的错误，希望能帮助大家避开雷区：
-
混用格式化语法： 比如在一个字符串中，既想用
f-string又想用format()或者%。这会导致语法错误或逻辑混乱。我刚开始学f-string时，就犯过类似错误，想当然地在一个f-string里又写了{}，结果发现它不再是f-string的占位符了。记住，选定一种方法就坚持用它！# 错误示例：混淆了 f-string 和 .format() 的用法 # name = "Grace" # age = 22 # print(f"Hello, {name}! Your age is {}.format(age)") # 会报错或输出非预期结果 # 正确做法：只用一种 # print(f"Hello, {name}! Your age is {age}.") # print("Hello, {}! Your age is {}.".format(name, age)) -
在循环中重复构建复杂字符串： 这是个经典的性能陷阱。很多人在处理列表或字典时，会习惯性地在循环内部频繁地进行字符串拼接或格式化操作。如果循环次数非常大，这会产生大量的中间字符串对象，导致内存开销和性能下降。
# 错误示例：在循环中频繁拼接，效率低 data = ["item1", "item2", "item3"] * 1000 # 假设有大量数据 long_string_bad = "" # 我以前为了图方便，经常这样写，直到有一天 profiler 告诉我这里是性能瓶颈 for item in data: long_string_bad += f"Processing {item}...n" # 推荐做法：使用列表存储片段，最后用 `join` 连接 string_parts = [] for item in data: string_parts.append(f"Processing {item}...n") long_string_good = "".join(string_parts) # 这样能极大减少中间字符串对象的创建，提升效率 -
对复杂对象直接打印而非格式化： 有时我们想打印一个自定义对象，却忘记重写它的
__str__或__repr__方法，结果直接在格式化字符串中嵌入对象，得到的是类似于<__main__.MyObject object at 0x...>的默认输出。class MyData: def __init__(self, value): self.value = value # 错误示例：没有定义 __str__ 或 __repr__ # def __str__(self): # return f"MyData(value={self.value})" # 定义后 f -string 才能正确调用 obj = MyData(123) print(f"The object is: {obj}") # 默认输出很难看懂 # 输出：The object is: <__main__.MyData object at 0x...> # 提醒下：记得为你的自定义类定义 __str__ 方法，# 这样在使用 print() 或 f-string 时才能得到友好的输出。
总结
在 Python 的字符串格式化工具箱里，f-string 无疑是当前最优雅、最强大且性能最优的选择，强烈建议大家在 Python 3.6+ 的项目中优先使用它。
你平时最常用哪种格式化方式？有什么独门技巧吗？欢迎在评论区分享！
