参考文档：内置类型 — Python 3.13.7 文档

在Python中，str（字符串） 是处理文本数据的核心类型，本质是由Unicode码位构成的不可变序列。这意味着字符串创建后无法修改内部字符，任何“修改”操作都会生成新的字符串对象。同时，Python不存在单独的“字符类型”，对字符串的索引操作会返回长度为1的字符串（例如 s = 'a' 时，s[0] == s[0:1] 结果为 True）。

1. 字符串字面值的创建方式

字符串字面值有多种写法，可根据场景灵活选择，核心是通过引号包裹文本内容：

1.1. 单引号与双引号

单引号（' '）和双引号（" "）功能完全一致，主要用于创建单行字符串，优势是可互相嵌套（避免转义）：

• 单引号内可直接包含双引号，无需转义；
• 双引号内可直接包含单引号，无需转义。

# 单引号内嵌双引号
single_quote = 'He said, "Python is easy!"'
print(single_quote)  # 输出：He said, "Python is easy!"

# 双引号内嵌单引号
double_quote = "She's learning Python."
print(double_quote)  # 输出：She's learning Python.

1.2. 三重引号

三重单引号（''' '''）或三重双引号（""" """）用于创建多行字符串，字符串内的空白字符（如换行、空格）会被完整保留，常用于文档字符串（docstring）或长文本：

# 三重双引号创建多行字符串
multi_line = """Python str特性：
1. 不可变Unicode序列
2. 支持多种字面值写法
3. 内置丰富方法"""

print(multi_line)
# 输出：
# Python str特性：
# 1. 不可变Unicode序列
# 2. 支持多种字面值写法
# 3. 内置丰富方法

# 三重单引号作为文档字符串
def add(a, b):
    '''计算两个数的和
    参数：
        a: 第一个数
        b: 第二个数
    返回：
        a + b 的结果
    '''
    return a + b

print(add.__doc__)  # 输出函数的文档字符串

1.3. 隐式拼接

多个字符串字面值之间仅用空格分隔时，Python会隐式拼接为单个字符串（无需 + 运算符），适合拆分长字符串以提高可读性：

# 隐式拼接（空格分隔）
combined = "Python is " "a powerful " "programming language."
print(combined)  # 输出：Python is a powerful programming language.

# 等价于显式拼接，但更简洁
explicit = "Python is " + "a powerful " + "programming language."
print(combined == explicit)  # 输出：True

2. str构造器

除了字面值，还可通过 str() 构造器从其他对象创建字符串，支持三种参数形式：

2.1. str()

无参数时，返回空字符串 ''。

empty_str = str()
print(empty_str)  # 输出：（空）
print(len(empty_str))  # 输出：0

2.2. str(object)

将传入的 object 转换为“适合显示的字符串”，优先调用对象的 __str__() 方法；若对象无 __str__()，则调用 repr() 方法。

# 转换数字为字符串
num_str = str(123.45)
print(num_str, type(num_str))  # 输出：123.45 <class 'str'>

# 转换列表为字符串
list_str = str([1, 2, 3])
print(list_str, type(list_str))  # 输出：[1, 2, 3] <class 'str'>

# 转换自定义对象（无__str__，调用repr）
class MyClass:
    def __repr__(self):
        return "MyClass()"

obj_str = str(MyClass())
print(obj_str)  # 输出：MyClass()

2.3. str(object, encoding='utf-8', errors='strict')

若传入 bytes 或 bytearray 等“类字节对象”，需指定 encoding（编码格式）和 errors（错误处理方式），本质是调用 object.decode(encoding, errors)。

# 转换bytes对象为字符串（指定编码）
bytes_data = b'Python 中文'
str_from_bytes = str(bytes_data, encoding='utf-8')
print(str_from_bytes)  # 输出：Python 中文

# 错误处理：当编码不匹配时，用'replace'替换无法解码的字符
bytes_data = b'Python \xe4\xb8\xad\xe6\x96\x87'  # utf-8编码的“中文”
# 若错误指定gbk编码，用replace处理
str_error = str(bytes_data, encoding='gbk', errors='replace')
print(str_error)  # 输出：Python 中�文（部分字符无法解码，替换为�）

