【0008】Python数据类型-String类型详解（全网最细教程）

程序员张小厨

已于 2025-03-04 23:53:45 修改

阅读量1.1k

点赞数 23

分类专栏：【007】Python 文章标签： python Python字符串 Python数据类型 Python String Python字符串数据类型

于 2025-03-04 23:02:05 首次发布

本文链接：https://blog.youkuaiyun.com/cxyzxc0325/article/details/146029240

版权

【007】Python 专栏收录该内容

17 篇文章

订阅专栏

如果你觉得我的文章写的不错，请关注我哟，请点赞、评论，收藏此文章，谢谢！

本文内容体系结构如下：
在这里插入图片描述

字符串是编程中非常基础且重要的数据类型，用来表示文本信息。在Python中，字符串功能丰富且强大，本文将用最通俗易懂的语言，带你一步步深入掌握Python中字符串的使用。

一、什么是字符串？

字符串（String）是由零个或多个字符组成的序列，用于表示文本信息。在Python中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能改变它的内容（但可以通过重新赋值来更改变量所引用的字符串）。字符串可以用单引号（‘）、双引号（"）或三引号（’‘’）、（“”"）括起来。

二、字符串的基本操作

2.1 字符串的创建

（1）单引号、双引号、三引号创建字符串

字符串可以用单引号、双引号或三引号创建。

# 使用单引号创建字符串
s1 = '大湖名城，创新高地'
print(s1)  # 大湖名城，创新高地
print(type(s1)) # <class 'str'>

# 使用双引号创建字符串
s2 = "科教之城，能源之都"
print(s2)  # 科教之城，能源之都"
print(type(s2)) # <class 'str'>

# 使用三个单引号创建字符串
s3 = '''中国·合肥，欢迎您！'''
print(s3) # 中国·合肥，欢迎您！
print(type(s3)) # <class 'str'>

# 使用三个双引号创建字符串
s4 = """You Are So Beautiful"""
print(s4) # You Are So Beautiful
print(type(s4)) # <class 'str'>

代码运行结果如下图所示：
在这里插入图片描述

（2）创建包含引号的字符串

如果字符串中包含引号，可以使用另一种引号来避免冲突

# 包含单引号的字符串
s1 = "It's a beautiful day!"
print(s1)  # It's a beautiful day!
s2 = """It's a beautiful day!"""
print(s2) # It's a beautiful day!

# 包含双引号的字符串
s3 = 'He said, "Hello!"'
print(s3)  # He said, "Hello!"
s4 = '''He said, "Hello!"'''
print(s4) # He said, "Hello!"

# 包含三引号的字符串
s5 = "莫言行路早，'''更'''有早行人"
print(s5) # 莫言行路早，'''更'''有早行人
s6 = '莫言行路早，"""更"""有早行人'
print(s6) # 莫言行路早，"""更"""有早行人

代码运行结果如下图所示：
在这里插入图片描述

（3）使用转义字符（\）创建字符串。

如果字符串中包含单引号，除了可以使用另外一种引号来避免冲突之外，还可以使用转义字符来避免冲突。在 Python 中，转义字符用于在字符串中表示特殊字符或行为

# 使用转义字符创建字符串
s1 = 'It\'s a beautiful day!'  # 注意：\' 是转义的单引号
print(s1)  # It's a beautiful day!

s2 = "莫言行路早，\"更\"有早行人"# 注意：\" 是转义的双引号
print(s2)

代码运行结果如下图所示：
在这里插入图片描述

除了上面的两个表示引号的转义字符，Python中常用的转义字符如下所示：

