【Python入门第四讲】字符串（上篇）

原创

不惑

发布于 2024-01-22 08:54:05

1760

发布于 2024-01-22 08:54:05

文章被收录于专栏：Python基础系列 Goboy

前言

Python3 中有六个标准的数据类型，它们分别是数字（Number）、字符串（String）、列表（List）、元组（Tuple）、集合（Set）、字典（Dictionary）。

数据类型分类可变数据类型、和不可变数据类型，其中可变类型包括列表、字典、集合，不可变类型包括数字、字符串、元组。

大多数程序都定义并收集某种数据，然后使用它们来做些有意义的事情。鉴于此，对数据进行分类大有裨益。这一章我们将介绍的第一种数据类型是字符串。字符串虽然看似简单，但能够以很多不同的方式使用它们。字符串(str)就是一系列字符是 Python 中最常用的数据类型.。

注意：

Python不支持单字符类型(对应 c 语言中的 char)，单字符在 Python 中也是字符串类型。
字符串是不可变类型，即无法直接修改字符串的某一索引对应的字符，需要转换为列表处理。可以认为字符串是特殊的元组类型。

在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号，如下所示：

"This is a string."
'This is also a string.'

字符串操作

常用操作

title

用于将字符串中每个单词的首字母大写。方法签名如下：

str.title()

使用 title() 方法的示例：

# 定义一个字符串
text = "hello python world"

# 使用 title() 方法将每个单词的首字母大写
titlecased_text = text.title()

# 打印结果
print("每个单词首字母大写后的字符串:", titlecased_text)

输出：

每个单词首字母大写后的字符串: Hello Python World

text.title() 将字符串 text 中每个单词的首字母大写，返回每个单词首字母大写后的字符串。

upper

用于将字符串中的所有字符转换为大写形式。方法签名如下：

str.upper()

使用 upper() 方法的示例：

# 定义一个字符串
text = "hello python world"

# 使用 upper() 方法将字符串转换为大写形式
uppercase_text = text.upper()

# 打印结果
print("转换为大写形式后的字符串:", uppercase_text)

输出：

转换为大写形式后的字符串: HELLO PYTHON WORLD

text.upper() 将字符串 text 中的所有字符转换为大写形式，返回转换为大写形式后的字符串。

lower

用于将字符串中的所有字符转换为小写形式。方法签名如下：

str.lower()

使用 lower() 方法的示例：

# 定义一个字符串
text = "Hello Python World"

# 使用 lower() 方法将字符串转换为小写形式
lowercase_text = text.lower()

# 打印结果
print("转换为小写形式后的字符串:", lowercase_text)

输出：

转换为小写形式后的字符串: hello python world

text.lower() 将字符串 text 中的所有字符转换为小写形式，返回转换为小写形式后的字符串。

capitalize

用于将字符串的第一个字符转换为大写形式，其余字符转换为小写形式。方法签名如下：

str.capitalize()

使用 capitalize() 方法的示例：

# 定义一个字符串
text = "hello python world"

# 使用 capitalize() 方法将字符串首字母大写，其余字母小写
capitalized_text = text.capitalize()

# 打印结果
print("首字母大写后的字符串:", capitalized_text)

输出：

首字母大写后的字符串: Hello python world

text.capitalize() 将字符串 text 的第一个字符转换为大写形式，其余字符转换为小写形式，返回首字母大写后的字符串。

swapcase

用于将字符串中的大小写进行互换。方法签名如下：

str.swapcase()

使用 swapcase() 方法的示例：

# 定义一个字符串
text = "Hello Python World"

# 使用 swapcase() 方法将字符串中的大小写互换
swapped_case_text = text.swapcase()

# 打印结果
print("大小写互换后的字符串:", swapped_case_text)

输出：

大小写互换后的字符串: hELLO pYTHON wORLD

text.swapcase() 将字符串 text 中的大小写进行互换，返回大小写互换后的字符串。

count:

用于统计子字符串在字符串中出现的次数。方法签名如下：

str.count(sub, start=0, end=len(string))

sub：要统计的子字符串。
start：开始统计的起始位置，默认为 0。
end：结束统计的位置，默认为整个字符串的长度。

使用 count() 方法的示例：

# 定义一个字符串
sentence = "Python is a powerful programming language. Python is also easy to learn."

# 使用 count() 方法统计子字符串出现的次数
occurrences = sentence.count("Python")

# 打印结果
print("子字符串出现的次数:", occurrences)

输出：

子字符串出现的次数: 2

count("Python") 统计子字符串 "Python" 在 sentence 中出现的次数，并返回次数。由于 "Python" 在 sentence 中出现了两次，因此输出结果为 2。

