Python学习5 之【字符串】

特性	单引号 ' '	双引号 `" "`	三引号 ''' ''' 或 `""" """`
基本用途	定义字符串	定义字符串	定义多行字符串或文档字符串
内部引号	内部可直接用双引号 `'He said "Hello"'`	内部可直接用单引号 `"It's a cat"`	内部单双引号均可直接使用
转义需求	内部单引号需转义 `\'`	内部双引号需转义 `\"`	无需转义内部单/双引号
多行支持	不支持	不支持	支持换行
作为文档字符串	不支持	不支持	用于函数/类/模块的文档
常用场景	简短短字符串	包含单引号的字符串	多行字符串、SQL语句、JSON、文档注释
存储表示	完全相同（内存中无区别）	完全相同	保留换行符和缩进
字符串类型	str	str	str

复制代码

# 单引号
name = 'Python'

# 双引号（避免转义）
message = "It's awesome"

# 三引号（多行）
sql = """
SELECT * 
FROM users 
WHERE age > 18
"""

# 三引号作为文档字符串
def greet():
    """This is a docstring"""
    print("Hello")

2.len()

特性	说明
函数定义	`len(s)` --- 返回对象的长度（元素个数）
返回值	整数（int类型）
参数类型	序列（str, list, tuple, range）集合（set, dict, frozenset）其他（bytes, bytearray等）
时间复杂度	O(1) --- 直接读取对象内部存储的长度值
空对象返回值	0

示例

数据类型	示例代码	返回值	说明
字符串	`len("Python")`	6	字符个数（中文字符算1个）
列表	`len([1, 2, 3, 4])`	4	元素个数
元组	`len((1, 2, 3))`	3	元素个数
字典	`len({'a':1, 'b':2})`	2	键值对个数
集合	`len({1, 2, 3, 4})`	4	元素个数
range	`len(range(5, 10))`	5	序列长度
字节串	`len(b'hello')`	5	字节数

注意事项

场景	说明	示例
不支持的类型	整数、浮点数、布尔值等	`len(123)` → TypeError
None类型	None没有长度	`len(None)` → TypeError
自定义类	需实现 `__len__()` 方法	`class MyClass: def __len__(self): return 10`
常见陷阱	字符串长度≠字节长度	`len("中")` = 1（UTF-8编码下字节数为3）

3.max() 与 min()

特性	`max()`	`min()`
功能	返回最大值	返回最小值
语法形式	`max(iterable, [, key, default])` `max(arg1, arg2, args[, key])`	`min(iterable, [, key, default])` `min(arg1, arg2, args[, key])`
返回值	最大值元素	最小值元素
空迭代器处理	需指定 `default` 参数，否则报 `ValueError`	需指定 `default` 参数，否则报 `ValueError`

参数说明

参数	说明	示例
`iterable`	可迭代对象（列表、元组、字符串等）	`max([1, 5, 3])`
`arg1, arg2, *args`	多个位置参数	`max(1, 5, 3)`
`key`	单参数函数，用于自定义比较规则	`max(lst, key=len)`
`default`	可迭代对象为空时返回的默认值	`max([], default=0)`

不同数据类型示例

数据类型	`max()` 示例	`min()` 示例
整数列表	`max([3, 7, 2, 9])` → 9	`min([3, 7, 2, 9])` → 2
字符串列表	`max(['apple', 'banana', 'cherry'])` → 'cherry'（字母序）	`min(['apple', 'banana', 'cherry'])` → 'apple'
数字元组	`max((4, 8, 2))` → 8	`min((4, 8, 2))` → 2
字符串	`max('Python')` → 'y'（ASCII最大）	`min('Python')` → 'P'（ASCII最小）
字典	`max({'a':5, 'b':2})` → 'b'（比较键）	`min({'a':5, 'b':2})` → 'a'
混合数字	`max(5, 8, 3, 10)` → 10	`min(5, 8, 3, 10)` → 3

key参数应用

