三：《Python基础语法汇总》— 字符串操作

• ​ 字符串是Python中最基本的数据类型之一，是可以存放多个单个单一元素的容器
• ​ 字符串是Python中序列的一种，是一个有序不可变序列
• ​ 由于字符串是不可变的序列，所以无法对其里面的内容进行修改，只能在去重新开辟空间存储

1.下标（索引）：

• ​ Python会对容器中的元素进行编号，也就是下标（索引）
• ​ 索引是指通过下标找到某一个元素
• ​ 索引分为正向索引和负向索引：正向索引从左到右，以0为起始点；负向索引从右到左，以-1为起始点

用下标去获取元素，用索引符号 [] 去索引，对象/变量名[下标]

a = "longze"
#用负向索引获取元素e
print(a[-1])
#用正向索引获取元素n
print(a[2])

2.切片：

• ​ 切片是指只截取一部分可操作的对象；字符串，列表，元组都支持切片操作
• ​ 切片是指通过一段下标，找到某一段元素
• ​ 凡需要获取的元素大于等于两位就都用切片
• ​ 在切片中正向索引第三参数默认为1（可以省略），负向索引第三参数为-1（必须写）

用切片去获取某一段元素，用索引符号 [] 去索引，对象/变量名[起始下标:结束下标:正负向参数（步长）]

​ 注意： 冒号 : 是一个范围符号，表示下标从某一个范围到某一个范围，冒号的左边是范围的起始，右边是指范围的结束**（结束下标不包含其本身，结束下标=结束下标-1）**

a = "longzeqiaoyue"
#用正整数正向索引获取g~y
print(a[3:11])
#用正整数负向索引获取y~g
print(a[10:2:-1])
#用负整数正向索引获取g~y
print(a[-10:-2])
#用负整数负向索引获取y~g
print(a[-3:-11:-1])

​ 图示：

• ​ 第三参数也为步长，也就是间隔
• ​ 步长是选取间隔，正负整数均可，默认步长为1

len()函数：获取对象中元素的长度

a = "longze0313jiang0327qiaoyue2023"
#获取a中所有元素的长度
print(len(a))
#获取所有元素
print(a[:])
print(a[0:len(a)])
#获取奇数位上的所有元素
print(a[0:len(a):2])
#获取偶数位上的所有元素
print(a[1:len(a):2])

3.字符串的方法与函数：

​ 字符串的常用操作方法有查找，修改和判断三大类

​ 字符串方法的调用：对象/变量名.方法名()

一：查找

​ 字符串的查找方法即是查找子串在字符串中出现的位置或出现的次数

find()方法：通过指定的元素（当有重复元素出现时，只能找到第一次出现的元素）去查询与之对应的下标 （索引）值（从左往右查询），当find()方法查询到一个不存在的元素时，会返回一个数值-1

find()方法的语法格式：对象/变量名.find(想要查询的元素字符,起始点（刚才查询到的下标+1）,结束位置)

a = "longzeo" 
#在此字符串中有两个o，但find()方法只能查询到从左往右第一次出现的o
print(a.find('o'))
#要想往右继续找重复出现的元素的下标（但也只找第一次出现的），可以在find()方法中设置起始参数和结束参数
print(a.find('o',2,len(a)))
print("longzeo".find('o',2,len("longzeo")))

rfind()方法：通过指定的元素（当有重复元素出现时，只能找到第一次出现的元素）去查询与之对应的下标 （索引）值（从右往左查询，但下标值是从左往右正向索引的下标值），当rfind()方法查询到一 个不存在的元素时，会返回一个数值-1

rfind()方法的语法格式：对象/变量名.rfind(想要查询的元素字符,结束位置,起始点（刚才查询到的下标-1）)

