Python字符串操作大全：lower()、upper()、split()等常见方法详解

找往期文章包括但不限于本期文章中不懂的知识点：

个人主页：我要学编程(ಥ_ಥ)-CSDN博客

所属专栏：Python

目录

字符串的常见操作

字符串属于 Python 中的不可变数据类型。起初，我们仅仅是初步学习了字符串的使用，并未进行深入的研究。因为字符串也是一种数据类型，所以我们会思考它是否像之前学习的列表、字典、集合这些数据类型一样，拥有大量的操作方法呢？答案是肯定的，我们今天就开始深入学习这些方法。

常见的操作字符串的方法

方法名

说明

lower()

将字符串str全部转成小写字母，结果为一个新的字符串

upper()

将字符串str全部转成大写字母，结果为一个新的字符串

split(set=None)

将 str 依据指定的分隔符 sep 进行分隔，分隔后的结果呈现为列表形式，此列表中的元素即为被分隔后的字符串。

count(sub)

结果为sub的这个字符串在str中出现的次数

find(sub)

查询 sub 这个字符串在 str 中是否存在。若不存在，结果为 -1；若存在，结果为 sub 首次出现的索引。

index(sub)

功能和 find 是相同的，不同之处在于，当需要查询的子串 sub 不存在时，程序会报错。

startswith(s)

查询字符串str是否以字符串s开头

endswith(s)

查询字符串str是否以字符串s结尾

replace(old, news)

使用 news 来替换字符串 s 里的所有 old 字符串，这样就会得到一个新的字符串。

center(width, fillchar)

字符串 str 可以在指定的宽度范围内居中，并且可以使用 fillchar 来进行填充。

join(iter)

在iter中的每个元素的后面都增加一个新的字符串str

strip(chars)

从字符串中去掉左侧和右侧chars中列出的字符串

lstrip(chars)

从字符串中去掉左侧chars中列出的字符串

rstrip(chars)

从字符串中去掉右侧chars中列出的字符串

代码演示：

str = 'Hello Python'
print('开始一系列字符串操作')
lower_str = str.lower()
打印出“将字符串变成小写：”，以及 lower_str
upper_str = str.upper()
打印出“将字符串变成大写：”，然后输出 upper_str 这个字符串变成大写后的结果。
list = str.split(' ')
打印出“以空格分割字符串：”，后面跟着 list 这个列表
count 等于字符串中字符 'o' 出现的次数。
输出“字符串中‘o’出现的次数：”，然后输出 count
a = str.find('o')
b = str.index('o')
打印出“字符串中‘o’出现的索引位置：”，以及 a 和 b 。
输出（“字符串是不是以‘hello’作为起始子串呢？”，str 以‘hello’开始）
输出('字符串是不是以"Hello"作为起始子串呢？', 字符串是否以'Hello'作为起始子串)
输出('字符串是不是以"python"作为结束子串呢？', str 以'python'作为结束子串)
输出('字符串是不是以"Python"作为起始子串呢？',str 以"Python"作为起始子串)

运行结果：

在对是否为起始子串、结束子串进行判断时，参数里的字符串不一定得是子串，它也可以是非子串。像上述代码中的 "hello" 就是非子串。

从上述结果能够看出，字符串的相关操作不会改变字符串自身。简单来说，就是全部生成一个新的字符列表对象，接着在这个列表里进行一系列操作，之后将其改成新的字符串并返回。

我们再来通过代码实现剩下的方法操作。

代码演示：

