【Python-Day 3】玩转文本：字符串(String)基础操作详解 (上)

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！
07-【深度解析】从GPT-1到GPT-4：ChatGPT背后的核心原理全揭秘

PyTorch系列文章目录

机器学习系列文章目录

Python系列文章目录

01-【Python-Day 1】告别编程恐惧：轻松掌握 Python 安装与第一个程序的 6 个步骤
02-【Python-Day 2】掌握Python基石：变量、内存、标识符及int/float/bool数据类型
03-【Python-Day 3】玩转文本：字符串(String)基础操作详解 (上)

---

---

前言

大家好！欢迎来到 Python 零基础入门系列的第三天。在前一篇文章《【Python-Day 2】与计算机对话 - 变量与基本数据类型》中，我们学习了 Python 的基本构成单元——变量，以及一些基础的数据类型，如整数（int）、浮点数（float）和布尔值（bool）。今天，我们将聚焦于另一种极其重要且常用的数据类型——字符串 (String)。

在编程世界里，无论是用户输入、文件内容、网络传输的数据，还是程序界面上的提示信息，文本无处不在。Python 提供了强大而灵活的字符串处理能力。本篇作为字符串详解的上半部分，我们将重点介绍字符串的基础概念和核心操作，包括如何创建字符串、如何将它们连接或重复、以及如何精确地访问字符串中的每一个字符或提取其中的一部分。掌握这些基础，是你处理文本数据的第一步，也是非常关键的一步。

准备好了吗？让我们一起揭开 Python 字符串的神秘面纱吧！

一、 什么是字符串？

1.1 字符串的定义

简单来说，字符串 (String) 就是由零个或多个字符组成的有序序列。这些字符可以是字母、数字、标点符号、特殊符号，甚至是空格。你可以把字符串想象成一串文字，比如一句话、一个名字、一个网址等等。

在 Python 中，字符串是一种内置的数据类型，用于表示和处理文本信息。它的“有序”特性意味着字符串中的每个字符都有一个固定的位置或顺序，后面我们会讲到如何通过这个位置（称为“索引”）来访问特定的字符。

1.2 字符串的表示方式

Python 提供了非常灵活的方式来创建（或称“表示”）字符串。主要有以下三种：

1.2.1 单引号与双引号

你可以使用一对单引号 ('...') 或一对双引号 ("...") 来包裹字符序列，从而创建字符串。

# 使用单引号创建字符串
my_string1 = 'Hello, Python!'
print(my_string1)
print(type(my_string1)) # 查看类型，确认是 str

# 使用双引号创建字符串
my_string2 = "你好，世界！"
print(my_string2)
print(type(my_string2))

输出:

Hello, Python!
<class 'str'>
你好，世界！
<class 'str'>

为什么需要两种引号？

这主要是为了方便。如果你的字符串本身包含了单引号，那么用双引号包裹起来就更方便，反之亦然。

# 字符串包含单引号，使用双引号包裹
sentence1 = "It's a beautiful day."
print(sentence1)

# 字符串包含双引号，使用单引号包裹
sentence2 = '他说："Python 很有趣！"'
print(sentence2)

输出:

It's a beautiful day.
他说："Python 很有趣！"

如果你坚持要在单引号包裹的字符串中使用单引号（或双引号包裹的字符串中使用双引号），你需要使用转义字符反斜杠 (\)。

# 在单引号字符串中使用单引号（需要转义）
sentence3 = 'It\'s a beautiful day.'
print(sentence3)

# 在双引号字符串中使用双引号（需要转义）
sentence4 = "他说：\"Python 很有趣！\""
print(sentence4)

输出:

It's a beautiful day.
他说："Python 很有趣！"

虽然转义可行，但合理选择外层引号通常更简洁易读。

1.2.2 三引号

Python 还支持使用三个连续的单引号 ('''...''') 或三个连续的双引号 ("""...""") 来创建字符串。这种方式主要有两个用途：

（1） 创建包含换行的多行字符串

如果你想创建一个包含多行文本的字符串，使用三引号是最自然的方式。

multi_line_string = """这是一个
包含多行的
字符串示例。"""
print(multi_line_string)

输出:

这是一个
包含多行的
字符串示例。

（2） 作为文档字符串 (Docstring)

在函数或类的定义下方，紧随其后的三引号字符串通常用作文档字符串 (Docstring)，用于解释该函数或类的作用、参数、返回值等。这是 Python 的一个重要规范（PEP 257），很多工具会利用 Docstring 自动生成文档。

