Python中的字符串

1、字符串的驻留机制

      字符串：

                   在Python中字符串是基本数据类型，是一个不可变的字符序列

      什么叫字符串驻留机制呢？

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

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

                 1、字符串的长度为0或1时

                 2、符合标识符的字符串

                 3、字符串只在编译时进行驻留，而非运行时

                 4、[-5,256]之间的整数数字

        sys中的intern方法强制2个字符串指向同一个对象

        PyCharm对字符串进行了优化处理

        字符串驻留机制的优缺点：

               1、当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销                           毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。

               2、在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join()方法是先计                         算出所有字符中的长度，然后在拷贝，只new一次对象，小笼包要比+效率高。

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

2、字符串的常用操作

   （1）查询方法：

          index():查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError

          rindex():查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError

          find():查找子串substr第一次出现的位置，如果查找的子串不存在，则返回-1

          rfind():查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-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.find('k')) # -1
print(s.rfind('k'))
print(s.rindex('k')) # ValueError: substring not found
print(s.index('k'))

       （2）：字符串的大小写转换操作的方法

                  upper():把字符串中所有字符都转成大写字母

                  lower():把字符串中所有字符都转成小写字母

                  swapcase():把字符串中所有大写字母转成小写字母，把所有小写字母转成大写字母

                  capitalize():把第一个字符转换成大写，把其余字符转换成小写

                  title():把每个单词的第一个字符转化为大写，把每个单词的剩余字符串转换为小写

# 字符串的大小写转换的操作
s='hello,python'
a=s.upper()
print(a,id(a)) # HELLO,PYTHON 1077505116912
print(s,id(s)) # hello,python 1077505117040
b=s.lower() # 转换之后，会产生一个新的字符串的对象
print(s.lower(),id(s.lower())) # print(s.lower(),id(s.lower()))
print(b,id(b)) # hello,python 472966333808
print(s,id(s)) # hello,python 472966318960
print(b==s) # True
print(b is s) # False

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

         （3）字符串内容对齐操作的方法：

                        center():居中对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可                                           选 的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串。

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

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

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

# 字符串对齐操作
s='hello,Python'
print(s.center(20,'*')) # 居中
print(s.ljust(20,"*")) # 左对齐
print(s.rjust(20,'*')) # 右对齐
print(s.zfill(20))
print(s.zfill(10))

              （3）字符串分割操作的方法：

                     split():从字符串左边开始分割，默认分割字符是空字符串，返回的值都是一个列表

                     rsplit():从字符串的右边开始分割，默认分割字符是空字符串，返回的值都是一个列表

# 分割字符串
s='hello world Python'
lst=s.split()
print(lst) # ['hello', 'world', 'Python']

# 左边分割
s1='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()) # ['hello|world|Python']
print(s1.rsplit(sep='|',maxsplit=1)) #['hello|world', 'Python']

            （4）判断字符串操作的方法：

                         isidentifier():判断指定的字符串是不是合法的标识符

                         isspace():判断指定的字符串是否全部由空白字符组成(回车，换行，水平制表符)

                         isalpha():判断指定的字符串是否全部由字母组成

                         isdecimal():判断指定字符串是否全部由数字组成

                         isnumeric():判断指定字符串是否全部由数字组成

                         isalnum():判断指定字符串是否全部由字母和数字组成

#判断字符串判断操作
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()) #False
print('8.','张三1'.isalpha()) #False

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

print('11.','123'.isnumeric()) # True
print('12.','123四'.isnumeric()) # True

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

          （4）字符串替换的操作方法：

                        1：replace()     字符串替换

                        2：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))

print('*'.join('Python')) # P*y*t*h*o*n

3、字符串的比较

             字符串的比较操作：

                        1、运算符：>,>=,<,<=,==,=,!=

                        2、比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个                                  字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两                                个字符串的比较结果，两个字符串中所有后续字符将不再被比较。

                       3、比较原理：两个字符进行比较是，比较的是其ordinal value(原始值),调用内置函                              数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr，                              调用内置函数chr时指定ordinal value可以得到其对应的字符。

# 字符串比较
print('apple'>'app') # True
print('apple'>'banner') # False 相当于97>98>False
print(ord('a'),ord('b')) # 97 98
print(ord('凡')) # 20961

print(chr(97),chr(98)) # a b
print(chr(20961)) # 凡

# ==与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)) # 584248022832
print(id(b)) # 584248022832
print(id(c)) # 584248022832

4、字符串的切片操作

            字符串是不可变类型：

                     不具备增删改等操作

                     切片操作将产生新的对象

# 字符串的切片
s='hello.Python'
s1=s[:5] # 由于没有指定起始的位置，使用从0开始切
s2=s[6:] # 由于没有指定结束位置，所以切刀字符串的最后一个元素
s3='!'
newStr=s1+s2+s3
print(s1)
print(s2)
print(newStr)
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:12:1])

5、格式化字符串

             格式化字符串的两种方式： 1、%做占位符                2、{}作占位符

  

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

# {}占位符
print('我叫{0},今年{1}岁'.format(name,age))

6、字符串的编码转换