【Python-Day 5】Python 格式化输出实战：%、format()、f-string 对比与最佳实践

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！
07-【深度解析】从GPT-1到GPT-4：ChatGPT背后的核心原理全揭秘

PyTorch系列文章目录

机器学习系列文章目录

Python系列文章目录

01-【Python-Day 1】告别编程恐惧：轻松掌握 Python 安装与第一个程序的 6 个步骤
02-【Python-Day 2】掌握Python基石：变量、内存、标识符及int/float/bool数据类型
03-【Python-Day 3】玩转文本：字符串(String)基础操作详解 (上)
04-【Python-Day 4】玩转文本：Python 字符串常用方法深度解析 (下篇)
05-【Python-Day 5】Python 格式化输出实战：%、format()、f-string 对比与最佳实践

---

---

前言

大家好，欢迎来到 Python 学习之旅的第五天！在前几天的学习中，我们掌握了 Python 的基础语法、变量、数据类型以及强大的字符串操作。然而，仅仅能够处理和操作字符串是不够的，如何将这些数据以清晰、美观、专业的方式展示出来，同样至关重要。想象一下，如果你需要打印一份报告、生成一段日志或者向用户显示一条信息，杂乱无章的输出会大大降低可读性。本篇文章将聚焦于 Python 中的字符串格式化技术，教你如何优雅地控制输出格式，让你的打印内容焕然一新！我们将从经典的 % 格式化讲起，逐步过渡到功能更强大的 str.format() 方法，最后重点介绍 Python 3.6+ 版本中备受推崇的 f-string。同时，我们还会深入探讨常用的格式控制符，如对齐、精度和类型转换，助你彻底掌握格式化输出的精髓。

一、为什么需要格式化输出？

在正式学习格式化方法之前，我们先来思考一个问题：为什么 Python 内置了 print() 函数还不够，我们还需要专门学习字符串格式化呢？

1.1 简单打印的局限性

使用基本的 print() 函数和字符串拼接（+）虽然也能组合输出，但在处理多个变量或不同数据类型时，代码会显得非常冗长和混乱，而且容易出错。

示例：

name = "Alice"
age = 30
city = "New York"

# 使用 + 拼接，需要手动转换非字符串类型
print("User Info: Name: " + name + ", Age: " + str(age) + ", City: " + city)

# 输出: User Info: Name: Alice, Age: 30, City: New York

# 如果变量很多，拼接会变得非常复杂且难以阅读
score = 95.5
is_active = True
print("Detail: " + name + " scored " + str(score) + " and is currently " + ("active" if is_active else "inactive") + ".")

# 输出: Detail: Alice scored 95.5 and is currently active.

从上面的例子可以看出，简单的拼接不仅代码可读性差，还需要频繁使用 str() 进行类型转换，非常不便。

1.2 格式化输出的优势

字符串格式化提供了一种更优雅、更强大、更易读的方式来构建包含变量的字符串。其主要优势包括：

1. 提高可读性: 将模板字符串与要插入的值分开，结构更清晰。
2. 简化类型转换: 大多数格式化方法会自动处理不同数据类型的转换。
3. 精确控制格式: 可以轻松控制数字的精度、文本的对齐方式、填充字符等。
4. 代码更简洁: 相较于繁琐的拼接，格式化通常需要更少的代码。
5. 易于维护: 当需要修改输出格式或变量时，格式化字符串更容易调整。

接下来，我们将详细介绍 Python 中三种主要的字符串格式化方法。

二、Python 字符串格式化方法概览

Python 提供了多种方式来进行字符串格式化，主要有以下三种：

1. 旧式 % 格式化: 源自 C 语言的 printf 风格，历史悠久。
2. str.format() 方法: Python 2.6 引入，功能更强大、更灵活。
3. f-string (格式化字符串字面值): Python 3.6 引入，目前最推荐的方式，简洁高效。

2.1 历史的足迹：旧式 % 格式化

这种方式使用 % 操作符连接一个模板字符串和一个或多个值（通常放在元组或字典中）。模板字符串中使用 % 加上特定的转换说明符（如 %s 表示字符串，%d 表示整数，%f 表示浮点数）作为占位符。

2.1.1 基本语法与示例

语法: template_string % values

示例:

name = "Bob"
age = 25
height = 1.75

# 使用元组传递值
formatted_string_tuple = "Name: %s, Age: %d, Height: %.2f meters" % (name, age, height)
print(formatted_string_tuple)
# 输出: Name: Bob, Age: 25, Height: 1.75 meters

