Python：字符串

字符串在Python中是基本数据类型，是不可变的字符序列字符串的驻留机制

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

字符串的驻留机制产生的几种情况：

# 1.字符串的长度为0或1
s1 = ''
s2 = ''
print(s1 is s2)  # True

# 2.符合标识符的字符串（符合命名规范：字母、数字、下划线）
s1 = 'ab_'
s2 = 'ab_'
print(s1 is s2)  # True

# 3.字符串只在编译时驻留，而非运行时
a = 'abc'
b = 'ab' + 'c'
c = ''.join(['ab', 'c'])
print(a is b)  # True
print(a is c)  # False

# 4.[-5, 256]直接的整数数字
a = '-5'
b = '-5'
print(a is b)  # True

驻留机制的优缺点：

需要值相同的字符串，可以直接从字符串池拿来使用，避免频繁的创建和销毁，提升效率、节约内存，因此拼接字符串和修改字符串是比较影响性能的。在需要进行字符串拼接时建议使用str类型的join方法，而非“+”，因为join()方法是先计算所有字符的长度，再拷贝，至新建一次对象，效率更高。

字符串的常用操作查询子串位置

# 1.index():子串首次出现的位置，不存在，抛出
# 2.rindex():子串末次出现的位置，不存在，抛出
# 3.find():子串首次出现的位置，不存在，返回-1
# 4.rfind():子串末次出现的位置，不存在，返回-1
s = 'hello hello'
print(s.index('h'))  # 0
# print(s.index('j'))  # ValueError: substring not found
print(s.rindex('h'))  # 6
print(s.find('h'))  # 0
print(s.find('j'))  # -1
print(s.rfind('h'))  # 6

大小写转换操作

# 1.upper: 把所有字符转成大写，产生新的字符串对象
# 2.lower: 把所有字符转成小写，产生新的字符串对象
# 3.swapcase: 把所有字符小写变大写，大写变小写，产生新的字符串对象
# 4.capitalize: 把第一个字符转成大写，其余转小写，产生新的字符串对象
# 4.title: 把每一个单词的首字符转成大写，其余转小写，产生新的字符串对象

s = 'hello world'
print(s.upper())  # HELLO WORLD
print(s.lower())  # hello world
print(s.swapcase())  # HELLO WORLD
print(s.capitalize())  # Hello world
print(s.title())  # Hello World

字符串内容的对齐操作

# 1.center(): 居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数可选，默认空格，设置宽度小于实际宽度则返回原字符串
# 2.ljust(): 左对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数可选，默认空格，设置宽度小于实际宽度则返回原字符串
# 3.rjust(): 右对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数可选，默认空格，设置宽度小于实际宽度则返回原字符串
# 4.zfill(): 右对齐，左边用0填充，只有一个参数指定宽度，设置宽度小于实际宽度则返回原字符串

s1 = 'hello Python'
print(s.center(20))
print(s.center(20, '-'))  # ----hello world-----
print(s.ljust(20, '-'))  # hello world---------
print(s.rjust(20, '-'))  # ---------hello world
print(s.zfill(20))  # 000000000hello world
print('-8911'.zfill(8))  # -0008911

字符串的劈分操作

# 1.split(): 从左开始劈分，默认的劈分字符是空格，返回一个列表；
# 通过sep参数指定劈分的字符；参数maxsplit指定最大劈分次数，超出次数后，剩余的子串会单独做为一部分

# 2.rsplit(): 从右开始劈分，默认的劈分字符是空格，返回一个列表；
# 通过sep参数指定劈分的字符；参数maxsplit指定最大劈分次数，超出次数后，剩余的子串会单独做为一部分

s3 = 'hello my name is Alin'
s4 = 'hello-my-name-is-Bill'
print(s3.split())  # ['hello', 'my', 'name', 'is', 'Alin']
print(s4.split(sep='-'))  # ['hello', 'my', 'name', 'is', 'Bill']
print(s4.split('-', maxsplit=3))  # ['hello', 'my', 'name', 'is-Bill']
print(s4.rsplit('-', maxsplit=3))  # ['hello-my', 'name', 'is', 'Bill']
print(s3.rsplit())  # ['hello', 'my', 'name', 'is', 'Alin']