# 未指定encoding时，返回bytes对象的repr形式
str_no_encoding = str(bytes_data)
print(str_no_encoding)  # 输出：b'Python \xe4\xb8\xad\xe6\x96\x87'

3. 字符串的核心方法

str内置了大量方法，覆盖大小写转换、对齐、查找、修改、判断等场景，以下按功能分类详解（所有方法均返回新字符串，原字符串不变，因str不可变）。

3.1. 大小写相关方法

这类方法用于转换字符串的大小写格式，满足不同场景的显示需求。

3.1.1. str.capitalize()

返回字符串副本，首个字符转为标题格式（Titlecase），其余字符转为小写。

• 版本变更：Python 3.8+ 中，首个字符采用“标题格式”而非“全大写”（例如德语 ß 会转为 ẞ，而非全大写的 SS）。

print('python'.capitalize())  # 输出：Python
print('PYTHON'.capitalize())  # 输出：Python
print('ß'.capitalize())       # 输出：ẞ（Python 3.8+）

3.1.2. str.casefold()

返回字符串的彻底小写副本，比 lower() 更彻底（例如处理非英语字符，如德语 ß 转为 ss），适合“忽略大小写的匹配场景”。

• 版本：Python 3.3+ 新增。

# 普通字符
print('PYTHON'.casefold())  # 输出：python
# 特殊字符（彻底小写）
print('Straße'.casefold())  # 输出：strasse（ß转为ss）
print('Straße'.lower())     # 输出：straße（ß不变）

# 忽略大小写匹配
text = 'Straße'
if text.casefold() == 'strasse':
    print('匹配成功')  # 输出：匹配成功

3.1.3. str.lower() / str.upper()

• str.lower()：将所有区分大小写的字符转为小写；
• str.upper()：将所有区分大小写的字符转为大写。

print('PyThOn'.lower())  # 输出：python
print('PyThOn'.upper())  # 输出：PYTHON

3.1.4. str.swapcase()

返回字符串副本，大写字符转为小写，小写字符转为大写（注意：s.swapcase().swapcase() 不一定等于原字符串，因部分字符大小写转换不对称）。

print('PyThOn'.swapcase())  # 输出：pYtHoN
print('ß'.swapcase())       # 输出：ß（无大小写区分，不变）

3.1.5. str.title()

返回字符串的标题格式副本，即“每个单词的首个字符大写，其余字符小写”。

• 注意：默认以“连续字母”为单词边界，可能导致撇号后的字符误大写（如 they're 转为 They'Re）。

print('hello world'.title())  # 输出：Hello World
print("they're bill's friends".title())  # 输出：They'Re Bill'S Friends（撇号问题）

# 解决撇号问题（用正则自定义单词边界）
import re
def proper_title(s):
    return re.sub(r"[A-Za-z]+('[A-Za-z]+)?", lambda m: m.group(0).capitalize(), s)

print(proper_title("they're bill's friends"))  # 输出：They're Bill's Friends

3.1.6. str.istitle() / str.islower() / str.isupper()

• str.istitle()：判断字符串是否为标题格式（至少一个字符，且每个单词首字母大写）；
• str.islower()：判断字符串是否全为小写（至少一个可大小写字符）；
• str.isupper()：判断字符串是否全为大写（至少一个可大小写字符）。

print('Hello World'.istitle())  # 输出：True
print('Hello world'.istitle())  # 输出：False

print('python'.islower())       # 输出：True
print('Python'.islower())       # 输出：False

print('PYTHON'.isupper())       # 输出：True
print('Python'.isupper())       # 输出：False
print(' '.isupper())            # 输出：False（无大小写字符）

3.2. 对齐与填充方法

这类方法用于调整字符串的对齐方式，并通过指定字符填充空白，常用于格式化输出（如表格、日志）。

3.2.1. str.center(width, fillchar=' ')

返回长度为 width 的居中对齐字符串，空白部分用 fillchar 填充（默认空格）；若 width <= len(s)，返回原字符串。

# 默认空格填充
print('Python'.center(10))        # 输出：  Python  （左右各2个空格）
# 自定义字符填充
print('Python'.center(10, '-'))   # 输出：--Python-- （左右各2个-）
# width不足时返回原串
print('Python'.center(4))         # 输出：Python

3.2.2. str.ljust(width, fillchar=' ') / str.rjust(width, fillchar=' ')

