前言

本文主要介绍字符串的常用操作。包括比较，索引与切片，字符串的查找，字符大小写转换，判断，劈分，替换与合并。字符串为不可变序列，故没有增删改等操作。本文学习材料来自马士兵Python中入门基础版(基础语法) 2020最新版Python小白教程。视频链接https://www.bilibili.com/video/BV1wD4y1o7AS?p=84

提示：以下是本篇文章正文内容，下面案例可供参考

字符串

• 字符串为不可变序列，不具备增删改等操作
• 字符串切片产生新的字符串对象

字符串的常用操作

字符串的比较，索引与切片

比较操作

比较运算符：>, >=, <, <=, ==, !=, is, is not

比较规则： 首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直达两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较。

比较原理： 两字符串进行比较时，比较的是其oridinal value(原始值)，调用内置函数ord(获取字符原始值)可以，得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr(获取数值所对应的字符)，调用内置函数chr时指定ordinal value可以得到其对应的字符。

【注】
== 与 is 的区别：
==比较的是两个比较对象的内容是否相同；
is比较的是两个对象的id是否相同

【代码示例】

print('1.', ord('a'))
print('2.', chr(97))
s1 = 'helloworld'
s2 = 'hello'+'world'
s3 = ''.join(['hello', 'world'])
print('3.', s3)
print('4.', s1 == s2)
print('5.', s1 == s3)
print('6.', s1 is s2)
print('7.', s1 is s3)
'''
输出结果为：
1. 97
2. a
3. helloworld
4. True
5. True
6. True
7. False
'''

索引与切片

正向索引: 从0到字符串长度-1；
倒向索引: 最后一个元素索引为-1，从此往前到 $-$(负的)字符串长度

字符串切片代码语法：

字符串名[开始索引:结束索引:步长]省略开始索引且步长为正，或同时省略步长则默认从切片从索引0开始；
省略结束索引且步长为正，或同时省略步长则默认从切片至最后一个元素结束；
省略步长，则默认步长为1.

【代码示例】

s = '你好，我叫小花。'
print(s[:2])
print(s[5:])
print(s[1:6:2])
'''
输出结果为：
你好
小花。
好我小
'''

字符串的查找

字符串查找方法：

index()  代码语法：字符串.index(所要查找的子串)。
rindex() 代码语法：字符串.rindex(所要查找的子串)。
find()   代码语法：字符串.find(所要查找的子串)。
rdind()  代码语法：字符串.rfind(所要查找的子串)。

1. index()。查找字符串中所要查找的第一个子串的位置，若子串多于一个元素，则返回第一个元素的索引位置。若所查找的子串不存在于字符串中，使用index()方法查找，则运行会报错，显示VakueError。

s = 'hellohello'
print(s.index('lo'))
#输出 3
print(s.index('k'))
#则报错显示
'''print(s.index('k'))
ValueError: substring not found
'''

2. rindex()。查找字符串中所要查找的最后一个子串的位置，若子串多于一个元素，则返回第一个元素的索引位置。若所查找的子串不存在于字符串中，使用index()方法查找，则运行会报错，显示VakueError。

s = 'hellohello'
print(s.rindex('lo'))
#输出 8
print(s.rindex('k'))
#则报错显示
'''print(s.rindex('k'))
ValueError: substring not found
'''

3. find()。查找字符串中所要查找的第一个子串的位置，若子串多于一个元素，则返回第一个元素的索引位置。若所查找的子串不存在于字符串中，使用find()方法查找，则运行会显示-1。

s = 'hellohello'
print(s.find('lo'))
#输出 3
print(s.find('k'))
#输出 -1

4. rfind()。查找字符串中所要查找的最后一个子串的位置，若子串多于一个元素，则返回第一个元素的索引位置。若所查找的子串不存在于字符串中，使用rfind()方法查找，则运行会显示-1。

s = 'hellohello'
print(s.rfind('lo'))
#输出 8
print(s.rfind('k'))
#输出 -1

字符串的大小写转换

【注】字符串大小写转化后产生新的字符串，原来字符串的标识不变。