转义字符	描述	作用
`\\`	反斜杠	表示一个实际的反斜杠字符
`\'`	单引号	在字符串中表示一个单引号，避免结束字符串
`\"`	双引号	在字符串中表示一个双引号，避免结束字符串
`\n`	换行符	将光标移到下一行开头
`\t`	水平制表符	增加水平间隔，通常用于对齐文本
`\r`	回车符	将光标移到当前行的开头
`\b`	退格符	将光标向左移动一个字符位置
`\f`	换页符	换到下一页（在大多数文本处理中不常用）
`\v`	垂直制表符	增加垂直间隔（在大多数文本处理中不常用）
`\ooo`	八进制转义（`ooo` 是八进制值）	用八进制数表示一个字符
`\xhh`	十六进制转义（`hh` 是十六进制值）	用十六进制数表示一个字符
`\uxxxx`	Unicode 转义（16 位）	用 16 位 Unicode 编码表示一个字符
`\Uxxxxxxxx`	Unicode 转义（32 位）	用 32 位 Unicode 编码表示一个字符

（4）使用r或R保留字符串原始内容

在 Python 中，前缀 r 或 R 用于创建原始字符串（raw string）。原始字符串的特点是反斜杠 \ 不会被解释为转义字符，而是作为普通字符处理。这在处理包含反斜杠的字符串时特别有用，例如文件路径、正则表达式（后面有文章专门说到正则表达式，如果你之前没有接触过正则表达式，当前知道有这么个概念即可）等。

1）作用

原始字符串：在原始字符串中，反斜杠 \ 不会转义字符，而是作为普通字符。这意味着 \n 不会被解释为换行符，而是被视为两个字符：反斜杠和 n。
正则表达式：原始字符串通常用于正则表达式，因为正则表达式中大量使用反斜杠。例如，\d 表示一个数字字符，在普通字符串中需要写成 \\d，而在原始字符串中可以直接写成 \d。

2）代码案例

下面是一些示例代码，展示如何使用原始字符串以及它们的优势。

# 普通字符串中的反斜杠需要转义
file_path = "C:\\Users\\Admin\\Documents\\file.txt"
print(file_path)  # C:\Users\Admin\Documents\file.txt

# 原始字符串中的反斜杠不需要转义
raw_file_path = r"C:\Users\Admin\Documents\file.txt"
print(raw_file_path)  # C:\Users\Admin\Documents\file.txt

# 正则表达式示例
import re

# 使用普通字符串，反斜杠需要转义
pattern = "\\d+"  # 匹配一个或多个数字
match = re.search(pattern, "abc123def")
if match:
    print("Matched:", match.group())  # Matched: 123

# 使用原始字符串，反斜杠不需要转义
raw_pattern = r"\d+"  # 匹配一个或多个数字
raw_match = re.search(raw_pattern, "abc123def")
if raw_match:
    print("Matched:", raw_match.group())  # Matched: 123

代码运行结果如下图所示：
在这里插入图片描述

3）解释

文件路径：在文件路径中，Windows 使用反斜杠作为路径分隔符。使用原始字符串可以避免手动转义每个反斜杠。
正则表达式：正则表达式中反斜杠用于转义特殊字符。例如，\d 表示一个数字。在原始字符串中，正则表达式可以更清晰地书写，因为反斜杠不需要转义。

通过使用原始字符串，代码的可读性和简洁性得到了提高，特别是在处理包含许多反斜杠的字符串时。

2.2 字符串的格式化输出

在 Python 中，有多种方式可以进行字符串格式化输出。以下是常用的几种方法：

（1）百分号 (%) 格式化

这种方法是最早的字符串格式化方式，类似于 C 语言中的 printf。

name = "Alice"
age = 30
formatted_string = "Name: %s, Age: %d岁" % (name, age)
print(formatted_string) # Name: Alice, Age: 30

# 直接使用print()语句输出格式化的字符串内容
print("Name: %s, Age: %d岁" % (name, age)) # Name: Alice, Age: 30

代码运行结果如下图所示：
在这里插入图片描述

（2）str.format() 方法

这种方法使用花括号 {} 作为占位符，更加灵活。

name = "Bob"
age = 25

