【Python学习】字符串
目录
一、字符串概述
字符串（String）是Python中最常用的数据类型之一，用于表示文本信息，本质是由一系列字符（字母、数字、符号、空格等）组成的不可变序列。
核心特点：
-
不可变性：字符串创建后，其内部字符无法直接修改（如不能直接替换某一个字符），只能通过重新赋值或切片等方式生成新字符串。
-
有序性：字符串中的每个字符都有唯一的索引（从0开始），可通过索引精准访问单个字符或多个字符（切片）。
-
可拼接、可重复：支持通过运算符或方法实现字符串的拼接、重复操作，生成新的字符串。
-
支持转义字符：可通过转义字符表示特殊符号（如换行、制表符等），满足不同场景的文本需求。
适用场景：文本处理、数据清洗、用户输入交互、日志输出、字符串格式化等，是Python编程中不可或缺的基础数据类型。
二、字符串的创建（定义）
Python中创建字符串非常灵活，主要有4种常用方式，可根据场景选择合适的方式，所有方式创建的字符串本质一致，仅语法不同。
2.1 单引号创建
使用单引号（' '）包裹文本，适合文本中包含双引号的场景，无需转义。
# 单引号创建字符串 str1 = 'Hello Python' str2 = 'I\'m a Python learner' # 若文本含单引号，需用转义字符\ str3 = 'He said "Python is easy"' # 文本含双引号，无需转义 print(type(str1)) # 输出：<class 'str'>，验证字符串类型
2.2 双引号创建
使用双引号（" "）包裹文本，与单引号功能对称，适合文本中包含单引号的场景。
# 双引号创建字符串 str4 = "Hello Python" str5 = "He said 'Python is easy'" # 文本含单引号，无需转义 str6 = "I love \"Python\"" # 若文本含双引号，需用转义字符\
2.3 三引号创建（多行字符串）
使用三个单引号（''' '''）或三个双引号（""" """）包裹文本，支持多行文本直接编写，无需添加换行符，适合大段文本、注释、文档字符串等场景。
# 三单引号创建多行字符串 str7 = '''这是一个多行字符串 无需手动添加换行符 直接换行即可 适合大段文本''' # 三双引号创建多行字符串（常用作文档字符串） str8 = """Python字符串教程 作者：初学者 功能：讲解字符串的基础操作和常用方法""" print(str7) # 输出时会保留换行格式
2.4 空字符串与特殊创建
空字符串：不包含任何字符的字符串，长度为0，常用于初始化变量。
str()函数：将其他数据类型（如数字、布尔值）转换为字符串。
# 空字符串 empty_str = '' # 单引号/双引号均可 empty_str2 = "" print(len(empty_str)) # 输出：0，len()函数获取字符串长度 # str()函数转换 num = 123 str_num = str(num) # 将数字123转换为字符串"123" bool_val = True str_bool = str(bool_val) # 将布尔值转换为字符串"True" print(type(str_num)) # 输出：<class 'str'>
三、字符串的基础操作
字符串的基础操作主要包括：索引访问、切片、拼接、重复、长度计算、成员判断，这些操作是后续学习字符串方法的基础，语法简单且常用。
3.1 索引访问（访问单个字符）
字符串是有序序列，每个字符都有一个唯一的索引，索引分为两种：
-
正向索引：从0开始，依次递增（第一个字符索引为0，第二个为1，以此类推）。
-
反向索引：从-1开始，依次递减（最后一个字符索引为-1，倒数第二个为-2，以此类推）。
语法：字符串名[索引值]
str9 = "Python" # 正向索引访问 print(str9[0]) # 输出：P（第一个字符） print(str9[2]) # 输出：t（第三个字符） print(str9[5]) # 输出：n（最后一个字符） # 反向索引访问 print(str9[-1]) # 输出：n（最后一个字符） print(str9[-3]) # 输出：h（倒数第三个字符） # 注意：索引越界会报错 # print(str9[6]) # 报错：IndexError: string index out of range
3.2 切片（访问多个字符）
切片是从字符串中截取一段连续的字符，生成一个新的字符串（不改变原字符串，符合不可变性）。
语法：字符串名[起始索引:结束索引:步长]，三个参数均可省略，默认值如下：
-
起始索引：默认0（从第一个字符开始）。
-
结束索引：默认字符串长度（截取到最后一个字符），注意：切片是左闭右开区间（包含起始索引，不包含结束索引）。
-
步长：默认1（依次截取，步长为正表示正向截取，为负表示反向截取）。
str10 = "abcdefghij" # 索引0-9，反向索引-1到-10 # 1. 省略步长（默认1） print(str10[2:5]) # 输出：cde（截取索引2、3、4，不包含5） print(str10[:5]) # 输出：abcde（省略起始索引，从0开始到4） print(str10[3:]) # 输出：defghij（省略结束索引，从3开始到最后） print(str10[:]) # 输出：abcdefghij（省略所有参数，截取整个字符串） # 2. 指定步长 print(str10[0:8:2]) # 输出：aceg（从0开始，每2个字符截取一次，到7结束） print(str10[8:2:-1]) # 输出：jihgfed（反向截取，从8到3，步长-1） print(str10[::-1]) # 输出：jihgfedcba（反向截取整个字符串，实现字符串反转） # 3. 反向切片实例 print(str10[-5:-2]) # 输出：fgh（反向索引-5到-3，左闭右开）
3.3 字符串拼接
将两个或多个字符串合并为一个新字符串，常用两种方式：+运算符、join()方法（后续详解），这里重点讲解+运算符。
语法：字符串1 + 字符串2 + ... + 字符串n
str11 = "Hello" str12 = " " str13 = "Python" # +运算符拼接 result = str11 + str12 + str13 print(result) # 输出：Hello Python # 注意：字符串不能与非字符串类型直接拼接 # print(str11 + 123) # 报错：TypeError: can only concatenate str (not "int") to str # 解决方案：先将非字符串类型转换为字符串 print(str11 + str(123)) # 输出：Hello123
3.4 字符串重复
将一个字符串重复指定次数，生成新字符串，使用*运算符。
语法：字符串 * 次数（次数为非负整数，0则返回空字符串）
str14 = "abc" print(str14 * 3) # 输出：abcabcabc（重复3次） print(str14 * 0) # 输出：空字符串 print(str14 * 1) # 输出：abc（重复1次，即原字符串）
3.5 长度计算（len()函数）
使用len()函数获取字符串的长度（即字符的个数，包括空格、转义字符）。
语法：len(字符串名)
str15 = "Hello Python" print(len(str15)) # 输出：11（包含空格） str16 = "a\nb\tc" # 包含转义字符\n（换行）、\t（制表符） print(len(str16)) # 输出：5（转义字符算1个字符） empty_str = "" print(len(empty_str)) # 输出：0
3.6 成员判断（in / not in）
判断一个字符或子字符串是否存在于目标字符串中，返回布尔值（True/False）。
语法：子字符串 in 目标字符串（存在返回True）；子字符串 not in 目标字符串（不存在返回True）
str17 = "Python is a powerful language" # 判断字符是否存在 print('P' in str17) # 输出：True print('p' in str17) # 输出：False（Python区分大小写） # 判断子字符串是否存在 print("powerful" in str17) # 输出：True print("java" in str17) # 输出：False # not in 判断 print("Python" not in str17) # 输出：False print("java" not in str17) # 输出：True
四、字符串常用方法（重点）
Python为字符串提供了大量内置方法，用于实现字符串的修改（生成新字符串）、查找、替换、分割、判断等操作，所有方法均不改变原字符串（因字符串不可变），以下是最常用、最实用的方法，按功能分类讲解。
4.1 大小写转换方法
用于将字符串中的字母转换为指定大小写，适用于文本统一格式场景（如用户输入清洗）。
|
方法 |
功能 |
示例 |
输出 |
|---|---|---|---|
|
upper() |
将所有小写字母转为大写，非字母不变 |
"hello python".upper() |
"HELLO PYTHON" |
|
lower() |
将所有大写字母转为小写，非字母不变 |
"HELLO Python".lower() |
"hello python" |
|
capitalize() |
首字母大写，其余字母小写（仅作用于字符串第一个字符） |
"hello python".capitalize() |
"Hello python" |
|
title() |
每个单词的首字母大写，其余小写（单词以空格、标点分隔） |
"hello python world".title() |
"Hello Python World" |
|
swapcase() |
大小写反转（大写转小写，小写转大写） |
"Hello Python".swapcase() |
"hELLO pYTHON" |
# 实例演示 str18 = "Hello Python 123!" print(str18.upper()) # 输出：HELLO PYTHON 123! print(str18.lower()) # 输出：hello python 123! print(str18.capitalize())# 输出：Hello python 123! print(str18.title()) # 输出：Hello Python 123! print(str18.swapcase()) # 输出：hELLO pYTHON 123!
4.2 查找与匹配方法
用于查找子字符串在目标字符串中的位置，或判断字符串是否符合指定规则（如是否以某字符开头/结尾）。
4.2.1 查找子字符串位置
-
find(sub, start, end)：从左到右查找子字符串sub，可指定查找范围（start：起始索引，end：结束索引，左闭右开），找到返回第一个匹配的起始索引，找不到返回-1（不报错）。
-
rfind(sub, start, end)：与find()类似，从右到左查找，返回最后一个匹配的起始索引，找不到返回-1。
-
index(sub, start, end)：与find()功能一致，区别是找不到子字符串时会报错（ValueError）。
-
rindex(sub, start, end)：与rfind()功能一致，找不到时报错。
str19 = "Python is Python, Python is easy" # find() 查找 print(str19.find("Python")) # 输出：0（第一个Python的起始索引） print(str19.find("Python", 5)) # 输出：10（从索引5开始查找，第一个匹配的位置） print(str19.find("java")) # 输出：-1（找不到） # rfind() 反向查找 print(str19.rfind("Python")) # 输出：18（最后一个Python的起始索引） # index() 查找（找不到报错） print(str19.index("Python")) # 输出：0 # print(str19.index("java")) # 报错：ValueError: substring not found # rindex() 反向查找（找不到报错） print(str19.rindex("Python")) # 输出：18
4.2.2 判断字符串开头/结尾
-
startswith(prefix, start, end)：判断字符串是否以指定前缀prefix开头，可指定查找范围，返回布尔值。
-
endswith(suffix, start, end)：判断字符串是否以指定后缀suffix结尾，可指定查找范围，返回布尔值。
str20 = "Python_learning_tutorial.py" # startswith() 判断开头 print(str20.startswith("Python")) # 输出：True print(str20.startswith("python")) # 输出：False（区分大小写） print(str20.startswith("learning", 7)) # 输出：True（从索引7开始，前缀为learning） # endswith() 判断结尾 print(str20.endswith(".py")) # 输出：True（后缀为.py，常见于Python文件） print(str20.endswith(".txt")) # 输出：False print(str20.endswith("tutorial", 0, 18)) # 输出：True（范围0-17，结尾为tutorial）
4.3 替换与删除方法
用于替换字符串中的指定子串，或删除字符串前后的空白字符（空格、制表符、换行符等）。
4.3.1 字符串替换
replace(old, new, count)：将字符串中的old子串替换为new子串，count为可选参数，指定替换的次数（默认替换所有匹配项），返回新字符串。
str21 = "I like apple, apple is delicious" # 替换所有apple为orange print(str21.replace("apple", "orange")) # 输出：I like orange, orange is delicious # 替换前1个apple为orange print(str21.replace("apple", "orange", 1)) # 输出：I like orange, apple is delicious # 替换不存在的子串，返回原字符串 print(str21.replace("banana", "orange")) # 输出：I like apple, apple is delicious
4.3.2 空白字符删除
-
strip()：删除字符串前后（开头和结尾）的所有空白字符（空格、\n、\t、\r等），中间的空白字符不变。
-
lstrip()：仅删除字符串开头的空白字符。
-
rstrip()：仅删除字符串结尾的空白字符。
str22 = " \tHello Python\n " # 开头有空格、制表符，结尾有空格、换行符 print(str22.strip()) # 输出：Hello Python（删除前后空白） print(str22.lstrip()) # 输出：Hello Python\n （仅删除开头空白） print(str22.rstrip()) # 输出： \tHello Python（仅删除结尾空白） # 可指定删除的字符（非空白字符也可） str23 = "###Hello Python###" print(str23.strip("#")) # 输出：Hello Python（删除前后的#）
4.4 分割与连接方法
分割：将一个字符串按照指定分隔符拆分为列表；连接：将一个列表（元素需为字符串）按照指定分隔符合并为字符串，两者是互逆操作。
4.4.1 字符串分割
-
split(sep, maxsplit)：按照指定分隔符sep分割字符串，maxsplit为可选参数，指定分割次数（默认分割所有），返回列表；若sep省略，默认以任意空白字符（空格、\n、\t）分割。
-
rsplit(sep, maxsplit)：与split()类似，从右到左分割，maxsplit指定分割次数。
-
splitlines(keepends)：按照换行符（\n、\r\n等）分割字符串，返回列表；keepends为可选参数，True保留换行符，False不保留（默认）。
# split() 分割 str24 = "apple,banana,orange,grape" print(str24.split(",")) # 输出：['apple', 'banana', 'orange', 'grape']（按逗号分割） print(str24.split(",", 2)) # 输出：['apple', 'banana', 'orange,grape']（分割2次） # 省略sep，按空白字符分割 str25 = "Hello Python\nI love it" # 中间有2个空格，换行 print(str25.split()) # 输出：['Hello', 'Python', 'I', 'love', 'it'] # rsplit() 反向分割 print(str24.rsplit(",", 2)) # 输出：['apple,banana', 'orange', 'grape']（从右分割2次） # splitlines() 按换行分割 str26 = "Line1\nLine2\r\nLine3" print(str26.splitlines()) # 输出：['Line1', 'Line2', 'Line3']（不保留换行符） print(str26.splitlines(True)) # 输出：['Line1\n', 'Line2\r\n', 'Line3']（保留换行符）
4.4.2 字符串连接
join(iterable)：将可迭代对象（如列表、元组，元素必须是字符串）中的所有元素，按照当前字符串作为分隔符，连接成一个新字符串。
注意：若可迭代对象中包含非字符串元素，会报错（TypeError）。
# 列表连接 list1 = ["apple", "banana", "orange"] print(",".join(list1)) # 输出：apple,banana,orange（以逗号为分隔符） print(" ".join(list1)) # 输出：apple banana orange（以空格为分隔符） # 元组连接 tuple1 = ("Python", "Java", "C++") print("|".join(tuple1)) # 输出：Python|Java|C++ # 字符串连接（可迭代对象也可以是字符串） str27 = "hello" print("-".join(str27)) # 输出：h-e-l-l-o # 错误示例：可迭代对象包含非字符串元素 # list2 = [1, 2, 3] # print(",".join(list2)) # 报错：TypeError: sequence item 0: expected str instance, int found
4.5 字符串判断方法
用于判断字符串的内容特征（如是否全为字母、是否全为数字等），返回布尔值，常用于数据验证（如判断用户输入是否为纯数字）。
|
方法 |
功能 |
示例 |
输出 |
|---|---|---|---|
|
isalpha() |
判断字符串是否全为字母（含中文），且非空 |
"Python".isalpha()、"你好".isalpha() |
True、True |
|
isdigit() |
判断字符串是否全为数字（0-9），且非空 |
"123".isdigit()、"12.3".isdigit() |
True、False |
|
isalnum() |
判断字符串是否全为字母+数字，且非空（不含符号、空格） |
"Python123".isalnum()、"Python 123".isalnum() |
True、False |
|
isspace() |
判断字符串是否全为空白字符（空格、\n、\t等），且非空 |
" \t".isspace()、" a ".isspace() |
True、False |
|
islower() |
判断字符串中所有字母是否全为小写（非字母不影响） |
"hello123".islower()、"Hello".islower() |
True、False |
|
isupper() |
判断字符串中所有字母是否全为大写（非字母不影响） |
"HELLO123".isupper()、"Hello".isupper() |
True、False |
# 实例演示 str28 = "Python" print(str28.isalpha()) # 输出：True print(str28.isdigit()) # 输出：False str29 = "123456" print(str29.isdigit()) # 输出：True print(str29.isalnum()) # 输出：True str30 = "Python123" print(str30.isalnum()) # 输出：True print(str30.isspace()) # 输出：False str31 = " " print(str31.isspace()) # 输出：True print(str31.isalpha()) # 输出：False
4.6 其他常用方法
-
count(sub, start, end)：统计子字符串sub在目标字符串中的出现次数，可指定查找范围，返回整数（找不到返回0）。
-
center(width, fillchar)：将字符串居中显示，width为总长度，fillchar为填充字符（默认空格），返回新字符串。
-
ljust(width, fillchar)：将字符串左对齐，width为总长度，fillchar为填充字符（默认空格）。
-
rjust(width, fillchar)：将字符串右对齐，width为总长度，fillchar为填充字符（默认空格）。
# count() 统计次数 str32 = "Python is Python, Python is easy" print(str32.count("Python")) # 输出：3（Python出现3次） print(str32.count("Python", 0, 15)) # 输出：2（范围0-14，出现2次） # center() 居中 str33 = "Hello" print(str33.center(11, "*")) # 输出：***Hello***（总长度11，*填充） # ljust() 左对齐 print(str33.ljust(10, "-")) # 输出：Hello-----（总长度10，-填充） # rjust() 右对齐 print(str33.rjust(10, "=")) # 输出：=====Hello（总长度10，=填充）
五、字符串格式化（重点）
字符串格式化是将变量、表达式等插入到字符串指定位置，生成新的格式化字符串，常用于动态文本输出（如日志、用户提示、数据展示）。Python中常用3种格式化方式，优先推荐f-string（Python3.6+），简洁高效。
5.1 %格式化（传统方式）
使用%作为占位符，将后续的变量/表达式替换到占位符位置，不同类型的数据需使用对应的占位符。
常用占位符：
-
%s：字符串占位符（可接收任何数据类型，会自动转换为字符串）。
-
%d：整数占位符（接收整数，可指定宽度、对齐方式）。
-
%f：浮点数占位符（接收浮点数，可指定小数位数）。
# 基本使用 name = "小明" age = 18 score = 95.5 # %s 字符串占位符 print("我的名字是%s" % name) # 输出：我的名字是小明 # %d 整数占位符 print("我今年%d岁" % age) # 输出：我今年18岁 # %f 浮点数占位符 print("我的成绩是%f分" % score) # 输出：我的成绩是95.500000分（默认6位小数） print("我的成绩是%.1f分" % score) # 输出：我的成绩是95.5分（保留1位小数） # 多个占位符（需用括号包裹变量，顺序对应） print("我的名字是%s，今年%d岁，成绩是%.1f分" % (name, age, score)) # 输出：我的名字是小明，今年18岁，成绩是95.5分 # 指定宽度和对齐（%d、%f、%s均可） print("成绩：%10.1f" % score) # 输出：成绩： 95.5（总宽度10，右对齐） print("成绩：%-10.1f" % score) # 输出：成绩：95.5 （总宽度10，左对齐）
5.2 format()方法（推荐过渡方式）
使用{}作为占位符，通过format()方法传入变量/表达式，相比%格式化更灵活，无需区分数据类型，支持位置参数、关键字参数、索引参数。
name = "小明" age = 18 score = 95.5 # 1. 位置参数（按顺序对应） print("我的名字是{}，今年{}岁，成绩是{}分".format(name, age, score)) # 输出：我的名字是小明，今年18岁，成绩是95.5分 # 2. 关键字参数（指定占位符名称，无需按顺序） print("我的名字是{name}，今年{age}岁，成绩是{score}分".format(name=name, age=age, score=score)) # 输出：同上 # 3. 索引参数（指定format()中参数的索引，0开始） print("我的名字是{0}，今年{1}岁，成绩是{2}分".format(name, age, score)) # 输出：同上 # 4. 格式化细节（保留小数、指定宽度） print("成绩：{:.1f}".format(score)) # 输出：成绩：95.5（保留1位小数） print("成绩：{:10.1f}".format(score)) # 输出：成绩： 95.5（总宽度10，右对齐） print("成绩：{:<10.1f}".format(score))# 输出：成绩：95.5 （总宽度10，左对齐） print("成绩：{:+10.1f}".format(score))# 输出：成绩： +95.5（显示正负号） # 5. 表达式格式化（可在占位符中直接写表达式） print("明年我{}岁".format(age + 1)) # 输出：明年我19岁
5.3 f-string（Python3.6+，推荐方式）
在字符串前加字母f或F，直接在{}中写入变量、表达式，语法最简洁，效率最高，是目前Python中最常用的格式化方式。
name = "小明" age = 18 score = 95.5 # 基本使用（直接写入变量） print(f"我的名字是{name}，今年{age}岁，成绩是{score}分") # 输出：我的名字是小明，今年18岁，成绩是95.5分 # 表达式格式化（直接在{}中计算） print(f"明年我{age + 1}岁") # 输出：明年我19岁 print(f"成绩的2倍是{score * 2}") # 输出：成绩的2倍是191.0 # 格式化细节（保留小数、指定宽度） print(f"成绩：{score:.1f}分") # 输出：成绩：95.5分 print(f"成绩：{score:10.1f}分") # 输出：成绩： 95.5分 print(f"成绩：{score:<10.1f}分")# 输出：成绩：95.5 分 # 字符串方法调用（可在{}中调用字符串方法） print(f"我的名字大写是{name.upper()}") # 输出：我的名字大写是小明（中文无影响） print(f"Python大写是{'python'.upper()}") # 输出：Python大写是PYTHON
六、字符串转义字符
转义字符是用反斜杠（\）开头的特殊字符，用于表示无法直接输入的字符（如换行、制表符）或具有特殊含义的字符（如单引号、双引号）。
常用转义字符：
|
转义字符 |
功能 |
示例 |
输出效果 |
|---|---|---|---|
|
\n |
换行 |
print("Hello\nPython") |
HelloPython |
|
\t |
制表符（相当于按Tab键，约4个空格） |
print("Name:\t小明") |
Name: 小明 |
|
\\ |
输出反斜杠本身 |
print("C:\\Users\\小明") |
C:\Users\小明 |
|
\' |
输出单引号 |
print('I\'m a student') |
I'm a student |
|
\\" |
输出双引号 |
print("He said \"Hello\"") |
He said "Hello" |
|
\r |
回车（覆盖当前行开头内容） |
print("Hello\rPython") |
Python |
原始字符串：在字符串前加r或R，可取消转义字符的作用，将字符串中的内容原样输出（适合路径、正则表达式等场景）。
# 原始字符串示例 print(r"C:\Users\小明") # 输出：C:\Users\小明（无需转义\） print(r"Hello\nPython") # 输出：Hello\nPython（\n不再是换行符）
七、字符串实战案例
结合前面所学的知识点，通过2个实战案例，巩固字符串的使用，解决实际开发中的简单问题。
案例1：用户输入清洗与验证
需求：接收用户输入的姓名和年龄，对输入进行清洗（去除空白）、验证（姓名仅含字母/中文，年龄为纯数字），若验证失败提示错误，验证成功输出用户信息。
# 用户输入清洗与验证 # 接收输入并去除前后空白 name = input("请输入您的姓名：").strip() age = input("请输入您的年龄：").strip() # 验证姓名（非空，且全为字母/中文） if not name.isalpha(): print("错误：姓名只能包含字母或中文，且不能为空！") else: # 验证年龄（非空，且全为数字） if not age.isdigit(): print("错误：年龄只能是纯数字，且不能为空！") else: # 将年龄转换为整数，格式化输出 age = int(age) print(f"验证成功！您的姓名：{name}，年龄：{age}岁，明年{age + 1}岁。") # 测试用例1（正确输入）： # 请输入您的姓名： 小明 # 请输入您的年龄： 18 # 输出：验证成功！您的姓名：小明，年龄：18岁，明年19岁。 # 测试用例2（错误输入）： # 请输入您的姓名： 小明123 # 输出：错误：姓名只能包含字母或中文，且不能为空！
案例2：字符串处理与统计
需求：给定一段文本，统计文本的总长度、单词个数（以空格分割）、大写字母个数、小写字母个数、数字个数，最后输出统计结果。
# 字符串处理与统计 text = "Hello Python 123! I Love Python 456." # 1. 统计总长度（包含符号、空格） total_len = len(text) # 2. 统计单词个数（按空格分割，去除空字符串） words = text.split() # 按空格分割，自动过滤多个空格 word_count = len(words) # 3. 统计大写字母、小写字母、数字个数 upper_count = 0 lower_count = 0 digit_count = 0 for char in text: if char.isupper(): upper_count += 1 elif char.islower(): lower_count += 1 elif char.isdigit(): digit_count += 1 # 格式化输出统计结果 print(f"文本统计结果：") print(f"总长度：{total_len} 个字符") print(f"单词个数：{word_count} 个") print(f"大写字母个数：{upper_count} 个") print(f"小写字母个数：{lower_count} 个") print(f"数字个数：{digit_count} 个") # 输出结果： # 文本统计结果： # 总长度：35 个字符 # 单词个数：6 个 # 大写字母个数：3 个 # 小写字母个数：20 个 # 数字个数：6 个
八、常见问题与注意事项
-
字符串不可变性：记住“字符串创建后无法直接修改”，所有看似“修改”的操作（如replace、strip），本质都是生成新字符串，原字符串不变。
-
索引越界问题：访问字符串时，索引不能超过字符串的长度-1，否则会报IndexError，可通过len()函数判断长度后再访问。
-
大小写敏感：Python字符串区分大小写，如"Python"和"python"是两个不同的字符串，判断、查找时需注意。
-
转义字符的使用：当字符串中包含单引号、双引号、反斜杠等特殊字符时，需使用转义字符，或使用原始字符串（r前缀）。
-
非字符串拼接报错：字符串不能与数字、布尔值等非字符串类型直接拼接，需先用str()函数转换。
-
join()方法的要求：join()方法的参数必须是可迭代对象，且元素必须是字符串，否则会报错。
九、总结
本教程详细讲解了Python字符串的核心知识点，从基础的创建、索引、切片，到常用的字符串方法、格式化方式，再到实战案例，覆盖了初学者必备的所有内容。
学习重点：
-
掌握字符串的不可变性和有序性，理解索引和切片的使用。
-
熟练运用常用字符串方法（大小写转换、查找、替换、分割、连接）。
-
掌握f-string格式化方式，能灵活实现动态文本输出。
-
通过实战案例巩固知识点，学会解决实际开发中的字符串处理问题。
字符串是Python编程中最基础、最常用的数据类型，后续学习文件
小龙虾开发者社区是 CSDN 旗下专注 OpenClaw 生态的官方阵地，聚焦技能开发、插件实践与部署教程，为开发者提供可直接落地的方案、工具与交流平台，助力高效构建与落地 AI 应用
更多推荐
10
0- 0
已为社区贡献4条内容
所有评论(0)