场景	代码	结果	说明
按长度比较	`max(['cat', 'elephant', 'dog'], key=len)`	'elephant'	最长字符串
按绝对值比较	`max([-5, -2, 3, -8], key=abs)`	-8	绝对值最大
按年龄取值	`max([{'age':25}, {'age':30}], key=lambda x: x['age'])`	{'age':30}	年龄最大的字典
按小写比较	`max('Apple', 'banana', key=str.lower)`	'banana'	忽略大小写
取模比较	`min([7, 3, 8, 4], key=lambda x: x % 5)`	8	模5最小的数

注意事项

问题	错误示例	正确示例
不同类型比较	`max([1, 'a', 3])` → TypeError	确保类型一致或提供比较函数
空迭代器	`max([])` → ValueError	`max([], default=0)`
字典比较默认键	想要比较值但实际比较了键	`max(dict, key=dict.get)`
None值处理	`max([1, None, 3])` → TypeError	`max([x for x in lst if x is not None])`

4.字符串索引

特性	说明
定义	通过位置编号访问字符串中的单个字符
返回值	长度为1的字符串
索引范围	正向：0 到 len(s)-1 负向：-1 到 -len(s)
越界错误	访问超出范围索引会引发 `IndexError`
数据类型	字符串不可变，不能通过索引修改字符

**索引不能超出范围：**访问字符串时使用的索引值超过了 -len(s) 到 len(s)-1 的有效区间
**空字符串没有索引：**对长度为0的空字符串使用任何非空索引(如 [0] 或 [-1])都会触发越界错误
**索引不能为浮点数：**索引值必须是整数类型，使用浮点数会引发类型错误

5.字符串切片

语法格式	说明
`s[start:end]`	从 `start` 提取到 `end-1`
`s[start:end:step]`	从 `start` 提取到 `end-1`，步长为 `step`
返回值	新的子字符串（原字符串不变）
时间复杂度	O(k)，k为切片长度

参数说明

参数	含义	默认值	正数含义	负数含义
`start`	起始索引（包含）	0（正向步长） -1（负向步长）	从左向右数	从右向左数
`end`	结束索引（不包含）	字符串长度（正向步长） -len(s)-1（负向步长）	从左向右数	从右向左数
`step`	步长（方向与间隔）	1	从左向右	从右向左

start 的默认值

step 方向	省略 start 时的默认值	含义	示例 (`s = "Hello"`)
正数 (step > 0)	`0`	从字符串开头开始	`s[:3]` → `'Hel'` 等效于 `s[0:3]`
负数 (step < 0)	`-1`	从字符串末尾开始（最后一个元素）	`s[::-1]` → `'olleH'` 等效于 `s[-1::-1]`

end 的默认值

step 方向	省略 end 时的默认值	含义	示例 (`s = "Hello"`)
正数 (step > 0)	`len(s)`	一直截取到字符串末尾（不越界）	`s[1:]` → `'ello'` 等效于 `s[1:5]`
负数 (step < 0)	`-len(s)-1`	一直截取到字符串开头之前（即索引 -6）	`s[:1:-1]` → `'oll'` 等效于 `s[-1:1:-1]` 或 `s[4:1:-1]`

**左闭右开：**切片提取从 start 索引（包含）到 end 索引（不包含）之间的元素
**越界忽略：**与索引不同，切片时索引超出字符串长度不会报错，而是静默忽略无效部分
**负步反转：**当步长 step 为 -1 时，可实现字符串的反转
**返回新串：**切片操作返回一个新的字符串，原始字符串不会被修改
**边界默认：**省略 start 或 end 时，Python 会根据切片方向自动将其补充为边界值
**混用取义：**正负索引混用时，Python 会将其转换为实际位置后再确定切片区间
**方向有效：**切片允许索引超出范围，但必须确保逻辑上 start 在 end 的左侧（步长为正时），否则结果为空字符串

切片示例

切片操作	结果	说明
`"Python"[0:3]`	'Pyt'	索引0到2
`"Python"[2:5]`	'tho'	索引2到4
`"Python"[:4]`	'Pyth'	从开头到索引3
`"Python"[3:]`	'hon'	从索引3到末尾
`"Python"[:]`	'Python'	完整复制

负索引切片