lower()      代码语法：字符串.lower()。
upper()      代码语法：字符串.upper()。
swapcase()   代码语法：字符串.swapcase()。
capitalize() 代码语法：字符串.capitalize()。
title()      代码语法：字符串.title()。

• lower()

lower()将字符串中所有的大写字母转化为小写。

s = 'Hello, World'
s1 = 'hELLO, wORLD'
s2 = 'hello, world'
s3 = 'helloworld'
print('原字符串为：', s, '标识为：', id(s))
print('使用lower方法后字符串为：', s.lower(), id(s.lower()))
print('原字符串为：', s1, '使用lower方法后字符串为：', s1.lower())
print('原字符串为：', s2, '使用lower方法后字符串为：', s2.lower())
print('原字符串为：', s3, '使用lower方法后字符串为：', s3.lower())
'''
输出结果为：
原字符串为： Hello, World 标识为： 2285142550768
使用lower方法后字符串为： hello, world 2285142654768
原字符串为： hELLO, wORLD 使用lower方法后字符串为： hello, world
原字符串为： hello, world 使用lower方法后字符串为： hello, world
原字符串为： helloworld 使用lower方法后字符串为： helloworld
'''

• upper()

upper()将字符串中所有的小写字母转化为大写。

s = 'Hello, World'
s1 = 'hELLO, wORLD'
s2 = 'hello, world'
s3 = 'helloworld'
print('原字符串为：', s, id(s))
print('使用upper方法后字符串为：', s.upper(), '标识为：', id(s.upper()))
print('原字符串为：', s1, '使用upper方法后字符串为：', s1.upper())
print('原字符串为：', s2, '使用upper方法后字符串为：', s2.upper())
print('原字符串为：', s3, '使用upper方法后字符串为：', s3.upper())
'''
输出结果为：
原字符串为： Hello, World 2285142550768
使用upper方法后字符串为： HELLO, WORLD 标识为： 2285142654832
原字符串为： hELLO, wORLD 使用upper方法后字符串为： HELLO, WORLD
原字符串为： hello, world 使用upper方法后字符串为： HELLO, WORLD
原字符串为： helloworld 使用upper方法后字符串为： HELLOWORLD
'''

• swapcase()

swapcase()将字符串中的大小写字母互换，即大写字母转化为小写字母，小写字母转化为大写字母。

s = 'Hello, World'
s1 = 'hELLO, wORLD'
s2 = 'hello, world'
s3 = 'helloworld'
print('原字符串为：', s, id(s))
print('使用swapcase方法后字符串为：', s.swapcase(), '标识为：', id(s.swapcase()))
print('原字符串为：', s1, '使用swapcase方法后字符串为：', s1.swapcase())
print('原字符串为：', s2, '使用swapcase方法后字符串为：', s2.swapcase())
print('原字符串为：', s3, '使用swapcase方法后字符串为：', s3.swapcase())
'''
输出结果为：
原字符串为： Hello, World 2285142550768
使用swapcase方法后字符串为： hELLO, wORLD 标识为： 2285142654768
原字符串为： hELLO, wORLD 使用swapcase方法后字符串为： Hello, World
原字符串为： hello, world 使用swapcase方法后字符串为： HELLO, WORLD
原字符串为： helloworld 使用swapcase方法后字符串为： HELLOWORLD
'''

• capitalize()

capitalize()不论之前字符串是什么情况，只大写字符串的第一个字母，除第一个字符外，其他字符之前是大写的统统改为小写，之前是小写的保持不变。

s = 'Hello, World'
s1 = 'hELLO, wORLD'
s2 = 'hello, world'
s3 = 'helloworld'
print('原字符串为：', s, id(s))
print('使用capitalize方法后字符串为：', s.capitalize(), '标识为：', id(s.capitalize()))
print('原字符串为：', s1, '使用capitalize方法后字符串为：', s1.capitalize())
print('原字符串为：', s2, '使用capitalize方法后字符串为：', s2.capitalize())
print('原字符串为：', s3, '使用capitalize方法后字符串为：', s3.capitalize())
'''
输出结果为：
原字符串为： Hello, World 2285142550768
使用capitalize方法后字符串为： Hello, world 标识为： 2285142654832
原字符串为： hELLO, wORLD 使用capitalize方法后字符串为： Hello, world
原字符串为： hello, world 使用capitalize方法后字符串为： Hello, world
原字符串为： helloworld 使用capitalize方法后字符串为： Helloworld
'''

