一篇搞定python基础(十一)

二十六、字符串

26.1、字符串的创建与驻留机制

• 字符串的创建

  #字符串的创建
  a='python'
  b="python"
  c='''python'''
  print(a,id(a))
  print(b,id(b))
  print(c,id(c))
  
  结果为：
  python 1199638675312
  python 1199638675312
  python 1199638675312
  

• 字符串的驻留机制

  '''字符串的驻留机制:
      仅保留相同且不可变字符串的方法，python的驻留机制对相同的字符串只保留一份拷贝，
  后续创建相同字符串时，不会开辟新的空间，而是把字符串的地址赋给新创建的变量
  '''
  
  '''驻留机制的几种情况（交互模式）
  1.字符串的长度为0或1时
  2.符合标识符的字符串
  3.字符串只在编译时进行驻留，而非运行时
  4.[-5,256]之间的整数数字
  '''
  
  
  ----------------这里使用交互模式------------------
  >>> s1=''    #字符串的长度为0或1时，会产生驻留
  >>> s2=''
  >>> s1=s2
  >>> s1 is s2
  True
  
  >>> s1='%'   #字符串的长度为0或1时，会产生驻留
  >>> s2='%'
  >>> s1 is s2
  True
  
  >>> s1='abc%'     #abc%不是符合标识符的字符串（字母，数字，下划线），字符串里面不包含百分号，所以s1和s2的值是相同的，但地址不相同，也就是说s1和s2没有产生驻留
  >>> s2='abc%'
  >>> s1==s2
  True
  >>> s1 is s2
  False
  >>> id(s1)
  2484620924272
  >>> id(s2)
  2484620925360
  
  >>> s1='abcx'
  >>> s2='abcx'
  >>> s1 is s2
  True
  >>> id(s1)
  2484620925424
  >>> id(s2)
  2484620925424
  
  >>> a='abc'
  >>> b='ab'+'c'
  >>> c=''.join(['ab','c'])   #c的值是在程序运行的时候通过join方法对列表中的数据进行连接，字符串只在编译时进行驻留，而非运行时
  >>> a is b
  True
  >>> a is c
  False
  >>> c
  'abc'
  >>> a
  'abc'
  >>> b
  'abc'
  >>> type(c)
  <class 'str'>
  >>> type(a)
  <class 'str'>
  
  >>> a=-5
  >>> b=-5
  >>> a is b
  True
  >>> a=-6      #[-5,256]之间的整数数字，-6不在这个范围内
  >>> b=-6
  >>> a is b
  False
  
  >>> import sys   #sys中的intern方法强制两个字符串指向同一个对象，pycharm对字符串进行了优化处理
  >>> 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    pycharm对字符串进行了优化处理
  
  '''字符串驻留机制的优缺点
  1.当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节省内存
  2.在需要进行字符串拼接时，建议使用str类型的join方法，而不是+，因为join方法是先计算出所有字符串的长度，然后再拷贝，只new一次对象，比+的效率高
  '''
  

26.2、字符串的查询

'''字符串的查询'''
s='hello,hello'
print(s.index('lo'))#查找子串第一次出现的位置
#print(s.index('ee'))#找不到就报错ValueError: substring not found
print(s.find('lo'))#查找子串第一次出现的位置
#print(s.find('ee'))#找不到就显示-1
print(s.rindex('lo'))#查找子串最后一次出现的位置,找不到就报错ValueError: substring not found
print(s.rfind('lo'))#查找子串最后一次出现的位置,找不到就显示-1

结果为：
3
3
9
9

26.3、字符串的大小写转换

'''字符串的大小写转换'''
s='hello,python'
a=s.upper()   #转成大写之后，会产生一个新的字符串对象，upper()都变大写
print(a,id(a))
print(s,id(s))
b=s.lower()  #转换之后，会产生一个新的字符串对象，lower()都变小写
print(b,id(b))
print(s,id(s))
print(b==s)   #内容是相同的，地址不同
print(b is s)

结果为：
HELLO,PYTHON 1791800617456
hello,python 1791800970032
hello,python 1791800672112
hello,python 1791800970032
True
False

s='hello,Python'
print(s.swapcase())#大写转小写，小写转大写
print(s.title())#每个单词首字符变大写，每个单词其余字符变小写
print(s.capitalize())#第一个字符变大写，其余字符变小写

结果为：
HELLO,pYTHON
Hello,Python
Hello,python

26.4、字符串的劈分

• 字符串的对齐

  '''字符串内容对齐操作'''
  s='hello,Python'
  print(s.center(20,'*'))#居中对齐，第一个参数指定宽度，第二个参数指定填充符（默认为空格）
  print(s.ljust(20,'*'))#左对齐
  print(s.ljust(10,'*'))#如果指定的宽度小于原字符串，就直接返回原字符串
  print(s.rjust(20,'*'))#右对齐
  print(s.zfill(20))#右对齐，只能指定宽度，左边补0
  print(s.zfill(10))#如果指定的宽度小于原字符串，就直接返回原字符串
  print('-9810'.zfill(8))#0补在减号后面，加上减号一共有8位
  
  结果为：
  ****hello,Python****
  hello,Python********
  hello,Python
  ********hello,Python
  00000000hello,Python
  hello,Python
  -0009810
  