# 使用花括号 {}作为占位符
formatted_string1 = "Name: {}, Age: {}岁".format(name, age)
print(formatted_string1) # Name: Bob, Age: 25

# 直接使用print()语句输出格式化的字符串内容
print("Name: {}, Age: {}岁".format(name, age)) # Name: Bob, Age: 25

可以通过索引标识位置：

# 通过索引标识位置
formatted_string2 = "Name: {0}, Age: {1}岁".format(name, age)
print(formatted_string2) # Name: Bob, Age: 25

# 直接使用print()语句输出格式化的字符串内容
print("Name: {0}, Age: {1}岁".format(name, age)) # Name: Bob, Age: 25

或使用关键字参数：

# 使用关键字参数
formatted_string3 = "Name: {name}, Age: {age}岁".format(name=name, age=age)
print(formatted_string3) # Name: Bob, Age: 25

# 直接使用print()语句输出格式化的字符串内容
print("Name: {name}, Age: {age}岁".format(name=name, age=age)) # Name: Bob, Age: 25

代码运行结果如下图所示：
在这里插入图片描述

（3）f-strings (格式化字符串字面值)

从 Python 3.6 开始引入的，这种方式使用前缀 f 并在字符串中直接嵌入变量。

name = "Charlie"
age = 22
formatted_string = f"Name: {name}, Age: {age}岁"
print(formatted_string)

# 直接使用print()语句输出格式化的字符串内容
print(f"Name: {name}, Age: {age}岁")

代码运行结果如下图所示：
在这里插入图片描述

（4）模板字符串 (Template Strings)

使用 string 模块中的 Template 类，可用于更复杂或安全要求更高的情况。

from string import Template

name = "Diana"
age = 28
template = Template("Name: $name, Age: $age岁")
formatted_string = template.substitute(name=name, age=age)
print(formatted_string)

# 直接使用print()语句输出格式化的字符串内容
print(Template("Name: $name, Age: $age岁").substitute(name=name, age=age))

代码运行结果如下图所示：
在这里插入图片描述

每种格式化方式都有其适用的场景，选择使用哪种取决于代码的具体需求和个人偏好。对于简单和快速的格式化，f-strings 是现代 Python 中的推荐方式。

2.3 字符串的拼接

字符串拼接是指将两个或多个字符串连接成一个新的字符串。在Python中，可以使用加号（+）来拼接字符串。

注意：字符串拼接时，加号两边必须是字符串类型，否则会引发类型错误。

str1 = 'Hello'
str2 = 'World'
concatenated_string = str1 + ', ' + str2 + '!'
print(concatenated_string)  # Hello, World!

# 直接使用print()语句输出
print("Hello"+",Python!") # Hello,Python!

# 注意：字符串拼接时，加号两边必须是字符串类型，否则会引发类型错误。
print("Hello，"+123) # TypeError: can only concatenate str (not "int") to str

代码运行结果如下图所示：
在这里插入图片描述

2.4 字符串的重复

可以使用星号（*）来重复字符串。

repeated_string = 'Python ' * 3
print(repeated_string)  # Python Python Python

代码运行结果如下图所示：
在这里插入图片描述

2.5 访问字符串中的字符

字符串中的字符可以通过**索引（下标）**来访问，索引就是编号，好比超市中存储柜的编号，通过这个编号就能找到相应的存储空间，Python中字符串，列表，元祖均支持下标索引。Python支持正向索引和负向索引，正向索引从左往右开始编号，起始值从0开始，负向索引表示从字符串末尾开始计数，从右向左，起始值从-1开始。索引如下图所示：
在这里插入图片描述

my_string = 'Hello, World!'

s1 = my_string[0]
print(s1) # H

s2 = my_string[1]
print(s2) # e

s3 = my_string[-1]
print(s3) # !

s4 = my_string[-2]
print(s4) # d

代码运行结果如下图所示：
在这里插入图片描述

2.6 字符串切片