• str.ljust(width, fillchar)：左对齐，空白部分在右侧；
• str.rjust(width, fillchar)：右对齐，空白部分在左侧。

# 左对齐，*填充
print('Python'.ljust(10, '*'))  # 输出：Python****（右侧4个*）
# 右对齐，#填充
print('Python'.rjust(10, '#'))  # 输出：####Python（左侧4个#）

3.2.3. str.zfill(width)

返回长度为 width 的字符串，左侧用0填充，特殊点：正负号（+/-）会被保留在最左侧，0填充在符号与数字之间。

print('42'.zfill(5))    # 输出：00042（无符号，左侧补3个0）
print('-42'.zfill(5))   # 输出：-0042（负号保留，中间补2个0）
print('+42'.zfill(5))   # 输出：+0042（正号保留，中间补2个0）
print('Python'.zfill(4))# 输出：Python（width不足，返回原串）

3.3. 查找与计数方法

这类方法用于定位子串位置或统计子串出现次数，是文本处理的核心功能。

3.3.1. str.count(sub[, start[, end]])

统计子串 sub 在 s[start:end] 范围内非重叠出现的次数；若 sub 为空字符串，返回 len(s) + 1（字符间的空串数）。

text = 'spam, spam, spam'
# 统计所有spam
print(text.count('spam'))          # 输出：3
# 从索引5开始统计
print(text.count('spam', 5))       # 输出：2（忽略第一个spam）
# 索引5~10范围内统计
print(text.count('spam', 5, 10))   # 输出：1（仅第二个spam的部分在范围内）
# 空字符串计数（长度+1）
print('abc'.count(''))             # 输出：4（a前、a-b间、b-c间、c后）

3.3.2. str.find(sub[, start[, end]]) / str.rfind(sub[, start[, end]])

• str.find(sub)：查找 sub 在 s[start:end] 中的最小索引（首次出现位置），未找到返回 -1；
• str.rfind(sub)：查找 sub 在 s[start:end] 中的最大索引（最后出现位置），未找到返回 -1。

text = 'spam, spam, egg'
# 首次出现spam的索引
print(text.find('spam'))        # 输出：0
# 从索引5开始找spam
print(text.find('spam', 5))     # 输出：6
# 未找到egg的索引（实际在12）
print(text.find('egg', 0, 10)) # 输出：-1

# 最后出现spam的索引
print(text.rfind('spam'))       # 输出：6

3.3.3. str.index(sub[, start[, end]]) / str.rindex(sub[, start[, end]])

与 find()/rfind() 功能一致，但未找到子串时会引发 ValueError（而非返回 -1），适合明确子串一定存在的场景。

text = 'spam, spam'
print(text.index('spam'))       # 输出：0
# 未找到时抛错
# print(text.index('egg'))      # 报错：ValueError: substring not found

3.3.4. str.startswith(prefix[, start[, end]]) / str.endswith(suffix[, start[, end]])

• str.startswith(prefix)：判断字符串是否以 prefix 开头，prefix 可为元组（多个前缀任选其一）；
• str.endswith(suffix)：判断字符串是否以 suffix 结尾，suffix 可为元组。

text = 'Python is fun'
# 单个前缀判断
print(text.startswith('Python'))  # 输出：True
# 元组前缀判断（任一匹配即可）
print(text.startswith(('Py', 'Ja')))  # 输出：True
# 指定范围判断（索引0~6）
print(text.startswith('is', 0, 6))    # 输出：False

# 单个后缀判断
print(text.endswith('fun'))      # 输出：True
# 元组后缀判断
print(text.endswith(('fun', 'boring')))  # 输出：True
# 指定范围判断（索引0~9）
print(text.endswith('is', 0, 9))        # 输出：True（text[0:9]是'Python is'）

3.4. 内容修改与清理方法

这类方法用于“修改”字符串内容（实际生成新串），如替换子串、移除首尾字符等。

3.4.1. str.replace(old, new, /, count=-1)

将字符串中所有 old 子串替换为 new，count 指定最大替换次数（默认 -1，全部替换）。

• 版本变更：Python 3.13+ 支持 count 作为关键字参数（如 replace('a', 'b', count=2)）。

