刷完这100道题，Python3字符串操作再也不怕了（含详解）

原创已于 2025-10-11 14:15:26 修改 · 595 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言 #pip

于 2025-10-11 09:33:42 首次发布

Python 专栏收录该内容

101 篇文章

订阅专栏

文章目录

刷完这100道题，Python3字符串操作再也不怕了（含详解）

刷完这100道题，Python3字符串操作再也不怕了（含详解）

以下是100个Python3字符串练习题的详解与代码示例，涵盖字符串创建、访问、修改、查找、判断、格式化等核心操作，由浅入深排列，适合入门学习。

一、字符串基础（1-10）

1. 题目：创建一个字符串并打印

需求：创建内容为"Python字符串练习"的字符串，并打印输出。

s = "Python字符串练习"
print(s)  # 输出：Python字符串练习

解析：用双引号或单引号包裹文本即可创建字符串，print()函数用于输出。

2. 题目：计算字符串长度

需求：计算字符串"Hello, World!"的长度（包含空格和标点）。

s = "Hello, World!"
print(len(s))  # 输出：13

解析：len()函数返回字符串中字符的数量（包括空格、标点等所有字符）。

3. 题目：访问字符串中的单个字符

需求：获取字符串"Python"中索引为2的字符（索引从0开始）。

s = "Python"
print(s[2])  # 输出：t

解析：字符串支持通过[索引]访问单个字符，索引从0开始计数（0对应第一个字符）。

4. 题目：访问字符串中的最后一个字符

需求：获取字符串"数据结构"的最后一个字符（不使用具体索引值）。

s = "数据结构"
print(s[-1])  # 输出：构

解析：Python支持负索引，-1表示最后一个字符，-2表示倒数第二个，以此类推。

5. 题目：字符串切片（获取子串）

需求：从字符串"abcdefgh"中截取索引2到5的子串（包含2，不包含5）。

s = "abcdefgh"
print(s[2:5])  # 输出：cde

解析：切片语法为[start:end]，截取从start到end-1的字符，省略start默认从0开始，省略end默认到末尾。

6. 题目：截取字符串前3个字符

需求：获取字符串"机器学习"的前3个字符。

s = "机器学习"
print(s[:3])  # 输出：机器学

解析：[:3]等价于[0:3]，截取从开头到索引2的字符。

7. 题目：截取字符串后4个字符

需求：获取字符串"Python编程基础"的后4个字符。

s = "Python编程基础"
print(s[-4:])  # 输出：编程基础

解析：[-4:]表示从倒数第4个字符开始截取到末尾。

8. 题目：字符串步长切片（间隔取字符）

需求：从字符串"0123456789"中每隔1个字符取一个（即取偶数索引字符）。

s = "0123456789"
print(s[::2])  # 输出：02468

解析：切片完整语法为[start:end:step]，step=2表示每隔1个字符取一个（步长为2）。

9. 题目：反转字符串

需求：将字符串"abcdef"反转成"fedcba"。

s = "abcdef"
print(s[::-1])  # 输出：fedcba

解析：[::-1]表示从末尾开始，步长为-1（反向），实现字符串反转。

10. 题目：判断字符串是否为空

需求：检查字符串""（空字符串）和" "（空格字符串）是否为空。

s1 = ""
s2 = " "
print(len(s1) == 0)  # 输出：True（空字符串）
print(len(s2) == 0)  # 输出：False（空格字符串非空）

解析：空字符串长度为0，而包含空格的字符串长度至少为1。

二、字符串拼接与重复（11-20）

11. 题目：拼接两个字符串

需求：将"Hello"和"Python"拼接成"HelloPython"。

s1 = "Hello"
s2 = "Python"
print(s1 + s2)  # 输出：HelloPython

解析：+运算符可用于字符串拼接，将两个字符串合并为一个。

12. 题目：拼接多个字符串

需求：将"我"、“爱”、“Python"拼接成"我爱Python”（中间加空格）。

s1 = "我"
s2 = "爱"
s3 = "Python"
print(f"{s1} {s2} {s3}")  # 输出：我 爱 Python

解析：f-string（格式化字符串）可便捷拼接多个字符串并添加分隔符。

13. 题目：重复字符串

需求：将字符串"ab"重复3次，得到"ababab"。

s = "ab"
print(s * 3)  # 输出：ababab

解析：*运算符可用于字符串重复，s * n表示将s重复n次。

14. 题目：用分隔符拼接列表元素

需求：将列表[“a”, “b”, “c”]用"-“拼接成"a-b-c”。

lst = ["a", "b", "c"]
print("-".join(lst))  # 输出：a-b-c

解析：str.join(iterable)方法用str作为分隔符，将可迭代对象（如列表）中的元素拼接成字符串。