# 使用字典传递值 (通过名称引用)
user_data = {"user_name": "Charlie", "user_age": 40}
formatted_string_dict = "User: %(user_name)s, Age: %(user_age)d" % user_data
print(formatted_string_dict)
# 输出: User: Charlie, Age: 40

2.1.2 常用转换说明符

说明符	转换	示例
%s	字符串 (或任何对象，会调用 str())	'Hello'
%d	十进制整数	123
%f	浮点数 (默认保留 6 位小数)	3.141593
%.nf	浮点数 (保留 n 位小数)	%.2f -> 3.14
%e	科学计数法 (小写 ‘e’)	3.14e+00
%E	科学计数法 (大写 ‘E’)	3.14E+00
%g	根据值自动选择 %f 或 %e
%G	根据值自动选择 %f 或 %E
%%	输出一个 % 字符	%

2.1.3 优点与缺点

• 优点: 语法相对简单，对于源自 C/C++ 背景的开发者比较熟悉。
• 缺点:
  • 可读性较差，尤其是当占位符和变量数量较多时，对应关系不直观。
  • 类型匹配需要严格，若类型不符（如用 %d 格式化字符串）会直接报错 TypeError。
  • 功能相对有限，不如后续方法灵活。

由于这些缺点，不推荐在新的 Python 代码中使用 % 格式化，但了解它有助于阅读旧代码。

2.2 承前启后：str.format() 方法

为了克服 % 格式化的不足，Python 2.6 引入了 str.format() 方法。它使用花括号 {} 作为占位符，并通过 format() 方法传入要替换的值。

2.2.1 基本语法与示例

语法: template_string.format(value1, value2, ...) 或 template_string.format(key1=value1, key2=value2, ...)

示例:

name = "David"
age = 35
pi = 3.1415926

# 按位置顺序填充
formatted_pos = "Name: {}, Age: {}, Pi: {}".format(name, age, pi)
print(formatted_pos)
# 输出: Name: David, Age: 35, Pi: 3.1415926

# 按索引填充 (可以改变顺序或重复使用)
formatted_idx = "Age: {1}, Name: {0}, Age again: {1}".format(name, age)
print(formatted_idx)
# 输出: Age: 35, Name: David, Age again: 35

# 按关键字填充 (更易读)
formatted_kw = "User {username} is {userage} years old.".format(username="Eve", userage=28)
print(formatted_kw)
# 输出: User Eve is 28 years old.

# 混合使用 (位置参数必须在前)
formatted_mix = "Name: {}, Age: {age}".format(name, age=age)
print(formatted_mix)
# 输出: Name: David, Age: 35

# 访问对象的属性或字典的键
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
p = Point(10, 20)
data = {"city": "London", "country": "UK"}

formatted_attr = "Point coordinates: ({p.x}, {p.y})".format(p=p)
print(formatted_attr)
# 输出: Point coordinates: (10, 20)

formatted_dict_key = "Location: {d[city]}, {d[country]}".format(d=data)
print(formatted_dict_key)
# 输出: Location: London, UK

2.2.2 格式规范迷你语言