text = 'spam spam spam'
# 全部替换
print(text.replace('spam', 'egg'))      # 输出：egg egg egg
# 替换前2次
print(text.replace('spam', 'egg', 2))   # 输出：egg egg spam

3.4.2. str.strip(chars=None) / str.lstrip(chars=None) / str.rstrip(chars=None)

• str.strip(chars)：移除字符串首尾的 chars 字符（默认移除空白字符：空格、\t、\n 等）；
• str.lstrip(chars)：仅移除首部的 chars 字符；
• str.rstrip(chars)：仅移除尾部的 chars 字符；
• 注意：chars 是“字符集合”，而非“固定前缀/后缀”，会移除所有包含在 chars 中的字符。

# 移除空白字符
text = '   Python is fun   '
print(text.strip())    # 输出：Python is fun（首尾空白移除）
print(text.lstrip())   # 输出：Python is fun   （仅首部空白移除）
print(text.rstrip())   # 输出：   Python is fun（仅尾部空白移除）

# 移除指定字符集合（chars='cmowz.'）
url = 'www.example.com'
print(url.strip('cmowz.'))  # 输出：example（移除首尾的w、.、c、m等）
print(url.lstrip('www.'))   # 输出：example.com（仅移除首部的www.）

3.4.3. str.removeprefix(prefix) / str.removesuffix(suffix)

• str.removeprefix(prefix)：仅移除开头的固定前缀（若存在），否则返回原串；
• str.removesuffix(suffix)：仅移除结尾的固定后缀（若存在），否则返回原串；
• 与 strip() 区别：strip() 移除“字符集合”，removeprefix() 移除“固定字符串”，更精准。
• 版本：Python 3.9+ 新增。

# 移除前缀
print('TestHook'.removeprefix('Test'))  # 输出：Hook（前缀匹配，移除）
print('BaseTestCase'.removeprefix('Test'))  # 输出：BaseTestCase（前缀不匹配，返回原串）

# 移除后缀
print('MiscTests'.removesuffix('Tests'))  # 输出：Misc（后缀匹配，移除）
print('TmpDirMixin'.removesuffix('Tests'))  # 输出：TmpDirMixin（后缀不匹配，返回原串）

# 对比strip()的差异
print('Arthur: three!'.lstrip('Arthur: '))  # 输出：ee!（移除字符集合，多移除了'th'）
print('Arthur: three!'.removeprefix('Arthur: '))  # 输出：three!（仅移除固定前缀，精准）

3.5. 拆分与拼接方法

这类方法用于将字符串拆分为列表，或拼接列表为字符串，是数据格式转换的常用工具。

3.5.1. str.split(sep=None, maxsplit=-1)

将字符串按 sep 拆分为列表，maxsplit 指定最大拆分次数（默认 -1，无限制）：

• 若 sep 为 None 或未指定：连续空白字符（空格、\t、\n 等）视为单个分隔符，且结果不包含首尾空串；
• 若 sep 为具体字符：连续 sep 会拆出空串（如 '1,,2'.split(',') 返回 ['1', '', '2']）。

# sep=None，拆分空白字符
text1 = '1  2   3'  # 连续空格
print(text1.split())  # 输出：['1', '2', '3']（忽略连续空格）

# sep为逗号，连续分隔符拆出空串
text2 = '1,,2,3,'
print(text2.split(','))  # 输出：['1', '', '2', '3', '']

# 指定maxsplit，拆分2次
text3 = 'a-b-c-d'
print(text3.split('-', maxsplit=2))  # 输出：['a', 'b', 'c-d']

3.5.2. str.rsplit(sep=None, maxsplit=-1)

与 split() 功能一致，但从字符串右侧开始拆分，适合需要保留右侧内容的场景（如文件路径）。

# 拆分文件路径，保留文件名（从右拆1次）
file_path = '/home/user/documents/note.txt'
print(file_path.rsplit('/', maxsplit=1))  # 输出：['/home/user/documents', 'note.txt']

# 对比split()（从左拆1次）
print(file_path.split('/', maxsplit=1))   # 输出：['', 'home/user/documents/note.txt']

3.5.3. str.splitlines(keepends=False)