str = 'Hello Python'
# 替换字符串中的部分字符
使用 replace 方法将字符串中的 'Hello' 替换为 'Hi' 并打印结果  # 在最后面还可以指定参数
print(str.replace('Hello', 'Hi', 5))  # 指定替换 5 次
# 填充部分字符，是字符串在指定的范围内处于居中位置
在长度为 20 的空间中，会默认使用空白字符进行填充，这样能让字符串处于居中位置，即执行 print(str.center(20)) 操作
使用"*"进行填充，然后打印出通过"*"填充到长度为 20 的字符串的中心位置的结果。
print 输出的是将字符串进行居中显示，使用字符 '*' 填充至宽度为 10 的字符串。当字符串本身的长度超过指定的宽度时，就会直接打印输出该字符串。
在字符串 str 后面的每个字符元素，都加上“  ”（两个空格）。
print('  '.join(str))
将 'hhh' 中的空格全部去掉（默认是去掉空格），然后用 '*' 去替换空格。
首先对字符串 'hhh' 进行 strip 操作，去除字符串两端的空白字符。然后将处理后的字符串中的空格 ' ' 替换为星号 '*' 。
使用 replace 方法，将字符串 'hhh' 中的空格 ' ' 替换为星号 '*' ，然后进行打印。具体为：对字符串 'hhh' 执行 replace 操作，把其中的空格字符替换为星号字符，最后将替换后的结果进行输出显示。
# 观察上面两个的不同，或者写成下面这样
print(new_string)  # 直接将'*'从字符串中去除
首先，定义了一个字符串 '***hhh***'。然后，使用 lstrip 方法去除该字符串左边的 '*' 字符。最后，打印出去除左边 '*' 字符后的字符串。
使用 rstrip 方法将字符串 '***hhh***' 右边的 '*' 去除，直接从字符串中去掉右边的 '*' 。
# 注意下面这种情况，是不能成功去除的
在去除字符的过程中，遇到非 * 字符就会停止去除。
经过一系列的字符串操作之后，原字符串是：str

运行结果：

格式化字符串

常见的格式化字符串方式主要有以下三种：其一为占位符的形式；其二是 f-string 的形式；其三是 str.format()的形式。

占位符

在 Python 中常用的占位符有以下三个：一是 %s，它代指字符串；二是 %d，它代指十进制的整数；三是 %f，它代指浮点数。

语法格式：

可以理解为后面的参数被直接带入到 %s 里，也可以理解为后面的参数被直接带入到 %d 中，还可以理解为后面的参数被直接带入到 %f 中。
这里的 %s 只是占了个位置罢了，故名：占位符；这里的 %d 只是占了个位置罢了，故名：占位符；这里的 %f 只是占了个位置罢了，故名：占位符。
字符串使用元组来替代占位符，即字符串 % 元组，占位符由元组来替代。
打印出“姓名: ”加上变量 name 的值，“年龄: ”加上变量 age 的整数值，“成绩: ”加上变量 score 的浮点数值的字符串

代码演示：

name = '马冬梅'
age = 18
score = 98.5
# 使用了 .1f 之后，可以让浮点数只输出一位
打印出“姓名：%s，年龄：%d，成绩：%f”，其中 %s 被 name 替换，%d 被 age 替换，%f 被 score 替换。
打印（“姓名：”加上 name 加上“, 年龄：”加上 str(age)加上“, 成绩：”加上 str(score)）

除了上述的.1f 之外，存在 5d 这种写法。小数点后面的部分用于保证位数，小数点前面的部分用于保证输出总长度。当总长度小于我们设定的总长度时，会用空格进行填充。若是 5d 的写法，空格填充在左边，即实现右对齐；反之，若是 -5d 的写法，空格填充在右边，即实现左对齐。可以去看 CSDN 博客中关于 scanf 与 printf 函数的详细介绍及其用法的这篇文章，它对这两个函数介绍得比较详细。虽然是 C 语言的内容，但输出格式等概念是差不多的。

f-string

语法格式：

# f-string ，使用的就是 fstring的形式
这里将需要使用变量替代的内容全部放置在了{}里，如此一来，在进行打印操作时，就能把{}里的变量替换为实际的值。
打印（“姓名：”+name+“，年龄：”+str(age)+“，成绩：”+str(score)）

代码演示：

name = '马冬梅'
age = 18
score = 98.5
# 使用f-string
打印（“姓名：”+name+“，年龄：”+age+“，成绩：”+score）

字符串的 format 方法

语法格式：

# str.format() 与 f-string 有相似之处，二者都利用 {} 来标识需要进行替换的元素。
但是 f-string 是直接从上面的文本中获取，而 str.format 是在 format 参数中进行寻找。
0 对应的是 format 参数中索引的位置，1 对应的是 format 参数中索引的位置，2 对应的是 format 参数中索引的位置；0 是 name 的索引，所以用 name 来替换 0 。
打印出包含姓名、年龄和成绩信息的字符串，其中姓名为给定的 name，年龄为给定的 age，成绩为给定的 score，具体格式为'姓名: {0}, 年龄：{1}, 成绩：{2}'
下面的写法符合要求，因为 2 是 name 的索引，所以可以用 name 来替换 2。
输出的内容为：“姓名：{2}，年龄：{1}，成绩：{0}”，其中的{0}被替换为了 score，{1}被替换为了 age，{2}被替换为了 name