str.format() 的强大之处在于花括号 {} 内部可以包含格式规范迷你语言 (Format Specification Mini-Language)，用来精确控制输出格式。基本语法是 {:[[fill]align][sign][#][0][width][,][.precision][type]}。我们将在第三部分详细讲解常用的控制符。

简单示例:

pi = 3.1415926

# 控制小数位数
formatted_precision = "Pi approximation: {:.2f}".format(pi)
print(formatted_precision)
# 输出: Pi approximation: 3.14

# 控制宽度和对齐
name = "Alice"
formatted_align = "Name: {:>10}".format(name) # 右对齐，总宽度10
print(formatted_align)
# 输出: Name:      Alice

2.2.3 优点与缺点

• 优点:
  • 比 % 格式化更易读，特别是使用关键字参数时。
  • 功能更强大，支持更复杂的格式控制。
  • 更灵活，可以通过索引、名称、属性、字典键等方式引用变量。
• 缺点:
  • 语法相对于 f-string 来说还是有些冗长。

str.format() 是一个功能完备且兼容性好的选择（兼容 Python 2.6+ 和 3.x）。

2.3 现代之选：f-string (Python 3.6+)

f-string（格式化字符串字面值）是 Python 3.6 引入的新特性，旨在提供一种更简洁、更直观、性能也通常更好的字符串格式化方式。

2.3.1 语法简洁性与直观性

f-string 的语法非常简单：在字符串字面量前面加上字母 f 或 F，然后在花括号 {} 内直接写入变量名或表达式。

语法: f"text {variable} text {expression} text"

2.3.2 基本用法与示例

name = "Frank"
age = 42
pi = 3.1415926

formatted_fstring = f"User {name} is {age} years old. Pi is approximately {pi}."
print(formatted_fstring)
# 输出: User Frank is 42 years old. Pi is approximately 3.1415926.

可以看到，代码非常简洁，变量直接嵌入字符串中，可读性极高。

2.3.3 f-string 内嵌表达式

f-string 的花括号内不仅可以放变量，还可以放任何有效的 Python 表达式。

x = 10
y = 5

formatted_expr = f"Sum: {x + y}, Product: {x * y}, Is x > y? {x > y}"
print(formatted_expr)
# 输出: Sum: 15, Product: 50, Is x > y? True

# 也可以调用函数
def greet(name):
    return f"Hello, {name.capitalize()}!"

formatted_func = f"{greet('grace')}"
print(formatted_func)
# 输出: Hello, Grace!

2.3.4 推荐使用的原因

• 简洁易读: 语法最接近自然语言，代码清晰。
• 性能优越: 通常比 str.format() 和 % 格式化更快，因为它们在编译时处理。
• 功能强大: 支持与 str.format() 相同的格式规范迷你语言。
• 方便调试: 如果花括号内的表达式出错，错误信息通常更直接。

强烈推荐在 Python 3.6 及以上版本中使用 f-string 进行字符串格式化。

三、常用格式控制详解

无论是 str.format() 还是 f-string，它们都支持一套强大的格式规范迷你语言 (Format Specification Mini-Language) 来控制输出的细节。格式规范位于花括号 {} 内，紧跟在变量名或表达式之后，并以冒号 : 分隔。

基本结构：:[[fill]align][sign][#][0][width][,][.precision][type]

我们重点关注其中最常用的几个部分：对齐、精度和类型。

3.1 对齐控制 (Alignment)

用于控制字符串在给定宽度内的对齐方式。需要配合 width（最小总宽度）使用。

对齐符	含义	示例 (width=10)
<	左对齐	f"{'text':<10}" -> text
>	右对齐	f"{'text':>10}" -> text
^	居中对齐	f"{'text':^10}" -> text

3.1.1 左对齐 (<)

name = "Leo"
width = 10

# 使用 format()
print("'{0:<{1}}'".format(name, width)) # '{0:<10}'.format(name)
# 使用 f-string
print(f"'{name:<{width}}'")            # f"'{name:<10}'"

# 输出:
# 'Leo       '
# 'Leo       '

3.1.2 右对齐 (>)

name = "Mia"
width = 10

# 使用 format()
print("'{0:>{1}}'".format(name, width))
# 使用 f-string
print(f"'{name:>{width}}'")

# 输出:
# '       Mia'
# '       Mia'

3.1.3 居中对齐 (^)

name = "Noah"
width = 10

# 使用 format()
print("'{0:^{1}}'".format(name, width))
# 使用 f-string
print(f"'{name:^{width}}'")

# 输出:
# '   Noah   '
# '   Noah   '

3.1.4 填充字符

可以在对齐符号前指定一个字符用于填充空白区域（默认为空格）。

name = "Zoe"
width = 10
fill_char = '*'

# 使用 format()
print("'{0:*^{1}}'".format(name, width)) # 居中对齐，用 * 填充
# 使用 f-string
print(f"'{name:*^{width}}'")            # 同上

# 输出:
# '***Zoe****'
# '***Zoe****'

# 右对齐，用 0 填充（常用于数字）
num = 123
print(f"{num:0>8}") # 注意，对于数字，0 有特殊含义（见下文），但这里放在 > 前，表示填充

# 输出: 00000123

注意: 如果指定了 0 作为格式说明符的一部分（如 08d），它表示用 0 填充 并且 应用于数字类型，此时它通常结合宽度使用，不需要显式指定对齐（默认右对齐）。如 f"{num:08d}" 效果同 f"{num:0>8d}"。

3.2 精度控制 (Precision)

主要用于控制浮点数的小数位数或字符串的最大显示宽度。用点号 . 后跟一个整数表示。

3.2.1 浮点数精度 (.nf)

指定浮点数输出时保留的小数位数 n。会进行四舍五入。

pi = 3.1415926535

# 使用 format()
print("Pi: {:.3f}".format(pi)) # 保留 3 位小数
# 使用 f-string
print(f"Pi: {pi:.3f}")         # 同上

# 输出:
# Pi: 3.142
# Pi: 3.142

# 结合宽度和对齐
print(f"'{pi:10.2f}'") # 总宽度 10，保留 2 位小数，默认右对齐
# 输出: '      3.14'

3.2.2 字符串最大宽度 (.ns)

指定字符串输出时的最大字符数 n。如果原字符串超过此长度，会被截断。

long_text = "This is a very long string."
max_width = 10

# 使用 format()
print("'{:.{}}'".format(long_text, max_width)) # '{:.10}'.format(long_text)
# 使用 f-string
print(f"'{long_text:.{max_width}}'")           # f"'{long_text:.10}'"

# 输出:
# 'This is a '
# 'This is a '

3.3 类型控制 (Type)

指定变量应被视为哪种类型进行格式化。

3.3.1 字符串 (s)

这是默认类型，通常可以省略。会将对象转换为字符串（调用 str()）。

name = "Olivia"
age = 22
print(f"Name: {name:s}, Age: {age:s}") # :s 可以省略
# 输出: Name: Olivia, Age: 22

3.3.2 整数 (d, b, o, x, X)

• d: 十进制整数 (Decimal) - 默认整数类型
• b: 二进制 (Binary)
• o: 八进制 (Octal)
• x: 十六进制 (Hexadecimal, 小写 a-f)
• X: 十六进制 (Hexadecimal, 大写 A-F)

num = 42

print(f"Decimal: {num:d}")     # Decimal: 42
print(f"Binary: {num:b}")      # Binary: 101010
print(f"Octal: {num:o}")       # Octal: 52
print(f"Hex (lower): {num:x}") # Hex (lower): 2a
print(f"Hex (upper): {num:X}") # Hex (upper): 2A

# 带 # 前缀，显示进制标识 (0b, 0o, 0x)
print(f"Binary with prefix: {num:#b}") # Binary with prefix: 0b101010
print(f"Hex with prefix: {num:#x}")    # Hex with prefix: 0x2a

3.3.3 浮点数 (f, e, E, g, G, %)

• f: 定点表示法 (Fixed-point notation)，默认 6 位小数。
• e: 科学计数法 (Exponent notation)，小写 ‘e’。
• E: 科学计数法 (Exponent notation)，大写 ‘E’。
• g: 通用格式 (General format)。对于给定精度 p >= 1，它会格式化数字为定点表示法（如果指数在 -4 到 p-1 之间），否则格式化为科学计数法。默认精度为 6。
• G: 通用格式 (General format)，类似 g，但在科学计数法时使用大写 ‘E’。
• %: 百分比格式。将数字乘以 100，然后使用 f 格式显示，并附加一个 % 号。

value = 12345.6789
ratio = 0.9876

print(f"Fixed point: {value:f}")       # Fixed point: 12345.678900
print(f"Fixed point (2 dec): {value:.2f}") # Fixed point (2 dec): 12345.68
print(f"Exponent (lower): {value:e}")    # Exponent (lower): 1.234568e+04
print(f"Exponent (upper): {value:E}")    # Exponent (upper): 1.234568E+04
print(f"General (default): {value:g}")   # General (default): 12345.7 (默认精度6)
print(f"General (precision 8): {value:.8g}") # General (precision 8): 12345.679
print(f"Percentage (1 dec): {ratio:.1%}")   # Percentage (1 dec): 98.8%

3.3.4 结合使用示例

我们可以将对齐、宽度、精度、类型等控制符组合使用。

item = "Apple"
price = 1.25
quantity = 10

# 目标：输出类似表格的一行
# | Item     | Price  | Quantity | Total    |
# | :------- | -----: | -------: | -------: |
# | Apple    |   1.25 |       10 |    12.50 |

header = f"| {'Item':<8} | {'Price':>6} | {'Quantity':>8} | {'Total':>8} |"
divider = "-" * len(header)
data_row = f"| {item:<8} | {price:>6.2f} | {quantity:>8d} | {price * quantity:>8.2f} |"

print(header)
print(divider)
print(data_row)

# 输出:
# | Item     |  Price | Quantity |    Total |
# ---------------------------------------------
# | Apple    |   1.25 |       10 |    12.50 |

四、场景应用与避坑指南

4.1 实际应用场景示例

字符串格式化在各种编程任务中都非常有用：

1. 生成报告: 创建格式整齐的文本报告，包含计算结果、统计数据等。
2. 日志记录: 输出带有时间戳、级别、模块名等信息的结构化日志。
3. 用户界面: 在命令行或图形界面中向用户显示格式化的信息、提示或错误。
4. 数据导出: 将数据格式化为特定格式（如 CSV、固定宽度文本）以便其他系统读取。
5. 构建 SQL 查询: (要特别注意 SQL 注入风险，通常使用参数化查询更安全，但有时需要动态构建部分查询结构)。

4.2 常见问题与陷阱

1. % 格式化类型不匹配: 使用 % 时，如果占位符类型与提供的变量类型不兼容（例如 %d 用于字符串），会抛出 TypeError。format() 和 f-string 通常更宽容，会尝试调用 __format__() 或 str()。
2. str.format() 占位符与参数数量/名称不匹配:
   • 使用位置参数时，提供的参数数量必须与占位符数量一致，否则 IndexError。
   • 使用关键字参数时，如果 format() 调用中缺少某个占位符所需的关键字，会抛出 KeyError。
3. f-string 版本兼容性: f-string 是 Python 3.6+ 的特性。在旧版本 Python 中使用会产生 SyntaxError。如果需要兼容旧版本，应使用 str.format()。
4. 花括号 {} 的转义: 如果想在格式化字符串中直接输出花括号本身，需要使用双花括号 {{ 和 }}。

   # 使用 format()
   print("This shows curly braces: {{}}".format()) # 输出: This shows curly braces: {}
   # 使用 f-string
   value = 42
   print(f"This includes a value {value} and literal braces {{}}")
   # 输出: This includes a value 42 and literal braces {}
   

5. f-string 内的反斜杠 \: 在 f-string 的表达式部分不能直接使用反斜杠 \ 进行换行或转义（除非是字符串字面量内部）。

   # 错误示例:
   # my_string = f"This is a long string \
   #               split across lines." # SyntaxError
   
   # 正确做法 (在表达式外拆分或使用括号):
   part1 = "This is a long string"
   part2 = "split across lines."
   my_string = f"{part1} {part2}"
   print(my_string)
   
   my_list = [1, 2, 3]
   # 在表达式中使用括号可以换行
   my_string_expr = f"List sum: {sum([
       x*2 for x in my_list
   ])}"
   print(my_string_expr)
   

