LabEx
登录免费加入

如何在 Python 打印中对齐输出

PythonBeginner
立即练习

简介

在编写 Python 程序时，以清晰、有条理的方式呈现输出对于代码可读性和用户体验都至关重要。无论你是在生成报告、显示表格数据，还是仅仅将信息打印到控制台，正确的文本对齐方式都会让你的输出更专业、更易读。

在这个实验中，你将学习在 Python 中对齐和格式化文本输出的各种技术。你将探索不同的对齐方法，练习格式化技巧，并创建结构良好的表格显示，这些技巧可应用于实际的应用程序中。

Python 中的基本字符串对齐

在第一步中，你将学习 Python 中文本对齐的基本概念，并实现基本的对齐技术。

什么是文本对齐？

文本对齐是指文本在给定空间内的位置方式。Python 提供了几种方法来控制文本在打印到控制台时的位置。主要有三种对齐方式：

  • 左对齐：文本从分配空间的左边缘开始。
  • 右对齐：文本在分配空间的右边缘结束。
  • 居中对齐：文本在分配空间内居中。

你的第一个对齐程序

让我们创建一个简单的 Python 脚本，来演示基本的对齐技术。

  1. 在你的 LabEx 环境中打开 WebIDE。

  2. 通过点击 WebIDE 中的“New File”图标，在 /home/labex/project 目录下创建一个名为 basic_alignment.py 的新文件。

  3. 在文件中添加以下代码：

## basic_alignment.py
print("Basic String Alignment Examples")
print("-" * 30)

## Left alignment example
print("Left alignment:")
print("Python".ljust(20) + "|")
print("Programming".ljust(20) + "|")
print("Alignment".ljust(20) + "|")
print()

## Right alignment example
print("Right alignment:")
print("Python".rjust(20) + "|")
print("Programming".rjust(20) + "|")
print("Alignment".rjust(20) + "|")
print()

## Center alignment example
print("Center alignment:")
print("Python".center(20) + "|")
print("Programming".center(20) + "|")
print("Alignment".center(20) + "|")

  1. 按 Ctrl+S 或从菜单中选择“File” > “Save”来保存文件。

  2. 如果 WebIDE 中的终端尚未打开，点击“Terminal”菜单并选择“New Terminal”来打开它。

  3. 使用 Python 解释器运行脚本：

cd ~/project
python3 basic_alignment.py
  1. 你应该会看到以下输出：
Basic String Alignment Examples
------------------------------
Left alignment:
Python              |
Programming         |
Alignment           |

Right alignment:
              Python|
         Programming|
           Alignment|

Center alignment:
       Python       |
     Programming    |
      Alignment     |

理解代码

你刚刚创建的脚本展示了 Python 中三种基本的字符串对齐方法：

  • ljust(width)：将字符串在指定宽度的字段内左对齐。
  • rjust(width)：将字符串在指定宽度的字段内右对齐。
  • center(width)：将字符串在指定宽度的字段内居中对齐。

在每个示例中，我们在每行的末尾添加了一个竖线 (|)，以清晰显示分配空间的边界。注意在每种情况下，文本的对齐方式不同，但总宽度都保持为 20 个字符。

使用不同字符进行字符串对齐

字符串对齐方法还可以接受第二个参数，用于指定填充字符。让我们修改脚本，看看实际效果。

  1. 在 /home/labex/project 目录下创建一个名为 alignment_with_chars.py 的新文件。

  2. 在文件中添加以下代码：

## alignment_with_chars.py
print("String Alignment With Custom Characters")
print("-" * 40)

## Using different padding characters
print("Left alignment with dots:")
print("Python".ljust(20, '.') + "|")
print("Programming".ljust(20, '.') + "|")
print()

print("Right alignment with asterisks:")
print("Python".rjust(20, '*') + "|")
print("Programming".rjust(20, '*') + "|")
print()

print("Center alignment with hyphens:")
print("Python".center(20, '-') + "|")
print("Programming".center(20, '-') + "|")
  1. 保存文件并运行：
python3 ~/project/alignment_with_chars.py
  1. 你应该会看到类似以下的输出：
String Alignment With Custom Characters
----------------------------------------
Left alignment with dots:
Python..............|
Programming.........|

Right alignment with asterisks:
**************Python|
*********Programming|

Center alignment with hyphens:
-------Python------|
----Programming----|

这些示例展示了你如何通过使用不同的填充字符来定制对齐文本的外观。

高级格式化方法对齐

