---

字符串是 Python 中表示文本数据的核心数据类型，本质是由单个字符组成的有序序列，广泛应用于文本处理、路径操作、用户输入输出、数据解析等几乎所有 Python 编程场景，是入门阶段必须重点掌握、熟练运用的基础知识点。

---

在 Python 中，字符串（str）是一种高频使用的数据类型，专门用于表示文本信息。值得注意的是，Python 字符串属于不可变序列类型——一旦创建字符串对象，其内部内容便无法直接修改，所有看似“修改”的操作，本质都是生成新的字符串。

1. 字符串基础

1.1 字符串创建

Python 提供三种灵活的字符串创建方式，分别是单引号、双引号和三重引号（单引号或双引号），三种方式创建的字符串本质完全一致，仅语法上有细微差异，可根据实际使用场景灵活选择。其中，三重引号的核心优势的是支持多行字符串，且能保留文本中的换行和缩进格式，无需额外处理。

single_quoted = 'Hello, World!'
double_quoted = "Hello, World!"
triple_quoted = '''This is a multi-line string.
It spans multiple lines.'''

print(type(single_quoted))    # <class 'str'>
print(type(double_quoted))    # <class 'str'>
print(type(triple_quoted))    # <class 'str'>

1.2 转义字符

转义字符是以反斜杠 \ 开头的特殊字符，用于表示那些无法直接在字符串中书写的字符（如换行、制表符、引号等），其核心作用是规避语法冲突，让 Python 准确识别特殊格式需求。以下是入门阶段必须掌握的高频转义字符，清晰整理如下：

转义字符	说明	作用与用法	示例代码	输出结果
\n	换行符	用于换行，将光标移到下一行开头。	print("第一行\n第二行")	第一行 第二行
\t	制表符	模拟 Tab 键，通常等于 4 个空格，用于对齐排版。	print("姓名\t年龄")	姓名 年龄
\’	转义单引号	在单引号包裹的字符串内，用来显示一个单引号 '。	str6 = 'It\'s a book'	It’s a book
\"	转义双引号	在双引号包裹的字符串内，用来显示一个双引号 "。	str7 = "He said \"Hi\""	He said “Hi”

补充说明：若字符串中无需使用任何转义字符，可借助后续讲解的原始字符串简化书写；需注意，转义字符必须以 \ 开头，若单独书写 \ 而后续无对应字符，会导致语法报错。

1.3 原始字符串

原始字符串（Raw String）的定义十分简单，只需在字符串开头添加字母 r（大小写均可，通常使用小写 r），即可让字符串中的所有字符按字面意思解释，不再解析任何转义字符——也就是说，\ 不再是转义符号，仅作为普通字符存在。

原始字符串的核心应用场景是处理文件路径、正则表达式等，这类场景中常包含大量 \，若不使用原始字符串，需频繁书写双反斜杠 \\ 进行转义，操作繁琐且易出错。

• 错误写法（普通字符串）：path = "C:\Users\Admin\Desktop\test.py"，Python会尝试解析 \U 为转义字符，导致路径无效，运行时可能报错。
• 正确写法（原始字符串）：path = r"C:\Users\Admin\Desktop\test.py"，在字符串开头加r后，所有 \ 都被当作普通字符，Python不会解析转义，路径可正常识别。

1.4 字符串拼接和重复

字符串的拼接与重复是入门阶段最常用的两个操作，语法简洁、实用性极强，无需复杂逻辑，通过简单运算符即可实现。

• 拼接：使用 + 运算符，可将多个字符串连接在一起，形成一个新字符串；

• 重复：使用 * 运算符，可让一个字符串重复指定次数，生成新字符串。

s1 = "Hello"
s2 = "World"
print(s1 + " " + s2)    # 输出: Hello World

print((s1 + ' ') * 3)    # 输出：Hello Hello Hello

1.5 字符串长度

获取字符串长度十分简单，使用 Python 内置函数 len() 即可，该函数会统计字符串中所有字符的总数，包括空格、标点符号等。

s1 = "Hello World!"
print(len(s1))    # 输出：12

1.6 字符串的不可变性

再次强调：Python 字符串是不可变的数据类型，这意味着字符串一旦创建，就无法直接修改、替换或删除其中的单个字符。若需修改字符串内容，只能通过切片、拼接等方式创建一个新的字符串，原字符串始终保持不变。

original = "hello"
# 下面这行代码会抛出 TypeError，无法直接修改单个字符
# original[0] = 'H'

# 正确的方式：通过切片拼接，创建新字符串
new_string = 'H' + original[1:]
print(new_string)  # 输出: Hello

2. 访问字符串

