【python学习】——字符串

字符串

一、字符串的驻留机制

（1）在python中它是基本数据类型，是一个不可变的字符序列
（2）字符串的驻留机制：仅保存一份相同且不可变字符串的方法，不用的值被存放在字符串的驻留池中，python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量

字符串的定义可以使用单引号，双引号，三引号
a='python'
b="python"
c='''python'''
print(a,id(a))——>python 2815240434496
print(b,id(b))——>python 2815240434496
print(c,id(c))——>python 2815240434496
上述输出结果相同表示产生了驻留

(3)那么，驻留机制产生的几种情况（交互模式，在IDLE环境下，cmd下的python）

• 字符串的长度为0或1时

- 为空，即长度为0
a = ' '
b = ' '
print(a==b)——>TRUE
print(a is b)——>TRUE
- 长度为1
a = 'S'
b = 'S'
print(a==b)——>TRUE
print(a is b)——>TRUE
- 长度超过1,且不符合标志符的字符串
>>> s1 = "abc%"
>>> s2 = "abc%"
>>> s1==s2
True
>>> s1 is s2
False

• 符合标志符的字符串

>>> s1="abc"
>>> s2="abc"
>>> s1 is s2
True

• 字符串只在编译时进行驻留，而非运行时
• [-5,256]之间的整数数字

>>> a=-5
>>> b=-5
>>> a is b
True
>>> a=-8
>>> b=-8
>>> a is b
False

（4）sys中的intern方法强制两个字符串指向同一个对象

>>> s1="abc%"
>>> s2="abc%"
>>> s1 is s2
False
>>> s1=sys.intern(s2)
>>> s1 is s2
True

（5）pycharm对字符串进行了优化处理

s1 = 'abc%'
s2 = 'abc%'
print(s1==s2)——>True
print(s1 is s2)——>True(进行了优化)

（6）字符串驻留机制的优缺点

• 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串时会比较影响性能的

• 在需要进行字符串拼接时，建议使用str类型的join方法，而非+,因为join()方法是先计算出所有字符串中的长度，然后再拷贝，只new一次对象，效率要比“+”效率高

二、字符串的常用操作

1、字符串的查询操作
2、大小写转换操作
3、内容对齐操作
4、劈分操作
5、判断操作
6、替换操作、合并操作

1、字符串的查询操作

（1）index()：查找子串substr第一次出现的位置，如果查找的子串 不存在时，抛出ValueError
（2）rindex()：查找子串substr最后一次出现的位置，如果查找的子串不存在时，抛出ValueError
（3）find()：查找子串substr第一次出现的位置，如果查找的子串 不存在时，则返回-1
（4）rfind()：查找子串substr最后一次出现的位置，如果查找的子串 不存在时，则返回-1

s1 = 'abc%,hello,hello'
print(s1.index('lo'))——>8
print(s1.find('lo'))——>8
print(s1.rindex('lo'))——>14
print(s1.rfind('lo'))——>14

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

 转换之后，会产生一个新的字符串对象，这也进一步证明字符串是不可变序列

（1）upper()：所有字母转成大写字母

s1 = 'PYthon,pyTHON,hELlo'
print(s1.upper())
——>PYTHON,PYTHON,HELLO

（2）lower()：所有字母转成小写

s1 = 'PYthon,pyTHON,hELlo'
print(s1.lower())
——>python,python,hello

（3）swapcase()：把字符串中所有大写字母变小写，小写字母变大写

s1 = 'PYthon,pyTHON,hELlo'
print(s1.swapcase())
——>pyTHON,PYthon,HelLO

（4）capitalize()：第一个字母转成大写，其余字母转小写

s1 = 'PYthon,pyTHON,hELlo'
print(s1.capitalize())
——>Python,python,hello

（5）title()：每个单词的第一个字符转成大写，每个单词的剩余字母转成小写

s1 = 'PYthon,pyTHON,hELlo'
print(s1.title())
——>Python,Python,Hello

3、字符串内容对齐操作的方法

（1）center():居中对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串

s1 = 'Hello,Python'
print(s1.center(20,'*'))
>>>****Hello,Python****

（2）ljust():左对齐，第1个参数指定宽度，第2个参数指定填充符，第二个参数可选，默认是空格，如果设置宽度小于实际宽度，则返回原字符串

s1 = 'Hello,Python'
print(s1.ljust(20,'*'))
>>>Hello,Python********
print(s1.ljust(10,"*"))
>>>Hello,Python

（3）rjust():右对齐，第1个参数指定宽度，第2个参数指定填充符，第二个参数可选，默认是空格，如果设置宽度小于实际宽度，则返回原字符串

s1 = 'Hello,Python'
print(s1.rjust(20,'*'))
>>>********Hello,Python
print(s1.rjust(20))
>>>        Hello,Python

（4）zfill():右对齐，左边用0填充，该方法只接受一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身。

s1 = 'Hello,Python'
print(s1.zfill(20))
>>>00000000Hello,Python

4、字符串劈分操作的方法

（1）split()

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

s1 = 'Hello world Python'
print(s1.split())
>>>['Hello', 'world', 'Python']默认根据空格进行劈分

s1 = 'Hello|world|Python'
print(s1.split(sep='|'))
>>>['Hello', 'world', 'Python']

s1 = 'Hello|world|Python'
print(s1.split(sep='|',maxsplit=1))
>>>['Hello', 'world|Python']

（2）rsplit():

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

s1 = 'Hello world Python'
print(s1.rsplit())
>>>['Hello', 'world', 'Python']默认根据空格进行劈分

s1 = 'Hello|world|Python'
print(s1.rsplit(sep='|'))
>>>['Hello', 'world', 'Python']

s1 = 'Hello|world|Python'
print(s1.rsplit(sep='|',maxsplit=1))
>>>['Hello|world', 'Python']

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