按“行边界”拆分字符串为列表，keepends 为 True 时保留行结束符（如 \n、\r\n）。
支持的行边界包括：\n（换行）、\r（回车）、\r\n（回车+换行）、\v（行制表符）等。

text = 'ab\ncd\r\nef'
# 不保留行结束符
print(text.splitlines())  # 输出：['ab', 'cd', 'ef']
# 保留行结束符
print(text.splitlines(keepends=True))  # 输出：['ab\n', 'cd\r\n', 'ef']

# 对比split('\n')（仅按\n拆分）
print(text.split('\n'))  # 输出：['ab', 'cd\r', 'ef']（\r未被处理）

3.5.4. str.join(iterable)

将 iterable 中的所有字符串拼接为一个字符串，调用该方法的字符串作为分隔符；若 iterable 包含非字符串元素，会引发 TypeError。

# 拼接列表为字符串，逗号分隔
lst = ['1', '2', '3']
print(','.join(lst))  # 输出：1,2,3

# 拼接字符串为空格分隔
print(' '.join('abc'))  # 输出：a b c（'abc'是可迭代对象，拆分为每个字符）

# 错误：iterable包含非字符串元素
# lst2 = [1, 2, 3]
# print(','.join(lst2))  # 报错：TypeError: sequence item 0: expected str instance, int found

3.6. 类型判断方法

这类方法用于判断字符串的内容类型（如是否为字母、数字、空白等），常用于输入验证。

方法	功能描述
str.isalnum()	所有字符为字母/数字，且至少1个字符 → True
str.isalpha()	所有字符为字母，且至少1个字符 → True
str.isascii()	所有字符为ASCII（码位0~127），或空串 → True（Python 3.7+）
str.isdecimal()	所有字符为十进制字符（如 0-9、阿拉伯数字 ０-９），且至少1个字符 → True
str.isdigit()	所有字符为数字（含特殊数字，如 ²、①），且至少1个字符 → True
str.isnumeric()	所有字符为数值字符（含分数、罗马数字，如 ½、Ⅲ），且至少1个字符 → True
str.isprintable()	所有字符为可打印字符（不含 \t、\n 等） → True
str.isspace()	所有字符为空白，且至少1个字符 → True
str.isidentifier()	字符串为有效Python标识符（符合变量命名规则） → True，需配合 keyword.iskeyword() 判断是否为关键字

# isalnum()：字母+数字
print('abc123'.isalnum())  # 输出：True
print('abc!123'.isalnum()) # 输出：False（含!）

# isdecimal() vs isdigit() vs isnumeric()
print('123'.isdecimal())   # 输出：True
print('123'.isdigit())     # 输出：True
print('123'.isnumeric())   # 输出：True

print('²'.isdecimal())     # 输出：False（特殊数字）
print('²'.isdigit())       # 输出：True
print('²'.isnumeric())     # 输出：True

print('½'.isdecimal())     # 输出：False（分数）
print('½'.isdigit())       # 输出：False
print('½'.isnumeric())     # 输出：True

# isidentifier()：判断是否为有效标识符
print('hello123'.isidentifier())  # 输出：True
print('123hello'.isidentifier())  # 输出：False（以数字开头）

# 配合keyword判断是否为关键字
from keyword import iskeyword
print('def'.isidentifier(), iskeyword('def'))  # 输出：True True（是标识符也是关键字）

3.7. 编码与转换方法

这类方法用于字符串与字节串（bytes）的转换，或字符映射转换。

3.7.1. str.encode(encoding='utf-8', errors='strict')

将字符串编码为 bytes 对象，encoding 指定编码格式（默认 utf-8），errors 指定错误处理方式（默认 strict，抛 UnicodeError）。

• 版本变更：Python 3.9+ 在开发模式/调试模式下会检查 errors 参数的有效性。

# 默认utf-8编码
print('Python'.encode())  # 输出：b'Python'
# 中文utf-8编码
print('中文'.encode('utf-8'))  # 输出：b'\xe4\xb8\xad\xe6\x96\x87'
# 错误处理：replace（无法编码的字符替换为?）
print('中文'.encode('ascii', errors='replace'))  # 输出：b'??'

3.7.2. str.maketrans(x) 与 str.translate(table)