切片是指从字符串中提取一部分子字符串。切片通过指定起始索引和结束索引来实现，语法为[start:end]，其中start是起始索引（包含），end是结束索引（不包含）。如果省略start，则表示从字符串开头开始；如果省略end，则表示到字符串结尾为止。

my_string = 'Hello, World!'

slice_string = my_string[0:5]
print(slice_string) # Hello
# 切片操作不会改变字符串本身内容
print(my_string) # Hello, World!

# 省略起始索引
slice_string2 = my_string[:5]
print(slice_string2) # Hello
# 切片操作不会改变字符串本身内容
print(my_string) # Hello, World!

# 省略结束索引
slice_string3 = my_string[7:]
print(slice_string3) # World!
# 切片操作不会改变字符串本身内容
print(my_string) # Hello, World!

# 使用负索引
slice_string4 = my_string[-6:-1]
print(slice_string4) # World
# 切片操作不会改变字符串本身内容
print(my_string) # Hello, World!

# 获取整个字符串（相当于复制）
slice_string5 = my_string[:]
print(slice_string5) # Hello, World!
# 切片操作不会改变字符串本身内容
print(my_string) # Hello, World!

代码运行结果如下图所示：
在这里插入图片描述

2.7 字符串的步长切片

除了基本的切片操作，Python还支持带步长的切片，语法为[start:end:step]，其中step表示步长，可以是正数或负数。

my_string = 'Hello, World!'

# 正向步长
slice_string = my_string[::2]  # Hlo ol!，每隔一个字符取一个
print(slice_string)

# 反向步长
slice_string2 = my_string[::-1]  # !dlroW ,olleH，反转字符串
print(slice_string2)

代码运行结果如下图所示：
在这里插入图片描述

三、操作字符串的内置函数

在Python中，有一些常用的公共内置函数不是专门为字符串设计的，但是可以用于处理字符串。以下是一些常用的内置函数：

3.1 len()

功能：返回对象的长度或项目个数。对于字符串而言，返回字符串中字符的数量。
用法：len(string)
示例：
```
s = "hello"
print(len(s))  # 5
```

3.2 `max()` 和 `min()`

功能：返回可迭代对象中的最大值和最小值。对于字符串而言，返回字符串中按字典序的最大和最小字符。
用法：max(string)，min(string)

示例：

s = "hello"
print(max(s))  # o
print(min(s))  # e

3.3 `sorted()`

功能：对可迭代对象进行排序，并返回一个新的已排序列表。对于字符串而言，返回字符串中字符按字典序排序后的新列表。
用法：sorted(string)

示例：

s = "hello"
print(sorted(s))  # ['e', 'h', 'l', 'l', 'o']

# 设置参数reverse=True可以实现降序排序
print(sorted(s,reverse=True)) # ['o', 'l', 'l', 'h', 'e']

3.4 `type()`

功能：返回对象的类型。对于字符串而言，返回<class 'str'>。
用法：type(string)

示例：

s = "hello"
print(type(s))  # <class 'str'>

3.5 `str()`

功能：将对象转换为字符串。虽然这不是一个专门用于处理字符串的内置函数，但在需要将其他类型的数据（如数字、列表、元组等）转换为字符串时非常有用。
用法：str(object)

示例：

num = 123
s = str(num)
print(s)  # 输出: 123
print(type(s))

s2=str(True)
print(s2) # True
print(type(s2)) # <class 'str'>

3.6 `format()`

功能：用于格式化字符串，将变量的值插入到字符串的占位符中。
用法：format(value, ...) 或 "{0} {1}".format(value1, value2)

示例：

name = "Alice"
age = 30
formatted_string = "My name is {} and I am {} years old.".format(name, age)
print(formatted_string)  # My name is Alice and I am 30 years old.

3.7 `chr()` 和 `ord()`

功能：chr()函数用于将Unicode码点转换为对应的字符，ord()函数用于将字符转换为对应的Unicode码点。
用法：chr(i)，ord(c)