切片操作	结果	说明
`"Python"[-3:]`	'hon'	最后3个字符
`"Python"[:-2]`	'Pyth'	去掉最后2个字符
`"Python"[-4:-1]`	'tho'	索引-4到-2
`"Python"[1:-2]`	'yth'	混合正负索引

步长（step）切片

切片操作	结果	说明
`"Python"[::2]`	'Pto'	步长2，取偶数位
`"Python"[1::2]`	'yhn'	步长2，取奇数位
`"Python"[::-1]`	'nohtyP'	步长-1，反转字符串
`"Python"[::-2]`	'nhy'	反向步长2
`"Python"[3:0:-1]`	'hty'	反向切片（索引3→1）

索引 vs 切片

对比项	索引	切片
语法	`s[index]`	`s[start:end:step]`
返回值	单个字符（字符串）	子字符串
越界处理	立即报错 `IndexError`	静默处理（忽略越界索引）
修改原字符串	不支持（字符串不可变）	不支持（返回新字符串）

复制代码

s = "Python"

# 正向越界
print(s[6])   # IndexError: string index out of range

# 负向越界
print(s[-7])  # IndexError: string index out of range

# 正向越界（end 超出）
print(s[3:100])   # 'hon'（不报错，只取到末尾）

# 正向越界（start 超出）
print(s[100:200]) # ''（空字符串，不报错）

# 负向越界（end 超出）
print(s[-10:4])   # 'Pyth'（从开头取到索引3）

# 负向越界（start 超出）
print(s[-10:-20]) # ''（空字符串，不报错）

# 完全越界
print(s[100:200]) # ''（空字符串）

6.回文判断

7. +（序列连接）

特性	算术加法	序列连接
操作对象	数字类型（int, float, complex）	序列类型（str, list, tuple）
功能	数值相加	将两个序列合并成一个新序列
返回值	数值	新序列（原序列不变）
类型要求	必须同为数字（可自动类型转换）	必须为相同类型的序列

序列连接示例

序列类型	代码	结果	说明
字符串	`"Hello" + " " + "World"`	`'Hello World'`	字符串拼接
列表	`[1, 2] + [3, 4]`	`[1, 2, 3, 4]`	列表合并
元组	`(1, 2) + (3, 4)`	`(1, 2, 3, 4)`	元组合并

错误示例

错误代码	问题	正确做法
`"abc" + 123`	字符串和数字不能直接相加	`"abc" + str(123)`
`[1, 2] + (3, 4)`	列表和元组类型不同	`[1, 2] + list((3, 4))`
`"abc" + [1, 2]`	字符串和列表类型不同	类型转换或使用其他方法

+=也可以

数字

x = 5
x += 3 # x = 8

字符串

s = "Hello"
s += " World" # s = "Hello World"

列表

lst = [1, 2]
lst += [3, 4] # lst = [1, 2, 3, 4]
- 的行为取决于左侧操作数的类型
数字用 + 做加法，序列用 + 做连接
不同类型不能直接使用 +，需要显式类型转换
大量字符串拼接时，用 join() 代替 + 以获得更好性能

8. *（序列重复复制）

特性	算术乘法	序列重复
操作对象	数字类型（int, float, complex）	序列类型 × 整数（str, list, tuple）
功能	数值相乘	将序列重复指定次数并合并
返回值	数值	新序列（原序列不变）
类型要求	必须同为数字（可自动转换）	序列 × 整数或整数 × 序列

序列重复示例

序列类型	代码	结果	说明
字符串	`"Hi" * 3`	`'HiHiHi'`	字符串重复拼接
列表	`[1, 2] * 3`	`[1, 2, 1, 2, 1, 2]`	列表元素重复
元组	`(1, 2) * 2`	`(1, 2, 1, 2)`	元组元素重复
整数在左	`3 * "Ha"`	`'HaHaHa'`	顺序可交换

序列重复的特殊情况

操作	代码	结果	说明
乘0	`"abc" * 0`	`''`	空字符串
乘0	`[1,2] * 0`	`[]`	空列表
乘负数	`"abc" * (-1)`	`''`	空字符串（负数视为0）
乘1	`"abc" * 1`	`'abc'`	原序列的浅拷贝

*=也可以

复制代码