• title()

title()大写字符串中每个单词的首字母。即可自动判别空格等间隔性的符号。

s = 'Hello, World'
s1 = 'hELLO, wORLD'
s2 = 'hello, world'
s3 = 'helloworld'
print('原字符串为：', s, id(s))
print('使用title方法后字符串为：', s.title(), '标识为：', id(s.title()))
print('原字符串为：', s1, '使用title方法后字符串为：', s1.title())
print('原字符串为：', s2, '使用title方法后字符串为：', s2.title())
print('原字符串为：', s3, '使用title方法后字符串为：', s3.title())
'''
输出结果为：
原字符串为： Hello, World 2285142550768
使用title方法后字符串为： Hello, World 标识为： 2285142654768
原字符串为： hELLO, wORLD 使用title方法后字符串为： Hello, World
原字符串为： hello, world 使用title方法后字符串为： Hello, World
原字符串为： helloworld 使用title方法后字符串为： Helloworld
'''

字符串的判断

• 字符串判断方法介绍

• 字符串判断代码语法

isidentifier()  代码语法：字符串.isidentifier()。
isspace()       代码语法：字符串.isspace()。
isalpha()       代码语法：字符串.isalpha()。
isdecimal()     代码语法：字符串.isdecimal()。
isnumeric()     代码语法：字符串.isnumeric()。
isalnum()       代码语法：字符串.isalnum()。

字符串的劈分

• 字符串劈分方法介绍

• 字符串劈分代码语法

split()  代码语法：字符串.split(sep= , maxsplit= ), 参数sep与maxsplit可省略。rsplit() 代码语法：字符串.rsplit(sep= , maxsplit= ), 参数sep与maxsplit可省略。

• 示例

【代码示例】：

s = 'hello world 2022'
print(s.split())#1
print(s.rsplit())#2
s1 = 'happy/new/year'
print(s1.split(sep='/'))#3 #指定“/”为认定分隔符
print(s1.split(sep='/', maxsplit=1))#4 #从左边起看到一次 “/”就实施字符串分隔，剩下的子字符串单独作为一部分输出。
print(s1.rsplit(sep='/'))#5
print(s1.rsplit(sep='/', maxsplit=1))#6

输出结果为：

['hello', 'world', '2022']#1处输出
['hello', 'world', '2022']#2处输出
['happy', 'new', 'year']#3处输出
['happy', 'new/year']#4处输出
['happy', 'new', 'year']#5处输出
['happy/new', 'year']#6处输出

字符串的替换与合并

• 字符串替换与合并方法介绍

• 代码语法

replace() 代码语法：字符串.replace(需要被替换的字符串，替换为的字符串，替换字符串的个数（可省略）)join()   代码语法： '连接符(省略则默认为空)'.join(需要连接的字符串，列表或元组)

• 示例

【代码示例】

s = 'hello hello world'
print('1.', s.replace('hello','nihao'))
print('2.', s.replace('hello','nihao', 1))lst = ['hello', 'hello', 'world']
tuple1 = ('hello', 'hello', 'world')
print('3.', '*'.join(s))#在字符串各个元素间添加*号
print('4.', ''.join(lst))#将列表里的各个元素无分隔符的拼合
print('5.', '*'.join(lst))#将列表里的各个元素使用分隔符*拼合
print('6.', ''.join(tuple1))#将元组里的各个元素无分隔符的拼合
print('7.', s+'nihao')

输出结果为：

1. nihao nihao world
2. nihao hello world
3. h*e*l*l*o* *h*e*l*l*o* *w*o*r*l*d
4. hellohelloworld
5. hello*hello*world
6. hellohelloworld
7. hello hello worldnihao

总结

字符串的比较、索引与切片
字符串的查找index(),rindex()find()rfind()
字符串的大小写转换lower()upper()swapcase()capitalize()title()
字符串的判断isidentifier()isspace()isalpha()
字符串的劈分split()rsplit()
isdecimal()isnumeric()isalnum()
字符串的替换与合并：replace()join()+