replace：

用于替换字符串中的指定子串。使用 replace() 方法的示例：

# 定义一个字符串
sentence = "Python is a powerful programming language. Python is also easy to learn."

# 使用 replace() 方法替换字符串中的子串
new_sentence = sentence.replace("Python", "Java")

# 打印结果
print(new_sentence)

输出结果会将所有的 "Python" 替换为 "Java"：

Java is a powerful programming language. Java is also easy to learn.

replace("Python", "Java") 将字符串 sentence 中所有的 "Python" 替换为 "Java"，生成了一个新的字符串 new_sentence。

split：

用于将字符串拆分为子串，并返回一个包含拆分结果的列表。默认情况下，split() 方法使用空格作为分隔符。使用 split() 方法的示例：

# 定义一个字符串
sentence = "Python is a powerful programming language."

# 使用 split() 方法拆分字符串
words = sentence.split()

# 打印结果
print(words)

输出结果会将字符串拆分成一个包含各个单词的列表：

['Python', 'is', 'a', 'powerful', 'programming', 'language.']

split() 方法将字符串 sentence 按照空格进行拆分，生成一个包含各个单词的列表 words。

还可以指定自定义的分隔符，例如：

# 使用逗号作为分隔符拆分字符串
csv_data = "apple,orange,banana,grape"
fruits = csv_data.split(',')

# 打印结果
print(fruits)

输出结果会将逗号分隔的字符串拆分成一个包含水果名称的列表：

['apple', 'orange', 'banana', 'grape']

splitlines：

用于按行拆分字符串，并返回包含拆分结果的列表。它识别多种换行符，包括 \n、\r 以及 \r\n。使用 splitlines() 方法的示例：

# 定义一个包含多行文本的字符串
multi_line_text = """Python is a powerful programming language.
It is also easy to learn.
Enjoy coding with Python!"""

# 使用 splitlines() 方法按行拆分字符串
lines = multi_line_text.splitlines()

# 打印结果
print(lines)

输出结果将字符串按行拆分成一个包含各行文本的列表：

['Python is a powerful programming language.', 'It is also easy to learn.', 'Enjoy coding with Python!']

splitlines() 方法根据字符串中的换行符将其拆分成多个行，生成一个包含各行文本的列表 lines。

len：

len() 函数可以用于获取字符串的长度，即字符串中包含的字符数目。示例：

# 定义一个字符串
text = "Hello,Python!"

# 使用 len() 获取字符串的长度
length = len(text)

# 打印结果
print("字符串长度:", length)

输出：

字符串长度: 13

len(text) 返回字符串 text 中字符的数量，然后将结果存储在变量 length 中。 print("字符串长度:", length) 用于输出字符串的长度。

find：

用于查找子字符串在字符串中的第一次出现的位置。如果找到了子字符串，find() 返回子字符串的起始索引；如果未找到，则返回 -1。使用 find() 方法的示例：

# 定义一个字符串
sentence = "Python is a powerful programming language."

# 使用 find() 方法查找子字符串
index = sentence.find("powerful")

# 打印结果
print("子字符串的起始索引:", index)

输出：

子字符串的起始索引: 12

find("powerful") 查找子字符串 "powerful" 在 sentence 中的位置，并返回其起始索引。由于 "powerful" 在 sentence 中的位置是从索引 12 开始的，因此输出结果为 12。

如果要查找的子字符串在原字符串中出现多次，find() 方法只返回第一次出现的位置。如果要查找所有出现位置，可以考虑使用 find() 方法的变种 finditer() 或使用正则表达式。

rfind：

用于查找子字符串在字符串中的最后一次出现的位置。与 find() 不同的是，rfind() 返回的是子字符串最后一次出现的起始索引。如果未找到子字符串，它返回 -1。使用 rfind() 方法的示例：

# 定义一个字符串
sentence = "Python is a powerful programming language. Python is also easy to learn."

# 使用 rfind() 方法查找子字符串
last_index = sentence.rfind("Python")

# 打印结果
print("子字符串最后一次出现的起始索引:", last_index)

输出：

子字符串最后一次出现的起始索引: 43

rfind("Python") 查找子字符串 "Python" 在 sentence 中的最后一次出现的位置，并返回其起始索引。由于 "Python" 最后一次出现在 sentence 中的位置是从索引 43开始的，因此输出结果为 43。

index：

用于查找子字符串在字符串中的第一次出现的位置。与 find() 方法类似，但有一些差异。

方法签名如下：

str.index(sub, start=0, end=len(string))