def greet(name):
  """
  这是一个简单的问候函数。
  Args:
    name (str): 要问候的人的名字。
  Returns:
    str: 包含问候语的字符串。
  """
  return f"Hello, {name}!"

print(greet.__doc__) # 打印函数的文档字符串

输出:

  这是一个简单的问候函数。
  Args:
    name (str): 要问候的人的名字。
  Returns:
    str: 包含问候语的字符串。
  

小结: 单引号、双引号用于创建单行字符串，优先选择能避免内部引号转义的方式。三引号（单/双皆可）用于创建多行字符串或编写文档字符串。

二、 字符串的基本操作

创建了字符串之后，我们就可以对它们进行各种操作了。下面介绍两种最基础的操作：拼接和重复。

2.1 字符串拼接 (+)

字符串拼接就是将两个或多个字符串连接起来，形成一个新的、更长的字符串。在 Python 中，使用加号 (+) 运算符可以实现字符串的拼接。

2.1.1 使用 ‘+’ 号连接

first_name = "张"
last_name = "三"
full_name = first_name + last_name # 拼接姓和名
print(full_name) # 输出: 张三

greeting = "Hello"
separator = ", "
target = "World"
message = greeting + separator + target + "!" # 可以连续拼接多个字符串
print(message) # 输出: Hello, World!

2.1.2 注意事项与常见错误

重要提示: + 运算符只能用于连接两个字符串，不能直接将字符串与其他类型（如数字）进行拼接。

# 错误示例：尝试将字符串和整数直接拼接
# error_message = "你的分数是：" + 95 # 这会引发 TypeError
# print(error_message)

如果你运行上面的注释掉的代码，你会得到一个 TypeError: can only concatenate str (not "int") to str 的错误。

如何解决？

在拼接之前，你需要使用 str() 函数将非字符串类型的数据显式转换为字符串。

score = 95
correct_message = "你的分数是：" + str(score) # 先将整数 score 转换为字符串
print(correct_message) # 输出: 你的分数是：95

price = 19.99
info = "价格：" + str(price) + " 元"
print(info) # 输出: 价格：19.99 元

记住：进行字符串拼接前，确保所有参与运算的都是字符串类型。

2.2 字符串重复 (*)

如果你想将一个字符串重复多次，可以使用乘号 (*) 运算符。

2.2.1 使用 ‘*’ 号重复

separator = "-" * 20 # 将 '-' 重复 20 次
print(separator) # 输出: --------------------

word = "哈"
laugh = word * 3 # 将 '哈' 重复 3 次
print(laugh) # 输出: 哈哈哈

pattern = " Ho" * 3 + "!" # 先重复，再拼接
print(pattern) # 输出:  Ho Ho Ho!

2.2.2 操作数类型

使用 * 进行字符串重复时，一个操作数必须是字符串，另一个必须是整数 (int)，表示重复的次数。整数必须是非负数。

# print("Hi" * 2.5) # 错误：不能乘以浮点数，会引发 TypeError
# print("Hello" * -1) # 错误：不能乘以负数，通常不会报错，但会得到空字符串或行为不确定，不推荐
print("Test" * 0) # 乘以 0 得到空字符串

输出:

(空行，表示空字符串)

三、 访问字符串中的字符 (索引)

3.1 字符串的本质：有序序列

前面提到，字符串是字符的有序序列。这意味着字符串中的每个字符都有一个确定的位置编号，这个编号就叫做索引 (Index)。Python 允许我们通过索引来精确地访问字符串中的任意单个字符。

想象一下字符串就像一排带编号的信箱，每个信箱里放着一个字符，而索引就是信箱的编号。

3.2 正向索引

Python 的索引是从 0 开始计数的。也就是说，字符串中第一个字符的索引是 0，第二个字符的索引是 1，以此类推，直到最后一个字符。

语法: string[index]

my_string = "Python"

# 索引:  P  y  t  h  o  n
#       0  1  2  3  4  5

first_char = my_string[0] # 获取第一个字符
print(f"第一个字符是: {first_char}") # 输出: 第一个字符是: P

third_char = my_string[2] # 获取第三个字符
print(f"第三个字符是: {third_char}") # 输出: 第三个字符是: t