由于字符串是有序序列，我们可以通过“索引”访问单个字符，通过“切片”访问子字符串，这两种方式是字符串操作的基础，需熟练掌握。

2.1 使用索引访问单个字符

Python 中字符串的索引分为两种，便于灵活获取不同位置的字符：

• 正向索引：从 0 开始，依次递增，对应字符串从左到右的顺序；

• 反向索引：从 -1 开始，依次递减，其中 -1 表示最后一个字符，-2 表示倒数第二个字符，以此类推。

greeting = "Hello, World!"
print(greeting[0])   # 输出: H（正向索引，第一个字符）
print(greeting[2])   # 输出: l（正向索引，第三个字符）
print(greeting[-1])  # 输出: !（反向索引，最后一个字符）
print(greeting[-2])  # 输出: d（反向索引，倒数第二个字符）

2.2 使用切片访问子字符串

切片用于获取字符串中的一部分字符，语法格式为 [start:stop:step]，三个参数的含义如下，核心原则是“包含起始，不包含结束”：

• start：切片的起始索引（包含该索引对应的字符，可省略，默认从开头开始）；

• stop：切片的结束索引（不包含该索引对应的字符，可省略，默认到字符串末尾）；

• step：切片的步长，即每次获取字符的间隔（可省略，默认步长为 1；步长为正，从左到右截取；步长为负，从右到左截取）。

greeting = "Hello, World!"

# (1)[开始索引:]  从开始索引截取到字符串的最后
res = greeting[3:]
print(res)           # 输出：lo, World!

# (2)[:结束索引]  从开头截取到结束索引之前（即结束索引-1的位置）
# 核心原则：取头舍尾，结束索引本身对应的字符无法获取
res = greeting[:5]
print(res)           # 输出：Hello

# (3)[开始索引:结束索引]  从开始索引截取到结束索引之前
res = greeting[10:12]
print(res)           # 输出：ld

# (4)[开始索引:结束索引:间隔值]  按指定间隔截取字符
# 从左向右截取（步长为正）
res = greeting[::3]
# 对应索引：0、3、6、9、12...
print(res)           # 输出：Hl r!

# 从右向左截取（步长为负）
res = greeting[::-1]
# 对应索引：-1、-2、-3、-4...（字符串反转）
print(res)           # 输出：!dlroW ,olleH

res = greeting[-3:-10:-2]
# 从索引-3开始，到-10结束（不包含），步长为-2，对应索引：-3、-5、-7、-9
print(res)          # 输出：lo o

关键提醒：从左到右截取时，步长需设为正值；从右到左截取时，步长需设为负值，才能确保正常获取到目标数据。

3. 字符串常用内置方法

Python 的字符串（str）类型提供了丰富的内置方法，无需额外导入模块，可直接调用，用于快速处理和操作字符串。以下是入门阶段高频使用的方法，按功能分类整理，便于记忆和使用。

str() 函数：将各类对象（如数字、列表、元组等）转换为字符串形式，返回一个可读的字符串表示，常用于数据显示、存储或拼接场景。

s1 = 1024
s2 = 5.12
s3 = [1,2,3,4,5]
print(str(s1), str(s2), str(s3))
print(type(str(s1)), type(str(s2)), type(str(s3)))

3.1 大小写转换相关方法

这类方法主要用于字符串大小写的统一处理，返回新的字符串，不改变原字符串内容。

• lower()：将字符串中所有大写字母转换为小写，返回新字符串。

  s = "Hello World"
  print(s.lower())  # 输出：hello world
  

• upper()：将字符串中所有小写字母转换为大写，返回新字符串。

  s = "Hello World"
  print(s.upper())  # 输出：HELLO WORLD
  

• capitalize()：仅将字符串首字母大写，其余字母全部转为小写，返回新字符串（仅对字符串第一个字符生效）。

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

• title()：将字符串中每个单词的首字母大写，其余字母小写（以空格分隔的内容视为“单词”），返回新字符串。

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

3.2 查找与替换相关方法

这类方法用于查找字符串中的子串、统计子串出现次数，或替换指定子串，是文本处理中最常用的功能之一。

