• python字符串

    python字符串

    字符串

    • 字符串是一个不可变的字符序列。

    1.字符串的创建

    # 单引号，双引号，三引号都可以
a = 'python'
b = "python"
c = '''pyhton'''

    • 1
    • 2
    • 3
    • 4

    2.字符串的常用操作

    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.index('k'))  # substring not found
print(s.find('k'))  # -1
#print(s.rindex('k'))  # substring not found
print(s.rfind('k'))  # -1

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    2.2大小写转换操作
    方法作用
    upper()把字符串中所有字符都转换成大写字母
    lower()把字符串中所有字符都转换成小写字母
    swapcase()把字符串中所有大写字母都转换成小写字母，把所有小写字母都转换成大写字母
    capitalize()把第一个字符转换为大写，把其余字符转换为小写
    title()把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写
    s = 'hello,python'
a = s.upper()
print(s.upper(), id(s.upper()))  # HELLO,PYTHON 2697940633264 转成大写之后，会产生一个新的字符串对象
print(s.lower(), id(s.lower()))  # hello,python 2697943577968 转成小写之后，会产生一个新的字符串对象
print(s, id(s))  # hello,python 2697940633008

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

print(s2.capitalize())  # Hello,python

print(s2.title())  # Hello,Python

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    2.3 内容对其操作
    方法作用
    center()居中对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格；如果设置宽度小于实际宽度，则返回原字符串
    ljust()左对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格；如果设置宽度小于实际宽度，则返回原字符串
    rjust()右对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格；如果设置宽度小于实际宽度，则返回原字符串
    zfill()右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度；如果指定的宽度小于等于字符串的长度，则返回字符串本身
    s = 'hello,Python'

print(s.center(20, '*'))  # ****hello,Python****

print(s.ljust(20, '*'))  # hello,Python********
print(s.ljust(10))  # hello,Python(原字符串)
print(s.ljust(20))  #hello,Python        (中间实际是空格)

print(s.rjust(20, '*'))  # ********hello,Python
print(s.rjust(20))  #         hello,Python
print(s.rjust(10))  # hello,Python（原字符串）

print(s.zfill(20))  # 00000000hello,Python
print(s.zfill(10))  # hello,Python（原字符串）
print('-666'.zfill(8))  # -0000666

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    2.4劈分操作
    方法作用
    split()从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
    通过参数sep指定劈分字符串时的劈分符
    通过参数maxsplit指定劈分字符串的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部分
    rsplit()从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
    通过参数sep指定劈分字符串时的劈分符
    通过参数maxsplit指定劈分字符串的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部分
    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(s1.rsplit('|'));  # ['hello', 'world', 'python']
print(s1.rsplit(sep='|', maxsplit=1))  # ['hello|world', 'python']

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    2.5判断操作
    方法作用
    isidentifier()判定指定的字符串是不是合法的标识符
    isspace()判断指定的字符串是否全部由空白字符串组成（回车、换行、水平制表符）
    isalpha()判断指定的字符串是否全部由字母组成
    isdecimal()判断指定的字符串是否全部由十进制的数字组成
    isnumeric()判断指定的字符串是否全部由数字组成
    isalnum()判断指定的字符串是否全部由字母和数字组成
    print('hello,python'.isidentifier())  # False
print('hello'.isidentifier())  # True
print('美羊羊'.isidentifier())  # True
print('美羊羊_123'.isidentifier())  # True

print('\n'.isspace())  # True
print('\t'.isspace())  # True

print('abc'.isalpha())  # True
print('张三'.isalpha())  # True
print('张三1'.isalpha())  # False

print('123'.isdecimal())  # True
print('123四'.isdecimal())  # False
print('Ⅱ Ⅱ'.isdecimal())  # False

print('123'.isnumeric())  # True
print('123四'.isnumeric())  # True
print('ⅡⅡ'.isnumeric())  # True

print('abc1'.isalnum())  # True
print('张三123'.isalnum())  # True
print('abc!'.isalnum())  # False

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    2.6替换与合并操作
    方法作用
    replace()第一个参数指定被替换的子串，第2个参数指定替换字串的字符串，第3个参数指定替换次数
    该方法返回替换后得到的字符串，替换前的字符串不发生变化
    join()将列表或元组中的字符串合并成一个字符串
    s = 'hello,python'
print(s.replace('python', 'Java'))  # hello,Java

s1 = 'hello,python,python,python'
print(s1.replace('python','Java',2))  # hello,Java,Java,python

lst = ['hello', 'Java', 'python']
print('|'.join(lst))  # hello|Java|python
print(''.join(lst))  # helloJavapython

