Python 中的三种字符串格式化方式：% 格式化字符、str.format方法、f-string函数

Python 中的三种字符串格式化方式：% 格式化字符、str.format() 方法 和 f-string（f 函数）

Python 提供了三种常用的字符串格式化方式，每种方式都有其特点、优点和适用场景。

以下是这三种方式的比较和说明：

1. 格式化字符（% 格式化）

% 格式化：适用于简单格式化，尤其是兼容旧代码时使用。

1.1 优缺点，使用场景

优点：

• 简单直接：语法简单，适用于简单的格式化需求。
• 历史遗留：这是最早的字符串格式化方式，Python 早期版本就已支持。

缺点：

• 不支持表达式：不能在 % 中进行计算或嵌入复杂的表达式。
• 易出错：如果格式标志和变量类型不匹配，容易发生错误。

不支持关键字参数：只能按位置传递参数，无法直接使用关键字。

适用场景：
用于简单的格式化和老旧代码的维护。

1.2 % 格式化字符详细说明

以下是常用的格式化字符的详细说明、用法以及对应场景：

格式字符	含义	用法示例	输出结果	使用场景
%c	单个字符	'%c' % 65	A	输出字符，适合处理字符和Unicode编码。
%s	字符串	'%s' % 'Hello'	Hello	输出字符串，适合字符串拼接与动态输出。
%d	有符号十进制整数	'%d' % -123	-123	输出整数，适合处理整数类型的数据。
%u	无符号十进制整数（已过时，与%d相同）	'%u' % 123	123	适用于旧代码兼容，但推荐使用%d。
%o	八进制整数	'%o' % 255	377	输出八进制数，适合文件权限、地址等场景。
%x	十六进制整数（小写字母）	'%x' % 255	ff	输出小写十六进制数，适合处理内存地址等数据。
%X	十六进制整数（大写字母）	'%X' % 255	FF	输出大写十六进制数，适合处理内存地址等数据。
%f	浮点数，默认保留6位小数	'%f' % 3.14159	3.141590	输出浮点数，适合小数精度控制与科学计算。
%e	科学计数法（小写e）	'%e' % 1234567.89	1.234568e+06	输出科学计数法，适合处理较大或较小的数值。
%E	科学计数法（大写E）	'%E' % 1234567.89	1.234568E+06	同上，仅字母为大写，适合科学报告的输出格式。
%g	自动选择%f或%e	'%g' % 0.000012345	1.2345e-05	根据数值大小自动选择最简洁的显示方式。
%G	自动选择%f或%E	'%G' % 123456789.0	1.23457E+08	同上，适合更简洁和更高端的格式化需求。

---

1.3 什么是宽度？

宽度是指输出内容占用的字符数（包括空格、符号等），主要用于对齐输出结果。宽度不足时，默认用空格填充，特殊情况下可以指定用 0 或其他字符填充。

示例：

print("%5d" % 12)   # 宽度为5，右对齐，输出: "   12" (前面填充3个空格)
print("%-5d" % 12)  # 宽度为5，左对齐，输出: "12   " (后面填充3个空格)
print("%05d" % 12)  # 宽度为5，右对齐，前面用0填充，输出: "00012"

1.4 格式化字符语法

# 格式化输出：按照我们自己想要输出的格式，先定义一个板，照着板输出
# 格式化输出思路：首先定义模板，然后照着模板把变量填进去
# 格式化输出语法： print(模板 %变量名)

1.5 格式化字符（% 格式化）示例代码

# 1. %c：输出单个字符
# 用法：可以传入字符或对应的 ASCII/Unicode 编码。
# 场景：适用于字符的显示，支持 Unicode 字符。
print("%c" % 65)  # 输出: A (ASCII码为65)
print("%c" % 0x4F60)  # 输出: 你 (Unicode编码为0x4F60)
print("--------------------------------------------------------------------------------------------------------------")