sub：要搜索的子字符串。
start：开始搜索的起始位置，默认为 0。
end：结束搜索的位置，默认为整个字符串的长度。

使用 index() 方法的示例：

# 定义一个字符串
sentence = "Python is a powerful programming language."

# 使用 index() 方法查找子字符串
index = sentence.index("powerful")

# 打印结果
print("子字符串的起始索引:", index)

输出：

子字符串的起始索引: 12

index("powerful") 查找子字符串 "powerful" 在 sentence 中的位置，并返回其起始索引。由于 "powerful" 在 sentence 中的位置是从索引 12 开始的，因此输出结果为 12。

需要注意的是，与 find() 不同的是，如果未找到子字符串，index() 方法会引发 ValueError 异常。

Traceback (most recent call last):
  File "E:\StudyPython\Lesson-one\str_down.py", line 5, in <module>
    index = sentence.index("powerful1")
ValueError: substring not found

因此，在使用 index() 方法时，需要确保要查找的子字符串确实存在于原字符串中，或者使用异常处理来处理可能的异常。

rindex：

与 index() 方法类似，但是它查找子字符串在字符串中的最后一次出现的位置。方法签名如下：

str.rindex(sub, start=0, end=len(string))

sub：要搜索的子字符串。
start：开始搜索的起始位置，默认为 0。
end：结束搜索的位置，默认为整个字符串的长度。

使用 rindex() 方法的示例：

# 定义一个字符串
sentence = "Python is a powerful programming language. Python is also easy to learn."

# 使用 rindex() 方法查找子字符串
last_index = sentence.rindex("Python")

# 打印结果
print("子字符串最后一次出现的起始索引:", last_index)

输出：

子字符串最后一次出现的起始索引: 43

rindex("Python") 查找子字符串 "Python" 在 sentence 中的最后一次出现的位置，并返回其起始索引。由于 "Python" 最后一次出现在 sentence 中的位置是从索引 43 开始的，因此输出结果为 43。

与 index() 方法类似，如果未找到子字符串，rindex() 方法也会引发 ValueError 异常，因此需要适当处理异常情况。

lstrip：

用于删除字符串左侧（开头）指定字符集（或字符）的所有字符。方法签名如下：

str.lstrip([chars])

chars：可选参数，指定要删除的字符集。如果不提供此参数，则默认删除字符串左侧的空白字符（空格、制表符等）。

使用 lstrip() 方法的示例：

# 定义一个字符串
text = "   Python is awesome!"

# 使用 lstrip() 方法删除左侧空白字符
stripped_text = text.lstrip()

# 打印结果
print("删除左侧空白字符后的字符串:", stripped_text)

输出：

删除左侧空白字符后的字符串: Python is awesome!

lstrip() 方法删除了字符串 text 左侧的空白字符，返回删除后的字符串。如果提供了 chars 参数，它会删除左侧包含在指定字符集中的字符。

rstrip：

用于删除字符串右侧（末尾）指定字符集（或字符）的所有字符。方法签名如下：

str.rstrip([chars])

chars：可选参数，指定要删除的字符集。如果不提供此参数，则默认删除字符串右侧的空白字符（空格、制表符等）。

使用 rstrip() 方法的示例：

# 定义一个字符串
text = "Python is awesome!    "

# 使用 rstrip() 方法删除右侧空白字符
stripped_text = text.rstrip()

# 打印结果
print("删除右侧空白字符后的字符串:", stripped_text)

输出：

删除右侧空白字符后的字符串: Python is awesome!

在这个例子中，rstrip() 方法删除了字符串 text 右侧的空白字符，返回删除后的字符串。如果提供了 chars 参数，它会删除右侧包含在指定字符集中的字符。

strip:

用于删除字符串两侧（开头和结尾）指定字符集的字符，默认删除空白字符。方法签名如下：

str.strip([chars])

chars：可选参数，指定要删除的字符集，默认为删除空白字符。

使用 strip() 方法的示例：

# 定义一个字符串
text = "   Hello, Python!   "

# 使用 strip() 方法删除两侧空白字符
stripped_text = text.strip()

# 打印结果
print("删除两侧空白字符后的字符串:", stripped_text)

输出：

删除两侧空白字符后的字符串: Hello, Python!

text.strip() 删除了字符串 text 两侧的空白字符，返回删除两侧空白字符后的字符串。可以通过传递参数 chars 来指定要删除的字符集。

center：

用于将字符串居中显示，并在两侧用指定字符（fillchar 参数指定，默认为空格）填充，以达到指定的宽度。方法签名如下：

