关于python:Python字符串

字符串

在 Python 中是根本数据类型，是不可变的字符序列

字符串的驻留机制

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

字符串的驻留机制产生的几种状况：

# 1. 字符串的长度为 0 或 1
s1 = ''s2 =''
print(s1 is s2)  # True

# 2. 合乎标识符的字符串（合乎命名标准：字母、数字、下划线）s1 = 'ab_'
s2 = 'ab_'
print(s1 is s2)  # True

# 3. 字符串只在编译时驻留，而非运行时
a = 'abc'
b = 'ab' + 'c'
c = ''.join(['ab','c'])
print(a is b)  # True
print(a is c)  # False

# 4.[-5, 256]间接的整数数字
a = '-5'
b = '-5'
print(a is b)  # True

驻留机制的优缺点：

须要值雷同的字符串，能够间接从字符串池拿来应用，防止频繁的创立和销毁，晋升效率、节约内存，因而拼接字符串和批改字符串是比拟影响性能的。在须要进行字符串拼接时倡议应用 str 类型的 join 办法，而非“+”，因为 join()办法是先计算所有字符的长度，再拷贝，至新建一次对象，效率更高。

字符串的罕用操作

查问子串地位

# 1.index(): 子串首次呈现的地位，不存在，抛出
# 2.rindex(): 子串末次呈现的地位，不存在，抛出
# 3.find(): 子串首次呈现的地位，不存在，返回 -1
# 4.rfind(): 子串末次呈现的地位，不存在，返回 -1
s = 'hello hello'
print(s.index('h'))  # 0
# print(s.index('j'))  # ValueError: substring not found
print(s.rindex('h'))  # 6
print(s.find('h'))  # 0
print(s.find('j'))  # -1
print(s.rfind('h'))  # 6

大小写转换操作

# 1.upper: 把所有字符转成大写，产生新的字符串对象
# 2.lower: 把所有字符转成小写，产生新的字符串对象
# 3.swapcase: 把所有字符小写变大写，大写变小写，产生新的字符串对象
# 4.capitalize: 把第一个字符转成大写，其余转小写，产生新的字符串对象
# 4.title: 把每一个单词的首字符转成大写，其余转小写，产生新的字符串对象

s = 'hello world'
print(s.upper())  # HELLO WORLD
print(s.lower())  # hello world
print(s.swapcase())  # HELLO WORLD
print(s.capitalize())  # Hello world
print(s.title())  # Hello World

字符串内容的对齐操作

# 1.center(): 居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数可选，默认空格，设置宽度小于理论宽度则返回原字符串
# 2.ljust(): 左对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数可选，默认空格，设置宽度小于理论宽度则返回原字符串
# 3.rjust(): 右对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数可选，默认空格，设置宽度小于理论宽度则返回原字符串
# 4.zfill(): 右对齐，右边用 0 填充，只有一个参数指定宽度，设置宽度小于理论宽度则返回原字符串

s1 = 'hello Python'
print(s.center(20))
print(s.center(20, '-'))  # ----hello world-----
print(s.ljust(20, '-'))  # hello world---------
print(s.rjust(20, '-'))  # ---------hello world
print(s.zfill(20))  # 000000000hello world
print('-8911'.zfill(8))  # -0008911

字符串的劈分操作

# 1.split(): 从左开始劈分，默认的劈分字符是空格，返回一个列表；# 通过 sep 参数指定劈分的字符；参数 maxsplit 指定最大劈分次数，超出次数后，残余的子串会独自做为一部分

# 2.rsplit(): 从右开始劈分，默认的劈分字符是空格，返回一个列表；# 通过 sep 参数指定劈分的字符；参数 maxsplit 指定最大劈分次数，超出次数后，残余的子串会独自做为一部分

s3 = 'hello my name is Alin'
s4 = 'hello-my-name-is-Bill'
print(s3.split())  # ['hello', 'my', 'name', 'is', 'Alin']
print(s4.split(sep='-'))  # ['hello', 'my', 'name', 'is', 'Bill']
print(s4.split('-', maxsplit=3))  # ['hello', 'my', 'name', 'is-Bill']
print(s4.rsplit('-', maxsplit=3))  # ['hello-my', 'name', 'is', 'Bill']
print(s3.rsplit())  # ['hello', 'my', 'name', 'is', 'Alin']