在之前的步骤中，你学习了使用 ljust(), rjust(), 和 center() 方法的基本字符串对齐。现在，让我们探索 Python 中更强大和灵活的格式化方法。

Python 字符串格式化方法

Python 提供了几种格式化字符串的方法：

  1. 旧式格式化 (使用 % 运算符)
  2. str.format() 方法
  3. F-字符串 (格式化字符串字面量，Python 3.6+ 版本可用)

每种方法都提供了一种对齐文本和格式化各种数据类型的方式。让我们逐一探索它们。

1. 旧式格式化 (% 运算符)

这是 Python 中最古老的字符串格式化方法，类似于 C 的 printf() 函数。

  1. 在 /home/labex/project 目录中创建一个名为 old_style_formatting.py 的新文件：
## old_style_formatting.py
print("旧式字符串格式化")
print("-" * 30)

## 使用 % 格式化左对齐
print("左对齐：")
print("%-15s | %-10s" % ("Python", "语言"))
print("%-15s | %-10s" % ("JavaScript", "Web"))
print()

## 使用 % 格式化右对齐
print("右对齐：")
print("%15s | %10s" % ("Python", "语言"))
print("%15s | %10s" % ("JavaScript", "Web"))
print()

## 数字格式化
price = 125.5
tax_rate = 0.21
print("数字格式化：")
print("价格：$%8.2f" % price)
print("税率：%6.1f%%" % (tax_rate * 100))
print("税额：$%6.2f" % (price * tax_rate))
print("总价：$%8.2f" % (price * (1 + tax_rate)))
  1. 保存文件并运行它：
python3 ~/project/old_style_formatting.py
  1. 你应该看到类似这样的输出：
旧式字符串格式化
------------------------------
左对齐：
Python          | 语言
JavaScript      | Web

右对齐：
         Python |  语言
     JavaScript |       Web

数字格式化：
价格：$  125.50
税率：  21.0%
税额：$  26.36
总价：$  151.86

2. str.format() 方法

str.format() 方法提供了一种更灵活的方式来格式化字符串，旨在解决 % 运算符的一些限制。

  1. 在 /home/labex/project 目录中创建一个名为 format_method.py 的新文件：
## format_method.py
print("使用 str.format() 格式化字符串")
print("-" * 35)

## 基本对齐
print("基本对齐：")
print("{:<15} | {:<10}".format("Python", "语言"))
print("{:>15} | {:>10}".format("Python", "语言"))
print("{:^15} | {:^10}".format("Python", "语言"))
print()

## 使用自定义填充字符
print("自定义填充字符：")
print("{:*<15} | {:.>10}".format("Python", "语言"))
print("{:#^15} | {:=^10}".format("Python", "语言"))
print()

## 使用字段名
print("使用字段名：")
print("{name:<15} | {type:<10}".format(name="JavaScript", type="Web"))
print("{name:>15} | {type:>10}".format(name="Python", type="语言"))
print()

## 数字格式化
price = 125.5
tax_rate = 0.21
print("数字格式化：")
print("价格：${:8.2f}".format(price))
print("税率：{:6.1f}%".format(tax_rate * 100))
print("税额：${:6.2f}".format(price * tax_rate))
print("总价：${:8.2f}".format(price * (1 + tax_rate)))
  1. 保存文件并运行它：
python3 ~/project/format_method.py
  1. 你应该看到类似这样的输出：
使用 str.format() 格式化字符串
-----------------------------------
基本对齐：
Python          | 语言
         Python |   语言
    Python      |  语言

自定义填充字符：
Python********* | 语言...
#####Python##### | ==语言==

使用字段名：
JavaScript      | Web
         Python |   语言

数字格式化：
价格：$  125.50
税率：  21.0%
税额：$  26.36
总价：$  151.86

3. F-字符串 (Python 3.6+)

F-字符串提供了一种简洁方便的方式在字符串字面量中嵌入表达式。它们以字母 'f' 开头，并使用花括号 {} 包含表达式。

  1. 在 /home/labex/project 目录中创建一个名为 f_strings.py 的新文件：
## f_strings.py
print("使用 F-字符串格式化字符串")
print("-" * 35)

language = "Python"
category = "语言"
version = 3.10
year = 2022

## 基本对齐
print("基本对齐：")
print(f"{language:<15} | {category:<10}")
print(f"{language:>15} | {category:>10}")
print(f"{language:^15} | {category:^10}")
print()

## 动态宽度指定
width1 = 15
width2 = 10
print("动态宽度：")
print(f"{language:<{width1}} | {category:<{width2}}")
print(f"{language:>{width1}} | {category:>{width2}}")
print()