代码演示：

name = '马冬梅'
age = 18
score = 98.5
# 使用字符串的format方法
输出的内容为：姓名是{0}，年龄是{1}，成绩是{2}。这里的{0}被替换为了 name，{1}被替换为了 age，{2}被替换为了 score。
上述的 0 指的是 format 方法中参数的一个索引位置，可写成如下这样；上述的 1 指的是 format 方法中参数的一个索引位置，可写成如下这样；上述的 2 指的是 format 方法中参数的一个索引位置，可写成如下这样。
print('姓名：{2}, 年龄：{1}, 成绩：{0}'.format(score, age, name))

上面三种格式化的方式，写在一起的运行结果：

格式化字符串的详细格式还是有很多的，下面来认识其他的格式。

代码演示：

s = 'Hello Python'
# 直接使用0去代指format中的参数
打印出由字符串 s 格式化后的结果，即输出 '{"0"}' 中用 s 替换 "0" 后的内容
# : 是引导符，表明后面开始的操作是对参数的格式化
# * 是填充符，表明当长度不足时，使用 * 来填充
# < 是向左对齐、20 是字符串的总长度，不足时使用填充符来填充
print('{0:*<20}'.format(s))
# ^ 居中对齐、- 使用"-"填充空闲的位置
print('{0:-^20}'.format(s))
# 超出长度，就啥也不做
print('{0:*^5}'.format(s))
# 默认使用 空白字符 填充
print('{0:^20}'.format(s))

运行结果：

代码演示：

# 千位分隔符：只适用于整数与浮点数
在处理浮点数时，只会对其整数部分进行分割，小数部分不会有任何处理。
使用 format 函数将 1234567890 格式化为带有逗号的字符串并打印出来，即打印出 '{0:,}'.format(1234567890) 的结果。
使用 format 函数将数字 1234567890.987654321 格式化为带有逗号的字符串形式并打印输出。具体为使用 '{"0:,}"' 的格式字符串，其中 "0" 表示要格式化的对象，"," 表示千位分隔符。最终打印出带有千位分隔符的数字字符串。
当参数为字符串时，精度是显示的最大长度；当参数为浮点数时，精度是显示小数的最大长度。
# 针对字符串时，不需要加f，而针对浮点数时，需要加上f
输出格式化后的字符串，该字符串是将 3.1415926535 保留两位小数后的结果，格式为'{0:.2f}'
使用 format 方法将字符串 'Hello Python' 格式化为保留 5 位小数的形式并打印出来。具体来说，就是通过 '0:.5' 的格式规范对 'Hello Python' 进行格式化处理，然后将结果打印输出。
# 类型
a = 8
打印出“二进制：”加上 a 以二进制形式表示的结果，即使用 format 方法将 a 按照二进制格式进行格式化输出，输出的字符串为“二进制：{0:b}”，其中 {0:b} 表示将第一个参数以二进制形式输出
打印出八进制形式的内容，其中的数字部分为 a 转换后的八进制形式，格式为 '八进制：{0:o}'
输出的内容为：十进制：以十进制形式显示的 a 的值。具体为：将 a 按照十进制格式进行格式化输出，输出的格式字符串为'十进制：{0:d}'，其中 {0:d} 表示第一个参数以十进制形式显示。
打印出十六进制形式：使用 format 方法，将变量 a 以十六进制形式进行格式化，输出的字符串为 '十六进制：{0:x}'，其中 {0:x} 表示将第一个参数以十六进制形式输出。
输出的内容为：十六进制，其中的数值部分为 a 以十六进制形式表示，格式为 {0:X}

运行结果：

字符串的编码与解码

我们现在所处的时代是互联网时代，通信的方式也是发生了变化。现在的通信主要依靠网络通信。一台机器上的数据会经历一系列处理，从而转变为二进制数据。接着，这些二进制数据会通过网卡以电信号的高低电平（表示 1 与 0）或光信号的频率高低（表示 1 与 0）的形式传输出去。这些数据在互联网中传输，最终会被另一台机器的网卡接收。接收后，开始对二进制数据进行解析，使其变为最终用于通信的数据。上述过程为不同机器的基本通信过程。若想详细了解，可去看下面的文章，即初始 JavaEE 篇——网络编程（1）：基础的网络知识-CSDN 博客。