判断字符串的操作方法

# 1.isidentifier(): 判断是否是非法的标识符
# 2.isspace(): 判断是否由空白字符组成（回车、换行、制表符）# 3.isalpha(): 判断是否由字母字符组成
# 3.isdecimal(): 判断是否由十进制数字组成
# 3.isnumeric(): 判断是否由数字组成(包含汉字、罗马数字等)
# 3.isalnum(): 判断是否由字母和数字组成
s5 = 'hello'
print(s5.isidentifier())  # True
print(s5.isspace())  # False
print(s5.isalpha())  # True
print(s5.isdecimal())  # False
print(s5.isnumeric())  # False
print(s5.isalnum())  # True

字符串的替换

# replace(): 返回替换后失去的新字符串对象，原字符串不发生变化
# 参数 1：被替换的子串
# 参数 2：用来替换的子串
# 参数 3：最大替换的次数
s6 = 'hello 1 1 1'
print(s6.replace('1', '2', 2))  # hello 2 2 1

字符串的合并

# join()：将列表或元组中的字符串合并成一个字符串
l1 = ['1', 2, '2']
l2 = ['1', '2', '3']
# print(''.join(l1))  # TypeError: sequence item 1: expected str instance, int found
print('-'.join(l2))  # 1-2-3

字符串的比拟操作

# 运算符：>,>=,<,<=,==,!=
# 比拟规定：从第一个开始，若相等，持续比拟下一个，顺次比拟，首次不相等时的比拟后果
# 为两个字符串的比拟后果，后续的字符将不再进行比拟
# 比拟原理：两个字符比拟的是其 ordinal value，调用内置函数 ord()能够失去字符的 ordinal value；# 内置函数 chr()：指定 ordinal value 获取对应的字符。print('apple' > 'appml')  # False
print('apple' > 'app')  # True
print('apple' > 'b')  # False
print(ord('l'))  # 108
print(ord('m'))  # 109
print(chr(109))  # m

== 和 is 的区别？== 判断 value 是否相等，is 比拟的是 id 是否相等

字符串的切片操作（与列表相似）

# 不可变类型，不反对增删改操作，切片操作将产生新的对象
# 语法：[start:end:step]
s = 'hello,Python'
s11 = s[:5]
s22 = s[6:]
s33 = '!'
ns = s11 + s33 + s22
print(s11)  # hello
print(s22)  # Python
print(s33)  # !
print(ns)  # hello!Python
print(s[-6::])  # Python
print(s[6::-1])  # P,olleh

格式化字符串

# 1. 应用 % 作占位符（%s: 字符串；%i 或 %d：整数；%f：浮点型数）name = 'all'
age = 22
print('我的名字是 %s，往年 %d 岁' % (name, age))  # 我的名字是 all，往年 22 岁

# 2.{}作占位符
print('我的名字是 {0}，往年{1} 岁'.format(name, age))  # 我的名字是 all，往年 22 岁

# 3.f-string
print(f'我的名字是 {name}，往年{age} 岁')  # 我的名字是 all，往年 22 岁

宽度与精度的设置

print('%10d' % 99)  # 10 标识宽度
print('%.3f' % 3.1415926)  # .3 标识小数点后保留位数，输入 3.142
print('%10.3f' % 3.1415926)  # 可同时应用，输入     3.142

print('{0:.3}'.format(3.1415926))  # 输入 3.14，限度总位数
print('{0:.3f}'.format(3.1415926))  # 输入 3.142，限度小数点后保留位数
print('{0:10.3f}'.format(3.1415926))  # 输入     3.142，限度小数点后保留位数

字符串的编码转换

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

s = '好天气'
print(s.encode(encoding='GBK'))  # b'\xba\xc3\xcc\xec\xc6\xf8'
print(s.encode(encoding='UTF-8'))  # b'\xe5\xa5\xbd\xe5\xa4\xa9\xe6\xb0\x94'

b = s.encode(encoding='GBK')
print(b.decode(encoding='GBK'))  # 好天气
# print(b.decode(encoding='UTF-8'))
# 编码格局不同，报错 UnicodeDecodeError: 'utf-8' codec can't decode byte 0xba in position 0: invalid start byte