示例：

code_point = 65
char = chr(code_point)
print(char)  # A

char = 'A'
code_point = ord(char)
print(code_point)  # 65

需要注意的是，虽然上述函数可以用于处理字符串，但它们并不是专门为字符串设计的。例如，len()函数可以用于任何可迭代对象，而max()和min()函数可以用于任何可比较的对象。这些函数在Python中是非常基础且通用的，适用于多种数据类型。

四、字符串类中常用方法

Python 的字符串对象提供了丰富的方法来处理和操作字符串。这些方法涵盖了字符串的查找、替换、分割、连接、格式化、转换、比较、编码等多个方面。以下是 Python 中与字符串相关的方法的详细介绍：

4.1 字符串查找和匹配

（1）`str.find(sub[, start[, end]])`

功能：返回子字符串 sub 在字符串中首次出现的最低索引。如果子字符串不在字符串中，则返回 -1。

示例：

s = "abcdabcdefg"
print(s.find("a")) # 0
print(s.find("m")) # -1 查找内容不存在，返回-1
print(s.find("a",3)) # 4
print(s.find("a",1,4)) # -1 说明查找区间是左闭右开区间，包含索引1不包含索引4的数据
print(s.find("a",1,5)) # 4

（2）`str.index(sub[, start[, end]])`

功能：类似于 find()，但如果子字符串不在字符串中，则抛出 ValueError。

示例：

s = "abcdabcdefg"
print(s.index("a")) # 0
# print(s.index("m")) # ValueError: substring not found
print(s.index("a",2)) # 4
print(s.index("a",2,5)) # 4
# print(s.index("a",2,4)) # ValueError: substring not found 说明包含2不包含4索引内容

（3）`str.rfind(sub[, start[, end]])`

功能：返回子字符串 sub 在字符串中最后一次出现的最高索引。如果子字符串不在字符串中，则返回 -1。

示例：

s = "abcdabcdefg"
print(s.rfind("a")) # 4
print(s.rfind("m")) # -1
print(s.rfind("a",2)) # 4
print(s.rfind("a",5)) # -1
print(s.rfind("a",2,5)) # 4

（4）`str.rindex(sub[, start[, end]])`

功能：类似于 rfind()，但如果子字符串不在字符串中，则抛出 ValueError。

示例：

s = "abcdabcdefg"
print(s.rindex("a")) # 4
# print(s.rindex("m")) # ValueError: substring not found
print(s.rindex("a",2)) # 4
# print(s.rindex("a",5)) # ValueError: substring not found
print(s.rindex("a",2,5)) # 4

（5）`str.count(sub[, start[, end]])`

功能：返回子字符串 sub 在字符串中出现的次数。

示例：

s = "abcdabcdefg"
print(s.count("a")) # 2
print(s.count("m")) # 0

4.2 字符串判断

（1）`str.startswith(prefix[, start[, end]])`

功能：用于判断字符串是否以指定的前缀开始。

示例：

s = "abcdabcdefg"
print(s.startswith("a")) # True
print(s.startswith("A")) # False
print(s.startswith("a",2)) # False
print(s.startswith("a",4)) # True
print(s.startswith("a",2,5)) # False
print(s.startswith("a",4,7)) # True

（2）`str.endswith(suffix[, start[, end]])`

功能：用于判断字符串是否以指定的后缀结束。

示例：

s = "abcdabcdefg"
print(s.endswith("g")) # True
print(s.endswith("A")) # False
print(s.endswith("g",2)) # True
print(s.endswith("g",4)) # True
print(s.endswith("a",1,5)) # True
print(s.endswith("a",4,7)) # False

（3）`str.isalpha()`

功能：用于判断字符串是否只包含字母字符（不包括空格、数字或特殊字符）。

示例：

text1 = "Hello"
print(text1.isalpha()) # True