• find(sub)：查找子字符串 sub 在目标字符串中首次出现的索引，若未找到，返回 -1（不报错）。

  s = "Python is fun, Python is powerful"
  print(s.find("Python"))  # 输出：0（首次出现的位置）
  print(s.find("java"))    # 输出：-1（未找到）
  

  扩展：find() 支持两个可选参数 start 和 end，用于限定查找范围（从 start 索引开始，到 end 索引结束，不包含 end）。

  # 语法：字符串.find(sub, start, end)
  
  s = "Hello, world! Hello again."
  # 从索引 10 开始查找 "Hello"
  print(s.find("Hello", 10))  # 输出：14（避开了第一个"Hello"）
  
  # 在索引 5-20 之间查找 "world"
  print(s.find("world", 5, 20))  # 输出：7（在范围内找到）
  print(s.find("world", 10, 20)) # 输出：-1（在范围内未找到）
  

  补充：rfind(sub) 与 find(sub) 功能类似，区别是从字符串右侧（末尾）开始查找，返回子串最后一次出现的索引，未找到同样返回 -1。

  s = "apple, banana, apple, orange"
  # 查找 "apple" 最后一次出现的位置（右侧开始）
  print(s.rfind("apple"))  # 输出：15（第二个 "apple" 的起始索引）
  
  # 查找不存在的子字符串
  print(s.rfind("grape"))  # 输出：-1
  

• index(sub)：功能与 find(sub) 完全一致，用于查找子串首次出现的索引，但子串未找到时，会抛出 ValueError 异常（区别于 find() 的不报错特性）。

  s = "Python is fun"
  print(s.index("is"))   # 输出：7
  # print(s.index("java"))  # 报错：ValueError: substring not found
  

  扩展：index() 同样支持 start 和 end 可选参数；rindex(sub) 从字符串末尾开始查找，未找到同样报错。

• count(sub)：统计子字符串 sub 在字符串中出现的次数，返回整数。

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

• replace(old, new [,count])：将字符串中所有 old 子字符串替换为 new 子字符串，返回新字符串；可选参数 count 用于指定最大替换次数，默认替换所有匹配的子串。

  s = "I like apple, apple is good"
  # 替换所有 "apple" 为 "banana"
  print(s.replace("apple", "banana"))  # 输出：I like banana, banana is good
  # 只替换第一次出现的 "apple"
  print(s.replace("apple", "banana", 1))  # 输出：I like banana, apple is good
  

3.3 编码与解码相关方法

在 Python 中，字符串（str）和字节（bytes）之间的转换，需通过编码（encode）和解码（decode）实现，常用于网络传输、文件读写等场景，核心是保证编码与解码格式一致，避免乱码。

• encode(encoding="utf-8", errors="strict")：将字符串转换为字节对象（编码），需指定编码格式。

  • encoding：编码格式（默认 utf-8，常用还有 gbk、utf-16 等）
  • errors：错误处理方式（默认 strict 报错，可选 ignore 忽略、replace 替换等）

  s = "编码测试：Hello"
  
  # 默认 utf-8 编码
  b_utf8 = s.encode()
  print(b_utf8)  # 输出：b'\xe7\xbc\x96\xe7\xa0\x81\xe6\xb5\x8b\xe8\xaf\x95\xef\xbc\x9aHello'
  
  # 指定 gbk 编码
  b_gbk = s.encode("gbk")
  print(b_gbk)  # 输出：b'\xb1\xe0\xc2\xeb\xb2\xe2\xca\xd4\xef\xbc\x9aHello'
  
  # 错误处理（用 ascii 编码中文会报错，捕获异常）
  try:
      s.encode("ascii")
  except UnicodeEncodeError:
      print("ASCII 编码无法处理中文")
  

• decode(encoding="utf-8", errors="strict")：将字节对象转换为字符串（解码），需与编码时的格式一致。

  参数：同 encode()，encoding 必须匹配编码格式，否则可能乱码或报错。

  b_utf8 = b'\xe7\xbc\x96\xe7\xa0\x81\xe6\xb5\x8b\xe8\xaf\x95'
  
  # 用 utf-8 解码（正确方式）
  s1 = b_utf8.decode("utf-8")
  print(s1)  # 输出：编码测试
  
  # 用错误格式解码（导致乱码）
  s2 = b_utf8.decode("gbk")
  print(s2)  # 输出乱码：缂栫爜娴嬭瘯
  
  # 忽略错误解码（丢失信息）
  b = b'\xe4\xbd\xa0\xe5\xa5\xbd\x80'  # 包含无效字节 \x80
  s3 = b.decode("utf-8", errors="ignore")
  print(s3)  # 输出：你好（忽略了错误字节）
  

核心提醒：

• 编码与解码必须使用相同的格式（如 utf-8 编码 → utf-8 解码），否则会乱码或报错。
• Python 3 中默认使用 utf-8，支持全球所有语言字符，推荐优先使用。
• 编码和解码是处理文本数据的基础，确保格式一致性是避免乱码的关键。

3.4 判断与检查相关方法

这类方法用于判断字符串是否满足特定条件，返回布尔值（True 或 False），常用于条件判断场景。