• str.maketrans(x)：静态方法，创建“字符转换表”（dict 类型），x 支持三种形式：
  1. 单个 dict：键为字符/码位，值为字符/码位/None（None 表示删除该字符）；
  2. 两个字符串 from 和 to：from 中每个字符映射到 to 对应位置的字符（长度需相等）；
  3. 两个字符串 from/to + 第三个字符串 remove：remove 中的字符会被映射到 None（删除）。
• str.translate(table)：按转换表 table 映射字符，返回新字符串。

# 1. 字典形式创建转换表（a→A，b→B，c→删除）
trans1 = str.maketrans({'a': 'A', 'b': 'B', 'c': None})
print('abc123'.translate(trans1))  # 输出：AB123（c被删除）

# 2. 两个字符串创建转换表（a→x，b→y）
trans2 = str.maketrans('ab', 'xy')
print('abcab'.translate(trans2))  # 输出：xycxy

# 3. 两个字符串+remove（a→x，b→y，c删除）
trans3 = str.maketrans('ab', 'xy', 'c')
print('abcabc'.translate(trans3))  # 输出：xyxy（c被删除）

3.8. 分区方法

这类方法按指定分隔符拆分字符串为“3元组”，适合明确分隔符存在的场景。

3.8.1. str.partition(sep)

按 sep 首次出现位置拆分字符串，返回 (sep前的部分, sep, sep后的部分)；若 sep 未找到，返回 (原字符串, '', '')。

3.8.2. str.rpartition(sep)

按 sep 最后出现位置拆分字符串，返回 (sep前的部分, sep, sep后的部分)；若 sep 未找到，返回 ('', '', 原字符串)。

text = 'a-b-c-d'
# partition：按首次出现的-拆分
print(text.partition('-'))  # 输出：('a', '-', 'b-c-d')

# rpartition：按最后出现的-拆分
print(text.rpartition('-'))  # 输出：('a-b-c', '-', 'd')

# 未找到sep的情况
print('abc'.partition('-'))  # 输出：('abc', '', '')
print('abc'.rpartition('-')) # 输出：('', '', 'abc')

4. 格式化字符串字面值（f-字符串）

f-字符串（格式化字符串字面值） 是Python 3.6+ 新增的字符串格式化方式，前缀为 f 或 F，支持在 {} 中嵌入任意Python表达式，运行时求值并替换，简洁高效且可读性强。

4.1. 基本用法

在 {} 中直接嵌入表达式，Python会自动计算结果并转换为字符串：

name = 'Alice'
age = 25
# 嵌入变量
print(f'Hello, my name is {name}, I am {age} years old.')  # 输出：Hello, my name is Alice, I am 25 years old.
# 嵌入表达式
print(f'Next year, I will be {age + 1} years old.')  # 输出：Next year, I will be 26 years old.
# 嵌入函数调用
print(f'My name in uppercase: {name.upper()}.')  # 输出：My name in uppercase: ALICE.

4.2. 转义与嵌套

• 若需在f-字符串中显示 { 或 }，需用双花括号 {{ 或 }} 转义；
• Python 3.12+ 支持在 {} 中嵌套字符串、注释和反斜杠（之前版本不支持）。

x = 3
# 转义{{和}}
print(f'{{x}} is {x}')  # 输出：{x} is 3

# Python 3.12+ 支持嵌套和注释
print(f'The result is { (x if x > 2 else 0) }')  # 输出：The result is 3（嵌套表达式）
print(f'Comment: {x + 1  # 这是注释\n}')  # 输出：Comment: 4（支持注释和换行）

4.3. 格式说明符

在 {表达式:格式说明符} 中添加格式说明符，可控制输出格式（如小数位数、对齐方式、千位分隔符等）：

from math import sqrt
# 小数位数：.2f（保留2位小数）
print(f'sqrt(2) ≈ {sqrt(2):.2f}')  # 输出：sqrt(2) ≈ 1.41
# 千位分隔符：_ 或 ,
print(f'Large number: {1234567:_}')  # 输出：Large number: 1_234_567
print(f'Large number: {1234567:,}')  # 输出：Large number: 1,234,567
# 对齐：<10（左对齐，占10位），>10（右对齐），^10（居中）
print(f'Left: {name:<10}end')  # 输出：Left: Alice     end（Alice左对齐，占10位）
print(f'Center: {name:^10}end')# 输出：Center:   Alice   end（Alice居中，占10位）