# 数字
x = 5
x *= 3      # x = 15

# 字符串
s = "Hi"
s *= 3      # s = "HiHiHi"

# 列表（注意陷阱）
lst = [1, 2]
lst *= 3    # lst = [1, 2, 1, 2, 1, 2]

# 二维列表陷阱同样存在
matrix = [[0]] * 3
matrix *= 2  # 所有元素仍是同一个对象

9. in VS not in

特性	`in`	`not in`
功能	判断元素是否存在于序列/集合中	判断元素是否不存在于序列/集合中
返回值	`True` 或 `False`	`True` 或 `False`
逻辑关系	存在性检查	不存在性检查
可读性	"元素在容器中"	"元素不在容器中"

操作对象类型

类型	`in` 示例	`not in` 示例	说明
字符串	`'a' in 'abc'` → `True`	`'d' not in 'abc'` → `True`	子串/字符检查
列表	`2 in [1,2,3]` → `True`	`4 not in [1,2,3]` → `True`	元素存在检查
元组	`(1,2) in ((1,2),3)` → `True`	`4 not in (1,2,3)` → `True`	元素存在检查
字典	`'name' in {'name':'Tom'}` → `True`	`'age' not in {'name':'Tom'}` → `True`	检查键是否存在
集合	`3 in {1,2,3}` → `True`	`4 not in {1,2,3}` → `True`	快速成员检查
range	`5 in range(10)` → `True`	`15 not in range(10)` → `True`	数值范围检查

字符串中的使用

操作	代码	结果	说明
字符检查	`'H' in "Hello"`	`True`	单个字符
子串检查	`'ell' in "Hello"`	`True`	连续子串
大小写敏感	`'h' in "Hello"`	`False`	区分大小写
空字符串	`'' in "Hello"`	`True`	空字符串总存在

字典中的使用（重要）

操作	代码	结果	说明
检查键	`'name' in {'name':'Tom', 'age':20}`	`True`	检查键，不是值
检查值	`'Tom' in {'name':'Tom'}.values()`	`True`	需显式调用 `values()`
检查键值对	`('name','Tom') in {'name':'Tom'}.items()`	`True`	需显式调用 `items()`

10.str()

特性	说明
函数定义	`str(object='')` --- 将对象转换为字符串形式
返回值	字符串（`str` 类型）
参数类型	任何Python对象
无参数调用	`str()` 返回空字符串 `''`
本质	调用对象的 `__str__()` 方法

不同数据类型的转换

输入类型	示例代码	输出结果	说明
整数	`str(123)`	`'123'`	数字转字符串
浮点数	`str(3.14)`	`'3.14'`	保留原格式
布尔值	`str(True)`	`'True'`	首字母大写
None	`str(None)`	`'None'`	字符串'None'
列表	`str([1, 2, 3])`	`'[1, 2, 3]'`	带方括号和逗号
元组	`str((1, 2))`	`'(1, 2)'`	带圆括号
字典	`str({'a': 1})`	`"{'a': 1}"`	带花括号
集合	`str({1, 2})`	`'{1, 2}'`	带花括号

11.上下文管理器简介

特性	说明
定义	通过 `__enter__` 和 `__exit__` 方法管理资源的对象
核心语法	`with` 语句
主要用途	自动管理资源（文件、锁、数据库连接等）
优势	确保资源正确释放，即使发生异常也会清理

工作原理

阶段	触发时机	执行操作	对应方法
进入	进入 `with` 代码块前	获取/打开资源	`__enter__()`
执行	运行代码块	使用资源	-
退出	离开代码块时（正常/异常）	释放/关闭资源	`__exit__()`

常见使用示例

场景	传统写法	上下文管理器写法
文件操作	`f = open('file.txt')` `data = f.read()` `f.close()`	`with open('file.txt') as f:` `data = f.read()`
线程锁	`lock.acquire()` `# 操作` `lock.release()`	`with lock:` `# 操作`
数据库连接	`conn = connect()` `cursor = conn.cursor()` `conn.close()`	`with connect() as conn:` `cursor = conn.cursor()`

12.string 模块提供的字符串常量

