【第6章 字符串】Python 字符串常用操作完全教程（含代码演示）

{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Python 字符串常用操作完全教程（含代码演示）\n",
"> 基于《Python字符串常用操作速查表》v1.0 编写，配套可运行代码示例，适合边学边练\n",
"\n",
"📌 核心须知：\n",
"- 字符串（str）是不可变类型：所有修改操作均返回新字符串，原字符串不变\n",
"- 时间复杂度说明：O(1)=常数级（快），O(n)=线性级（随长度增长），O(k)=取决于参数长度\n",
"- 通用警告：避免索引越界、空字符串无效访问、编码字符集不匹配"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 一、字符串核心特性与字符串比大小\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 1. 不可变性演示（修改操作返回新串）\n",
"s = "hello"\n",
"s_upper = s.upper() # 转为大写，返回新串\n",
"print("\n原字符串：", s) # 原串不变,不可变性\n",
"print("新字符串：", s_upper) # 新串生效"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 2. 长度获取（O(1) 高效）\n",
"s1 = "hello"\n",
"print("\n字符串长度：", len(s1)) # 内置函数 len()\n",
"s2=""\n",
"print("空串长度：", len(s2))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 3. 字母大小写比较（大写字母编码 < 小写字母编码）\n",
"print("Apple" < "banana") # True（'A'=65 < 'b'=98，首字符已决定结果）\n",
"print("abc" > "abd") # False（前2个字符相同，第3个 'c'=99 < 'd'=100）\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 4. 数字与字母比较（数字编码 < 字母编码）\n",
"print("123" < "abc") # True（'1'=49 < 'a'=97）\n",
"print("999" > "a") # False（'9'=57 < 'a'=97）\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"True\n"
]
}
],
"source": [
"# 5. 长度不同的情况（前N字符相同，长度长的更大）\n",
"print("hello" < "helloworld") # True（前5个字符相同，后者更长）\n",
"print("abc" > "ab") # True（前2个字符相同，前者更长）\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 6. 中文比较（按 Unicode 编码顺序）\n",
"print("北京" < "上海") # True（'北'=21271 < '上'=19978？不，实际运行：'北'=21271，'上'=19978 → 21271>19978，所以输出 False）\n",
"# 验证中文编码\n",
"print(ord('北')) # 21271\n",
"print(ord('上')) # 19978\n",
"print("北京" > "上海") # True（首字符 '北' 编码更大）\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 7. 链式比较\n",
"print("a" < "b" < "c") # True（等价于 ("a"<"b") and ("b"<"c")）"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 二、字符串核心操作（含代码演示）\n",
"按「增/删/改/查/进阶」分类，对应速查表核心操作"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### （一）增/拼接操作"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 1. 直接拼接（+ 运算符）\n",
"s1 = "Hello"\n",
"s2 = "World"\n",
"s_concat = s1 + " " + s2\n",
"print("直接拼接：", s_concat) # 输出：Hello World\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 2. 批量拼接（join() 高效，推荐！）\n",
"str_list = ["Python", "Java", "C++"]\n",
"s_join = "-".join(str_list) # 用 "-" 分隔\n",
"s_join_empty = "".join(str_list) # 无分隔符拼接\n",
"print("\njoin() 批量拼接：", s_join)\n",
"print("无分隔符拼接：", s_join_empty)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 3. 重复拼接（* 运算符）\n",
"s_repeat = "ab" * 3\n",
"print("\n重复拼接：", s_repeat) # 输出：ababab\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 4. 格式化拼接（3种方式）\n",
"name = "张三"\n",
"age = 25\n",
"score = 98.5\n",
"\n",
"# f-string（3.6+ 推荐，简洁高效）\n",
"s_f = f"姓名：{name}，年龄：{age}，分数：{score:.1f}" # :.1f 保留1位小数\n",
"# format()（兼容所有版本）\n",
"s_format = "姓名：{}，年龄：{}，分数：{:.2f}".format(name, age, score)\n",
"# % 格式化（旧式，兼容旧代码）\n",
"s_percent = "姓名：%s，年龄：%d，分数：%.2f" % (name, age, score)\n",
"\n",
"print("\nf-string：", s_f)\n",
"print("format()：", s_format)\n",
"print("% 格式化：", s_percent)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### （二）删/截取操作"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 1. 切片截取（左闭右开，支持步长）\n",
"s = "Python字符串操作"\n",
"# 基础切片：[start🔚step]\n",
"print("原字符串：", s)\n",
"print("截取前6个字符：", s[:6]) # 从开头到索引5（Python）\n",
"print("截取第7-10个字符：", s[6:10]) # 索引6到9（字符串）\n",
"print("反转字符串：", s[::-1]) # step=-1 反转\n",
"print("隔1个字符截取：", s[::2]) # 0,2,4...索引\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 2. 删除首尾字符（strip/lstrip/rstrip）\n",
"s_strip = " ,Python！ "\n",
"print("\n原字符串：", repr(s_strip)) # repr() 显示空白字符\n",
"print("删除首尾空格和逗号：", s_strip.strip(" ,")) # 删除指定字符\n",
"print("仅删开头空格：", s_strip.lstrip())\n",
"print("仅删结尾感叹号和空格：", s_strip.rstrip(" ！"))\n",
"\n",
"# 例1：移除字符串两端的多种标点符号\n",
"txt = "!!!Hello, World!!!"\n",
"cleaned = txt.strip("!.,")\n",
"print(cleaned) # 输出: "Hello, World"\n",
"\n",
"# 例2：移除字符串两端的括号和引号\n",
"txt = '''(["Hello"])'''\n",
"cleaned = txt.strip('''()"[]''')\n",
"print(cleaned) # 输出: "Hello"\n",
"\n",
"# 例3：移除字符串两端的数字和符号\n",
"txt = "123-ABC-456"\n",
"cleaned = txt.strip("0123456789-")\n",
"print(cleaned) # 输出: "ABC"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 3. 过滤字符（推导式+join()）\n",
"s_filter = "Python123字符串456"\n",
"# 保留字母\n",
"s_alpha = ''.join([c for c in s_filter if c.isalpha()])\n",
"# 保留数字\n",
"s_digit = ''.join([c for c in s_filter if c.isdigit()])\n",
"print("\n保留字母：", s_alpha)\n",
"print("保留数字：", s_digit)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 4. 替换删除（replace() 替换为空串）\n",
"s_replace = "abacadae"\n",
"s_del = s_replace.replace("a", "", 2) # 删除前2个"a"\n",
"print("\n删除前2个'a'：", s_del) # 输出：bcadae"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### （三）改/转换操作"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 1. 大小写转换\n",
"s_case = "Python 字符串 OPERATIONS"\n",
"print("原字符串：", s_case)\n",
"print("全大写：", s_case.upper())\n",
"print("全小写：", s_case.lower())\n",
"print("标题格式（首字母大写）：", s_case.title())\n",
"print("字符串首字母大写：", s_case.capitalize())\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 2. 字符替换（replace()）\n",
"s_replace = "I love Python, Python is easy!"\n",
"s_new = s_replace.replace("Python", "Java", 1) # 仅替换第1个\n",
"print("\n替换后：", s_new)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 3. 编码与解码\n",
"s_encode = "中文编码测试"\n",
"# 编码为 bytes\n",
"b_utf8 = s_encode.encode("utf-8")\n",
"b_gbk = s_encode.encode("gbk")\n",
"print("\nUTF-8编码：", b_utf8)\n",
"print("GBK编码：", b_gbk)\n",
"# 解码为字符串\n",
"s_decode_utf8 = b_utf8.decode("utf-8")\n",
"print("UTF-8解码：", s_decode_utf8)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 4. 对齐填充\n",
"s_align = "Python"\n",
"print("\n左对齐（10位，'-'填充）：", s_align.ljust(10, "-"))\n",
"print("右对齐（10位，''填充）：", s_align.rjust(10, ""))\n",
"print("居中对齐（10位，'='填充）：", s_align.center(10, "="))\n",
"print("数字左补0（5位）：", "123".zfill(5)) # 适合数字字符串"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### （四）查/判断操作"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 1. 索引访问（O(1) 高效）\n",
"s = "Python"\n",
"print("第1个字符（索引0）：", s[0])\n",
"print("最后1个字符（负索引-1）：", s[-1])\n",
"print("第3-5个字符：", s[2:5]) # 索引2-4（左闭右开）\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 2. 查找子串（find/index）\n",
"s_find = "Python is powerful, Python is easy"\n",
"print("\n'Python'首次出现索引：", s_find.find("Python"))\n",
"print("'Python'从索引10开始查找：", s_find.find("Python", 10))\n",
"print("'Java'未找到返回-1：", s_find.find("Java"))\n",
"\n",
"# index() 未找到会报错，适合确定子串存在的场景\n",
"# print(s_find.index("Java")) # 抛出 ValueError\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 3. 统计子串次数（count()）\n",
"print("'Python'出现次数：", s_find.count("Python"))\n",
"print("'is'从索引5开始统计：", s_find.count("is", 5))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 4. 包含判断（in/not in）\n",
"print("\n是否包含'powerful'：", "powerful" in s_find)\n",
"print("是否包含'Java'：", "Java" not in s_find)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 5. 开头/结尾判断（startswith/endswith）\n",
"s_prefix = "https://www.python.org"\n",
"print("是否以'https'开头：", s_prefix.startswith("https"))\n",
"print("是否以'.org'结尾：", s_prefix.endswith(".org"))\n",
"# 支持多个前缀/后缀（元组形式）\n",
"print("是否以'http'或'https'开头：", s_prefix.startswith(("http", "https")))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 6. 字符类型判断\n",
"s_type = "Python123 测试"\n",
"print("\n是否全为字母：", s_type.isalpha())\n",
"print("是否全为数字：", "123456".isdigit())\n",
"print("是否为字母或数字：", "Python123".isalnum())\n",
"print("是否为空白字符：", " \t\n".isspace())\n",
"print("是否为标题格式：", "Python Is Easy".istitle())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### （五）进阶操作"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 1. 分割字符串（split/splitlines）\n",
"s_split = "Python,Java,C++,Go"\n",
"# 按逗号分割，默认分割所有\n",
"print("按逗号分割：", s_split.split(","))\n",
"# 最多分割2次\n",
"print("最多分割2次：", s_split.split(",", maxsplit=2))\n",
"\n",
"# 按换行符分割（支持 \n/\r/\r\n）\n",
"s_lines = "第一行\n第二行\r第三行\r\n第四行"\n",
"print("\n按换行符分割：", s_lines.splitlines())\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 2. partition 分割（返回三元组）\n",
"s_part = "name:张三,age:25"\n",
"print("\n按':'分割（首次出现）：", s_part.partition("😊)\n",
"print("按','分割（从右首次出现）：", s_part.rpartition(","))\n",
"\n",
"# 3. 字符翻译（translate + maketrans）\n",
"# 创建映射表：a→x, b→y, c→z\n",
"trans_table = str.maketrans({"a": "x", "b": "y", "c": "z"})\n",
"s_trans = "abc123cba"\n",
"print("\n字符翻译后：", s_trans.translate(trans_table))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 4. 遍历字符（for 循环/enumerate）\n",
"s_iter = "Python"\n",
"print("\n遍历字符：")\n",
"for c in s_iter:\n",
" print(c, end=" ")\n",
"\n",
"# 枚举遍历（索引+字符）\n",
"print("\n\n枚举遍历（索引起始为1）：")\n",
"for i, c in enumerate(s_iter, start=1):\n",
" print(f"第{i}个字符：{c}")\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 5. 字符去重（保留顺序）\n",
"s_duplicate = "abacadaeaf"\n",
"# 利用字典3.7+有序性去重（键唯一且保留插入顺序）\n",
"s_unique = ''.join(dict.fromkeys(s_duplicate))\n",
"print("字符去重（保留顺序）：", s_unique) # 输出：abcedf\n",
"\n",
"# 6. 制表符替换（expandtabs）\n",
"s_tab = "Name\tAge\tCity\tScore"\n",
"print("\n原字符串（含制表符）：", s_tab)\n",
"print("制表符替换为4个空格：", s_tab.expandtabs(4))\n",
"print("制表符替换为8个空格（默认）：", s_tab.expandtabs())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 三、实战案例（综合应用）\n",
"结合多个字符串操作，解决实际开发中的常见问题"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 案例1：用户输入格式化（去除无效字符+统一格式）\n",
"def format_user_input(input_str):\n",
" """\n",
" 功能：处理用户输入，去除首尾空格、特殊字符，首字母大写\n",
" 参数：input_str - 用户原始输入\n",
" 返回：格式化后的字符串\n",
" """\n",
" # 1. 去除首尾空格和标点符号\n",
" cleaned = input_str.strip(""" !@#$%^&*()_+-=[]{{}}|;':",./<>?)""")\n",
" # 2. 首字母大写，其余小写（统一格式）\n",
" formatted = cleaned.capitalize()\n",
" return formatted\n",
"\n",
"# 测试案例1\n",
"user_inputs = [" zhang san! ", "LI SI@", " wang wu123 ", ""]\n",
"print("用户输入格式化结果：")\n",
"for idx, input_str in enumerate(user_inputs, 1):\n",
" result = format_user_input(input_str)\n",
" print(f"{idx}. 原始输入：{repr(input_str)} → 格式化后：{repr(result)}")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 四、核心知识点总结\n",
"### 1. 不可变类型核心原则\n",
"- 所有修改操作（upper()、replace()、strip() 等）均返回新字符串，原字符串不变\n",
"- 示例：s = \"hello\" → s.upper() 生成新串 \"HELLO\"，s 仍为 \"hello\"\n",
"- 优化建议：避免频繁用 + 拼接字符串（多次创建新对象），优先用 str.join()\n",
"\n",
"### 2. 高效操作推荐\n",
"| 操作场景 | 推荐方法 | 时间复杂度 | 避免用法 |\n",
"|----------|----------|------------|----------|\n",
"| 批量拼接 | str.join(iterable) | O(k) | 多次 s1 + s2 + s3 |\n",
"| 索引访问 | s[i] / s[-1] | O(1) | 转换为列表后访问（多此一举） |\n",
"| 空串判断 | if not s | O(1) | if len(s) == 0（等价但繁琐） |\n",
"| 多字符替换 | str.translate() | O(n) | 多次 str.replace() |\n",
"\n",
"### 3. 常见坑点提醒\n",
"- 索引越界：字符串索引范围 0 ≤ i < len(s)，负索引 -len(s) ≤ i ≤ -1，超出会抛 IndexError\n",
"- 编码问题：encode() 与 decode() 字符集需一致（如均用 UTF-8），否则抛 UnicodeDecodeError\n",
"- strip() 误区：s.strip(\"ab\") 是删除首尾所有 'a' 或 'b'，而非删除 \"ab\" 子串\n",
"- 字符类型判断：isdigit() 仅匹配数字字符（0-9/全角数字），不包含小数点和正负号（如 \"123.45\" 返回 False）\n",
"\n",
"### 4. 实用工具推荐\n",
"- 正则表达式：复杂文本提取（如手机号、邮箱）用 re 模块（需额外学习）\n",
"- collections.Counter：更简洁的字符计数（from collections import Counter; Counter(s)）\n",
"- textwrap 模块：文本换行、缩进格式化（适合长文本处理）"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 五、课后练习（巩固提升）\n",
"1. 编写函数，判断一个字符串是否是回文（正读和反读一致，如 "abcba"、"12321"）\n",
"2. 提取字符串中所有的邮箱地址（邮箱规则：包含 @ 和 .，如 "test@example.com"）\n",
"3. 将字符串 "hello world python is easy" 转换为 "Hello World Python Is Easy"（每个单词首字母大写）\n",
"4. 统计字符串中出现次数最多的字符（如果有多个，返回所有最多的字符）\n",
"\n",
"💡 提示：可结合本教程中的操作方法，尝试独立实现；遇到问题可查看代码示例或查阅速查表。"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.9"
}
},
"nbformat": 4,
"nbformat_minor": 4
}