4.4. 显式类型转换

在 {表达式!转换符} 中用 !a/!r/!s 指定转换方式：

• !a：用 ascii() 转换（非ASCII字符转义）；
• !r：用 repr() 转换（显示对象的原始表示）；
• !s：用 str() 转换（默认，显示适合阅读的格式）。

text = '中文'
# !a：ascii转换（中文转义）
print(f'{text!a}')  # 输出：'\u4e2d\u6587'
# !r：repr转换（显示原始字符串）
print(f'{text!r}')  # 输出：'中文'
# !s：str转换（默认）
print(f'{text!s}')  # 输出：中文

4.5. 调试运算符 =（Python 3.8+）

在 {表达式=} 中添加 =，可同时显示“表达式”和“结果”，适合调试（默认用 repr() 转换，可配合 !s 等修改）：

x = 5
y = 3
# 显示表达式和结果
print(f'{x=}, {y=}')  # 输出：x=5, y=3
# 显示表达式计算结果
print(f'{x + y=}')    # 输出：x + y=8
# 配合类型转换
print(f'{x=!s}, {y=!s}')  # 输出：x=5, y=3（用str()转换）

5. printf风格的字符串格式化

Python还支持类似C语言 printf 的格式化方式，通过 % 运算符实现。虽然官方推荐用f-字符串或 str.format()（避免其怪异特性），但仍需了解其用法以兼容旧代码。

5.1. 基本语法

格式：format_string % values，其中 format_string 包含 %转换符，values 为要替换的值（单个值或元组/字典）。

# 单个值：%s（字符串），%d（整数）
print('Name: %s, Age: %d' % ('Alice', 25))  # 输出：Name: Alice, Age: 25
# 元组值：多个值用元组包裹
print('%d + %d = %d' % (1, 2, 3))  # 输出：1 + 2 = 3
# 字典值：用%(key)转换符
print('Name: %(name)s, Age: %(age)d' % {'name': 'Bob', 'age': 30})  # 输出：Name: Bob, Age: 30

5.2. 常用转换符

转换符	功能描述	示例
%d/%i	十进制整数	%d % 123 → ‘123’
%o	八进制整数（带前缀0o，用#旗标）	%#o % 8 → ‘0o10’
%x/%X	十六进制整数（小写/大写）	%x % 255 → ‘ff’
%f/%F	浮点数（十进制格式）	%.2f % 123.456 → ‘123.46’
%e/%E	浮点数（指数格式）	%e % 123.45 → ‘1.234500e+02’
%s	字符串（用str()转换）	%s % 123 → ‘123’
%r	字符串（用repr()转换）	%r % ‘123’ → “‘123’”
%%	输出%字符	%% → ‘%’

5.3. 常用转换旗标

旗标用于调整输出格式，放在 % 和转换符之间：

• #：启用“替代形式”（如八进制加 0o，十六进制加 0x）；
• 0：数字左侧用0填充（而非空格）；
• -：左对齐；
• +：显式显示正负号；
• 空格：正数左侧留一个空格（用于与负数对齐）。

# #：替代形式（十六进制加0x）
print('%#x' % 255)  # 输出：0xff
# 0：0填充（占5位）
print('%05d' % 42)  # 输出：00042
# -：左对齐（占10位）
print('%-10s end' % 'Alice')  # 输出：Alice      end
# +：显式正负号
print('%+d' % 42)   # 输出：+42
print('%+d' % -42)  # 输出：-42

6. 总结

str作为Python处理文本的核心类型，其核心特性与用法可归纳为：

1. 不可变性：任何修改操作（如替换、大小写转换）都会生成新字符串，原串不变；
2. Unicode支持：原生支持Unicode，可处理多语言文本，编码转换通过 encode()/decode() 实现；
3. 方法丰富：覆盖大小写、对齐、查找、拆分、判断等场景，需注意版本差异（如3.9+的 removeprefix()）；
4. 格式化优先：字符串格式化优先选择f-字符串（3.6+），简洁高效且支持动态表达式；复杂场景用 str.format()；printf风格仅用于兼容旧代码；
5. 注意细节：无单独字符类型、strip() 与 removeprefix() 的区别、空字符串计数规则等细节需重点关注。