# 2. %s：输出字符串
# 用法：动态输出字符串，可配合宽度（宽度不足时，默认用空格填充）、对齐使用。
# 场景：适用于字符串拼接和格式化输出。
print("%10s" % "Hello")  # 输出:      Hello (宽度10，右对齐)
print("%-10s" % "World")  # 输出: World      (宽度10，左对齐)
print("--------------------------------------------------------------------------------------------------------------")

# 3. %d：输出带符号的十进制整数
# 用法：支持正负数，可指定宽度和填充方式。
# 场景：适用于整数类型的格式化输出，如统计数据。
print("%5d" % 42)  # 输出:    42 (宽度5，右对齐)
print("%-5d" % 42)  # 输出: 42   (宽度5，左对齐)
print("%05d" % 42)  # 输出: 00042 (宽度5，前面补0)
print("--------------------------------------------------------------------------------------------------------------")

# 4. %o：输出八进制整数
# 用法：将整数转换为八进制表示。
# 场景：适用于权限值、位运算等相关场景。
print("%o" % 255)  # 输出: 377 (255的八进制表示)
print("%06o" % 255)  # 输出: 000377 (宽度6，前面补0)
print("--------------------------------------------------------------------------------------------------------------")

# 5. %x 和 %X：输出十六进制整数
# 用法：小写字母用%x，大写字母用%X。
# 场景：适用于内存地址、颜色编码等。
print("%x" % 255)  # 输出: ff (小写十六进制)
print("%X" % 255)  # 输出: FF (大写十六进制)
print("%04x" % 255)  # 输出: 00ff (宽度4，前面补0)
print("--------------------------------------------------------------------------------------------------------------")

# 6. %f：输出浮点数
# 用法：默认保留6位小数，可指定精度和宽度。
# 场景：适用于小数点精度控制与科学计算。
print("%f" % 3.14159)  # 输出: 3.141590 (默认6位小数)
print("%.2f" % 3.14159)  # 输出: 3.14 (保留2位小数)
print("%10.3f" % 3.14159)  # 输出:      3.142 (宽度10，保留3位小数)
print("--------------------------------------------------------------------------------------------------------------")

# 7. %e 和 %E：输出科学计数法
# 用法：%e使用小写e，%E使用大写E。
# 场景：适用于较大或较小的数值表示。
print("%e" % 1234567.89)  # 输出: 1.234568e+06
print("%E" % 1234567.89)  # 输出: 1.234568E+06
print("%.3e" % 0.0000123)  # 输出: 1.230e-05 (保留3位小数)
print("--------------------------------------------------------------------------------------------------------------")

# 8. %g 和 %G：自动选择最简洁的格式
# 用法：%g会在%f和%e之间选择，%G会在%f和%E之间选择。
# 场景：适用于需要简洁表示数值的情况。
print("%g" % 0.000012345)  # 输出: 1.2345e-05 (小数形式太长时用科学计数法)
print("%g" % 123456.78)  # 输出: 123457 (自动去掉多余的零)
print("%.3g" % 123456.78)  # 输出: 1.23e+05 (保留3位有效数字)
print("--------------------------------------------------------------------------------------------------------------")

2. str.format方法

在 Python 中，format 是一个强大的字符串格式化工具，它提供了比传统的 % 格式化方法更灵活和可读的方式来处理字符串插值。format 可以对字符串中的占位符进行动态替换，支持位置参数、关键字参数以及格式化控制等功能。

2.1 优缺点，使用场景

优点：

• 更灵活：可以按位置或关键字参数传递格式化的值。
• 支持表达式：可以在 {} 中嵌入表达式计算。
• 更清晰：格式化语法比 % 更加清晰，并且支持多次引用同一个变量。

缺点：

• 略显冗长：虽然比 % 更灵活，但仍然比 f-string 少了一些简洁性。
• 性能较差：相较于 f-string，str.format() 在性能上稍逊一筹，尤其是在高频格式化的场景下。