t = ('hello', 'Java', 'python')
print(''.join(t))  # helloJavapython

print('*'.join('python'))  # p*y*t*h*o*n

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    2.7比较操作
    运算符：>，>=，<，<=，==，!=
    比较规则： 首先比较两个字符串中的第一个字符，如果相等，则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串的所有后续字符不再被比较。
    比较原理： 两个字符进行比较时，比较的是齐ordinal value（原始值），调用内置函数ord()可以得到指定字符的ordinal value。与内置函数ord()对应的是内置函数chr()，调用内置函数chr()时指定ordinal value可以得到其对应的字符。
    print('apple' > 'app')  # True
print('apple' > 'banana')  # False

print(ord('a'), ord('b'))  # 97 98
print(ord('王'))  # 29579

print(chr(97), chr(98))  #
print(chr(29579))  # 王

'''== 与 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（驻留机制）

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    2.8切片操作
    s [start : end : step]
    第一个元素表示切片的起始位置，第二个元素表示切片的结束位置（不包括该下标），step代表切片的步长
    未写start，默认起始位置为第一个；未写end，默认起始位置为最后一个；未写step，默认步长为1
    s = 'hello,python'
s1 = s[:5]  # 没有指定起始位置，所以从0开始切
s2 = s[6:]  # 没有指定结束位置，所以切到字符串的最后一个元素
s3 = '!'
newstr = s1 + s3 + s2
print(s, id(s))  # hello,python 1937847354864
print(s1, id(s1))  # hello 1636502734576
print(s2, id(s2))  # python 1636505679024
print(newstr, id(newstr))  # hello!python 1636505681136

print(s[1:5:1])  # ello(从1开始截到5（不包含5），步长为1)
print(s[::2])  # hlopto（默认从0开始，截到字符串的最后一个元素，步长为2）
print(s[::-1])  # nohtyp,olleh(默认从字符串的最后一个元素开始，到字符串的第一个元素结束，步长为1)
print(s[-6::1])  # python

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    2.9格式化字符串操作
    %作占位符%s：字符串；%i或%d：整数；%f：浮点数（见方法1）
    {}作占位符‘{0}{1}.format()’（见方法2）
    {}作占位符f-string(见方法3)
    name = '张三'
age = 20
# 方法1
print('我叫%s,今年%d岁' % (name, age))  # 我叫张三,今年20岁
# 方法2
print('我叫{0},今年{1}岁'.format(name, age))  # 我叫张三,今年20岁
# 方法3 f-string
print(f'我叫{name},今年{age}岁')  # 我叫张三,今年20岁

print('%10d' % 99) #         99：10表示的是宽度
print('%.3f' % 3.1415926)  # 3.142：.3表示的是小数点后三位
#同时表示宽度和精度
print('%10.3f' % 3.1415926)  #      3.142：一共总宽度为10，小数点后3位

print('{0:.3}'.format(3.1415926))  # 3.14：.3表示的是一共是3位数
print('{0:.3f}'.format(3.1415926))  # 3.142：.3表示3位小数
print('{0:10.3f}'.format(3.1415926))  #      3.142：一共10位，3位小数

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    3.字符串的编码转换

    编码与解码

    • 编码：将字符串转换为二进制数据（bytes）
    • 解码：将bytes类型的数据转换为字符串类型
    s = "一日看尽长安花"
# 编码
# 在GBK这种编码中，一个中文占两个字节
print(s.encode(encoding='GBK'))  # b'\xd2\xbb\xc8\xd5\xbf\xb4\xbe\xa1\xb3\xa4\xb0\xb2\xbb\xa8'
# 在UTF-8这种编码中，一个中文占三个字节
print(s.encode(encoding='UTF-8'))  # b'\xe4\xb8\x80\xe6\x97\xa5\xe7\x9c\x8b\xe5\xb0\xbd\xe9\x95\xbf\xe5\xae\x89\xe8\x8a\xb1'

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

byte = s.encode(encoding='UTF-8')
print(byte.decode('UTF-8'))  # 一日看尽长安花

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
  • 相关阅读:
    重学前端——事件循环
    原子操作是如何实现的？---（拓跋阿秀笔记记录）
    Mac配置iTerm样式终端
    基于改进海洋捕食者算法求解单目标优化问题附matlab代码(NMPA)
    Java多线程笔记1
    漏电保护器的工作原理
    【计算机网络笔记】TCP的拥塞控制机制
    爬虫部署 Gerapy 安装(centos 8)演示
    通过skia/freetype 解析字体获取fontfamily fontstyle name 支持多语言翻译
    create® 3入门教程-里程计
  • 原文地址：https://blog.csdn.net/weixin_45865773/article/details/132891825