字符串及相关操作

一、什么是字符串

• 在python中字符串是基本数据类型，是一个不可变的字符序列

二、字符串的驻留机制

• 仅保留一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋值给新创建的变量
• 即相同的字符串只有一个，只用赋值地址

a='python'
b="python"
c='''python'''

print('a的值：',a,id(a))
print('b的值：',b,id(b))
print('c的值：',c,id(c))

运行结果：

a的值： python 1741697609328
b的值： python 1741697609328
c的值： python 1741697609328

1、驻留机制的几种情况（交互模式）

• 字符串的长度为0或1时
• 符号标识符的字符串——字符串中只包含大小写字母、数字、下划线
• 字符串只在编译时进行驻留，而非运行时——在编译时不知道结果
• 【-5，256】之间的整数数字

2、sys中的intern方法强制2个字符串指向同一个对象

3、PyCharm对字符串进行了优化处理

4、字符串驻留机制的优缺点

• 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存
• 在需要进行字符串的拼接时建议使用str类型的join方法，而非+，因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比“+”效率高

三、字符串的常用操作

1、字符串的查找

• index()：查找子串substr第一次出现的位置，如果查找到的子串不存在时，则抛出异常
• rindex()：查找子串最后一次出现的位置，如果查找的子串不存在时，则抛出异常
• find()：查找子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1
• rfind()：查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1

demo="hello,hello"

print(demo.index('lo'))
#print(demo.index('savgdh'))#ValueError: substring not found 子串查找不到，报错
print(demo.rindex('lo'))
#print(demo.rindex('ahvfgah'))#ValueError: substring not found子串查找不到，报错
print(demo.find('lo'))
print(demo.find('sdfbh'))#-1 子串查找不到，返回-1
print(demo.rfind('lo'))
print(demo.rfind('sdfbh'))#-1 子串查找不到，返回-1

运行结果：

3
9
3
-1
9
-1

2、字符串大小写转换操作的方法

• upper()：把字符串中所有字符转化为大写字母
• lower()：把字符串中所有字符转化为小写字母
• swapcase()：把字符串中所有大写字母转为小写字母，把所有小写字母转为大写字母
• capitalize()：把第一个字符转换为大写，把其余字符转换为小写
• title()：把每个单词的第一个字符转换为大写，把每个单词的剩余字符变为小写

#字符串中大小写转换方法

s='hello,python'
a=s.upper()     #将所有字符串转化为大写
print(s,type(s))#hello,python <class 'str'>
print(a,type(a))#HELLO,PYTHON <class 'str'>
#使用upper()之后是新创建一个对象
print(id(s))#2610054516336
print(id(a))#2610054846640

b=s.lower()   #将所有字符转变为小写
#可以看出，即使是一样的数据，也会生成一个新的对象
print(s,id(s))#hello,python 2718729137776
print(b,id(b))#hello,python 2718729460272

demo='hello,Python'
demo2=demo.swapcase()#将大写变为小写，小写变为大写
print(demo,id(demo))  #hello,Python 1827402832368
print(demo2,id(demo2))#HELLO,pYTHON 1827402832752

demo3=demo.capitalize()#第一个字符变为大写，其余字符都是小写
print(demo3,id(demo3)) #Hello,python 1960434162608
print(demo,id(demo))   #hello,Python 1960434162032

demo4=demo.title()     #把每个单词的第一个字母变为大写，其余字符都变成小写
print(demo4,id(demo4)) #Hello,Python 1440205982960
print(demo,id(demo))   #hello,Python 1440205982128

　　

3、字符串对齐操作

1. centeer()：居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串
2. ljust()：左对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格。如果设置宽度小于实际宽度，则返回原字符串
3. rjust()：右对齐。第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格。如果设置宽度小于实际宽度，则返回原字符串
4. zfill()：右对齐，左边用0填充，该方法只接受一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，则返回字符串本身

'''
设置字符串对齐
'''

demo='hello,python' #12个字符
#居中对齐
print(demo.center(20))
print(demo.center(20,'*')) #第一个参数指定宽度，第二个指定填充物
print(demo.center(10))     #指定宽度太小，返回原字符串
#左对齐
print(demo.ljust(20))
print(demo.ljust(20,'*'))  #第一个参数指定宽度，第二个指定填充物
print(demo.ljust(1))       #指定宽度太小，返回原字符串
#右对齐
print(demo.rjust(20))
print(demo.rjust(20,'*'))
print(demo.rjust(10))
#右对齐，左边用0填充——只接收一个参数，用于指定字符串宽度
print(demo.zfill(20))

运行结果：

    hello,python    
****hello,python****
hello,python
hello,python        
hello,python********
hello,python
        hello,python
********hello,python
hello,python
00000000hello,python

Process finished with exit code 0

4、字符串的劈分——将字符串划分为列表

split():

• 从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
• 以通过参数sep指定劈分字符串
• 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分

rsplit():

• 从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
• 以通过参数sep指定劈分字符串
• 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部分

lst='hello world 你好'
print(lst)
print(lst.split())
print(lst.split(maxsplit=1))

demo='hello|world|nihao'
print(demo.split('|'))
print(demo.split(sep='|',maxsplit=1))

运行结果：

hello world 你好
['hello', 'world', '你好']
['hello', 'world 你好']
['hello', 'world', 'nihao']
['hello', 'world|nihao']

5、判断字符串操作的方法

