字符串是基本数据类型，是一个不可变序列，python的驻留机制，不同的值被存到字符串的驻留池中，创建相同字符串的变量时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量
pythona='python'
b="python"
c='''python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))
在交互模式下的驻留机制
字符串长度为 0 或者 1 时
python>>> s1='' # 字符串长度为0
>>> s2=''
>>> s1 is s2
True
>>> s1='%' # 字符串长度为1
>>> s2='%'
>>> s1 is s2
True
>>> s1='abc%'
>>> s2='abc%'
>>> s1 == s2
True
>>> s1 is s2
False
>>> id(s1)
2196612824048
>>> id(s2)
2196612823984
符合标识符的字符串(字母，数字，下划线)
python>>> s1='abcd123_'
>>> s2='abcd123_'
>>> s1 is s2
True
>>> id(s1)
2196612824176
>>> id(s2)
2196612824176
字符串只在编译时进行驻留，而非运行时
python>>> a='abc'
>>> b='ab'+'c' # 程序运行之前就赋值好了
>>> c=''.join(['ab','c']) # 这个是程序运行时才赋值的
>>> a is b
True
>>> a is c
False
>>> c
'abc'
>>> type(c)
<class 'str'>
>>> a
'abc'
>>> type(a)
<class 'str'>
[-5,256]之间的整数数字
python>>> a=-5
>>> b=-5
>>> a is b
True
>>> a=-6
>>> b=-6
>>> a is b
False
>>> import sys
>>> a='abc%'
>>> b='abc%'
>>> a is b
False
>>> a=sys.intern(b) # 强制驻留
>>> a is b
True
在需要进行字符串拼接时建议使用str类型的 join 方法，因为 join() 方法是先计算出所有字符串中的长度，然后再拷贝，只创建一次对象，效率比 + 效率高
字符串的查询操作
| 功能 | 方法名称 | 作用 |
| 查询方法 | ||
| index() | 查找子串substr第一次出现的位置，如果查找的子串不存在，会抛出异常ValueError | |
| rindex() | 查找子串substr最后一次出现的位置，如果查找的子串不存在，会抛出异常ValueError | |
| find() | 查找子串substr第一次出现的位置，如果查找的子串不存在，则返回-1 | |
| rfind() | 查找子串substr最后一次出现的位置，如果查找的子串不存在，则返回-1 |
pythons='hello,hello'
print(s.index('lo'))
print(s.find('lo'))
print(s.rindex('lo'))
print(s.rfind('lo'))
# print(s.index('a')) # ValueError: substring not found 查找不存在的子串会抛异常
print(s.find('a')) # -1 查找不存在的子串返回-1
字符串的大小写转换
| 功能 | 方法名称 | 作用 |
| 大小写转换 | ||
| upper() | 把字符串中的所有字符都转成大写字母 | |
| lower() | 把字符串中所有的字符都转成小写字母 | |
| swapcase() | 把字符串中的所有大写字母转成小写字母，把所有的小写字母转成大写字母 | |
| capitalize() | 把第一个字符串转换成大写，把其余的字符串转成小写 | |
| title() | 把每个单词的第一个字符串转成大写，每个单词的其他的字符串转成小写 |
pythons='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填充，该方法只接收一个参数，用于指定字符串的宽度，如果字符串以“+”或“-”开头，则在符号之后填充，如果指定的宽度小于等于字符串的长度，返回字符串本身 |
pythons='hello,Python'
print(s.center(20,'*')) # 居中对齐
print(s.ljust(20,'*')) # 左对齐
print(s.ljust(20)) # 左对齐，默认填充空格
print(s.ljust(10)) # 指定宽度小于原字符串，返回原字符串
print(s.rjust(20,'*')) # 右对齐
print(s.rjust(20))
print(s.rjust(10))
print(s.zfill(20)) # 右对齐，默认填充0
print(s.zfill(10))
print('-9835'.zfill(8)) # 如果字符串以“+”或“-”开头，则在符号之后填充
字符串劈分操作
| 功能 | 方法名称 | 作用 |
| 字符串的劈分 | ||
| split() | ||
| 从字符串的左边开始劈分，默认的劈分字符串是空格字符串，返回的值都是一个列表 | ||
| 以通过参数sep指定劈分字符串是劈分符 | ||
| 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部分 | ||
| rsplit() | ||
| 从字符串的右边开始劈分，默认的劈分字符串是空格字符串，返回的值都是一个列表 | ||
| 以通过参数sep指定劈分字符串是劈分符 | ||
| 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部分 |
pythons='hello world python'
lst=s.split() # 默认空格分隔符
print(lst)
s1='hello:world:python'
print(s1.split(sep=':')) # 指定以”：“分隔
print(s1.split(sep=':',maxsplit=1)) # 指定最大分隔次数
print(s1.rsplit(':')) # 没有指定最大分隔次数，rsplit和split是一样的
print(s1.rsplit(':',maxsplit=1)) # 从右侧开始分隔，设置了最大分隔次数
判断字符串操作
| 功能 | 方法名称 | 作用 |
| 判断字符串的方法 | ||
| isidentifier() | 判断指定的字符串是不是合法的标识符 | |
| isspace() | 判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符等） | |
| isalpha() | 判断指定的字符串是否全部由字母组成 | |
| isdecimal() | 判断指定字符串是否全部由十进制的数字组成 | |
| isnumeric() | 判断指定的字符串是否全部由数字组成 | |
| isalnum() | 判断指定字符串是否全部由字母和数字组成 |
pythons='hello，python'
print('1.',s.isidentifier()) # 判断是否是合法字符串
print('2.','hello123_张三'.isidentifier()) # True
print('3.','\t'.isspace()) # 判断是否是空白字符
print('4.','abc'.isalpha()) # 判断是否全部由字母组成
print('5.','张三'.isalpha()) # True
print('6.','张三1'.isalpha()) # False
print('7.','1234'.isdecimal()) # 判断字符串是否由十进制数字组成
print('8.','123四'.isdecimal()) # False
print('9.','ⅠⅡⅢ'.isdecimal()) # False
print('10.','123'.isnumeric()) # 判断指定字符串是否由数字组成
print('11.','123四'.isnumeric()) # True
print('12.','ⅠⅡⅢ'.isnumeric()) # True
print('13.','abc'.isalnum()) # 判断字符串是否全部由字母和数字组成
print('14.','张三123abc'.isalnum()) # True
print('15.','abc!'.isalnum()) # False
字符串操作的其他方法
| 功能 | 方法名称 | 作用 |
| 字符串替换 | repace() | 第一个参数指定被替换的子串，第二个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以通过第三个参数指定最大替换次数 |
| 字符串的合并 | join() | 将列表或元组中的字符串合并成一个字符串 |
pythons='hello，python'
print(s.replace('python','java')) # 把python字符串替换成java
s1='hello,python,python,python'
print(s1.replace('python','java',2)) # 设置替换最大次数
lst=['hello','world','python']
print('|'.join(lst)) # 把字符串用“|”连接
t=('hello','world','python')
print(''.join(t)) # 把元组内的字符串合并一个字符串
print('*'.join('python')) # 把字符串使用”*“连接起来
运算符 ： > ,>= , < , <= , = , == , != ， == 比较的是 value ， is 比较的是 id 是否相等。
比较规则 ：首先比较2个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较。
比较原理 ：两个字符串比较时，比较的是其 ordinal value (原始值)，调用内置函数 ord 可以得到指定字符串的 ordinal value 。调用内置函数 chr 时指定 ordinal value 可以得到其对应的字符。
pythonprint('apple'>'app') # True
print('apple'>'banana') # False 第一个字母比较相当于97>98，所以为False
print(ord('a'),ord('b')) # 获得字母的原始值
print(chr(97),chr(98)) # 使用原始值获取字符
a=b='python'
c='python'
print(a==b) # True
print(a==c) # True
print(a is b) # True
print(a is c) # True
print(id(b)) # 1838709970608
print(id(c)) # 1838709970608
字符串是不可变类型，切片后会产生新的对象，语法 [start:end:step] 第一个参数 开始 ，第二个参数 结束 ，第三个参数为 步长
pythons='hello,python'
s1=s[:5] # 没有指定起始位置，默认从索引0开始切
s2=s[6:] # 没有指定结束位置，默认会切片到最后一个元素
print(s,id(s)) # 切片操作会产生新的对象
print(s1,id(s1))
print(s2,id(s2))
print(s[1:5:1]) # 从索引1开始截到索引5（不包含索引5的位置），步长为1
print(s[::2]) # 默认从0开始，默认截到最后一个元素，步长为2
print(s[::-1]) # 步长为负数，默认从最后一个元素开始
print(s[-6::1]) # 从-6索引开始，到最后一个元素结束，步长为1
格式化字符串就是按照一定的格式输出字符串，可以使用 % 、 {} 和 str.format() 来格式化字符串，示例如下：
pythonname='张三'
age=48
print('我叫%s，今年%d岁了' % (name,age)) # 使用"%"作为占位符
print('我叫{0}，今年{1}岁了'.format(name,age)) # 调用format()方法，使用“{}”作为占位符
print(f'我叫{name},今年{age}岁了') # 使用f也可以格式化字符串
print('%10d' % 87) # 10表示的是宽度
print('%.2f' % 3.1415926) # %f表示浮点数.2表示保留小数点后2位
print('%10.2f' % 3.1415926) # 同时表示宽度和精度，总宽度为10，小数点后2为
print('{0:.2}'.format(3.1415926)) # 0表示的是占位符的顺序（可以省略），.2表示一共2位数
print('{0:.2f}'.format(3.1415926)) # .2f表示2为小数
print('{0:10.2f}'.format(3.1415926)) # 总宽度为10，保留2为小数
| 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
| -1 | {:-.2f} | -1.00 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |
| 5 | {<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |
| 10 | {<4d} | 10xx | 数字补x (填充右边, 宽度为4) |
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00e+09 | 指数记法 |
| 13 | {:>10d} | 13 | 右对齐 (默认, 宽度为10) |
| 13 | {:<10d} | 13 | 左对齐 (宽度为10) |
| 13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
| 11 | '{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11) | 1011 11 13 b 0xb 0XB | 进制 |
^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
计算机在网络传输的时候，需要将数据转换成 byte 字节传输，编码是为了存储传输，解码是为了方便显示阅读
pythons='我是字符串'
# 编码
print(s.encode(encoding='GBK')) # 在GBK编码中，一个中文占2个字节
print(s.encode(encoding='UTF-8')) # 在UTF-8编码格式中，一个中文占用3个字节
# 解码
byte=s.encode(encoding='GBK') # 把byte编码后的结果赋值给byte
print(byte.decode(encoding='GBK'))
byte1=s.encode(encoding='UTF-8')
print(byte1.decode(encoding='UTF-8')) # 解码UTF-8
本文作者:柯南
本文链接:
版权声明:©2023 柯南 All rights reserved.