last_char_index = len(my_string) - 1 # 最后一个字符的索引是 长度 - 1
last_char = my_string[last_char_index]
print(f"最后一个字符是: {last_char}") # 输出: 最后一个字符是: n

可视化理解:

字符	P	y	t	h	o	n
正向索引	0	1	2	3	4	5

3.3 反向索引

除了从左到右的正向索引，Python 还支持从右到左的反向索引。反向索引从 -1 开始，表示最后一个字符，-2 表示倒数第二个字符，以此类推。

这对于快速获取字符串末尾的字符非常方便。

语法: string[-index]

my_string = "Python"

# 索引:  P   y   t   h   o   n
#      -6  -5  -4  -3  -2  -1

last_char = my_string[-1] # 获取最后一个字符
print(f"最后一个字符 (反向): {last_char}") # 输出: 最后一个字符 (反向): n

second_last_char = my_string[-2] # 获取倒数第二个字符
print(f"倒数第二个字符 (反向): {second_last_char}") # 输出: 倒数第二个字符 (反向): o

first_char_reverse = my_string[-len(my_string)] # 第一个字符的反向索引是 负的字符串长度
print(f"第一个字符 (反向): {first_char_reverse}") # 输出: 第一个字符 (反向): P

可视化理解:

字符	P	y	t	h	o	n
正向索引	0	1	2	3	4	5
反向索引	-6	-5	-4	-3	-2	-1

3.4 索引越界错误

无论是正向索引还是反向索引，如果你尝试访问一个不存在的索引位置（即超出了字符串的范围），Python 会抛出 IndexError: string index out of range 错误。

my_string = "Code" # 长度为 4，有效正向索引 0, 1, 2, 3；有效反向索引 -1, -2, -3, -4

# print(my_string[4]) # 错误：正向索引最大是 3
# print(my_string[-5]) # 错误：反向索引最小是 -4

在编写代码时，要确保使用的索引在有效范围内，特别是在处理长度可变的字符串时。

四、 获取子字符串 (字符串切片)

索引能让我们访问单个字符，但如果我们想获取字符串中的一部分连续字符（即子字符串），就需要使用切片 (Slicing) 操作。切片是 Python 序列类型（包括字符串、列表、元组）非常强大和常用的功能。

4.1 什么是切片？

切片就像从一整块蛋糕中切下一小块。它允许你指定一个起始索引和一个结束索引，来提取这两个索引之间的所有字符。

4.2 切片的基本语法

切片的基本语法是：string[start:stop:step]

• start: 切片开始的索引（包含该位置的字符）。如果省略，默认为 0（字符串开头）。
• stop: 切片结束的索引（不包含该位置的字符）。如果省略，默认为字符串的末尾。
• step: 步长，表示每隔多少个字符取一个。如果省略，默认为 1（连续取）。

我们先重点关注 start 和 stop。

4.2.1 指定 start 和 stop

提取从 start 索引开始，直到 stop 索引之前的所有字符。

my_string = "HelloWorld"
# 索引:  H  e  l  l  o  W  o  r  l  d
#       0  1  2  3  4  5  6  7  8  9

# 提取从索引 1 到索引 4 的字符 (不包括索引 5)
substring1 = my_string[1:5]
print(f"my_string[1:5] -> '{substring1}'") # 输出: my_string[1:5] -> 'ello'

# 提取从索引 0 到索引 4 的字符 (不包括索引 5)
substring2 = my_string[0:5]
print(f"my_string[0:5] -> '{substring2}'") # 输出: my_string[0:5] -> 'Hello'

关键点: 切片的结束索引 stop 是不包含在结果中的。可以理解为“切到 stop 位置的前一个字符为止”。

4.2.2 省略 start 或 stop

• 省略 start ([:stop]): 从字符串开头一直取到 stop 索引之前。
• 省略 stop ([start:]): 从 start 索引开始一直取到字符串末尾。
• 同时省略 start 和 stop ([:]): 获取整个字符串的副本。

my_string = "HelloWorld"

# 从开头到索引 4 (不含 5)
substring3 = my_string[:5]
print(f"my_string[:5] -> '{substring3}'") # 输出: my_string[:5] -> 'Hello'

# 从索引 5 到末尾
substring4 = my_string[5:]
print(f"my_string[5:] -> '{substring4}'") # 输出: my_string[5:] -> 'World'