a = "longzeo" 
#在此字符串中有两个o，但rfind()方法只能查询到从右往左第一次出现的o
print(a.rfind('o'))
#要想往左继续找重复出现的元素的下标（但也只找第一次出现的），可以在rfind()方法中设置起始参数和结束参数
print(a.rfind('o',0,5)
print("longzeo".find('o',0,5)

index()方法：通过指定的元素去查询下标，从左往右去找，与find()方法类似，唯一不同的是，当index()方法 查询到一个不存在的元素时，会发生报错

rindex()方法：通过指定的元素去查询下标，从右往左去找，与rfind()方法类似，唯一不同的是，当index()方 法查询到一个不存在的元素时，会发生报错

count()方法：用于统计指定的某个字符出现的次数

count()方法的语法格式：对象/变量名.count(想要查询的元素字符,起始点,结束位置)

a = "sdfyuiolkjgxcvbnklkjgf"
print(a.count('g'))
print(a.count('g',0,21))

二：修改

​ 对字符串中的内容进行修改

​ 注意： 字符串本身是不可变类型，定义之后，无法被修改 ! ! !

replace()方法：将指定的字符替换成新的字符

replace()方法的语法格式：对象/变量名.replace(要被替换的字符,要替换成为的新字符,count = -1)

​ count = -1指定的是替换的次数，默认值为-1，也就是在不设置这个参数的时候，就相当于替换全部，当第三参数超出了可替换的范围的时候，也相当于替换全部，是无用的，但不会报错

a = "woaini"
print(a.replace('ni','ziji'))
c = "asdfghjkiii"
#只把两个i替换成o
print(c.replace('i','o',2))

​ 注意： 1. a并没有真正意义上被替换，再次输出a时依旧是原字符串，replace()只是作为临时修改

​ 2. 要想使用被修改掉的临时字符串，只能重新的用变量去赋值

​ 3. 只要对字符串进行重新赋值，就相当于系统为其又开辟了一个空间，不在是原字符串

a = "woaini"
b = a.replace('ni','ziji')
print(b)

split()方法：将字符串中的某个字符作为分割字符，将这个字符串分割成多个子字符串，最终的结果以列表的 形式输出，用作指定的分割字符会自动转变为列表里的分割字符，也就是逗号；若作为分割字符 的两个元素是挨着的，则都会变成空字符存储；当分割字符非字符串中的字符，则不发生 任何改变，自动将这个字符串转换为列表输出

split()方法的语法格式：对象/变量名.split(指定的字符串里的字符)

a = "qeqtqyquiqo"
print(a.split('q'))
print(a.split('+++'))
b = "67899"
print(b.split('9'))

a = input("请输入个人信息，并用空格分开：").split()
#因为split()里面没有加入分割字符，当输入的个人信息有空格时，split()会自动把空格当做分割字符
print(a)

join()方法：把字符串/字符序列中每个元素按照指定的符号进行连接

join()方法的语法格式：分割字符(这里可以是任何字符).join(字符串/字符序列)

a = "qwert"#这里的每个字符都是单独的个体
print('+'.join(a))
b = ["qwe","567",a]#这里的每个元素都是单独的个体
print('@'.join(b))
c = ''.join("wer")#因为是空分割符，所以正常输出
print(c)
d = {"hj":"qwe","tyuiol":"567"}#当是字典时只会拼接键
print('@'.join(d))

​ 注意： 1. join()方法通常被用于字符串的拼接，与字符串相加所实现的效果是一样的，但join()方法会让拼接的效率更高

​ 2. join()方法不能拼接带数字的字符序列，只能是字符串

a = "tyu"+"hj"
print(a)

截取

lstrip()方法：去除字符串最左侧的空格

lstrip()方法的语法格式：对象/变量名.lstrip(chars)

								   chars参数默认情况下为None，也就是什么都没有，意思是去除的是空格，这个参数可以给它传入一个字符串对象中从最左侧开始连续的字符串，意思是把最左侧的什么什么给去除

a = "    ai love you"
print(a.lstrip())
print(a.lstrip("    ai"))

rstrip()方法：去除字符串最右侧的空格

rstrip()方法的语法格式：对象/变量名.rstrip(chars)

​ chars参数默认情况下为None，也就是什么都没有，意思是去除的是空格，这个参数可以给它传入一个字符串对象中从最右侧开始连续的字符串，意思是把最右侧的什么什么给去除

a = "ai love you    "
print(a.rstrip())
print(a.rstrip("you    "))

strip()方法：去除字符串左右侧的空格

strip()方法的语法格式：对象/变量名.strip(chars)

​ chars参数默认情况下为None，也就是什么都没有，意思是去除的是空格，这个参数可以给它传入一个字符串对象中从最左侧或最右侧开始的字符串，意思是同时去除左侧和右侧相匹配的字符串

a = "    ai love you    "
print(a.strip())
print(a.strip("    au"))

removeprefix()方法：允许指定将要删除的字符串前缀

removeprefix()方法的语法格式：对象/变量名.removeprefix(连续的字符串前缀)

a = "asdff mmm iofewp"
print(a.removeprefix("asd"))

removesuffix()方法：允许指定将要删除的字符串后缀

removesuffix()方法的语法格式：对象/变量名.removesuffix(连续的字符串后缀)

a = "asdff mmm iofewp"
print(a.removesuffix("wp"))

左中右对齐

ljust()方法：左对齐（填充右侧），并使用指定字符（默认空格）填充至对应长度的空字符串

ljust()方法的语法格式：对象/变量名.ljust(指定整个字符串的长度,指定字符填充对应长度（默认空格）)

a = "我爱你"
print(a.ljust(8,'$'))

rjust()方法：右对齐（填充左侧），并使用指定字符（默认空格）填充至对应长度的空字符串

rjust()方法的语法格式：对象/变量名.rjust(指定整个字符串的长度,指定字符填充对应长度（默认空格）)

a = "我爱你"
print(a.rjust(8,'$'))

center()方法：字符串居中（填充左右两侧），并使用指定字符（默认空格）填充至对应长度的空字符串

center()方法的语法格式：对象/变量名.center(指定整个字符串的长度,指定字符填充对应长度（默认空格）)

a = "我爱你"
print(a.center(8,'$'))

zfill()方法：用0去填充左侧

zfill()方法的语法格式：对象/变量名.zfill(指定整个字符串的长度)

a = "我爱你"
print(a.zfill(8))

​ 注意： 1. zfill()方法在做数据报表的时候会比较实用

​ 2. zfill()方法也可以处理带负数的情况，它并不是一味的在左侧填充0，它会把负号挪到最左面去，当然负号也占一个字符

a = "-520"
print(a.zfill(5))

大小写转换

capitalize()方法：将字符串中的第一个字母变成大写

a = "aasdef qwer"
print(a.capitalize())

casefold()方法：返回一个所有字母都是小写的新字符串

a = "ASDFGH"
print(a.casefold())

title()方法：将字符串中的每个单词的首字母都变成大写，其余所有字母都变成小写

a = "SDF JKL asdf"
print(a.title())

upper()方法：将字符串中的所有字母都变成大写

a = "asdf jklo ASio"
print(a.upper())

lower()方法：将字符串中的所有字母都变成小写

a = "DFGHJ asKO"
print(a.lower())

swapcase()方法：将字符串中的所有字母大小写翻转，大写变小写，小写变大写

a = "ASDF Hijw"
print(a.swapcase())

​ 注意： 空格之后的每一个单词都表示一个新的单词

三：判断

​ 判断方法的结果都是布尔值：正确返回True，错误返回False

startswith()方法：判断字符串是否以指定的子字符串为开头

startswith()方法的语法格式：对象/变量名.startswith(指定的子字符串,起始点下标,结束下标)

​ 也可指定一个范围去查找这个范围的起始字符

a = "我爱你一生一世"
print(a.startswith("我爱"))
print(a.startswith("我",1,5))

endswith()方法：判断字符串是否以指定的子字符串为结尾

endswith()方法的语法格式：对象/变量名.endswith(指定的子字符串,起始点下标,结束下标)

​ 也可指定一个范围去查找这个范围的结尾字符

a = "我爱你一生一世"
print(a.endswith("世"))
print(a.endswith("一世",3,6))

istitle()方法：判断一个字符串中所有单词是否都是以大写字母开头，其余字母都是小写

istitle()方法的语法格式：对象/变量名.istitle()

a = "lOve YOU"
print(a.istitle())

isupper()方法：判断一个字符串中是否所有字母都是大写字母

isupper()方法的语法格式：对象/变量名.isupper()

a = "lOve YOU"
print(a.isupper())

islower()方法：判断一个字符串中是否所有字母都是小写字母

islower()方法的语法格式：对象/变量名.islower()

a = "love you"
print(a.islower())

isalpha()方法：判断一个字符串中是否只有字母构成（中间有空格也算False）

isalpha()方法的语法格式：对象/变量名.isalpha()

a = "loveyou"
print(a.isalpha())

isspace()方法：判断是否为一个空白字符串（并不是只有空格才算空白字符串，例如：tab，转义字符\n也都 是空白字符串

isspace()方法的语法格式：对象/变量名.isspace()

print("\n".isspace())

isprintable()方法：判断一个字符串中是否所有字符都是可打印的，例如：转义字符\n并不是一个可打印字符

isprintable()方法的语法格式：对象/变量名.isprintable()

a = "fwcww\n"
print(a.isprintable())

isdigit()方法：可以用来判断一个字符串中是否是纯数字，只可用来判断单一的数字

isdigit()方法的语法格式：对象/变量名.isdigit()

a = "12345"
print(a.isdigit())

isalnum()方法：判断一个字符串中是否是字母或数字

isalnum()方法的语法格式：对象/变量名.isalnum()

a = "123asd45"
print(a.isalnum())

4.字符串的运算：

符号	描述
+	字符串的拼接
[]	通过索引获取到字符串中的字符
[:]	切片，获取到一段字符串
in	成员运算符 – 如果字符串中包含给定的字符返回True
not in	成员运算符 – 如果字符串中不包含给定的字符返回True
r	取消转义
%	格式化字符串

#给定的字符 in 字符串（对象）/变量名
a = "qwert"
print('t' in a)
#给定的字符 not in 字符串（对象）/变量名
print('q' not in "rtyuigh")
#取消转义
print(r"hello\nya")
通过索引获取到字符串中的字符                       |
| `[:]`    | 切片，获取到一段字符串                             |
| `in`     | 成员运算符 -- 如果字符串中包含给定的字符返回True   |
| `not in` | 成员运算符 -- 如果字符串中不包含给定的字符返回True |
| `r`      | 取消转义                                           |
| `%`      | 格式化字符串                                       |

```python
#给定的字符 in 字符串（对象）/变量名
a = "qwert"
print('t' in a)
#给定的字符 not in 字符串（对象）/变量名
print('q' not in "rtyuigh")
#取消转义
print(r"hello\nya")