从零开始学Python 8

字符串

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

#字符串的驻留机制
a='Python'
b="Python"
c='''Python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))  #三者内存地址相同 

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

• 字符串长度为1或0时
• 符合标识符的字符串
• 字符串只在编译时进行驻留，而非运行时
• [-5,256]之间的整数数字
  sys中的intern方法强制2个字串指向同一个对象
  PyCharm对字符串进行了优化处理
  
  

s1='abc%'
s2='abc%'
print(s1 is s2) #True  PyCharm对字符串做了优化

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

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


#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

字符串大小写转换操作的方法
upper()把字符串中所有字符转换成大写字母
lower()把字符串中所有字符转换成小写字母
swapcase()把字符串中所有大写字母转换成小写字母，把所有小写字母转换成大写字母
capitalize()把第一个字符转换为大写，把其余字符转换为小写
title()把每个单词的第一个字符转换成大写，把每个单词的剩余字符转换为小写

#字符串大小写转换操作
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))

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

print(s2.title())

字符串内容对其操作方法
center()：居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串

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

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

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

s='hello,Python'
#居中对齐
print(s.center(20,'*'))
#左对齐
print(s.ljust(20,'*'))
#右对齐
print(s.rjust(20,'*'))
#右对齐,使用0填充
print(s.zfill(20))

print('-8910'.zfill(8))

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

s='hello world Python'
lst=s.split()
print(lst)
s1='hello|world|Python'
print(s1)
print(s1.split(sep='|'))
print(s1.split(maxsplit=1,sep='|'))

#从右边开始劈分
print(s.rsplit())
print(s1.rsplit(sep='|'))
print(s1.rsplit(sep='|',maxsplit=1))

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

#判断是否是合法字符
s='hello,python'
print('1.',s.isidentifier())  #False
print('2.','hellp'.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('12.','123'.isnumeric())  #True
print('13.','123四'.isnumeric())  #True

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

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

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=('helo','Java','Python')
print(''.join(t))

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

字符串的比较操作
运算符：>,>=,<,<=,==,!=
比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，知道两个字符串中的字符不相等时，其比较结果就是两个字符串中的比较结果，两个字符串中的所有字符将不再被比较
比较原理：两个以上字符进行比较时，比较的是七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'))
print(ord('雷'))

print(chr(38647))
print(chr(97),chr(98))

'''==与is的区别是
==比较的是value
is比较的是id'''
a=b='Python'
c='Python'
print(a==b)
print(b==c)

print(a is b)
print(a is c)
print(id(a),id(b),id(c))

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

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

print('--------------[start:end:step]-----------')
print(s[1:5:1])  #从1开始切到5，不包含5，步长为1
print(s[::2])  #从头切到尾，步长为2
print(s[::-1])  #倒切
print(s[-6::1]) #从索引-6开始，切到字符串最后一个元素

格式化字符串
两种方式：%作占位符，{}作占位符

#格式化字符串第一种方式
name='张三'
age=20
print('我是%s,今年%d岁' % (name,age))

#格式化字符串第二种方式
print('我是{0},今年{1}岁'.format(name,age))

#f-string
print(f'我是{name},今年{age}岁')

print('%10d' % 99)  #10表示的是宽度
print('%.3f' % 3.1415926)  #.3表示保留三位小数
print('%10.3f' % 3.1415926)  #总宽度为10，小数点后3位
print('{0:.3}'.format(3.1415926))  #.3表示保留三位有效数字
print('{0:.3f}'.format(3.1415926))  #.3f表示保留三位小数

print('{:10.3f}'.format(3.1415926))  #同时设置宽度和保留数位

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

#编码
s='天涯共此时'
print(s.encode(encoding='GBK'))  #该编码格式中一个中文占两个字节
print(s.encode(encoding='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'))