Python中的字符串

1. 字符串的创建与驻留机制

• 字符串
  • 在python中字符串是基本数据类型，是一个不可变的字符序列
• 字符串驻留机制定义
  • 仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量
• 驻留机制的几种情况（交互模式）
  • 字符串的长度为0或1时
  • 符合标识符的字符串（数字字母下划线）
  • 字符串只在编译时进行驻留，而非运行时
  • [-5, 256]之间的整数数字
• sys中的intern方法强制2个字符串指向同一个对象
• PyCharm对字符串进行了优化处理
• 字符串驻留机制的优缺点
  • 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的
  • 在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比“+”效率高

"""字符串的驻留机制"""
a = 'Python'
b = "Python"
c = '''Python'''
print(a, id(a))
print(b, id(b))
print(c, id(c))

Pycharm中运行结果：
Python 3004696703088
Python 3004696703088
Python 3004696703088

Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> s1=''
>>> s2=''
>>> s1 is s2
True
>>> s1='%'
>>> s2='%'
>>> s1 is s2
True
>>> s1='abc%'
>>> s2='abc%'
>>> s1==s2
True
>>> s1 is s2
False
>>> id(s1)
2456645311216
>>> id(s2)
2456645313776
>>> s1='abcx'
>>> s2='abcx'
>>> s1 is s2
True
>>> id(s1)
2456645313840
>>> id(s2)
2456645313840
>>> a='abc'
>>> b='ab'+'c'
>>> c=''.join(['ab','c'])
>>> a is b
True
>>> a is c
False
>>> c
'abc'
>>> type(c)
<class 'str'>
>>> a
'abc'
>>> type(a)
<class 'str'>
>>> a=-5
>>> b=-5
>>> a is b
True
>>> a=-6
>>> b=-6
>>> a is b
False
>>> import sys
>>> a='abc%'
>>> b='abc%'
>>> a is b
False
>>> a=sys.intern(b)
>>> a is b
True

在PyCharm中运行，会自动强制驻留

s1 = 'abc%'
s2 = 'abc%'
print(s1 is s2)  # True

2. 字符串的常用操作

2.1 字符串的查询操作

"""字符串的查询操作"""
s = 'hello,hello'
print(s.index('lo'))  # 3
print(s.find('lo'))  # 3
print(s.rindex('lo'))  # 9
print(s.rfind('lo'))  # 9

# print(s.index('k'))  # ValueError: substring not found
print(s.find('k'))  # -1
# print(s.rindex('k'))  # ValueError: substring not found
print(s.rfind('k'))  # -1

2.2 字符串的大小写转换操作

"""字符串中的大小写转换的方法"""
s = 'hello,python'
a = s.upper()  # 转成大写之后，会产生一个新的字符串对象
print(a, id(a))
print(s, id(s))
b = s.lower()  # 转换之后，会产生一个新的字符串对象
print(b, id(b))
print(s, id(s))
print(b == s)
print(b is s)  # False

s2 = 'hello, Python'
print(s2.swapcase())
print(s2.capitalize())
print(s2.title())

2.3 字符串的内容对齐操作

"""字符串内容对齐操作"""
s = 'hello,Python'
'''居中对齐'''
print(s.center(20, '*'))

'''左对齐'''
print(s.ljust(20, '*'))
print(s.ljust(10))  # 指定长度小于字符串长度时，返回字符串本身
print(s.ljust(20))  # 不指定填充符时，用空格填充

'''右对齐'''
print(s.rjust(20, '*'))
print(s.rjust(20))
print(s.rjust(10))

'''右对齐，使用0进行填充'''
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8))  # 如字符串开头是负号，则会添加在负号之后

2.4 字符串的分割操作

"""字符串的分割"""
s = 'hello world Python'
lst = s.split()
print(lst)
s1 = 'hello|world|Python'
print(s1.split(sep='|'))
print(s1.split(sep='|', maxsplit=1))  # ['hello', 'world|Python']
print('-------------------------------')
'''rsplit()从右侧开始劈分'''
print(s.rsplit())  # ['hello', 'world', 'Python']
print(s1.rsplit('|'))
print(s1.rsplit(sep='|', maxsplit=1))  # ['hello|world', 'Python']

2.5 字符串的判断操作

"""字符串的判断操作"""
s = 'hello,python'
print('1.', s.isidentifier())  # False
print('2.', 'hello'.isidentifier())  # True
print('3.', '张三_'.isidentifier())  # True
print('4.', '张三_123'.isidentifier())  # True

print('5.', '\t'.isspace())  # True

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

print('9.', '123'.isdecimal())  # True
print('10.', '123四'.isdecimal())  # False
print('11.', 'ⅡⅡⅡ'.isdecimal())  # False

print('12.', '123'.isnumeric())  # True
print('13.', '123四'.isnumeric())  # True
print('14.', 'ⅡⅡⅡ'.isnumeric())  # True

print('15.', 'abc1'.isalnum())  # True
print('16.', '张三123'.isalnum())  # True
print('17.', 'abc!'.isalnum())  # False

2.6 字符串的替换与合并

s = 'hello, Python'
print(s.replace('Python', 'Java'))
s1 = 'hello, Python, Python, Python'
print(s1.replace('Python', 'Java', 2))

lst = ['hello', 'java', 'Python']
print('|'.join(lst))
print(''.join(lst))

t = ('hello', 'java', 'Python')
print(''.join(t))

print('*'.join('Python'))

3. 字符串的比较操作

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

print('apple' > 'app')  # True
print('apple' > 'banana')  # False  相当于97>98 -> False
print(ord('a'), ord('b'))  # Unicode码
print(ord('杨'))

print(chr(97), chr(98))
print(chr(26472))

'''
    == 与 is 的区别
    == 比较的是 value
    is 比较的是 id 是否相等
'''
a = b = 'Python'
c = 'Python'
print(a == b)  # True
print(b == c)  # True

print(a is b)  # True
print(a is c)  # True
print(id(a))  # 3111052128368
print(id(b))  # 3111052128368
print(id(c))  # 3111052128368

4. 字符串的切片操作

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

print(s1)
print(s2)
print(newstr)
print('------------------------')
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))

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

5. 格式化字符串

"""格式化字符串"""
# (1) % 占位符
name = '张三'
age = 20
print('我叫%s，今年%d岁' % (name, age))

# (2) {}
print('我叫{0}，今年{1}岁'.format(name, age))

# (3)f-string
print(f'我叫{name}，今年{age}岁')

print('%10d' % 99)  # 10表示的是宽度
print('%.3f' % 3.1415926)  # .3表示是小数点后三位
# 同时表示宽度和精度
print('%10.3f' % 3.1415926)  # 一共总宽度为10，小数点后 3位

print('hellohello')

print('{0:.3}'.format(3.1415926))  # .3表示的是一共是3位数，0表示的是占位符的索引

print('{:.3f}'.format(3.1415926))  # .3f表示的是3位小数

print('{:10.3f}'.format(3.1415926))  # 同时设置宽度和精度，一共是10位，3位是小数

6. 字符串的编码与解码

"""字符串的编码与解码"""
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'))  # 解码