# 获取整个字符串的副本
copy_string = my_string[:]
print(f"my_string[:] -> '{copy_string}'") # 输出: my_string[:] -> 'HelloWorld'
print(copy_string is my_string) # 输出: False (表明是副本，不是同一个对象)

4.2.3 使用负数索引进行切片

切片同样支持使用负数索引来指定 start 和 stop。

my_string = "HelloWorld"
# 索引:  H  e  l  l  o  W  o  r  l  d
#      -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

# 提取倒数第 5 个到倒数第 2 个字符 (不含 -1)
substring5 = my_string[-5:-1]
print(f"my_string[-5:-1] -> '{substring5}'") # 输出: my_string[-5:-1] -> 'Worl'

# 从索引 2 到倒数第 3 个字符 (不含 -2)
substring6 = my_string[2:-2]
print(f"my_string[2:-2] -> '{substring6}'") # 输出: my_string[2:-2] -> 'lloWor'

4.3 切片的步长 (Step)

step 参数控制切片时选取字符的间隔。默认步长为 1，表示连续选取。

4.3.1 理解 step

my_string = "0123456789"

# 从索引 1 到索引 8，每隔 2 个字符取一个
substring7 = my_string[1:8:2] # 取索引 1, 3, 5, 7
print(f"my_string[1:8:2] -> '{substring7}'") # 输出: my_string[1:8:2] -> '1357'

# 取整个字符串中的偶数索引字符
substring8 = my_string[::2] # start 和 stop 省略，step 为 2
print(f"my_string[::2] -> '{substring8}'") # 输出: my_string[::2] -> '02468'

4.3.2 使用负数步长实现反转

当 step 为负数时，切片会从右向左进行。一个非常常用的技巧是使用 [::-1] 来快速反转整个字符串。

my_string = "Python"

# 反转字符串
reversed_string = my_string[::-1]
print(f"'{my_string}' 反转后是 '{reversed_string}'") # 输出: 'Python' 反转后是 'nohtyP'

# 从索引 4 到索引 1，反向每隔 1 个取
substring9 = my_string[4:1:-1] # 取索引 4, 3, 2 (不含 1)
print(f"my_string[4:1:-1] -> '{substring9}'") # 输出: my_string[4:1:-1] -> 'oht'

4.4 切片的应用场景

字符串切片非常灵活，应用广泛：

• 提取文件名中的扩展名。
• 获取 URL 中的协议、域名或路径部分。
• 从固定格式的数据字符串中解析出特定字段。
• 文本处理中截取需要的部分。
• 快速反转字符串。

五、 总结

恭喜你，完成了 Python 字符串基础操作（上）的学习！让我们回顾一下今天掌握的核心知识点：

1. 什么是字符串？ 字符串是 Python 中用于表示文本的有序字符序列。
2. 字符串的表示方式：
   • 单引号 ('...') 和 双引号 ("...") 用于创建单行字符串，选择哪种取决于字符串内部是否包含另一种引号，以避免转义。
   • 三引号 ('''...''' 或 """...""") 用于创建多行字符串或编写文档字符串 (Docstring)。
3. 字符串拼接 (+)： 使用 + 号可以将两个或多个字符串连接成一个新字符串。注意，只能拼接字符串，非字符串类型需要先用 str() 转换。
4. 字符串重复 (*)： 使用 * 号可以将一个字符串重复指定的整数次。
5. 访问字符串中的字符 (索引)：
   • 字符串是有序的，可以通过索引访问单个字符。
   • 正向索引从 0 开始，string[0] 是第一个字符。
   • 反向索引从 -1 开始，string[-1] 是最后一个字符。
   • 访问不存在的索引会引发 IndexError。
6. 获取子字符串 (切片)：
   • 使用 string[start:stop:step] 语法提取字符串的一部分。
   • start 是起始索引（包含），stop 是结束索引（不包含）。
   • start、stop、step 都可以省略，有默认值。
   • step 控制取值间隔，可以为负数（实现反向选取或反转）。
   • 切片是获取子字符串的强大工具。

掌握了这些基础操作，你就拥有了处理文本数据的基本能力。在下一篇文章《【Python-Day 4】处理文本信息 - 字符串 (String) 详解 (下)》中，我们将继续深入探索字符串的更多强大功能——常用方法，例如查找、替换、分割、连接、大小写转换等等，敬请期待！

如果你在学习过程中遇到任何问题，欢迎在评论区留言讨论。继续加油！

---