适用场景：
当需要格式化多个变量，或者需要用关键字来标识位置时。

2.2 str.format 语法

"模板字符串".format(参数1, 参数2, ...)

占位符使用 {}，其中的内容可以是参数的索引、命名、格式化标志等。

2.3 str.format 示例代码

# 定义一些变量用于演示
name = "Bob"  # 姓名
age = 25      # 年龄
height = 1.75  # 身高

# 1. 使用位置参数，格式化字符串
# 使用 `{0}`, `{1}`, `{2}` 来标识位置参数的顺序，替换成对应的变量
print("My name is {0}, I am {1} years old and {0} is {2} meters tall.".format(name, age, height))
# 输出：My name is Bob, I am 25 years old and Bob is 1.75 meters tall.
print("--------------------------------------------------------------------------------------------------------------")

# 2. 使用关键字参数，格式化字符串
# 使用 `{name}`, `{age}`, `{height}` 来直接使用关键字参数，替换对应的值
print("My name is {name}, I am {age} years old and {name} is {height} meters tall.".format(name="Bob", age=25, height=1.75))
# 输出：My name is Bob, I am 25 years old and Bob is 1.75 meters tall.
print("--------------------------------------------------------------------------------------------------------------")

# 3. 使用字典解包，格式化字符串
# 使用 `**` 解包字典并传递给 `format` 函数，字典中的键值对应于占位符的名字
person_info = {'name': 'Alice', 'age': 30, 'height': 1.68}
print("My name is {name}, I am {age} years old and my height is {height} meters.".format(**person_info))
# 输出：My name is Alice, I am 30 years old and my height is 1.68 meters.
print("--------------------------------------------------------------------------------------------------------------")

# 4. 格式化数字
# 使用 `:.3f` 表示将数字格式化为浮动小数点类型，并保留三位小数
pi = 3.14159265358979
print("The value of pi to 3 decimal places is {:.3f}".format(pi))
# 输出：The value of pi to 3 decimal places is 3.142
print("--------------------------------------------------------------------------------------------------------------")

# 5. 对齐和填充
# `:<10`：左对齐，占10个字符宽度，不足部分用空格填充
# `:>10`：右对齐，占10个字符宽度，不足部分用空格填充
# `:^10`：居中对齐，占10个字符宽度，不足部分用空格填充
# `:0>10`：右对齐，占10个字符宽度，不足部分用零填充
text = "Python"
print("{:<10}".format(text))  # 左对齐
print("{:>10}".format(text))  # 右对齐
print("{:^10}".format(text))  # 居中对齐
print("{:0>10}".format(text))  # 使用 0 填充，右对齐
# 输出：
# Python
#     Python
#   Python
# 000000Python
print("--------------------------------------------------------------------------------------------------------------")

# 6. 对数字进行补充和格式化
# 对数值进行千位分隔符的格式化
num = 1234567.89
print("Formatted number: {:,}".format(num))
# 输出：Formatted number: 1,234,567.89
print("--------------------------------------------------------------------------------------------------------------")

# 7. 使用浮动精度格式化
# 控制浮动小数的精度显示
number = 123.45678
print("Formatted float: {:.2f}".format(number))  # 显示两位小数
# 输出：Formatted float: 123.46
print("--------------------------------------------------------------------------------------------------------------")

# 8. 使用宽度和填充
# 填充字符串并指定最小宽度
print("{:>10}".format("hello"))  # 右对齐，宽度为10
print("{:<10}".format("world"))  # 左对齐，宽度为10
# 输出：
#      hello
# world
print("--------------------------------------------------------------------------------------------------------------")

# 9. 使用多个格式化参数
# 在同一个字符串中使用多个占位符来显示不同的内容
print("Name: {0}, Age: {1}, Height: {2:.2f}".format(name, age, height))
# 输出：Name: Bob, Age: 25, Height: 1.75
print("--------------------------------------------------------------------------------------------------------------")