• isidentifier()：判断指定的字符串是不是合法的标识符
• isspace()：判断指定的字符串是否全部由空白字符组成（回车，换行，水平制表符）
• isalpha()：判断指定的字符串是否全部由字母组成
• isdecimal()：判断指定字符串是否全部由十进制组成
• isnumeric()：判断指定的字符串是否全部数字组成
• isalnum()：判断指定字符串是否全部由字母和数字组成

6、字符串替换和合并操作

• replace()：第一个参数指定被替换的子串，第二个参数指定替换子串的字符串，该方法返回替换后得到的新的字符串，替换前的字符串不发生变化，调用该方法是可以通过设置第三个参数指定最大替换次数
• join()：将列表或元组中的字符串合并成一个字符串

'''
字符串的替换-生成了新的字符串
'''
s='hello,python'
print(s.replace('python','java'))
print(s)

s='hello,python,python,python'
print(s.replace('python','java',2))
print(s.replace('python','java'))

'''
字符串的合并-将列表或元组中的字符串合并成一个字符串
'''
#列表
lst=['hello','java','python']
print(''.join(lst))
print('*'.join(lst))
print('我是分隔符'.join(lst))
#元组
t=('hello','java','python')
print(''.join(t))
#字符串
print('*'.join('python'))

运算结果：

hello,java
hello,python
hello,java,java,python
hello,java,java,java
hellojavapython
hello*java*python
hello我是分隔符java我是分隔符python
hellojavapython
p*y*t*h*o*n

7、字符串的比较操作

• 运算符：>,>=,<,<=,==,!=
• 比较规则：首先比较两个字符串中第一个字符，如果相等则继续比较下一个字符，依此比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
• 比较原理：两个字符进行比较时，比较的是其原始值，调用内置函数ord可以得到指定字符的原始值。与内置函数ord对应的是内置函数chr，调用内置函数chr时指定原始值可以得到其对应的字符（原始值就是ascii）

#字符串的比较
print('apple'>'app')
print('apple'>'banana')
#ord函数可以获得一个字符的原始值
print(ord('a'),ord('b'))#97 98
print(ord('秦'))         #31206
#chr()函数可以从原始值查找对应的字符
print(chr(97),chr(98))
print(chr(31206))

'''
==与is的区别
==比较的是值
is比较的是id
'''
a=b='python'
c='python'
print(a==b)#True
print(a==c)#True
print(b==c)#True

print(a is b)#True
print(a is c)#True
print(b is c)#True
#字符串内存的驻留机制
print(id(a))#2922877630640
print(id(b))#2922877630640
print(id(c))#2922877630640

8、字符串的切片操作

#字符串的切片操作
s='hello,Python'
s1=s[:5]#由于没有指定初始位置，所以从索引0开始切片
s2=s[6:]#由于没有指定结束位置，所以切到字符串的最后一个元素
s3='!'
newstr=s1+s3+s2

print(s1)#hello
print(s2)#Python
print(s3)
print(newstr)#hello!Python
#可以发现三个id块都不同，所以对于字符串的切片产生了新的对象
print(id(s1))#2964438800624
print(id(s2))#2964438800752
print(id(s3))#2964438467056

'''
切片操作[start:end:step]
'''
print(s[1:5:1])#ello  从1开始截到5（不包含5），步长为1
print(s[::2])#hloPto  默认从0开始，没有写结束，默认到字符串的最后一个元素，步长为2，两个元素之间的索引间隔为2
print(s[::-1])#nohtyP,olleh   因为步长是负数，默认从字符串的最后一个元素开始，到字符串的第一个元素截至
print(s[-6::1])#Python   从索引-6开始，到字符串的最后一个元素结束，步长为1

9、格式化字符串

三种方式：

• %作占位符，%s做字符串；%i或%d做整数；%f做浮点数
• {}作占位符
• f-string调用

name='张三'
age=30

print('我的名字叫：',name,'今年',age,'岁')
#我的名字叫： 张三 今年 30 岁  可以看见，在name和age的附近多出了空格

#第一种方法：%占位符
print('我的名字叫%s，今年%d岁' % (name,age))
#第二种方法：{}
print('我叫{0}，今年{1}岁，我的名字是{0}'.format(name,age))
#第三种方法：f-string
print(f'我叫{name},今年{age}岁')　　

宽度和精度的设置

print('{}'.format(3.1415927))
print('{0:.3}'.format(3.1415927))#.3表示的是一共是三位数

print('{:.3}'.format(3.1415927))
print('{:.3f}'.format(3.1415927))#.3f表示的是有三位小数
#同时设置宽度和精度
print('{0:10.3}'.format(3.1415927))#10表示设置的宽度
print('{0:10.3}'.format(3.1415927))
print('hellohello')

print('%10d' % 99)         #10表示设置的宽度
print('%.3f' % 3.1415926)  #.3f表示是小数点后三位

print('%10.3f' % 3.1415926)#同时设置宽度和精度，一共总宽度为10，小数点后三位

10、字符串的编码转换

编码：将字符串转换为二进制数据（bytes）

解码：将bytes类型的数据转换成字符串类型

s='天涯共此时'
#编码
print(s.encode(encoding='GBK'))  #在GBK这种编码格式中，一个中文占两个字节
print(s.encode(encoding='UTF-8'))#在UTF-8这种编码格式中，一个中文占三个字节

#解码
#byte代表的就是一个二进制数据（字节类型的数据）
#编码和解码要一一对应
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))

byte=s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTf-8'))