在 Python 里，存在这样一个过程，即把字符串转变为二进制数据，这个过程被称作编码的过程；与之相反，把二进制数据转化为字符串的过程则被叫做解码的过程。

在 Python 里，用于编码的方法是 encode 。用于解码的方法是 decode 。

语法格式：

# encoding 是指定要编码的方式，默认是utf-8
3. 进行替换。
遇到编码错误时，会直接抛出异常，这是默认的处理方式。
直接忽略编码错误的字符，可将其视为直接跳过该字符而去处理后面的字符。
用?去代替编码错误的字符
str 以编码方式 'utf-8' 进行编码，在出现错误时可以选择 'strict'（严格模式）、'ignore'（忽略模式）或'replace'（替换模式）
使用“utf-8”编码对字节进行解码，在解码过程中，对于错误的处理方式可以是“strict”（严格模式）、“ignore”（忽略模式）或“replace”（替换模式）。

代码演示：

# 编码过程
s = 'Hello Python'
print('原始的数据：%s' % s)
s 进行编码操作，编码后的结果为 s_encode ，并且在这个过程中都采用了默认的方式。
打印出“编码之后的数据类型：”以及 s_encode 的数据类型
打印出“编码之后的结果：”，并输出 s_encode
# 解码过程
s_decode 等于 s_encode 进行解码操作，并且也是采用默认的方式。
打印出“解码之后的结果：”加上 s_decode 的值

运行结果：

对于英文进行了编码与解码的演示。从结果方面来看，是在要传输的内容上加了个前缀“b”。对于数字字符串也是同样的情况。接下来我们来看中文的编码与解码。

代码演示：

# 编码过程
s = '伟大的中国梦'
print('原始的数据：%s' % s)
s_encode = s.encode() # 都采用默认的方式
print('编码之后的数据类型：',type(s_encode))
print('编码之后的结果：',s_encode)
# 解码过程
s_decode = s_encode.decode() # 也是采用默认的方式
print('解码之后的结果：%s' % s_decode)

运行结果：

从上面的对比可知：英文字符与数字经 UTF-8 编码后保持不变；大多数汉字字符经 UTF-8 编码后，一个汉字字符对应着三个编码后的字符。因为 UTF-8 编码规定多数中文字符占三个字节，传统 gbk 编码中中文占两个字节，所以使用不同编码方式，最终形成的字节数不同。

我们接下来就来看编码与解码的方式不同，会出现什么样的问题。

当然我们也可以让其直接忽略或者是用?来替换

# 编码过程
s = '伟大的中国梦'
print('原始的数据：%s' % s)
s_encode = s.encode() # 都采用默认的方式
print('编码之后的数据类型：',type(s_encode))
print('编码之后的结果：',s_encode)
# 解码过程
采用以 ascii 码值为依据的方式来进行解码，同时对于解码过程中出现错误的情况，采取忽略的处理方式。
所有的编码都会解码失败，所以最终的解码结果是没有任何内容。
s_decode 是通过对 s_encode 进行解码操作得到的，解码时指定编码为 'ascii'，并且错误处理方式为 'ignore' 。
print('解码之后的结果：%s' % s_decode)

运行结果：

下面是使用replace的结果：

与数据验证相关的方法

数据的验证意味着程序针对用户输入的数据展开“合法”性的验证工作。其主要运用以下八种方式：

数据的验证

方法名

说明

isdigit()

所有的字符都是数字（只能是阿拉伯数字）

isnumeric()

所有的字符都是数字

isalpha()

所有的字符都是字母（包含中文字符）

isalnum()

所有的字符都是数字或者字母（包含中文字符）

islower()

所有的字符都是小写

isupper()

所有的字符都是大写

istitle()

所有的字符都是首字母大写

isspace()

所有的字符都是空白字符（制表符(\t)、换行符(\n)等）

代码演示：