3. f-string（f 函数）

在 Python 中，f 函数是指 f-string（格式化字符串字面量），用于简化字符串格式化的过程。通过 f-string，您可以将变量或表达式直接嵌入到字符串中。它在 Python 3.6 引入，并成为了推荐的字符串格式化方法。

3.1 优缺点，使用场景

优点：

• 最简洁：语法最简洁，直接在字符串中嵌入变量或表达式。
• 高效：相较于 % 和 str.format()，f-string 在性能上通常是最好的，特别是在大规模数据格式化时。
• 支持表达式：可以嵌入任意 Python 表达式（如计算、函数调用等）。
• 代码可读性高：格式化语法更直观，易于理解和维护。

缺点：

• 仅支持 Python 3.6 及以上：f-string 是在 Python 3.6 引入的，因此不兼容低版本的 Python。
• 只能用于字符串：f-string 只能用来格式化字符串，不能直接用于其他类型。

适用场景：
Python 3.6 及以上版本，尤其适用于需要频繁进行字符串格式化的场景。

3.2 f-string 语法

f"字符串 {表达式}"

• f：表示这是一个格式化字符串。
• {}：内部的部分可以是任何合法的 Python 表达式（包括变量、函数调用、算术运算等）。

使用场景

1. 嵌入变量值：直接将变量插入到字符串中。
2. 表达式计算：不仅可以嵌入变量，还可以在 {} 中进行表达式计算。
3. 格式化输出：可以使用 f-string 来进行数值、日期等的格式化输出。

优势
简洁性：比传统的 % 格式化或 .format() 更直观简洁。
高效性：f-string 的性能比其他格式化方法好，尤其是在处理大量数据时。

3.3 f-string 示例代码

# 定义一些变量用于演示
name = "Alice"  # 姓名
age = 30  # 年龄
height = 1.75  # 身高

# 简单变量嵌入
greeting = f"Hello, my name is {name} and I am {age} years old."
print(greeting)  # Hello, my name is Alice and I am 30 years old.
print("--------------------------------------------------------------------------------------------------------------")

# 表达式计算
area = f"The area of a circle with radius {height} is {3.14 * height ** 2:.2f}."
print(area)  # The area of a circle with radius 1.75 is 9.62.
print("--------------------------------------------------------------------------------------------------------------")

# 使用字典中的值
person = {'name': 'Bob', 'age': 25}
info = f"{person['name']} is {person['age']} years old."
print(info)  # Bob is 25 years old.
print("--------------------------------------------------------------------------------------------------------------")

# 日期格式化
from datetime import datetime

now = datetime.now()
formatted_date = f"Today's date is {now:%Y-%m-%d %H:%M:%S}."
print(formatted_date)  # Today's date is 2025-01-07 14:30:45.
print("--------------------------------------------------------------------------------------------------------------")

总结

特性	%格式化	str.format()	f-string(f 函数)
简洁性	较简洁，但不直观	相对冗长，尤其是格式较复杂时	最简洁，直观易读
灵活性	较低，仅支持位置传参	高，支持位置和关键字传参	高，支持表达式及计算
性能	较差	比f-string 差，尤其是频繁格式化时	最优，特别是频繁格式化时
可读性	较差，易出错	较好，尤其是复杂格式化时	极佳，简洁明了，易于维护
支持表达式	不支持	支持	支持
Python版本支持	所有版本	所有版本	Python3.6及以上
使用场景	简单格式化需求，兼容旧版本	多变量格式化，关键字传参时	高效、简洁的格式化需求

结论：

• % 格式化：适用于简单格式化，尤其是兼容旧代码时使用。
• str.format()：适用于复杂格式化，尤其需要位置或关键字传递参数时。
• f-string：推荐用于 Python 3.6 及以上版本，尤其在需要高效、简洁的字符串格式化时使用