常量	值	说明
`string.ascii_letters`	`'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'`	所有ASCII字母（大小写）
`string.ascii_lowercase`	`'abcdefghijklmnopqrstuvwxyz'`	所有小写ASCII字母
`string.ascii_uppercase`	`'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`	所有大写ASCII字母
`string.digits`	`'0123456789'`	十进制数字
`string.hexdigits`	`'0123456789abcdefABCDEF'`	十六进制数字
`string.octdigits`	`'01234567'`	八进制数字
`string.punctuation`	`'!"#$%&\'()*+,-./:;<=>?@[\\]^_\`{\|}~'` \| 标点符号 \|
`string.whitespace`	`' \t\n\r\x0b\x0c'`	空白字符（空格、制表、换行等）
`string.printable`	digits + ascii_letters + punctuation + whitespace	所有可打印字符

13.`str.find()`

特性	说明
方法定义	`str.find(sub[, start[, end]])`
功能	返回子串第一次出现的索引，不存在返回 `-1`
返回值	整数（索引位置或 `-1`）
不报错	找不到时不抛出异常（与 `index()` 区别）

参数说明

参数	含义	默认值	说明
`sub`	要搜索的子字符串	必填	不能省略
`start`	搜索起始索引	`0`	包含此位置
`end`	搜索结束索引	`len(s)`	不包含此位置

基本示例

代码	返回值	说明
`"Hello World".find("World")`	`6`	找到返回索引
`"Hello World".find("Java")`	`-1`	找不到返回 -1
`"Hello World".find("o")`	`4`	返回第一次出现
`"aaaaa".find("aa")`	`0`	返回最左边匹配

带 start/end 参数

代码	返回值	说明
`"Hello World".find("o", 5)`	`7`	从索引5开始搜索
`"Hello World".find("o", 0, 5)`	`4`	在索引0-4范围内搜索
`"Hello World".find("o", 8, 11)`	`-1`	范围内找不到
`"Hello World".find("H", 1, 5)`	`-1`	起始位置在H之后

方法	找不到时	搜索方向	示例
`find()`	返回 `-1`	从左到右	`"abc".find("d")` → `-1`
`rfind()`	返回 `-1`	从右到左	`"abcabc".rfind("a")` → `3`
`index()`	抛出 `ValueError`	从左到右	`"abc".index("d")` → 报错
`rindex()`	抛出 `ValueError`	从右到左	`"abcabc".rindex("a")` → `3`

14.str.strip()

特性	说明
方法定义	`str.strip([chars])`
功能	去除字符串两端的指定字符（默认去除空白字符）
返回值	新的字符串（原字符串不变）
参数	`chars`（可选）--- 指定要去除的字符集合

三种 strip 方法对比

方法	去除位置	示例	结果
`strip()`	两端	`" hello ".strip()`	`'hello'`
`lstrip()`	左端（开头）	`" hello ".lstrip()`	`'hello '`
`rstrip()`	右端（结尾）	`" hello ".rstrip()`	`' hello'`

默认行为（去除空白字符）

空白字符	转义	说明
空格	`' '`	普通空格
制表符	`\t`	Tab键
换行符	`\n`	换行
回车符	`\r`	回车
换页符	`\f`	换页
垂直制表符	`\v`	垂直制表

指定字符参数

代码	结果	说明
`"..hello..".strip(".")`	`'hello'`	去除两端的点号
`"###hello###".strip("#")`	`'hello'`	去除两端的井号
`"abchelloabc".strip("abc")`	`'hello'`	去除 a/b/c 任意组合
`"123hello456".strip("0123456789")`	`'hello'`	去除所有数字

15.str.replace()

特性	说明
方法定义	`str.replace(old, new[, count])`
功能	将字符串中的指定子串替换为新的子串
返回值	新的字符串（原字符串不变）
参数	`old` - 要被替换的子串 `new` - 替换后的子串 `count`（可选）- 替换的最大次数(整数)

基本用法

代码	结果	说明
`"hello".replace("l", "x")`	`'hexxo'`	替换所有匹配
`"hello".replace("l", "L", 1)`	`'heLlo'`	只替换第1次
`"hello".replace("l", "L", 2)`	`'heLLo'`	只替换前2次
`"hello".replace("z", "x")`	`'hello'`	找不到不报错