text2 = "Hello123"
print(text2.isalpha()) # False

（4）`str.isdigit()`

功能：用于判断字符串是否只包含数字字符。

示例：

text1 = "12345"
print(text1.isdigit()) # True

text2 = "12345abc"
print(text2.isdigit()) # False

（5）`str.isalnum()`

功能：用于判断字符串是否只包含字母和数字字符。

示例：

text1 = "Hello123"
print(text1.isalnum()) # True

text2 = "Hello 123"
print(text2.isalnum()) # False

（6）`str.isspace()`

功能：用于判断字符串是否只包含空白字符（如空格、制表符、换行符等）。

示例：

text1 = "   "
print(text1.isspace()) # True

text2 = "Hello"
print(text2.isspace()) # False

（7）`str.islower()`

功能：islower() 用于判断字符串是否全部为小写

示例：

text1 = "hello"
print(text1.islower()) # True

text2 = "HELLO"
print(text2.isupper()) # True

（8） `str.isupper()`

功能：isupper() 用于判断字符串是否全部为大写。

示例：

text1 = "hello"
print(text1.islower()) # True

text2 = "HELLO"
print(text2.isupper()) # True

（9）`str.istitle()`

功能：用于判断字符串中的每个单词是否首字母大写。

示例：

text1 = "Hello World"
print(text1.istitle()) # True

text2 = "hello world"
print(text2.istitle()) # False

（10）in`和`not in

在Python中，in和not in是用于判断子串是否存在于另一个字符串中的运算符。这两个运算符在字符串处理中非常常用，可以方便地用于条件判断、过滤等操作。

1）`in`运算符

功能：用于检查一个子串是否存在于另一个字符串中。如果子串存在，则返回True；否则，返回False。

示例：

text = "Hello, world!"
print("Hello" in text) # True
print("Python" in text) # False

2）`not in`运算符

功能：用于检查一个子串是否不存在于另一个字符串中。如果子串不存在，则返回True；否则，返回False。

示例：

text = "Hello, world!"
print("Python" not in text) # True
print("world" not in text) # False

4.3 字符串替换

（1）`str.replace(old, new[, count])`

功能：将字符串中的所有 old 子字符串替换为 new 子字符串。如果指定了 count，则只替换前 count 次。

示例：

s = "hello world! hi world! good world"
new_s1 = s.replace("world", "Python")
print(new_s1) # hello Python! hi Python! good Python

new_s2 = s.replace("world", "Python",1)
print(new_s2) # hello Python! hi world! good world

4.4 字符串分割和连接

（1）`str.split([sep[, maxsplit]])`

功能：将字符串拆分为列表。如果未指定 sep，则默认使用空白字符（空格、制表符、换行符等）作为分隔符。如果指定了 maxsplit，则最多分割 maxsplit 次。

示例：

s = "hello world hi world-good world-yes good"
words1 = s.split()
print(words1)  # ['hello', 'world', 'hi', 'world-good', 'world-yes', 'good']
words2 = s.split(" ")
print(words2) # ['hello', 'world', 'hi', 'world-good', 'world-yes', 'good']
words3 = s.split(" ",3)
print(words3) # ['hello', 'world', 'hi', 'world-good world-yes good']
words4 = s.split("-")
print(words4) # ['hello world hi world', 'good world', 'yes good']

（2）`str.rsplit([sep[, maxsplit]])`

功能：类似于 split()，但从右向左分割字符串。

示例：

s = "hello world hi world-good world-yes good"
words1 = s.rsplit()
print(words1)  # ['hello', 'world', 'hi', 'world-good', 'world-yes', 'good']
words2 = s.split(" ")
print(words2) # ['hello', 'world', 'hi', 'world-good', 'world-yes', 'good']
words3 = s.rsplit(" ",3)
print(words3) # ['hello world hi', 'world-good', 'world-yes', 'good']
words4 = s.rsplit("-")
print(words4) # ['hello world hi world', 'good world', 'yes good']