（1）isidentifier():判断指定的字符串是不是合法的标识符

s1 = 'Hello,world,Python'
print('1.',s1.isidentifier())
print('2.','hello'.isidentifier())
print('3.','浅析'.isidentifier())
print('4.',"易烊千玺——弟弟".isidentifier())
print('4.',"易烊千玺_弟弟".isidentifier())
1. False
2. True
3. True
4. False
4. True

（2）isspace():判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表等）

print("5.",'\t'.isspace())
>>>5. True

（3）isalpha():判断指定字符串是否全部由字母组成

print("6.","abc".isalpha())
print("7.","张三".isalpha())
print("8.","张三1".isalpha())
6. True
7. True
8. False

（4）isdecimal()：是否全部由十进制的数字组成

print("9.","123".isdecimal())
print("10.","1234五".isdecimal())
9. True
10. False

（5）isnumeric():是否全部由数字组成

print("11.","1234".isnumeric())
print("12.","1234五".isnumeric())
11. True
12. True
其中，罗马数字也是数字

（6）isalnum():是否全部由字母和数字组成

print("13.","1234abx".isalnum())
print("14.","开心abx".isalnum())
print("15.","1234abx！".isalnum())
13. True
14. True
15. False

6、字符串操作的其他方法

（1）字符串的替换，replace()

第1个参数指定被替换的子串，第2个参数指定替换字串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可通过第3个参数指定最大替换次数

s1 = 'Hello,python'
print(s1.replace('python','c++'))
>>>Hello,c++

s2 = 'Hello,python,python,python'
print(s2.replace('python','c++',2))
>>>Hello,c++,c++,python(虽然有3个python可被替换，但是这里只需要替换两个)

（2）字符串的合并，join()

将列表或元组中的字符串合并成一个字符串

- 列表
lst = ['hello','python','java','c++']
print('|'.join(lst))
print(''.join(lst))
>>>hello|python|java|c++
>>>hellopythonjavac++
- 元组
tup = ('hello','python','java','c++')
print('|'.join(tup))
print(''.join(tup))
>>>hello|python|java|c++
>>>hellopythonjavac++

print('*'.join('python'))
>>>p*y*t*h*o*n

三、字符串的比较

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

print('python'>'pyt')
print('python'>'java')
print(ord('p'),ord('j'))
>>>True
>>>True
>>>112 106
这里返回的是Unicode码，不是ASCII值

- ord和chr是一组相反的操作
print(ord("汪"))
print(chr(27754))
>>>27754
>>>汪

- “==”与is的区别：==比较的是value,is比较的是id
a=b='python'
c='python'
print(a==b)
print(a==c)
print(b==c)
print(a is b)
print(a is c)
print(b is c)

>>>True
>>>True
>>>True
>>>True
>>>True
>>>True

四、字符串的切片操作

字符串是不可变类型

• 不具备增、删、改等操作
• 切片将产生新的对象

切片[start🔚step]

s = 'hello,Python'
s1=s[:5]
s2=s[6:]
s3='!'
newstr=s1+s2+s3
print(s1)
print(s2)
print(newstr)
>>>hello
>>>Python
>>>helloPython!

五、格式化字符串

格式化字符串的两种方式
（1）%作占位符
（2）{}作占位符

name="倩倩"
age="18"
print("我叫%s，今年%s"%(name,age))
print("我叫{0}，今年{1}".format(name,age))
print(f"我叫{name}，今年{age}")
>>>我叫倩倩，今年18
>>>我叫倩倩，今年18
>>>我叫倩倩，今年18

print('1.','%d'%99)
print('2.','%10d'%99) 这里的d表示的是宽度
print('3.','hellohello')
print('4.','%f'%3.1415926)
print('5.','%.3f'%3.1415926)保留3位小数，表示精度
print('6.','%10.3f'%3.1415926)同时表示宽度和精度，表示总宽度为10，且小数点后面保留3位
>>>1. 99
>>>2.         99
>>>3. hellohello
>>>4. 3.141593
>>>5. 3.142
>>>6.      3.142


print('7.','{0}'.format(3.1415926))#0可以省略不写
print('8.','{0:.3}'.format(3.1415926))#保留前三位
print('9.','{0:.3f}'.format(3.1415926))#保留三位小数
print('10.','{0:10.3f}'.format(3.1415926))#宽度为10，保留三位小数，同时设置宽度和精度
>>>7. 3.1415926
>>>8. 3.14
>>>9. 3.142
>>>10.      3.142

六、字符串的编码转换

1、为什么需要字符串的编码转换

在计算机中，str在内存中以Unicode表示，通过编码的方式将其转换为byte字节传输并进行解码，从而在显示屏上展示为我们最终看到的结果

2、编码与解码的方式

编码：将字符串转换为二进制数据（bytes）
解码：将bytes类型的数据转换成字符串类型

-几种不同的编码方式的编码结果
s='好好学习'
print('1.',s.encode(encoding='GBK'))#在GBK这种编码格式中，一个中文占两个字节
>>>1.b'\xba\xc3\xba\xc3\xd1\xa7\xcf\xb0'(在这里的b表示byte二进制，所以“好好学习”四个字，最终是8个字节)
>>>2. b'\xe5\xa5\xbd\xe5\xa5\xbd\xe5\xad\xa6\xe4\xb9\xa0'(所以这里多出4个字节)

- 解码过程,先有编码才有解码，编码和解码格式要相同
s='好好学习'
byte = s.encode(encoding='GBK')
print('3.',byte.decode(encoding='GBK'))
>>>3. 好好学习

s='好好学习'
byte = s.encode(encoding='UTF-8')
print('4.',byte.decode(encoding='UTF-8'))
>>>4. 好好学习