count 参数示例

代码	结果	说明
`"aaaaa".replace("a", "b")`	`'bbbbb'`	全部替换
`"aaaaa".replace("a", "b", 0)`	`'aaaaa'`	替换0次
`"aaaaa".replace("a", "b", 2)`	`'bbaaa'`	只替换前2个
`"aaaaa".replace("a", "b", 10)`	`'bbbbb'`	count超过总数=全部替换

16.str.upper() VS str.lower()

特性	`str.upper()`	`str.lower()`
功能	将字符串中的所有字母字符转换为大写	将字符串中的所有字母字符转换为小写
语法	`s.upper()`	`s.lower()`
返回值	新的字符串（全大写）	新的字符串（全小写）
原字符串	不变（返回新字符串）	不变（返回新字符串）
非字母字符	保持不变	保持不变

基本示例

代码	`upper()` 结果	`lower()` 结果
`"Hello".upper()` / `"Hello".lower()`	`'HELLO'`	`'hello'`
`"Python3.14".upper()` / `".lower()`	`'PYTHON3.14'`	`'python3.14'`
`"AbCdEf".upper()` / `".lower()`	`'ABCDEF'`	`'abcdef'`
`"中文English".upper()` / `".lower()`	`'中文ENGLISH'`	`'中文english'`

非字母字符处理

输入	`upper()`	`lower()`	说明
`"123!@#"`	`'123!@#'`	`'123!@#'`	数字、标点不变
`"Hello 世界"`	`'HELLO 世界'`	`'hello 世界'`	中文不变
`"a b\tc\n"`	`'A B\tC\n'`	`'a b\tc\n'`	空白字符不变
`"True/False"`	`'TRUE/FALSE'`	`'true/false'`	斜杠等不变

17.str.join()

特性	说明
方法定义	`str.join(iterable)`
功能	使用指定的字符串作为分隔符，将一个可迭代对象中的元素连接成一个新的字符串
返回值	新的字符串
调用方式	`分隔符.join(可迭代对象)`
常见用途	列表/元组元素拼接、字符串拼接、路径构建

可迭代对象中的元素必须是字符串

语法结构

组成部分	说明	示例
分隔符	`join` 前面的字符串，用于连接各个元素	`", "`、`" "`、`""`
可迭代对象	要连接的元素集合	列表、元组、字符串等

基本示例

代码	结果	说明
`",".join(["a", "b", "c"])`	`'a,b,c'`	用逗号连接列表
`" ".join(["Hello", "World"])`	`'Hello World'`	用空格连接
`"".join(["H", "e", "l", "l", "o"])`	`'Hello'`	空字符串连接（合并）
`"-".join(("2024", "01", "15"))`	`'2024-01-15'`	用连字符连接元组
`"," .join("abc")`	`'a,b,c'`	连接字符串（逐个字符）

不同可迭代对象示例

可迭代类型	代码	结果
列表	`"	".join(["x", "y", "z"])`
元组	`" ".join(("a", "b", "c"))`	`'a b c'`
字符串	`"+".join("123")`	`'1+2+3'`
集合	`",".join({"A", "B", "C"})`	顺序不定（如 `'A,B,C'`）
range	`",".join(str(i) for i in range(3))`	`'0,1,2'`

18.str.split()

见 Python学习3

19.str.count()

特性	说明
方法定义	`str.count(sub[, start[, end]])`
功能	返回子串在字符串中非重叠出现的次数
返回值	整数（`int` 类型）
找不到时	返回 `0`（不报错）
大小写	区分大小写

参数说明

参数	默认值	说明
`sub`	必填	要计数的子字符串
`start`	`0`	搜索起始索引（包含）
`end`	`len(s)`	搜索结束索引（不包含）

基本示例

代码	结果	说明
`"hello".count("l")`	`2`	统计字符 `l` 出现次数
`"hello".count("z")`	`0`	找不到返回 0
`"hello".count("ll")`	`0`	`"ll"` 不存在
`"hello".count("he")`	`1`	统计子串
`"aaaa".count("aa")`	`2`	非重叠匹配

