我在CSDN学python-9

1、字符串的驻留机制

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/10  14:06

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

2、字符串的常用操作

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/10  15:45

# 字符串的常用操作
# -字符串的查询操作的方法：index()、rindex()、find()、rfind()
# -字符串的大小写转换操作的方法：upper()、lower()、swapcase()、capitalize()、title()
# -字符串内容对齐操作的方法：center()、ljust()、rjust()、zfill()
# -字符串劈分操作的方法：split()、rsplit()
# -判断字符串操作的方法：isidentifier()、isspace()、isalpha()、isdecimal()、isnumeric()、isalnum()
# -字符串操作的其他方法：替换replace()、合并join()
print('------字符串的查询操作------')
s = 'hello, hello'
print(s.index('lo'))  # 3
print(s.find('lo'))  # 3
print(s.rindex('lo'))  # 10
print(s.rfind('lo'))  # 10
# print(s.index('k'))  # 字符不存在的时候会报错，异常
print(s.find('k'))  # 字符不存在的时候会输出-1
# print(s.rindex('k'))
print(s.rfind('k'))
print('------字符串的大小写转换操作------')
s = 'hello,python'
a = s.upper()  # 转成大写之后，会产生一个新的字符串对象
print(a, id(a))
print(s, id(s))
b = s.lower()  # 转换之后会产生一个新的字符串对象
print(b, id(b))
print(b == s)  # True内容相同
print(b is s)  # False地址不相同，标识不同
s2 = 'Hello,Python'
print(s2.swapcase())  # hELLO,pYTHON大小写互换
print(s2.capitalize())  # Hello,python第一个字符大写，其余都小写
print(s2.title())  # Hello,Python把每一个单词的第一个字符都大写，其余都小写
print('------字符串内容对齐操作------')
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))
print(s.zfill(20))  # 右对齐，使用0进行填充
print(s.zfill(10))
print('-11'.zfill(8))  # 注意0填充在负号后边
print('------字符串劈分操作------')
s = 'hello world python'
lst = s.split()  # split()从左侧开始劈分
print(lst)
s1 = 'hello|world|python'
print(s1.split(sep='|'))  # sep=后面是分割符
print(s1.split(sep='|', maxsplit=1))
# maxsplit=后面是最大劈分次数，经过最大劈分次数后，剩余的子串会单独做为一部分
print(s.rsplit())  # rsplit()从右侧开始劈分
print(s1.rsplit('|'))
print(s1.rsplit(sep='|', maxsplit=1))  # 左右劈分的区别体现在这里
print('------判断字符串操作------')
s = 'hello,python'
print('------isidentifier()判断指定的字符串是否为合法的标识符------')
print('1.', s.isidentifier())   # False
print('2.', 'hello'.isidentifier())  # True
print('3.', '余生_'.isidentifier())  # True
print('4.', '余生_000'.isidentifier())  # True
print('------isspace()判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）------')
print('5.', '\t'.isspace())  # True
print('------isalpha()判断指定的字符串是否全部由字母组成------')
print('6.', 'abc'.isalpha())  # True
print('7.', '余生'.isalpha())  # True # 汉字也属于字母
print('8.', '余生1'.isalpha())  # False # 1不是字母
print('------isdecimal()判断指定的字符串是否全部由十进制的数字组成------')
print('9.', '123'.isdecimal())  # True # 强调十进制数字
print('10.', '123四'.isdecimal())  # False
print('11.', 'ⅠⅡⅢ'.isdecimal())  # False
print('------isnumeric()判断指定的字符串是否全部由数字组成------')
print('12.', '123'.isnumeric())  # True # 罗马数字，汉字数字均属于数字
print('13.', '123四'.isnumeric())  # True
print('14.', 'ⅠⅡⅢ'.isnumeric())  # True
print('------isalnum()判断指定的字符串是否全部由字母和数字组成------')
print('15.', 'abc1'.isalnum())  # True
print('16.', '余生111'.isalnum())  # True
print('17.', 'abc!'.isalnum())  # False
print('------字符串替换操作------')
s = 'hello,python'
print(s.replace('python', 'java'))
s1 = 'hello,python,python,python'
print(s1.replace('python', 'java', 2))
print(s1.replace('python', 'java', 3))
print('------字符串合并操作------')
lst = ['hello', 'java', 'python']
print(''.join(lst))
print('|'.join(lst))
t = ('hello', 'java', 'python')
print(''.join(t))
print('*'.join('python'))

3、字符串的比较

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/10  17:03

# 字符串的比较操作：>,>=,<,<=,==,!=
# -比较规则：
#    首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果
# -比较原理：
#  两个字符进行比较时，比较的是其ordinal value(原始值)，
#  调用内置函数ord()可以得到指定字符的ordinal value。与内置函数ord()对应的是内置函数chr()，调用内置函数chr()时指定ordinal value可以得到对应的字符
print('apple' > 'app')  # True
print('apple' > 'banana')  # False
print(ord('a'), ord('b'))  # 得到的是字符的Unicode值
print(ord('余'))
print(chr(97), chr(98))
print(chr(20313))
print('------ ==与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))  # 2223291007984
print(id(b))  # 2223291007984
print(id(c))  # 2223291007984

4、字符串的切片操作

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/11  9:12

# 字符串的切片操作：
# -不具备增删改操作
# -切片操作将产生新的对象
s = 'hello,python'
print('------切片操作：[start:end:step]------')
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))
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、格式化字符串

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/11  9:25

# 格式化字符串两种方式
# -%作占位符：%s字符串 %i或%d整数 %f浮点数
# -{}作占位符
print('------%作占位符------')
name = '余生'
age = 22
print('我叫%s，今年%d岁' % (name, age))
print('------{}作占位符------')
print('我叫{0}，今年{1}岁'.format(name, age))
print('------ f-string ------')
print(f'我叫{name}，今年{age}岁')
print('%10d' % 99)  # 10表示宽度
print('%.3f' % 3.1415926)  # .3表示是小数点后三位
print('------同时表示宽度和精度------')
print('%10.3f' % 3.1415926)  # 一共总宽度为10，小数点后3位
print('hello,python')
print('{}'.format(3.1415926))
print('{0:.3}'.format(3.1415926))  # .3表示的是一共是3位
print('{0:.3f}'.format(3.1415926))  # .3f表示是3位小数
print('{:.3f}'.format(3.1415926))
print('{:10.3f}'.format(3.1415926))  # 同时设置宽度和精度，一共是10位，3位小数

6、字符串的编码转换

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/11  9:43

# 字符串的编码转换
# -编码：将字符串转换为二进制数据（bytes）
# -解码：将bytes类型的数据转换为字符串类型
s = '余生'
print('------编码------')
print(s.encode(encoding='GBK'))  # 在GBK这种编码格式中，一个中文占两个字节
print(s.encode(encoding='UTF-8'))  # 在UTF-8这种编码格式中，一个中文占三个字节
print('------解码------')
byte = s.encode(encoding='GBK')  # 编码
print(byte.decode(encoding='GBK'))  # 解码
byte = s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))