## F-字符串中的表达式
print("F-字符串中的表达式：")
print(f"{language + ' ' + str(version):<15} | {year - 1991:>10} 年")
print()

## 数字格式化
price = 125.5
tax_rate = 0.21
print("数字格式化：")
print(f"价格：${price:8.2f}")
print(f"税率：{tax_rate * 100:6.1f}%")
print(f"税额：${price * tax_rate:6.2f}")
print(f"总价：${price * (1 + tax_rate):8.2f}")
  1. 保存文件并运行它：
python3 ~/project/f_strings.py
  1. 你应该看到类似这样的输出：
使用 F-字符串格式化字符串
-----------------------------------
基本对齐：
Python          | 语言
         Python |   语言
    Python      |  语言

动态宽度：
Python          | 语言
         Python |   语言

F-字符串中的表达式：
Python 3.1      |         31 年

数字格式化：
价格：$  125.50
税率：  21.0%
税额：$  26.36
总价：$  151.86

格式化方法比较

每种格式化方法都有其优势。以下是何时使用每种方法：

  • % 运算符: 用于旧代码或需要与旧版 Python 版本兼容的情况。
  • str.format() 方法: 比 % 格式化更强大，尤其是在复杂格式化需求时。
  • F-字符串: 最简洁易读的选择，建议用于所有新的 Python 代码 (Python 3.6+)。

Python 的现代趋势是尽可能使用 F-字符串，因为它具有更好的可读性和性能优势。

使用 Python 创建格式化表格

现在你已经学习了不同的对齐技巧，让我们将其应用于创建格式良好的表格。表格是显示结构化数据的常用方法，以便于阅读，正确的对齐对于有效地呈现表格信息至关重要。

使用固定宽度列的简单表格

让我们从使用固定宽度列创建简单的表格开始。

  1. 在 /home/labex/project 目录中创建一个名为 simple_table.py 的新文件：
## simple_table.py
print("简单的固定宽度表格")
print("-" * 50)

## 定义一些数据
header = ["姓名", "年龄", "城市", "职业"]
data = [
    ["John Smith", 34, "纽约", "医生"],
    ["Sarah Johnson", 28, "旧金山", "工程师"],
    ["Michael Brown", 42, "芝加哥", "教师"],
    ["Emily Davis", 31, "波士顿", "科学家"]
]

## 打印表头
print(f"{header[0]:<20} {header[1]:<8} {header[2]:<15} {header[3]:<15}")
print("-" * 60)

## 打印行
for row in data:
    print(f"{row[0]:<20} {row[1]:<8} {row[2]:<15} {row[3]:<15}")
  1. 保存文件并运行它：
python3 ~/project/simple_table.py
  1. 你应该看到一个格式整齐的表格，如下所示：
简单的固定宽度表格
--------------------------------------------------
姓名                 年龄      城市            职业
------------------------------------------------------------
John Smith           34       纽约            医生
Sarah Johnson        28       旧金山          工程师
Michael Brown        42       芝加哥          教师
Emily Davis          31       波士顿          科学家

使用多种对齐类型的动态表格

不同类型的数据通常在不同的对齐样式下看起来更好。例如，文本通常左对齐，而数字通常右对齐。让我们创建一个更复杂的表格，包含混合对齐方式。

  1. 在 /home/labex/project 目录中创建一个名为 dynamic_table.py 的新文件：
## dynamic_table.py
print("混合对齐的动态表格")
print("-" * 50)

## 定义一些数据
header = ["产品", "价格", "数量", "总价"]
products = [
    ["笔记本电脑", 1299.99, 3, 3899.97],
    ["鼠标", 24.50, 10, 245.00],
    ["显示器", 349.95, 2, 699.90],
    ["键盘", 49.99, 5, 249.95],
    ["耳机", 89.95, 4, 359.80]
]

## 根据内容计算列宽度
col_widths = [
    max(len(str(header[0])), max(len(str(row[0])) for row in products)) + 2,
    max(len(str(header[1])), max(len(f"${row[1]:.2f}") for row in products)) + 2,
    max(len(str(header[2])), max(len(str(row[2])) for row in products)) + 2,
    max(len(str(header[3])), max(len(f"${row[3]:.2f}") for row in products)) + 2
]

## 打印表头
print(f"{header[0]:<{col_widths[0]}}"
      f"{header[1]:>{col_widths[1]}}"
      f"{header[2]:>{col_widths[2]}}"
      f"{header[3]:>{col_widths[3]}}")