• 字符串的劈分

  '''字符串劈分操作'''
  s='hello world python'
  lst=s.split()#从字符串左边开始劈分，默认的劈分字符是空格字符串，返回的都是一个列表
  print(lst)
  
  结果为：
  ['hello', 'world', 'python']
  
  s1='hello|world|python'
  print(s1.split(sep='|'))#通过参数sep指定劈分字符串的劈分符
  print(s1.split(sep='|',maxsplit=1))#通过maxsplit参数指定最大劈分次数，劈分后，剩余的子串单独作为一部分
  print(s.rsplit())#从右侧开始劈分
  print(s1.rsplit(sep='|'))
  print(s1.rsplit(sep='|',maxsplit=1))#从右边劈分，左边单独作为一部分
  
  结果为：
  ['hello', 'world', 'python']
  ['hello', 'world|python']
  ['hello', 'world', 'python']
  ['hello', 'world', 'python']
  ['hello|world', 'python']
  

26.5、字符串判断的相关方法

'''判断字符串操作的方法'''
s='hello,python'
print('1.',s.isidentifier())#判断是否为合法的标识符
print('2.','hello'.isidentifier())
print('3.','张三_'.isidentifier())
print('4.','张三_123'.isidentifier())

print('5.','\t'.isspace())#判断是否全部有空白字符组成（空格、换行、水平制表符）
print('6.','abc'.isalpha())#判断是否全部由字母组成
print('7.','张三'.isalpha())
print('8.','张三1'.isalpha())

print('9','123'.isdecimal())#判断是否全部由十进制的数字组成
print('10.','123四'.isdecimal())

print('11.','123'.isnumeric())#判断是否全部由数字组成
print('12.','123四'.isnumeric())
print('13.','②'.isnumeric())

print('14.','abc1'.isalnum())#判断是否全部由字母和数字组成
print('15.','张三123'.isalnum())
print('16.','abc!'.isalnum())

结果为：
1. False
2. True
3. True
4. True
5. True
6. True
7. True
8. False
9 True
10. False
11. True
12. True
13. True
14. True
15. True
16. False

26.6、字符串的替换与合并

s='hello,python'
print(s.replace('python','java'))#第一个参数指定被替换的子串，第二个参数指定替换子串的字符串
s1='hello,python,python,python'
print(s1.replace('python','java',2))#第三个参数指定最大替换次数

结果为：
hello,java
hello,java,java,python

#将列表或元组中的字符串合并成一个字符串
lst=['hello','java','python']
print('|'.join(lst))
print(''.join(lst))

结果为：
hello|java|python
hellojavapython

t=('hello','java','python')
print('*'.join(t))
print('*'.join('python'))#将python作为字符串序列用*连接起来

结果为：
hello*java*python
p*y*t*h*o*n

26.7、字符串的比较

'''字符串的比较
规则：首先比较两个字符串中的第一个字符，相等就比较下一个字符，依次比较下去，直到两个字符串的字符不相等时，其比较结果就是两个字符串的比较结果，
这两个字符串后面的所有字符也不用比较了
原理：两个字符进行比较时，比较的是它们的ordinal value（原始值），调用内置函数ord可以得到指定字符的ordinal value，
调用内置函数chr时指定ordinal value可以得到其对应的字符
'''

print('apple'>'app')
print('apple'>'banana')#False    97>98 --> False
print(ord('a'),ord('b'))
print(chr(97),chr(98))

结果为：
True
False
97 98
a b

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

结果为：
True
True
True
True
2038920514352
2038920514352
2038920514352

26.8、字符串的切片

'''字符串的切片操作
字符串是不可变类型
不具备增删改操作
切片操作将产生新的对象
'''
s='hello,python'
s1=s[:5]        #没有指定起始位置，就从0开始切
s2=s[6:]        #没有指定结束位置，就切到字符串最后一个元素
s3='!'
newstr=s1+s3+s2
print(s1)
print(s2)
print(newstr)
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))

结果为：
hello
python
hello!python
2522416024240
2522415726320
2522416076144
2522412001776
2522416078448

26.9、格式化字符串

'''格式化字符串的两种方式：
    %作占位符
        %s       字符串
        %i或%d    整数
        %f       浮点数
    {}作占位符
'''

name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age))
print('我叫{0},今年{1}岁'.format(name,age))
print(f'我叫{name},今年{age}岁')

结果为：
我叫张三,今年20岁
我叫张三,今年20岁
我叫张三,今年20岁

print('%10d' % 99)#10表示的是宽度
print('%.3f' % 3.1415926)#.3表示的是保留几位小数
print('%10.3f' % 3.1415926)#同时表示宽度和精度
print('hellohello')

结果为：
        99
3.142
     3.142
hellohello

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

结果为：
3.14
3.142
     3.142

26.10、字符串的编码与解码

'''字符串的编码与解码'''
s='天涯共此时'
#编码
print(s.encode(encoding='GBK'))#GBK编码中，一个中文占两个字符
print(s.encode(encoding='UTF-8'))#UTF-8中，一个中文占三个字符

结果为：
b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'

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

结果为：
天涯共此时

#编码和解码格式要一致，不一致就报错UnicodeDecodeError: 'gbk' codec can't decode byte 0xad in position 10: illegal multibyte sequence
byte=s.encode(encoding='UTF-8')#编码
print(byte.decode(encoding='UTF-8'))#解码

结果为：
天涯共此时