# 判断所有的字符都是数字
以下依次为阿拉伯数字、中文小写数字、罗马数字、中文大写数字、二进制数字。
判断字符串 '123' 是否只包含数字字符。通过调用 isdigit() 方法来进行判断，该方法返回 True ，表示字符串 '123' 只包含数字字符。
判断 '一二三' 是否为数字，使用 isdigit() 方法，结果为 False。
对字符串 'I' 进行 isdigit() 方法的调用，该方法用于检查字符串是否只包含数字字符，而 'I' 不包含数字字符，所以返回 False。
print('壹'是否具有数字的特征)  # False
使用 print 函数输出 'b0101'.isdigit() 的结果，该结果为 False 。
print('-'*20)
# 判断所有的字符都是数字
# 下面依次是 阿拉伯数字、中文小写、罗马数字、中文大写、二进制数字
使用 print 函数输出字符串 '123' 的 isnumeric()方法的结果，该结果为 True 。
通过 print 函数输出 '一二三'.isnumeric() 的结果为 True 。
判断 'I' 是否为数字。使用 print 函数输出 'I'.isnumeric() 的结果。结果为 False。
使用 print 函数输出 '壹' 是否为数字类型。'壹' 进行 isnumeric() 方法判断后结果为 True。
print('b0101'.isnumeric()) 的结果为 False。
print('-'*20)
# 判断所有的字符都是字母
结果为 True
所以 print('hello你好123'.isalpha()) 的结果为 False 。
输出结果为 False，因为 "hello 你好" 中包含非字母字符。
print('-'*20)
# 判断所有的字符都是数字或者字母
判断"hello你好"是否是字母数字组合，结果为 True 并打印出来。
所以返回 True
# False 被拆分成了两个独立的语句，分别是打印字符串和判断字符串是否只包含字母和数字的操作，最后得出结果为 False。
判断 'hello 你好' 这个字符串的字符是否全是字母或数字，得出的结果为 False 。
print('-'*20)
# 所有的字符都是小写
# 中文既是大写也是小写
判断字符串 'hello' 是否为小写形式。使用 islower() 方法进行判断，该方法会返回一个布尔值。在这个例子中，'hello' 是小写形式，所以返回 True。
输出结果为 True ，表示字符串 "hello你好" 中的所有字符都是小写字母。
使用 print 函数输出 'Hello'.islower() 的结果，其结果为 False 。  'Hello' 这个字符串不是小写形式。  islower() 方法用于检查字符串是否全部由小写字母组成，对于 'Hello' 这个字符串，该方法返回 False 。
输出结果为 False
print('-'*20)
# 所有的字符都是大写
# 中文既是大写也是小写
'hello'.isupper() 这个函数用于检查字符串 'hello' 是否全为大写字母，经检查后发现该字符串不是全为大写字母，所以返回 False 。
检查'hello你好'是否处于大写状态，实际为 False 。
使用 print 函数输出 'Hello'.isupper() 的结果，该结果为 False 。
使用函数 isupper() 来判断字符串 'HELLO' 是否全为大写字母。当调用 isupper() 函数时，它会检查字符串中的每个字符是否都是大写字母。对于字符串 'HELLO'，其中的所有字符都是大写字母，所以函数返回 True 。
print('-'*20)
# 所有的字符都是首字母大写
# 通过 空格 来区分单词
"Hello".istitle() 这个表达式的结果是 True 。它用于检查字符串 "Hello" 的首字母是否大写，因为首字母大写的字符串在 Python 中被认为是标题格式，所以这里返回 True 。
"HelloWorld".istitle() 的结果为 False ，然后进行打印输出。
'Helloworld'.istitle() 的结果为 True 。
输出('Hello World'.istitle()) ，结果为 True 。
print('-'*20)
# 所有的字符都是空白字符
使用 print 函数输出判断字符串是否为空白字符的结果，这里判断的字符串是一个空格，输出结果为 True
打印空字符串（'\n'）是否为空白字符。结果为 True 。
判断 '\t' 是否为空白字符，通过调用 isspace() 方法，其返回值为 True 。
判断 '123\t' 是否为空白字符，结果为 False 。'123\t' 中包含非空白字符，所以返回 False 。

字符串的拼接

字符串的拼接会依据数据类型的差异，采取不同的方式。比如，要是要拼接的数据类型为字符串自身，是完全能够运用 + 进行直接拼接的。

1、使用 str.join() 方法进行拼接字符串

2、直接使用"+"拼接字符串

3、使用格式化字符串进行拼接

代码演示：