str.center(width, fillchar)

width：指定字符串的总宽度。
fillchar：可选参数，指定填充字符，默认为空格。

使用 center() 方法的示例：

# 定义一个字符串
text = "Python"

# 使用 center() 方法将字符串居中显示，总宽度为 20，用 - 填充
centered_text = text.center(20, '-')

# 打印结果
print("居中显示后的字符串:", centered_text)

输出：

居中显示后的字符串: -------Python-------

center(20, '-') 将字符串 text 居中显示，并在两侧用字符 '-' 填充，以使总宽度为 20。返回的字符串即为居中显示后的结果。

ljust：

用于将字符串左对齐，并在右侧用指定字符（fillchar 参数指定，默认为空格）填充，以达到指定的宽度。方法签名如下：

str.ljust(width, fillchar)

width：指定字符串的总宽度。
fillchar：可选参数，指定填充字符，默认为空格。

使用 ljust() 方法的示例：

# 定义一个字符串
text = "Python"

# 使用 ljust() 方法将字符串左对齐，总宽度为 15，用 - 填充
left_justified_text = text.ljust(15, '-')

# 打印结果
print("左对齐后的字符串:", left_justified_text)

输出：

左对齐后的字符串: Python---------

ljust(15, '-') 将字符串 text 左对齐，并在右侧用字符 '-' 填充，以使总宽度为 15。返回的字符串即为左对齐后的结果。

rjust：

用于将字符串右对齐，并在左侧用指定字符（fillchar 参数指定，默认为空格）填充，以达到指定的宽度。方法签名如下：

str.rjust(width, fillchar)

width：指定字符串的总宽度。
fillchar：可选参数，指定填充字符，默认为空格。

使用 rjust() 方法的示例：

# 定义一个字符串
text = "Python"

# 使用 rjust() 方法将字符串右对齐，总宽度为 15，用 - 填充
right_justified_text = text.rjust(15, '-')

# 打印结果
print("右对齐后的字符串:", right_justified_text)

输出：

右对齐后的字符串: ---------Python

rjust(15, '-') 将字符串 text 右对齐，并在左侧用字符 '-' 填充，以使总宽度为 15。返回的字符串即为右对齐后的结果。

zfill：

用于在字符串左侧用零填充，以达到指定的宽度。方法签名如下：

str.zfill(width)

width：指定字符串的总宽度。

使用 zfill() 方法的示例：

# 定义一个字符串
number = "42"

# 使用 zfill() 方法在左侧用零填充，总宽度为 5
zero_padded_number = number.zfill(5)

# 打印结果
print("左侧用零填充后的字符串:", zero_padded_number)

输出：

左侧用零填充后的字符串: 00042

zfill(5) 将字符串 number 在左侧用零填充，以使总宽度为 5。返回的字符串即为左侧用零填充后的结果。

join：

用于将序列（如列表、元组、字符串等）中的元素连接成一个字符串。方法签名如下：

str.join(seq)

seq：要连接的序列。

使用 join() 方法的示例：

# 定义一个列表
words = ["Hello", "World", "Python"]

# 使用 join() 方法连接列表中的元素
joined_string = " ".join(words)

# 打印结果
print("连接后的字符串:", joined_string)

输出：

连接后的字符串: Hello World Python

" ".join(words) 将列表 words 中的元素用空格连接成一个字符串。返回的字符串即为连接后的结果。可以根据需要选择不同的连接符。

maketrans：

用于创建一个字符映射表，以便在字符串中执行替换操作。这个方法通常与 translate() 方法一起使用。方法签名如下：

str.maketrans(x[, y[, z]])

x：要替换的字符或字符集。
y：替换的字符或字符集。
z：可选参数，删除的字符或字符集。

使用 maketrans() 方法的示例：

# 创建一个字符映射表，将字符"a"替换为"x"，字符"b"替换为"y"
translation_table = str.maketrans("ab", "xy")

# 定义一个字符串
text = "abcde"

# 使用 translate() 方法进行替换
translated_text = text.translate(translation_table)

# 打印结果
print("替换后的字符串:", translated_text)

输出：

替换后的字符串: xycde

str.maketrans("ab", "xy") 创建了一个字符映射表，将字符"a"替换为"x"，字符"b"替换为"y"。然后，通过 text.translate(translation_table) 将字符串中的对应字符进行替换，返回替换后的字符串。

我正在参与2024腾讯技术创作特训营第五期有奖征文，快来和我瓜分大奖！

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

运行代码块活动

2024腾讯·技术创作特训营第五期

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

运行代码块活动

2024腾讯·技术创作特训营第五期