print("-" * sum(col_widths))

## 打印带有适当对齐的行
for product in products:
    print(f"{product[0]:<{col_widths[0]}}",
          f"${product[1]:.2f}".rjust(col_widths[1]),
          f"{product[2]}".rjust(col_widths[2]),
          f"${product[3]:.2f}".rjust(col_widths[3]))

## 打印汇总
total_quantity = sum(product[2] for product in products)
total_cost = sum(product[3] for product in products)
print("-" * sum(col_widths))
print(f"{'总计':<{col_widths[0]}}",
      f"".rjust(col_widths[1]),
      f"{total_quantity}".rjust(col_widths[2]),
      f"${total_cost:.2f}".rjust(col_widths[3]))
  1. 这个代码存在需要修复的错误。价格和总价列的格式不正确。让我们纠正它：
## dynamic_table.py - 修正后的版本
## ... (代码内容与上一个代码块相同)
  1. 保存修正后的文件并运行它：
python3 ~/project/dynamic_table.py
  1. 让我们简化这个例子，使其更健壮，更容易让初学者理解：
## dynamic_table.py - 简化版本
## ... (代码内容与上一个代码块相同)
  1. 将此简化版本保存到之前的文件，并运行它：
python3 ~/project/dynamic_table.py
  1. 你应该看到一个格式良好的表格，如下所示：
混合对齐的动态表格
--------------------------------------------------
产品            价格 ($)  数量   总价 ($)
-------------------------------------------------------
笔记本电脑          1299.99         3     3899.97
鼠标                24.50        10      245.00
显示器              349.95         2      699.90
键盘                49.99         5      249.95
耳机                89.95         4      359.80
-------------------------------------------------------
总计                                24     5454.62

创建财务报告

现在，让我们创建一个更实用的例子——一个使用对齐技术以提高可读性的财务报告。

  1. 在 /home/labex/project 目录中创建一个名为 financial_report.py 的新文件：
## financial_report.py
## ... (代码内容与上一个代码块相同)
  1. 保存文件并运行它：
python3 ~/project/financial_report.py
  1. 你应该看到一个包含良好对齐列的综合财务报告：
每月财务报告
============================================================

收入报表
----------------------------------------
项目              金额 ($)
----------------------------------------
工资                  5000.00
自由职业工作          1200.50
投资                  450.75
其他收入             300.00
----------------------------------------
总收入              6951.25


支出报表
----------------------------------------
类别              金额 ($)
----------------------------------------
租金                    1500.00
公用事业                250.30
杂货                    600.45
交通                    200.00
保险                    300.00
娱乐                    150.25
储蓄                    800.00
杂项                    300.00
----------------------------------------
总支出              4101.00


每月总结
----------------------------------------
总收入              6951.25
总支出              4101.00
----------------------------------------
净余额             2850.25

状态：本月节省了 2850.25 美元！

这个例子展示了如何使用正确的对齐方式使复杂的财务信息更容易阅读和理解。

关键要点

通过这些例子，你已经学习了如何：

  1. 创建具有一致对齐方式的简单固定宽度表格
  2. 根据数据类型应用不同的对齐方式（文本左对齐，数字右对齐）
  3. 创建具有清晰视觉组织的实用、真实的报告
  4. 使用字符串格式化方法来精确控制输出

这些技能不仅适用于控制台输出，还可以应用于生成报告、创建日志文件或以任何文本格式呈现数据。

总结

在本次实验中，你学习了在 Python 中对齐和格式化文本输出的各种技术：

  • 基本的字符串对齐方法：ljust()、rjust() 和 center()
  • 不同的字符串格式化方法：% 运算符、str.format() 和 F 字符串
  • 如何创建具有固定宽度列的结构良好的表格
  • 如何根据数据类型应用不同的对齐方式
  • 如何创建像财务报告这样格式规范的实际应用程序

这些文本对齐技能对于在许多应用程序中创建可读的、专业的输出至关重要，从简单的命令行实用工具到复杂的数据处理系统。通过掌握 Python 中的文本对齐，你可以显著提升程序的用户体验和可读性。

在你继续 Python 学习之旅时，请记住，干净、格式良好的输出通常与程序的逻辑同样重要。本次实验中学到的技术将帮助你以既实用又美观的方式呈现数据。

相关 Python 课程
Python 快速入门

Python 快速入门

python
Python 速查表

Python 速查表

python
Python 实践挑战

Python 实践挑战

python