start 和 end 参数

代码	结果	说明
`"hello world".count("o")`	`2`	整个字符串
`"hello world".count("o", 5)`	`1`	从索引5开始
`"hello world".count("o", 0, 5)`	`1`	索引0-4范围内
`"hello world".count("o", 5, 8)`	`0`	索引5-7范围内

非重叠匹配（重要）

代码	结果	说明
`"aaaa".count("aa")`	`2`	匹配索引(0,1)和(2,3)，不重叠
`"ababa".count("aba")`	`1`	匹配索引(0,2)，(2,4)重叠不计数
`"nnnn".count("nn")`	`2`	匹配(0,1)和(2,3)

20.str.index()

特性	说明
方法定义	`str.index(sub[, start[, end]])`
功能	返回子串第一次出现的索引位置
找不到时	抛出 `ValueError` 异常
返回值	整数（索引位置）
大小写	区分大小写

index() vs find() 对比（重要）

对比项	`index()`	`find()`
找不到时	抛出 `ValueError`	返回 `-1`
适用场景	确定子串一定存在	不确定子串是否存在
异常处理	需要 `try-except`	只需判断 `!= -1`
性能	基本相同	基本相同

参数说明

参数	默认值	说明
`sub`	必填	要查找的子字符串
`start`	`0`	搜索起始索引（包含）
`end`	`len(s)`	搜索结束索引（不包含）

基本示例

代码	结果	说明
`"hello".index("e")`	`1`	返回第一次出现位置
`"hello".index("l")`	`2`	返回第一个 `l` 的位置
`"hello".index("z")`	`ValueError`	找不到抛异常
`"hello".index("ll")`	`2`	子串起始位置

start 和 end 参数

代码	结果	说明
`"hello world".index("o")`	`4`	整个字符串搜索
`"hello world".index("o", 5)`	`7`	从索引5开始搜索
`"hello world".index("o", 0, 5)`	`4`	索引0-4范围内
`"hello world".index("o", 5, 8)`	`ValueError`	索引5-7范围内没有 `o`

21.str.maketrans() 与 str.translate()

复制代码

# 标准配合使用流程
trans_table = str.maketrans("aeiou", "12345")  # 创建映射表
result = "hello".translate(trans_table)         # 应用转换
print(result)  # 'h2ll4'

特性	`str.maketrans()`	`str.translate()`
功能	创建字符映射转换表	使用转换表对字符串进行转换
调用方式	类方法：`str.maketrans(...)`	实例方法：`s.translate(table)`
返回值	转换表（字典或映射对象）	新的字符串
参数	1个、2个或3个参数	1个必需参数（转换表）
常见用途	配合 `translate()` 使用	批量字符替换、删除字符

`maketrans()` 的三种调用形式

形式	参数	说明	示例
形式1	`x, y, z`	`x` 和 `y` 等长字符串（一一映射） `z` 是要删除的字符（可选）	`str.maketrans("abc", "123", " ")`
形式2	`x, y`	两个等长字符串，字符一一映射	`str.maketrans("abc", "123")`
形式3	`x`	一个字典，键为字符的Unicode码点，值为对应映射	`str.maketrans({97: 49, 98: 50})`

复制代码

# 将 a→1, b→2, c→3，并删除空格
trans = str.maketrans("abc", "123", " ")
print("a b c".translate(trans))  # '123'

# 将 a→1, b→2, c→3
trans = str.maketrans("abc", "123")
print("cab".translate(trans))  # '312'

# 使用 Unicode 码点映射
trans = str.maketrans({
    ord('a'): '1',
    ord('b'): '2',
    ord('c'): '3'
})
print("abc".translate(trans))  # '123'

方法	方向	找不到时	示例
`index()`	从左到右（首次）	`ValueError`	`"abab".index("ab")` → `0`
`rindex()`	从右到左（末次）	`ValueError`	`"abab".rindex("ab")` → `2`
`find()`	从左到右（首次）	`-1`	`"abab".find("ab")` → `0`
`rfind()`	从右到左（末次）	`-1`	`"abab".rfind("ab")` → `2`