（3）`str.join(iterable)`

功能：将可迭代对象中的元素连接为一个字符串，使用当前字符串作为分隔符。

示例：

words = ['hello', 'world']
s1 = " ".join(words)
print(s1) # hello world

s2 = "-".join(words)
print(s2) # hello-world

4.5 字符串格式化和转换

（1）`str.format(*args, **kwargs)`

功能：格式化字符串，将参数插入到字符串的占位符中。

示例：

name = "Alice"
age = 30
s = "My name is {} and I am {} years old.".format(name, age)
print(s) # My name is Alice and I am 30 years old.

（2）`str.capitalize()`

功能：将字符串的第一个字符转换为大写，其他字符转换为小写。

示例：

s = "hello world"
new_s = s.capitalize()
print(new_s) # Hello world

（3）`str.title()`

功能：将字符串中的每个单词的首字母转换为大写。

示例：

s = "hello world"
new_s = s.title()
print(new_s) # Hello World

（4）`str.upper()`

功能：将字符串中的所有字符转换为大写。

示例：

s = "hello world"
new_s = s.upper()
print(new_s) # HELLO WORLD

（5）`str.lower()`

功能：将字符串中的所有字符转换为小写。

示例：

s = "HELLO WORLD"
new_s = s.lower()
print(new_s) # hello world

（6）`str.swapcase()`

功能：将字符串中的大写字母转换为小写，小写字母转换为大写。

示例：

s = "Hello World"
new_s = s.swapcase()
print(new_s) # hELLO wORLD

4.6 字符串去除空白

（1）`str.strip([chars])`

功能：移除字符串两端的空白字符或指定字符。

示例：

s = "  hello world  "
new_s = s.strip()
print(new_s) # hello world

（2）`str.lstrip([chars])`

功能：移除字符串左侧的空白字符或指定字符。

示例：

s = "  hello world"
new_s = s.lstrip()
print(new_s) # hello world

（3）`str.rstrip([chars])`

功能：移除字符串右侧的空白字符或指定字符。

示例：

s = "hello world  "
new_s = s.rstrip()
print(new_s) # hello world

4.7 字符串比较

（1）`str.eq(other)` (`==`)

功能：检查两个字符串是否相等。

示例：

s1 = "hello"
s2 = "world"
print(s1 == s2) # False

（2）`str.lt(other)` (`<`)

功能：按字典序比较两个字符串，返回是否小于。

示例：

s1 = "hello"
s2 = "world"
print(s1 < s2) # True

（3）`str.le(other)` (`<=`)

功能：按字典序比较两个字符串，返回是否小于或等于。

示例：

s1 = "hello"
s2 = "world"
print(s1 <= s2) # True

（4）`str.gt(other)` (`>`)

功能：按字典序比较两个字符串，返回是否大于。

示例：

s1 = "hello"
s2 = "world"
print(s1 > s2) # False

（5）`str.ge(other)` (`>=`)

功能：按字典序比较两个字符串，返回是否大于或等于。

示例：

s1 = "hello"
s2 = "world"
print(s1 >= s2) # False

五、总结

字符串，作为Python编程语言中的基础数据类型之一，承载着处理文本信息的重任。其设计简洁明了，却蕴含着强大的功能。字符串的不可变性特性，确保了数据在传递和处理过程中的安全性和一致性，让开发者可以更加放心地使用。

在Python中，字符串的操作直观易懂。通过简单的运算符，比如判断子串存在的in和not in，我们能够迅速地对文本内容进行分析和筛选，极大地提高了编程效率。

此外，字符串还支持索引和切片等高级操作，使得对文本内容的访问、提取和处理变得更加灵活和便捷。Python的字符串处理功能，不仅满足了基本的文本操作需求，更为复杂的文本处理提供了无限可能。

【0008】Python数据类型-String类型详解（全网最细教程）