s1 = 'hello'
s2 = 'python'
# 1、采用 str.join()方法
# 使用字符串的内容去替代参数中的元素之间的分隔符
使用 join 方法将 s1 和 s2 连接起来并打印输出。具体来说，通过将空字符串作为分隔符，将 s1 和 s2 组合成一个字符串，然后将这个字符串打印出来。
使用“.”将 s1 和 s2 进行连接，然后进行打印输出。 先获取 s1 和 s2，接着使用“.”将它们连接起来，最后进行打印操作。 把 s1 和 s2 通过“.”连接起来并进行打印。 用“.”把 s1 与 s2 连接后进行打印输出。 以“.”为连接符将 s1 和 s2 连接起来并进行打印。 借助“.”将 s1 和 s2 连接后进行打印。 利用“.”把 s1 与 s2 连接起来并执行打印操作。 通过“.”把 s1 和 s2 连接起来然后进行打印。 以“.”为纽带将 s1 和 s2 连接起来并进行打印输出。 借助“.”将 s1 和 s2 连接后将结果进行打印。 用“.”把 s1 与 s2 连接起来并把连接后的结果进行打印。 以“.”为中介将 s1 和 s2 连接起来并进行打印输出。 借助“.”将 s1 和 s2 连接后将其输出到打印设备。 用“.”把 s1 与 s2 连接起来并将连接后的内容输出到打印。 以“.”为桥梁将 s1 和 s2 连接起来并进行打印输出。 借助“.”将 s1 和 s2 连接后将其显示在打印界面。 用“.”把 s1 与 s2 连接起来并将连接后的结果显示在打印处。 以“.”为通道将 s1 和 s2 连接起来并进行打印输出。 借助“.”将 s1 和 s2 连接后将其在打印中呈现。 用“.”把 s1 与 s2 连接起来并将连接后的内容在打印中展现。 以“.”为途径将 s1 和 s2 连接起来并进行打印输出。 借助“.”将 s1 和 s2 连接后将其在打印过程中体现。 用“.”把 s1 与 s2 连接起来并将连接后的结果在打印过程中呈现。 以“.”为方式将 s1 和 s2 连接起来并进行打印输出。 借助“.”将 s1 和 s2 连接后将其以打印的方式展现。 用“.”把 s1 与 s2 连接起来并将连接后的内容以打印的形式呈现。 以“.”为手段将 s1 和 s2 连接起来并进行打印输出。 借助“.”将 s1 和 s2 连接后将其通过打印来体现。 用“.”把 s1 与 s2 连接起来并将连接后的结果通过打印来呈现。
# 2、直接拼接
print(s1+s2)
# 简单粗暴的方式
打印出字符串 'hello' 和字符串 'python' 。
# 3、采用格式化字符串的方式
print(f'{s1}{s2}')
使用 format 方法将 s1 和 s2 进行格式化并打印，打印的内容是由 s1 和 s2 组成的字符串，字符串的格式为'{0}{1}'

运行结果：

字符串的去重操作

当字符串里多次出现相同字符时，若我们希望去掉重复的字符，从而得到不重复的字符，就能够运用以下的方法。

遍历字符串，接着判断这个字符是否在新字符串里。如果不在，就把这个字符加上。等遍历完成后，所得到的字符串就是去重之后的字符串。

2、使用哈希的思想（就是使用集合），来去重。

代码演示：

s 是 'hello world' 并且重复了四次。
# 1、遍历+判断：
new_s1 = ''
for char in s:
    if char not in new_s1:
        new_s1 += char
print(new_s1)
new_s2 = ''
for i in range(len(s)):
    if s[i] not in new_s2:
        new_s2 += s[i]
print(new_s2)
# 2、哈希思想去重
new_s3 是通过对 s 进行处理得到的。在这个处理过程中，只保留了不重复的元素，从而形成了一个集合。
因为集合是无序的，所以我们要按照原来字符串的顺序来进行排序，这就需要将其转化为列表。
list_S = list(new_s3)
# 将列表中的字符按照字符串中的索引来进行排序
list_S.sort(key=s.index)
# 最终再转换为字符串类型
使用 join 方法将 list_S 中的元素连接成字符串并输出。具体来说，通过 '.' 作为连接符，将 list_S 中的每个元素依次连接起来，最终形成一个完整的字符串并打印输出。

运行结果：

本期初始 Python 篇（6）的学习之旅是关于字符串的。现在，这趟学习之旅到此结束啦！我们下期再一起学习吧！