4.3 选择哪种格式化方法？

• 首选 f-string (Python 3.6+): 如果你的项目环境允许，f-string 因其简洁、易读和高效性成为最佳选择。
• 备选 str.format(): 当需要兼容 Python 2.6-3.5 版本，或者在某些特定场景（如模板字符串来源不确定，需要延迟格式化）下，str.format() 是一个强大且可靠的选择。
• 避免 % 格式化 (新代码): 尽量不要在新的代码中使用 % 格式化，除非是在维护必须兼容非常古老 Python 版本的旧代码。

五、总结

今天我们深入学习了 Python 中让输出变得美观专业的关键技术——字符串格式化。核心要点回顾如下：

1. 格式化输出的必要性: 克服了简单 print() 和字符串拼接的局限性，提高了代码的可读性、简洁性和可维护性，并能精确控制输出样式。
2. 三种主要方法:
   • % 格式化: C printf 风格，语法简单但功能有限、可读性差，不推荐在新代码中使用。
   • str.format(): Python 2.6+ 引入，功能强大，支持位置/关键字参数、索引、属性访问，使用 {} 占位符和格式规范迷你语言，是兼容性好的选择。
   • f-string (格式化字符串字面值): Python 3.6+ 引入，在字符串前加 f，直接在 {} 内嵌入变量和表达式，语法最简洁、可读性最好、性能通常最优，是现代 Python 的首选。
3. f-string 的优势: 简洁直观、性能好、支持完整格式规范、易于调试。
4. 常用格式控制符: 掌握了 : 后面的格式规范迷你语言中的核心部分：
   • 对齐 (<, >, ^) 配合宽度和可选的填充字符。
   • 精度 (.n) 控制浮点数小数位数或字符串最大长度。
   • 类型 (d, s, f, e, g, %, b, o, x 等) 指定数据如何被解释和显示。
5. 选择建议: 优先使用 f-string，若需兼容旧版 Python 或有特殊需求则选用 str.format()，避免在新建项目中使用 % 格式化。

熟练掌握字符串格式化，不仅能让你的程序输出更加专业，也能在调试和展示数据时提供极大的便利。希望通过今天的学习，你能自信地运用这些技巧美化你的 Python 输出！下一篇，我们将学习 Python 中的运算符，敬请期待！

---