判断字符串的操作方法

# 1.isidentifier(): 判断是否是合法的标识符
# 2.isspace(): 判断是否由空白字符组成（回车、换行、制表符）
# 3.isalpha(): 判断是否由字母字符组成
# 3.isdecimal(): 判断是否由十进制数字组成
# 3.isnumeric(): 判断是否由数字组成(包括汉字、罗马数字等)
# 3.isalnum(): 判断是否由字母和数字组成
s5 = 'hello'
print(s5.isidentifier())  # True
print(s5.isspace())  # False
print(s5.isalpha())  # True
print(s5.isdecimal())  # False
print(s5.isnumeric())  # False
print(s5.isalnum())  # True

字符串的替换

# replace(): 返回替换后得到的新字符串对象，原字符串不发生变化
# 参数1：被替换的子串
# 参数2：用来替换的子串
# 参数3：最大替换的次数
s6 = 'hello 1 1 1'
print(s6.replace('1', '2', 2))  # hello 2 2 1

字符串的合并

# join()：将列表或元组中的字符串合并成一个字符串
l1 = ['1', 2, '2']
l2 = ['1', '2', '3']
# print(''.join(l1))  # TypeError: sequence item 1: expected str instance, int found
print('-'.join(l2))  # 1-2-3

字符串的比较操作

# 运算符：>,>=,<,<=,==,!=
# 比较规则：从第一个开始，若相等，继续比较下一个，依次比较，首次不相等时的比较结果
# 为两个字符串的比较结果，后续的字符将不再进行比较
# 比较原理：两个字符比较的是其ordinal value，调用内置函数ord()可以得到字符的ordinal value；
# 内置函数chr()：指定ordinal value获取对应的字符。

print('apple' > 'appml')  # False
print('apple' > 'app')  # True
print('apple' > 'b')  # False
print(ord('l'))  # 108
print(ord('m'))  # 109
print(chr(109))  # m

==和is的区别？==判断value是否相等，is比较的是id是否相等字符串的切片操作（与列表类似）

# 不可变类型，不支持增删改操作，切片操作将产生新的对象
# 语法：[start:end:step]
s = 'hello,Python'
s11 = s[:5]
s22 = s[6:]
s33 = '!'
ns = s11 + s33 + s22
print(s11)  # hello
print(s22)  # Python
print(s33)  # !
print(ns)  # hello!Python
print(s[-6::])  # Python
print(s[6::-1])  # P,olleh

格式化字符串

# 1.使用%作占位符（%s:字符串；%i或%d：整数；%f：浮点型数）
name = 'all'
age = 22
print('我的名字是%s，今年%d岁' % (name, age))  # 我的名字是all，今年22岁

# 2.{}作占位符
print('我的名字是{0}，今年{1}岁'.format(name, age))  # 我的名字是all，今年22岁

# 3.f-string
print(f'我的名字是{name}，今年{age}岁')  # 我的名字是all，今年22岁

宽度与精度的设置

print('%10d' % 99)  # 10标识宽度
print('%.3f' % 3.1415926)  # .3标识小数点后保留位数，输出3.142
print('%10.3f' % 3.1415926)  # 可同时使用，输出     3.142

print('{0:.3}'.format(3.1415926))  # 输出3.14，限制总位数
print('{0:.3f}'.format(3.1415926))  # 输出3.142，限制小数点后保留位数
print('{0:10.3f}'.format(3.1415926))  # 输出     3.142，限制小数点后保留位数

字符串的编码转换

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

s = '好天气'
print(s.encode(encoding='GBK'))  # b'\xba\xc3\xcc\xec\xc6\xf8'
print(s.encode(encoding='UTF-8'))  # b'\xe5\xa5\xbd\xe5\xa4\xa9\xe6\xb0\x94'

b = s.encode(encoding='GBK')
print(b.decode(encoding='GBK'))  # 好天气
# print(b.decode(encoding='UTF-8'))
# 编码格式不同，报错UnicodeDecodeError: 'utf-8' codec can't decode byte 0xba in position 0: invalid start byte