15. 题目：拼接字符串与数字

需求：将字符串"年龄：“和数字18拼接成"年龄：18”。

s = "年龄："
age = 18
print(s + str(age))  # 输出：年龄：18

解析：不同类型（字符串与数字）不能直接拼接，需用str()将数字转为字符串。

16. 题目：用f-string拼接变量

需求：已知name = "张三"，score = 95，拼接成"张三的成绩是95分"。

name = "张三"
score = 95
print(f"{name}的成绩是{score}分")  # 输出：张三的成绩是95分

解析：f-string中用{变量名}直接嵌入变量，无需显式转换类型。

17. 题目：拼接多行字符串

需求：创建一个包含三行文本的字符串，内容为：

第一行
第二行
第三行

s = "第一行\n第二行\n第三行"
print(s)
# 输出：
# 第一行
# 第二行
# 第三行

解析：\n是换行符，用于在字符串中插入换行。

18. 题目：用三引号创建多行字符串

需求：用三引号创建与上题相同的多行字符串。

s = """第一行
第二行
第三行"""
print(s)
# 输出同上

解析：三引号（"""或'''）可直接包含换行，无需手动添加\n，适合创建多行文本。

19. 题目：拼接时去除多余空格

需求：将" hello “（前后有空格）和” world “拼接，并去除整体前后空格，得到"hello world”。

s1 = " hello "
s2 = " world "
print((s1 + s2).strip())  # 输出：hello world

解析：strip()方法去除字符串前后的空白字符（空格、换行等），中间空格保留。

20. 题目：批量拼接带序号的字符串

需求：生成[“item1”, “item2”, “item3”]，并拼接成"item1, item2, item3"。

items = [f"item{i}" for i in range(1, 4)]
print(", ".join(items))  # 输出：item1, item2, item3

解析：先通过列表推导式生成带序号的字符串列表，再用join()拼接。

三、大小写转换（21-30）

21. 题目：字符串转大写

需求：将"hello"转换为"HELLO"。

s = "hello"
print(s.upper())  # 输出：HELLO

解析：upper()方法将字符串中所有小写字母转为大写，非字母字符不变。

22. 题目：字符串转小写

需求：将"HELLO WORLD"转换为"hello world"。

s = "HELLO WORLD"
print(s.lower())  # 输出：hello world

解析：lower()方法将字符串中所有大写字母转为小写。

23. 题目：首字母大写，其余小写

需求：将"hElLo"转换为"Hello"。

s = "hElLo"
print(s.capitalize())  # 输出：Hello

解析：capitalize()方法将字符串首字母转为大写，其余字母转为小写。

24. 题目：每个单词首字母大写

需求：将"hello world python"转换为"Hello World Python"。

s = "hello world python"
print(s.title())  # 输出：Hello World Python

解析：title()方法将每个单词的首字母转为大写，单词以空格分隔。

25. 题目：大小写反转

需求：将"Hello World"转换为"hELLO wORLD"（大写转小写，小写转大写）。

s = "Hello World"
print(s.swapcase())  # 输出：hELLO wORLD

解析：swapcase()方法反转字符串中所有字母的大小写。

26. 题目：判断字符串是否全为大写

需求：检查"PYTHON"和"Python"是否全为大写。

s1 = "PYTHON"
s2 = "Python"
print(s1.isupper())  # 输出：True
print(s2.isupper())  # 输出：False

解析：isupper()方法返回True当且仅当字符串中所有字母都是大写，且至少有一个字母。

27. 题目：判断字符串是否全为小写

需求：检查"python"和"Python"是否全为小写。

s1 = "python"
s2 = "Python"
print(s1.islower())  # 输出：True
print(s2.islower())  # 输出：False

解析：islower()方法返回True当且仅当字符串中所有字母都是小写，且至少有一个字母。

28. 题目：统一用户输入的大小写

需求：将用户输入的"yes"、“YES”、"Yes"统一转为"yes"进行判断。

user_input = input("请输入yes/no：")  # 假设输入"YES"
normalized = user_input.lower()
if normalized == "yes":
    print("确认")  # 输出：确认

解析：通过lower()将输入统一转为小写，避免因大小写不同导致判断错误。

29. 题目：格式化姓名（首字母大写）

需求：将"zhangsan"转换为"Zhangsan"（姓名首字母大写）。

name = "zhangsan"
print(name.capitalize())  # 输出：Zhangsan

解析：capitalize()适合处理姓名等需要首字母大写的场景。

30. 题目：标题格式化

需求：将"the lord of the rings"转换为"The Lord Of The Rings"（每个单词首字母大写）。

title = "the lord of the rings"
print(title.title())  # 输出：The Lord Of The Rings

解析：title()是标题格式化的便捷方法，自动处理每个单词的首字母。

四、查找与替换（31-45）

31. 题目：查找子串首次出现的位置

需求：查找"hello world"中"o"首次出现的索引。

s = "hello world"
print(s.find("o"))  # 输出：4

解析：find(sub)返回子串sub在字符串中首次出现的索引，未找到返回-1。

32. 题目：查找子串最后出现的位置

需求：查找"hello world"中"o"最后出现的索引。

s = "hello world"
print(s.rfind("o"))  # 输出：7

解析：rfind(sub)返回子串sub在字符串中最后出现的索引，未找到返回-1。

33. 题目：查找子串（找不到时抛异常）

需求：查找"python"中"y"的位置，若找不到则抛出异常。

s = "python"
try:
    print(s.index("y"))  # 输出：1
    print(s.index("x"))  # 未找到，抛ValueError
except ValueError:
    print("子串不存在")

解析：index(sub)与find(sub)类似，但子串未找到时会抛出ValueError，而非返回-1。

34. 题目：从指定位置开始查找

需求：从"abcabcabc"的索引3开始，查找"abc"首次出现的位置。

s = "abcabcabc"
print(s.find("abc", 3))  # 输出：3（索引3开始的第一个"abc"）

解析：find(sub, start)从start索引开始查找子串sub。

35. 题目：替换子串

需求：将"hello python"中的"python"替换为"world"，得到"hello world"。

s = "hello python"
print(s.replace("python", "world"))  # 输出：hello world

解析：replace(old, new)将字符串中所有old子串替换为new子串。

36. 题目：限制替换次数

需求：将"aaaabaaaa"中的前2个"a"替换为"x"，得到"xxaabaaaa"。

s = "aaaabaaaa"
print(s.replace("a", "x", 2))  # 输出：xxaabaaaa

解析：replace(old, new, count)的count参数限制替换次数（默认替换所有）。

37. 题目：替换多个不同子串

需求：将"a+b-cd"中的"+“替换为"加”，“-“替换为"减”，”“替换为"乘”。

s = "a+b-c*d"
replace_map = {"+": "加", "-": "减", "*": "乘"}
for old, new in replace_map.items():
    s = s.replace(old, new)
print(s)  # 输出：a加b减c乘d

解析：通过循环遍历替换映射，实现多个子串的批量替换。

38. 题目：判断字符串是否以指定子串开头

需求：检查"http://example.com"是否以"http://"开头。

s = "http://example.com"
print(s.startswith("http://"))  # 输出：True

解析：startswith(prefix)判断字符串是否以prefix开头，返回布尔值。

39. 题目：判断字符串是否以指定子串结尾

需求：检查"file.txt"是否以".txt"结尾。

s = "file.txt"
print(s.endswith(".txt"))  # 输出：True

解析：endswith(suffix)判断字符串是否以suffix结尾，返回布尔值。

40. 题目：检查多个可能的开头

需求：检查字符串是否以"http://"或"https://"开头。

s1 = "http://example.com"
s2 = "https://example.com"
s3 = "ftp://example.com"
prefixes = ("http://", "https://")
print(s1.startswith(prefixes))  # 输出：True
print(s2.startswith(prefixes))  # 输出：True
print(s3.startswith(prefixes))  # 输出：False

解析：startswith()可接受元组作为参数，检查是否以元组中的任一子串开头。

41. 题目：统计子串出现次数

需求：统计"ababaab"中"aba"出现的次数。

s = "ababaab"
print(s.count("aba"))  # 输出：2（位置0-2和2-4）

解析：count(sub)返回子串sub在字符串中出现的非重叠次数。

42. 题目：从指定范围统计子串次数

需求：在"abcabcabc"的索引2到8范围内，统计"abc"出现的次数。

s = "abcabcabc"
print(s.count("abc", 2, 8))  # 输出：1（仅索引3-5的"abc"在范围内）

解析：count(sub, start, end)在[start, end)范围内统计子串出现次数。

43. 题目：提取文件名中的扩展名

需求：从"document.pdf"中提取扩展名".pdf"。

filename = "document.pdf"
if filename.endswith("."):
    ext = ""
else:
    ext = "." + filename.split(".")[-1] if "." in filename else ""
print(ext)  # 输出：.pdf

解析：通过split(".")分割文件名，取最后一部分即为扩展名，再拼接"."。

44. 题目：去除字符串中的指定子串

需求：去除"a-b-c-d"中的所有"-“，得到"abcd”。

s = "a-b-c-d"
print(s.replace("-", ""))  # 输出：abcd

解析：将指定子串替换为空字符串，等价于删除该子串。

45. 题目：查找并替换HTML转义字符

需求：将"<div>“中的”<“替换为”<“，”>“替换为”>“，得到”

"。

html = "&lt;div&gt;"
html = html.replace("&lt;", "<").replace("&gt;", ">")
print(html)  # 输出：<div>

解析：HTML转义字符的替换是文本处理中的常见场景，可通过多次replace()实现。

五、分割与连接（46-55）

46. 题目：按空格分割字符串

需求：将"hello world python"按空格分割成列表[“hello”, “world”, “python”]。

s = "hello world python"
print(s.split())  # 输出：['hello', 'world', 'python']

解析：split()默认按任意数量的空白字符（空格、换行等）分割，自动忽略空字符串。

47. 题目：按指定字符分割字符串

需求：将"a,b,c,d"按逗号分割成列表[“a”, “b”, “c”, “d”]。

s = "a,b,c,d"
print(s.split(","))  # 输出：['a', 'b', 'c', 'd']

解析：split(sep)按指定分隔符sep分割字符串，返回包含子串的列表。

48. 题目：限制分割次数

需求：将"a-b-c-d"按"-"分割，只分割2次，得到[“a”, “b”, “c-d”]。

s = "a-b-c-d"
print(s.split("-", 2))  # 输出：['a', 'b', 'c-d']

解析：split(sep, maxsplit)的maxsplit参数限制分割次数，剩余部分作为最后一个元素。

49. 题目：从右侧开始分割

需求：将"a-b-c-d"从右侧按"-"分割2次，得到[“a-b”, “c”, “d”]。

s = "a-b-c-d"
print(s.rsplit("-", 2))  # 输出：['a-b', 'c', 'd']

解析：rsplit(sep, maxsplit)从字符串右侧开始分割，适合按最后几个分隔符拆分的场景。

50. 题目：按换行分割多行字符串

需求：将"第一行\n第二行\n第三行"分割成每行一个元素的列表。

s = "第一行\n第二行\n第三行"
print(s.splitlines())  # 输出：['第一行', '第二行', '第三行']

解析：splitlines()专门用于分割多行字符串，会识别\n、\r\n等换行符。

51. 题目：用换行符连接列表元素

需求：将[“line1”, “line2”, “line3”]用换行符连接成多行字符串。

lines = ["line1", "line2", "line3"]
print("\n".join(lines))
# 输出：
# line1
# line2
# line3

解析："\n".join(lines)用换行符拼接列表元素，生成多行文本。

52. 题目：分割后过滤空字符串

需求：将"a,b,c"按逗号分割，并过滤掉空字符串，得到[“a”, “b”, “c”]。

s = "a,,b,,c"
parts = [p for p in s.split(",") if p]
print(parts)  # 输出：['a', 'b', 'c']

解析：split(",")会生成空字符串（因连续逗号），通过列表推导式过滤空值。

53. 题目：分割URL获取域名

需求：从"https://www.example.com/path"中提取域名"www.example.com"。

url = "https://www.example.com/path"
# 先分割掉协议部分，再分割路径
domain = url.split("//")[-1].split("/")[0]
print(domain)  # 输出：www.example.com

解析：通过多次分割，先去除协议（http://或https://），再去除路径部分，得到域名。

54. 题目：将字符串分割为键值对

需求：将"name=张三;age=18;gender=男"分割为字典{“name”:“张三”, “age”:“18”, “gender”:“男”}。

s = "name=张三;age=18;gender=男"
pairs = s.split(";")
result = {}
for pair in pairs:
    key, value = pair.split("=")
    result[key] = value
print(result)  # 输出：{'name': '张三', 'age': '18', 'gender': '男'}

解析：先按";“分割得到键值对字符串，再按”="分割每个键值对，构建字典。

55. 题目：拼接带分隔符的数字字符串

需求：将1-5的数字转为字符串后，用"|“拼接成"1|2|3|4|5”。

numbers = range(1, 6)
# 先转为字符串列表，再拼接
print("|".join(str(n) for n in numbers))  # 输出：1|2|3|4|5

解析：通过生成器表达式将数字转为字符串，再用join()拼接。

六、去除空白与填充（56-65）

56. 题目：去除字符串前后空白

需求：去除" hello world “前后的空格，得到"hello world”。

s = "  hello world  "
print(s.strip())  # 输出：hello world

解析：strip()去除字符串开头和结尾的所有空白字符（空格、制表符\t、换行符\n等）。

57. 题目：去除字符串左侧空白

需求：去除" left space "左侧的空格，得到"left space "。

s = "  left space  "
print(s.lstrip())  # 输出：left space

解析：lstrip()仅去除字符串左侧（开头）的空白字符。

58. 题目：去除字符串右侧空白

需求：去除" right space “右侧的空格，得到” right space"。

s = "  right space  "
print(s.rstrip())  # 输出：  right space

解析：rstrip()仅去除字符串右侧（结尾）的空白字符。

59. 题目：去除字符串前后指定字符

需求：去除"###hello###“前后的”#“，得到"hello”。

s = "###hello###"
print(s.strip("#"))  # 输出：hello

解析：strip(chars)可指定要去除的字符集（chars是字符串，包含所有要去除的字符）。

60. 题目：左侧填充字符至指定长度

需求：将"123"左侧用"0"填充至长度5，得到"00123"。

s = "123"
print(s.zfill(5))  # 输出：00123

解析：zfill(width)在字符串左侧用"0"填充，使总长度为width，适合数字补零场景。

61. 题目：左侧填充任意字符

需求：将"abc"左侧用"*“填充至长度10，得到”*******abc"。

s = "abc"
print(s.rjust(10, "*"))  # 输出：*******abc

解析：rjust(width, fillchar)将字符串右对齐，左侧用fillchar填充至总长度width。

62. 题目：右侧填充任意字符

需求：将"abc"右侧用"-“填充至长度8，得到"abc-----”。

s = "abc"
print(s.ljust(8, "-"))  # 输出：abc-----

解析：ljust(width, fillchar)将字符串左对齐，右侧用fillchar填充至总长度width。

63. 题目：居中对齐并填充字符

需求：将"center"居中对齐，两侧用"=“填充至长度10，得到"center”。

s = "center"
print(s.center(10, "="))  # 输出：==center==

解析：center(width, fillchar)将字符串居中，两侧用fillchar填充至总长度width。

64. 题目：处理用户输入的多余空格

需求：用户输入" 张三 “，去除前后空格后输出"张三”。

user_input = input("请输入姓名：").strip()  # 输入"  张三  "
print(user_input)  # 输出：张三

解析：用户输入常包含意外空格，strip()是预处理输入的常用操作。

65. 题目：格式化输出表格

需求：将数据按列对齐，输出如下表格：

姓名  | 年龄 | 成绩
张三  | 18   | 95
李四  | 20   | 88

# 数据
data = [
    ["姓名", "年龄", "成绩"],
    ["张三", "18", "95"],
    ["李四", "20", "88"]
]

# 按列格式化（每列左对齐，宽度8）
for row in data:
    print("|".join(cell.ljust(8) for cell in row))

# 输出：
# 姓名      |年龄      |成绩      
# 张三      |18        |95        
# 李四      |20        |88

解析：通过ljust(8)使每列宽度统一为8，实现表格对齐效果。

七、判断与检查（66-75）

66. 题目：判断字符串是否全为字母

需求：检查"Python"和"Python3"是否全由字母组成。

s1 = "Python"
s2 = "Python3"
print(s1.isalpha())  # 输出：True
print(s2.isalpha())  # 输出：False（包含数字3）

解析：isalpha()返回True当且仅当字符串非空且所有字符都是字母。

67. 题目：判断字符串是否全为数字

需求：检查"12345"和"123abc"是否全由数字组成。

s1 = "12345"
s2 = "123abc"
print(s1.isdigit())  # 输出：True
print(s2.isdigit())  # 输出：False（包含字母）

解析：isdigit()返回True当且仅当字符串非空且所有字符都是数字。

68. 题目：判断字符串是否为字母或数字

需求：检查"Python123"和"Python#123"是否由字母或数字组成。

s1 = "Python123"
s2 = "Python#123"
print(s1.isalnum())  # 输出：True
print(s2.isalnum())  # 输出：False（包含#）

解析：isalnum()返回True当且仅当字符串非空且所有字符是字母或数字。

69. 题目：判断字符串是否全为空格

需求：检查" “（三个空格）和” a "是否全为空格。

s1 = "   "
s2 = "  a "
print(s1.isspace())  # 输出：True
print(s2.isspace())  # 输出：False（包含字母a）

解析：isspace()返回True当且仅当字符串非空且所有字符都是空白字符。

70. 题目：检查字符串是否为标题格式

需求：检查"The Lord Of The Rings"和"the lord of the rings"是否为标题格式（每个单词首字母大写）。

s1 = "The Lord Of The Rings"
s2 = "the lord of the rings"
print(s1.istitle())  # 输出：True
print(s2.istitle())  # 输出：False

解析：istitle()返回True当且仅当字符串是标题格式（每个单词首字母大写，其余小写）。

71. 题目：验证用户名格式（字母开头，含字母数字）

需求：用户名需以字母开头，且仅包含字母和数字，检查"user123"和"123user"是否合法。

def is_valid_username(username):
    if not username:
        return False
    # 首字符是字母，且所有字符是字母或数字
    return username[0].isalpha() and username.isalnum()

print(is_valid_username("user123"))  # 输出：True
print(is_valid_username("123user"))  # 输出：False

解析：结合isalpha()和isalnum()实现简单的用户名格式验证。

72. 题目：验证密码强度（至少8位，含字母和数字）

需求：密码需至少8位，且同时包含字母和数字，检查"pass1234"和"password"是否合法。

def is_strong_password(password):
    if len(password) < 8:
        return False
    has_alpha = any(c.isalpha() for c in password)
    has_digit = any(c.isdigit() for c in password)
    return has_alpha and has_digit

print(is_strong_password("pass1234"))  # 输出：True
print(is_strong_password("password"))  # 输出：False（无数字）

解析：通过any()结合生成器表达式检查是否包含字母和数字，再验证长度。

73. 题目：判断字符串是否包含中文字符

需求：检查"Python编程"和"Python"是否包含中文字符。

def has_chinese(s):
    for c in s:
        # 中文字符的Unicode范围：\u4e00-\u9fa5
        if '\u4e00' <= c <= '\u9fa5':
            return True
    return False

print(has_chinese("Python编程"))  # 输出：True
print(has_chinese("Python"))      # 输出：False

解析：中文字符的Unicode编码范围是\u4e00-\u9fa5，遍历字符检查是否在此范围内。

74. 题目：检查字符串是否为纯英文

需求：检查"Hello World"和"Hello 世界"是否为纯英文（仅含字母、空格和标点）。

def is_english(s):
    # 检查所有字符是否为ASCII字符（英文及常见标点）
    return all(ord(c) < 128 for c in s)

print(is_english("Hello World!"))  # 输出：True
print(is_english("Hello 世界"))    # 输出：False（中文不在ASCII范围内）

解析：英文及常见标点属于ASCII字符（Unicode码<128），通过ord(c)获取字符编码判断。

75. 题目：判断字符串是否为回文

需求：回文是指正反读都相同的字符串（忽略大小写和非字母），检查"Level"和"Hello"是否为回文。

def is_palindrome(s):
    # 过滤非字母并转为小写
    filtered = [c.lower() for c in s if c.isalpha()]
    # 比较过滤后的列表与反转列表
    return filtered == filtered[::-1]

print(is_palindrome("Level"))  # 输出：True（过滤后为['l','e','v','e','l']）
print(is_palindrome("Hello"))  # 输出：False

解析：先过滤非字母字符并统一大小写，再比较原列表与反转列表是否相同。

八、格式化与进阶操作（76-100）

76. 题目：用format方法格式化字符串

需求：用format()将"姓名：{0}，年龄：{1}"中的占位符替换为"张三"和18。

s = "姓名：{0}，年龄：{1}"
print(s.format("张三", 18))  # 输出：姓名：张三，年龄：18

解析：format()方法用参数替换字符串中的{n}占位符（n是参数索引）。

77. 题目：用关键字参数格式化

需求：用format()将"姓名：{name}，年龄：{age}"中的占位符替换为"张三"和18。

s = "姓名：{name}，年龄：{age}"
print(s.format(name="张三", age=18))  # 输出：姓名：张三，年龄：18

解析：format()支持关键字参数，直接对应字符串中的命名占位符（如{name}）。

78. 题目：格式化数字保留2位小数

需求：将3.1415926格式化为保留2位小数的字符串"3.14"。

num = 3.1415926
print("{:.2f}".format(num))  # 输出：3.14

解析：格式说明符.2f表示保留2位小数的浮点数。

79. 题目：格式化整数补零至5位

需求：将123格式化为5位数字，不足补零，得到"00123"。

num = 123
print("{:05d}".format(num))  # 输出：00123

解析：格式说明符05d表示总长度5的整数，不足部分用0填充。

80. 题目：用f-string格式化数字

需求：已知pi = 3.14159，用f-string格式化输出"π的值约为3.14"（保留2位小数）。

pi = 3.14159
print(f"π的值约为{pi:.2f}")  # 输出：π的值约为3.14

解析：f-string中可用{变量:格式}直接指定格式，比format()更简洁。

81. 题目：统计每个字符出现的次数

需求：统计"abracadabra"中每个字符出现的次数，结果为字典。

s = "abracadabra"
count = {}
for c in s:
    count[c] = count.get(c, 0) + 1
print(count)  # 输出：{'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}

解析：通过字典记录每个字符的出现次数，get(c, 0)确保初始值为0。

82. 题目：提取字符串中的所有数字

需求：从"abc123def456"中提取所有数字，得到"123456"。

s = "abc123def456"
numbers = [c for c in s if c.isdigit()]
print("".join(numbers))  # 输出：123456

解析：用列表推导式筛选出所有数字字符，再用join()拼接。

83. 题目：提取字符串中的所有字母

需求：从"123abc456def"中提取所有字母，得到"abcdef"。

s = "123abc456def"
letters = [c for c in s if c.isalpha()]
print("".join(letters))  # 输出：abcdef

解析：类似上题，筛选字母字符并拼接。

84. 题目：去除字符串中的所有标点符号

需求：从"Hello, World! How are you?“中去除标点，得到"Hello World How are you”。

import string

s = "Hello, World! How are you?"
# 创建包含所有标点的集合
punctuation = set(string.punctuation)
# 筛选非标点字符
filtered = [c for c in s if c not in punctuation]
print("".join(filtered))  # 输出：Hello World How are you

解析：string.punctuation包含所有标点符号，通过列表推导式过滤。

85. 题目：将字符串中每个字符重复n次

需求：将"abc"中每个字符重复3次，得到"aaabbbccc"。

s = "abc"
n = 3
print("".join([c * n for c in s]))  # 输出：aaabbbccc

解析：列表推导式中每个字符重复n次，再拼接成字符串。

86. 题目：字符串中字符位置互换

需求：将"abcd"中索引0和1的字符互换，得到"bacd"。

s = "abcd"
# 字符串不可变，需转为列表操作
lst = list(s)
lst[0], lst[1] = lst[1], lst[0]
print("".join(lst))  # 输出：bacd

解析：字符串是不可变类型，需先转为列表修改，再转回字符串。

87. 题目：查找字符串中最长的连续相同字符

需求：在"aabbbccddddd"中找到最长的连续相同字符（“d”，长度5）。

s = "aabbbccddddd"
if not s:
    print("空字符串")
else:
    max_char = s[0]
    max_len = 1
    current_char = s[0]
    current_len = 1
    
    for c in s[1:]:
        if c == current_char:
            current_len += 1
            if current_len > max_len:
                max_len = current_len
                max_char = current_char
        else:
            current_char = c
            current_len = 1
    
    print(f"最长连续字符：{max_char}，长度：{max_len}")  # 输出：最长连续字符：d，长度：5

解析：遍历字符串，记录当前连续字符及其长度，实时更新最大值。

88. 题目：将字符串按单词反转

需求：将"hello world python"按单词反转，得到"python world hello"。

s = "hello world python"
words = s.split()
reversed_words = words[::-1]
print(" ".join(reversed_words))  # 输出：python world hello

解析：先分割为单词列表，反转列表后再拼接。

89. 题目：统计字符串中单词的数量

需求：统计"Hello world, how are you?"中单词的数量（以空格分隔，忽略标点）。

import string

s = "Hello world, how are you?"
# 去除标点后分割
translator = str.maketrans("", "", string.punctuation)
s_clean = s.translate(translator)
word_count = len(s_clean.split())
print(word_count)  # 输出：5

解析：先用str.maketrans()创建标点映射表，translate()去除标点，再分割统计单词数。

90. 题目：将字符串中每个单词的首字母和尾字母互换

需求：将"hello world"转换为"oellh dlorw"。

s = "hello world"
words = s.split()
result = []
for word in words:
    if len(word) <= 1:
        result.append(word)
    else:
        # 首字母和尾字母互换，中间字符不变
        swapped = word[-1] + word[1:-1] + word[0]
        result.append(swapped)
print(" ".join(result))  # 输出：oellh dlorw

解析：对每个单词，通过切片实现首字母与尾字母的互换。

91. 题目：用正则表达式匹配邮箱格式

需求：检查"test@example.com"和"test.example.com"是否为合法邮箱。

import re

def is_valid_email(email):
    # 简单邮箱正则：用户名@域名.后缀
    pattern = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
    return re.match(pattern, email) is not None

print(is_valid_email("test@example.com"))  # 输出：True
print(is_valid_email("test.example.com"))  # 输出：False

解析：正则表达式r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'可匹配大多数邮箱格式。

92. 题目：用正则表达式提取URL中的域名

需求：从"https://www.example.com/path?query=1"中提取域名"www.example.com"。

import re

url = "https://www.example.com/path?query=1"
# 匹配域名（协议后，第一个/前）
pattern = r'https?://([^/]+)'
match = re.search(pattern, url)
if match:
    print(match.group(1))  # 输出：www.example.com

解析：正则r'https?://([^/]+)'匹配"http://"或"https://"后的非/字符（即域名）。

93. 题目：用正则表达式替换敏感词

需求：将字符串中的"bad"替换为""，如"this is bad"→"this is"。

import re

s = "this is bad, very bad!"
censored = re.sub(r'bad', '***', s)
print(censored)  # 输出：this is ***, very ***!

解析：re.sub(pattern, repl, string)用repl替换string中所有匹配pattern的子串。

94. 题目：用正则表达式查找所有数字

需求：从"价格：99元，数量：5个，总价：495元"中提取所有数字[“99”, “5”, “495”]。

import re

s = "价格：99元，数量：5个，总价：495元"
numbers = re.findall(r'\d+', s)
print(numbers)  # 输出：['99', '5', '495']

解析：正则r'\d+'匹配一个或多个数字，re.findall()返回所有匹配的列表。

95. 题目：字符串加密（每个字符后移3位）

需求：将"abcXYZ"加密（每个字母后移3位，a→d，X→A），得到"defABC"。

def encrypt(s):
    result = []
    for c in s:
        if c.islower():
            # 小写字母：(ord(c) - ord('a') + 3) % 26 + ord('a')
            shifted = (ord(c) - 97 + 3) % 26 + 97
            result.append(chr(shifted))
        elif c.isupper():
            # 大写字母：(ord(c) - ord('A') + 3) % 26 + ord('A')
            shifted = (ord(c) - 65 + 3) % 26 + 65
            result.append(chr(shifted))
        else:
            # 非字母不变
            result.append(c)
    return "".join(result)

print(encrypt("abcXYZ"))  # 输出：defABC

解析：通过ASCII码计算字符后移3位的新字符，超出’z’或’Z’则循环到开头。

96. 题目：字符串解密（每个字符前移3位）

需求：将上题加密的"defABC"解密为"abcXYZ"。

def decrypt(s):
    result = []
    for c in s:
        if c.islower():
            shifted = (ord(c) - 97 - 3) % 26 + 97
            result.append(chr(shifted))
        elif c.isupper():
            shifted = (ord(c) - 65 - 3) % 26 + 65
            result.append(chr(shifted))
        else:
            result.append(c)
    return "".join(result)

print(decrypt("defABC"))  # 输出：abcXYZ

解析：与加密逻辑相反，每个字母前移3位，通过取模运算处理边界。

97. 题目：生成随机验证码（4位字母数字组合）

需求：生成一个4位随机验证码，包含大写字母、小写字母和数字。

import random
import string

# 所有可能的字符：大小写字母+数字
chars = string.ascii_letters + string.digits
# 随机选择4个字符
verification_code = ''.join(random.choice(chars) for _ in range(4))
print(verification_code)  # 输出：如"3Ab7"（随机结果）

解析：string.ascii_letters包含所有大小写字母，string.digits包含数字，通过random.choice()随机选择。

98. 题目：将长字符串按固定长度换行

需求：将"abcdefghijklmnopqrstuvwxyz"按每8个字符换一行。

s = "abcdefghijklmnopqrstuvwxyz"
line_length = 8
# 按固定长度切片，再用换行连接
lines = [s[i:i+line_length] for i in range(0, len(s), line_length)]
print("\n".join(lines))
# 输出：
# abcdefgh
# ijklmnop
# qrstuvwx
# yz

解析：通过列表推导式按line_length切片，再用\n连接实现换行。

99. 题目：统计字符串中元音字母的数量

需求：统计"Hello World"中元音字母（a,e,i,o,u，忽略大小写）的数量。

s = "Hello World"
vowels = {'a', 'e', 'i', 'o', 'u'}
count = 0
for c in s.lower():
    if c in vowels:
        count += 1
print(count)  # 输出：3（e, o, o）

解析：先将字符串转为小写，再统计属于元音集合的字符数量。

100. 题目：比较两个字符串的相似度（简单算法）

需求：计算"kitten"和"sitting"的相似度（相同位置字符的比例）。

def string_similarity(s1, s2):
    # 取较短字符串的长度
    min_len = min(len(s1), len(s2))
    # 统计相同位置的字符数
    matches = sum(1 for i in range(min_len) if s1[i] == s2[i])
    # 相似度 = 匹配数 / 较长字符串长度
    max_len = max(len(s1), len(s2))
    return matches / max_len if max_len != 0 else 1.0

print(string_similarity("kitten", "sitting"))  # 输出：0.428...（3/7）

解析：简单相似度算法：相同位置字符数除以较长字符串的长度，值越接近1则越相似。

总结

以上100题覆盖了Python字符串的核心操作，包括基础访问、拼接、转换、查找、替换、分割、格式化等，还涉及正则表达式和简单算法应用。通过练习这些题目，可系统掌握字符串处理技巧，为文本分析、数据清洗等场景打下基础。实际应用中，需根据具体需求选择合适的方法，复杂场景可结合正则表达式或第三方库（如re、string）提升效率。