字符串str

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

a='python'
b='python'
c='python'
print(a,id(a))
print(b,id(b))
print(c,id(c))#id地址都相同——驻留机制

驻留机制的几种情况(交互模式):
字符串的长度为0或1时；符合标识符的字符串；字符串只在编译时进行驻留，而非运行时；[-5,256]之间的整数数字

sys中的item方法强制2个字符指向同一个对象
PyCharm对字符串进行了优化处理

#注意：这里要在交互式环境中运行，即cmd命令行或者IDEL中运行有的才是False,如果在Pycharm中运行是True
s1=''
s2=''
print(s1 is s2)#True
s1='%'
s2='%'
print(s1 is s2)#True
s1='abc%'
s2='abc%'
print(s1 == s2)#True
print(s1 is s2)#False
s1='abcx'
s2='abcx'
print(s1 is s2)#True
a='abc'
b='ab'+'c'
c=''.join(['ab','c'])
print(a is b)#True
print(a is c)#False
print(c,type(c))#abc <class 'str'>
print(a,type(a))#abc <class 'str'>
a=-5
b=-5
print(a is b)#True
a=-6
b=-6
print(a is b)#Flase  因为-6不在[-5,256]之间，所以不驻留
import sys
a='abc%'
b='abc%'
print(a is b)#False
a=sys.intern(b)
print(a is b)#True 强制驻留，让两个指向同一个空间，不开新的空间

字符串驻留的优缺点：
当需要值相同的字符串时，可以直接从字符串池里拿出来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是比较影响性能的
在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比“+”效率高
(2)字符串的常用操作
(1)查询
index()，查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError
rindex()，查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError
find()，查找子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1
rfind()，查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1

-11	-10	-9	-8	-7	-6	-5	-4	-3	-2	-1	逆向索引
h	e	l	l	o	,	h	e	l	l	o
0	1	2	3	4	5	6	7	8	9	10	正向索引

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)大小写转换
upper()，把字符串中所有字符都转成大写字母
lower()，把字符串中所有字符都转成小写字母
swapcase()，把字符串中所有大写字母都转成小写字母，所有小写字母都转成大写字母，
capitalize()，把第一个字符转换为大写，把其余字符转换为小写
title()，把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写

s='hello,python'
a=s.upper()
print(s,id(s))#hello,python 2144465510512
print(a,id(a))#HELLO,PYTHON 2144470465712  id地址改变
print(s.lower(),id(s.lower()))#hello,python 2251373444016 就算本来就是小写，id地址也改变了，产生了新的字符串
print(a.lower())#hello,python

s2='hello,Python'
print(s2.swapcase())#HELLO,pYTHON
print(s2.title())#Hello,Python

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

s='hello,python'
print(s.center(20,'*'))#****hello,python****
print(s.ljust(20,'*'))#hello,python********
print(s.ljust(10,'*'))#hello,python
print(s.ljust(20))#hello,python           后面默认填充空格
print(s.rjust(20,'*'))#********hello,python
print(s.rjust(10,'*'))#hello,python
print(s.rjust(20))#        hello,python  前面默认填充空格
print(s.zfill(20))#00000000hello,python
print(s.zfill(10))#hello,python
print('-8910'.zfill(8))#-0008910

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

s='hello world python'
lst=s.split()
print(lst)#['hello', 'world', 'python']
s1='hello|world|python'
print(s1.split())#['hello|world|python']
print(s1.split(sep='|'))#['hello', 'world', 'python']
print(s1.split(sep='|',maxsplit=1))#['hello', 'world|python']
print(s.rsplit())#['hello', 'world', 'python']
print(s1.rsplit(sep='|'))#['hello', 'world', 'python']
print(s1.rsplit(sep='|',maxsplit=1))#['hello|world', 'python']

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