一、什么是字符串？

二、字符串的基本操作

2.1 字符串的创建

（1）单引号、双引号、三引号创建字符串

（2）创建包含引号的字符串

（3）使用转义字符（\）创建字符串。

（4）使用r或R保留字符串原始内容

1）作用

2）代码案例

3）解释

2.2 字符串的格式化输出

（1）百分号 (%) 格式化

（2）str.format() 方法

（3）f-strings (格式化字符串字面值)

（4）模板字符串 (Template Strings)

2.3 字符串的拼接

2.4 字符串的重复

2.5 访问字符串中的字符

2.6 字符串切片

2.7 字符串的步长切片

三、操作字符串的内置函数

3.1 len()

3.2 max() 和 min()

3.3 sorted()

3.4 type()

3.5 str()

3.6 format()

3.7 chr() 和 ord()

四、字符串类中常用方法

4.1 字符串查找和匹配

（1）str.find(sub[, start[, end]])

（2）str.index(sub[, start[, end]])

（3）str.rfind(sub[, start[, end]])

（4）str.rindex(sub[, start[, end]])

（5）str.count(sub[, start[, end]])

4.2 字符串判断

（1）str.startswith(prefix[, start[, end]])

（2）str.endswith(suffix[, start[, end]])

（3）str.isalpha()

（4）str.isdigit()

（5）str.isalnum()

（6）str.isspace()

（7）str.islower()

（8） str.isupper()

（9）str.istitle()

（10）in和not in

1）in运算符

2）not in运算符

4.3 字符串替换

（1）str.replace(old, new[, count])

4.4 字符串分割和连接

（1）str.split([sep[, maxsplit]])

（2）str.rsplit([sep[, maxsplit]])

（3）str.join(iterable)

4.5 字符串格式化和转换

（1）str.format(*args, **kwargs)

（2）str.capitalize()

（3）str.title()

（4）str.upper()

（5）str.lower()

（6）str.swapcase()

4.6 字符串去除空白

（1）str.strip([chars])

（2）str.lstrip([chars])

（3）str.rstrip([chars])

4.7 字符串比较

（1）str.__eq__(other) (==)

（2）str.__lt__(other) (<)

（3）str.__le__(other) (<=)

（4）str.__gt__(other) (>)

（5）str.__ge__(other) (>=)

五、总结

3.2 `max()` 和 `min()`

3.3 `sorted()`

3.4 `type()`

3.5 `str()`

3.6 `format()`

3.7 `chr()` 和 `ord()`

（1）`str.find(sub[, start[, end]])`

（2）`str.index(sub[, start[, end]])`

（3）`str.rfind(sub[, start[, end]])`

（4）`str.rindex(sub[, start[, end]])`

（5）`str.count(sub[, start[, end]])`

（1）`str.startswith(prefix[, start[, end]])`

（2）`str.endswith(suffix[, start[, end]])`

（3）`str.isalpha()`

（4）`str.isdigit()`

（5）`str.isalnum()`

（6）`str.isspace()`

（7）`str.islower()`

（8） `str.isupper()`

（9）`str.istitle()`

（10）in`和`not in

1）`in`运算符

2）`not in`运算符

（1）`str.replace(old, new[, count])`

（1）`str.split([sep[, maxsplit]])`

（2）`str.rsplit([sep[, maxsplit]])`

（3）`str.join(iterable)`

（1）`str.format(*args, **kwargs)`

（2）`str.capitalize()`

（3）`str.title()`

（4）`str.upper()`

（5）`str.lower()`

（6）`str.swapcase()`

（1）`str.strip([chars])`

（2）`str.lstrip([chars])`

（3）`str.rstrip([chars])`

（1）`str.eq(other)` (`==`)

（2）`str.lt(other)` (`<`)

（3）`str.le(other)` (`<=`)

（4）`str.gt(other)` (`>`)

（5）`str.ge(other)` (`>=`)