• startswith(prefix)：判断字符串是否以指定前缀 prefix 开头，返回布尔值。

  s = "Python is great"
  print(s.startswith("Python"))  # 输出：True
  print(s.startswith("java"))    # 输出：False
  

• endswith(suffix)：判断字符串是否以指定后缀 suffix 结尾，返回布尔值。

  s = "Python is great"
  print(s.endswith("great"))  # 输出：True
  print(s.endswith("good"))   # 输出：False
  

• isalpha()：判断字符串是否只包含字母（a-z, A-Z），且非空，返回布尔值。

  print("Hello".isalpha())   # 输出：True
  print("Hello123".isalpha())# 输出：False（包含数字）
  

• isdigit()：判断字符串是否只包含数字（0-9），且非空，返回布尔值。

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

• isalnum()：判断字符串是否只包含字母和数字，且非空，返回布尔值。

  print("Python123".isalnum())  # 输出：True
  print("Python 123".isalnum()) # 输出：False（包含空格）
  

• strip()：移除字符串两端的空白字符（空格、换行符 \n、制表符 \t 等），返回新字符串。

  s = "  \tHello World\n  "
  print(s.strip())  # 输出：Hello World
  

  扩展：lstrip() 仅移除字符串左端空白，rstrip() 仅移除字符串右端空白，可根据需求选择使用。

3.5 分割与拼接相关方法

分割与拼接是字符串处理中高频搭配使用的方法，常用于将字符串拆分为列表、或将列表拼接为字符串。

• split(sep)：以 sep 为分隔符分割字符串，返回分割后的列表（默认以空白字符分割）。

  s = "apple,banana,orange"
  print(s.split(","))  # 输出：['apple', 'banana', 'orange']
  
  s2 = "Hello world python"
  print(s2.split())    # 输出：['Hello', 'world', 'python']（默认按空格分割）
  

  • 如果 sep 是一个空字符串 “”，会抛出 ValueError 错误。
  • 可以通过第二个参数 maxsplit 限制分割次数

  text = "a,b,c,d"
  result = text.split(sep=",", maxsplit=2)  # 最多分割2次
  print(result)  # 输出: ['a', 'b', 'c,d']
  

• join(iterable)：将可迭代对象（如列表、元组）中的元素以当前字符串为分隔符拼接成新字符串。

  fruits = ["apple", "banana", "orange"]
  print(", ".join(fruits))  # 输出：apple, banana, orange（以 ", " 拼接）
  

3.6 其他常用方法

• len(s)：虽然不是字符串的方法（是内置函数），但常用于获取字符串长度。

  s = "Hello"
  print(len(s))  # 输出：5
  

• center(width)：将字符串居中，并用空格填充至指定宽度 width。

  s = "Hello"
  print(s.center(10))  # 输出：  Hello   （两边各补2个空格，总长度10）
  

• zfill(width)：在字符串左侧填充 0，使总长度为 width（常用于数字字符串格式化）。

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

4. 字符串的成员运算

Python 中字符串支持成员运算，通过 in 和 not in 两个关键字，可快速判断一个子字符串（或单个字符）是否存在于目标字符串中，返回结果为布尔值（True 或 False），语法简洁、实用性强。

1. in 运算：判断子字符串（或单个字符）是否存在于目标字符串中，存在则返回 True，不存在则返回 False。

   s = "Hello, world!"
   
   print("Hello" in s)      # 输出: True（"Hello"是s的子串）
   print("world" in s)      # 输出: True（"world"是s的子串）
   print("Python" in s)     # 输出: False（"Python"不是s的子串）
   print("o" in s)          # 输出: True（单个字符也是子串）
   

2. not in 运算：判断子字符串（或单个字符）是否不存在于目标字符串中，不存在则返回 True，存在则返回 False，与 in 运算逻辑相反。

   s = "Hello, world!"
   
   print("Java" not in s)   # 输出: True（"Java"不在s中）
   print("llo" not in s)    # 输出: False（"llo"在s中）
   

3. 注意事项：

   • 成员运算区分大小写：例如 "hello" in s 与 "Hello" in s 是两个不同的判断，结果可能不同；
   • 空字符串（""）是任何字符串的子串，即"" in 任意字符串 始终返回 True；
   • 成员运算常用于条件判断场景，例如检查字符串中是否包含特定关键词、符号等，简化逻辑判断。

---

本文已涵盖Python字符串入门核心知识点，包括创建、访问、内置方法及成员运算，字符串作为Python高频使用的数据类型，是进阶学习的基础。
需牢记字符串“不可变性”这一核心特性，内置方法无需死记硬背，多动手实践即可熟练运用，打好基础，为后续学习筑牢根基。

---