s='hello,python'
print(s.isidentifier())#False
print('hello'.isidentifier())#True
print('张三_'.isidentifier())#True
print('张三_123'.isidentifier())#True
print('\t'.isspace())#True
print('abc'.isalpha())#True
print('张三'.isalpha())#True
print('张三1'.isalpha())#False
print('123'.isdecimal())#True
print('123四'.isdecimal())#False
print('ⅠⅡⅢⅢ'.isdecimal())#False
print('123'.isnumeric())#True
print('123四'.isnumeric())#True
print('ⅠⅡⅢⅢ'.isnumeric())#True  罗马数字是数字但不是十进制数字
print('abc1'.isalnum())#True
print('张三123'.isalnum())#True
print('abc！'.isalnum())#False

(6)替换与合并操作
replace()，第1个参数指定被替换的子串，第2个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以通过第3个参数指定最大替换次数
join()，将列表或元组中的字符串合并成一个字符串

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

lst=['hello','java','python']
print('|'.join(lst))#hello|java|python
print(''.join(lst))#hellojavapython

t=('hello','java','python')
print(''.join(t))#hellojavapython

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

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

print('apple'>'app')#True
print('apple'>'banana')#False  相当于比较97>98
print(ord('a'),ord('b'))#97 98
print(ord('章'))#31456
print(chr(97),chr(98))#a b
print(chr(31456))#章

#==比较的是value    is比较的是id
a=b='python'
c='python'
print(a==b)#True
print(c==b)#True
print(a is b)#True
print(c is b)#True abc的值和id地址都是相同的 字符串驻留机制

(4)字符串的切片操作
字符串是不可变类型，不具备增删改等操作，切片操作将产生新的对象

s='hello,python'
s1=s[:5]#由于没有指定起始位置，所以从0开始切
s2=s[6:]#由于没有指定结束位置，所以切到字符串的最后一个元素
print(s[1:5:1])#ello  [start:end:step]
print(s[::2])#hlopto
print(s[::-1])#nohtyp,olleh  默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负
print(s[-6::1])#python 从索引为-6开始，到最后一个元素结束，步长为1
print(id(s))#2582135453424
print(s1,id(s1))#hello 2582135536688
print(s2,id(s2))#python 2582135536752
s3='!'
print(id(s3))#2582135453488
newstr=s1+s3+s2
print(newstr,id(newstr))#hello!python 2582135536816

(5)格式化字符串
填写格式文件，xxxx的地方可以变，其他地方不可变，格式化字符串就是按一定格式输出的字符串
%作占位符，%s为字符串，%i或%d为整数，%f为浮点数。 ‘我的名字叫：%s,今年%d岁了’ (name,age)
{}作占位符，‘我的名字叫：{0}，今年{1}岁了，我真的叫：{0}’.format(name,age)

name='张三'
age=20
print('我叫%s,今年%d岁'% (name,age))#我叫张三,今年20岁

print('我叫{0},今年{1}岁'.format (name,age))#我叫张三,今年20岁

print(f'我叫{name},今年{age}岁')#我叫张三,今年20岁

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

print('{0}'.format(3.1415926))#3.1415926
print('{0:.3}'.format(3.1415926))#3.14    .3表示一共三位数
print('{0:.3f}'.format(3.1415926))#3.142    .3f表示一共三位小数
print('{:.3f}'.format(3.1415926))#3.142    .3f表示一共三位小数
print('{:10.3f}'.format(3.1415926))#     3.142  同时表示宽度和精度

(6)字符串的编码转换
在A计算机中，str在内存中以Unicode表示，编码后由byte字节传输，解码后显示到B计算机中
编码：将字符串转换成二进制数据(bytes)
解码：将bytes类型的数据转换成字符串类型

s='天涯共此时'
print(s.encode(encoding='GBK'))#b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'   在GBK这种编码格式中 一个中文占两个字节 输出结国中的b表示二进制
print(s.encode(encoding='UTF-8'))#b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'   在UTF-8这种编码格式中 一个中文占三个字节

byte=s.encode(encoding='GBK')#编码  byte代表一个二进制数据(字节类型的数据)
print(byte.decode(encoding='GBK'))#解码

byte=s.encode(encoding='UTF-8')#编码  
print(byte.decode(encoding='UTF-8'))#解码