文章目录


字符串

基本特点

字符串的本质是：字符序列。Python的字符串是不可变的。

Python不支持单字符类型，单字符也是作为一个字符串使用的。

编码

  • Python3直接支持Unicode，可以表示世界上任何书面语言的字符。Python3的字符默认就是16位Unicode编码，ASCII码是Unicode编码的子集。
  • 使用内置函数​​ord()​​获取字符对应的编码。
  • 使用内置函数​​chr()​​根据编码获取对应的字符。
>>> ord('马')
39532
>>> chr(39532)
'马'

表示方式（创建）

a = "I'm Tom"  # 一对双引号

b = 'Tom said:"I am Tom"'  # 一对单引号

c = '''Tom said:"I'm Tom"'''  # 一对三个单引号

d = """Tom said:"I'm Tom" """  # 一对三个双引号

转义字符

使用 ​​\​​​来表示一个转义字符，​​\​​在行尾时，表示续行符。

  • ​​\n​​ 表示一个换行
  • ​​\t​​ 表示一个tab
  • ​​\'​​ 显示一个普通的单引号
  • ​​\"​​ 显示一个普通的双引号
  • ​​\\​​ 表示一个普通的反斜线
  • ​​\r​​ 表示一个回车
  • ​​\b​​ 表示一个退格（backspace）

注：​在python中，在字符串的前面添加r，表示原生字符串​

k = r'good mor\ning'
print(k)  # good mor\ning

字符串拼接

  • str + str
  • 空格

注：这两种方式都会生成新的字符串对象

>>> 'a' + 'b'
'ab'
>>> 'c' 'd'
'cd'

字符串复制

  • str * int
>>> 'jack'*3
'jackjackjack'

常见操作

1. 获取长度

  • len函数可以获取字符串的长度

    mystr = '今天天气好晴朗，处处好风光呀好风光'
    print(len(mystr))  # 17 获取字符串的长度
2. 查找内容

  • find

  • 返回所查找的内容在字符串中第一次出现的开始位置索引值，如果不存在，返回-1
  • ​​S.find(sub[, start[, end]]) -> int​​

  • rfind

  • 类似于 find()函数，不过是从右边开始查找

    str1 = 'hello'
    print(str1.rfind('l'))  # 3

  • index

  • 与find()方法一样，只不过，find方法未找到时，返回 -1 ，而index未找到时，会报一个异常

  • rindex

  • 类似于 index()，不过是从右边开始
3. 判断

  • startswith

  • 判断字符串是否以指定内容开始

  • ​​S.startswith(prefix[, start[, end]]) -> bool​​

    print('hello'.startswith('he'))  # True

  • endswith

  • 判断字符串是否以指定内容结束

  • ​​S.endswith(suffix[, start[, end]]) -> bool​​

    print('hello'.endswith('o'))  # True

  • isalpha

  • 判断字符串是否是纯字母

    mystr = 'hello world'
    print(mystr.isalpha()) # False 因为中间有空格

  • isdigit

  • 判断一个字符串是否是纯数字，只要出现非0~9的数字，结果就是False

    print('good'.isdigit())  # False

    print('123'.isdigit())  # True

    print('3.14'.isdigit())  # False

  • isalnum

  • 判断是否由数字和字母组成。只要出现了非数字和字母，就返回False

    print('hello123'.isalnum())  # True
    print('hello'.isalnum())  # True

  • isspace

  • 如果字符串中只包含空格，则返回 True，否则返回 False

    print('  '.isspace())  # True

  • isascii

  • 如果字符串中的所有字符都是ASCII，则返回True；否则返回False。

  • 判断时必须是字符串形式，否则会报错

    a = 'a'
    print(a.isascii())  # True

  • isupper

  • 字符串中所有的字母都为大写，则返回True；否则返回False

    b = 'Hello'
    print(b.isupper())  # False
    c = 'LUCY'
    print(c.isupper())  # True

  • islower

  • 字符串中所有的字母都为小写，则返回True；否则返回False

    b = 'Hello'
    print(b.islower())  # False
    c = 'lucy'
    print(c.islower())  # True

  • isnumeric

  • 检测字符串是否只由数字组成。这种方法是只针对unicode对象

  • 这里的数字包括：阿拉伯数字、罗马数字、中文简体数字、中文繁体数字

  • 定义一个字符串为Unicode，只需要在字符串前添加 ‘u’ 前缀即可

    str1 = u"一壹①②③⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩ❶❷❸❺❺❻❼❽❾❿2009"
    print(str1.isnumeric())  # True

  • isprintable

  • 判断是否为可打印字符串，如果所有字符都是可打印的，则返回 True，否则返回 False

  • 不可打印的字符可以是回车、换行符、制表符

    str1 = 'abc'
    print(str1.isprintable())  # True
    str2 = 'abc\tdef'
    print(str2.isprintable())  # False

  • istitle

  • 判断是否首字母大写，其他字母小写

    str1 = 'LuCy'
    print(str1.istitle())  # False
    str2 = 'Lucy Ha'
    print(str2.istitle())  # True

  • isidentifier

  • 判断字符串是否是有效的 Python 标识符

    str1 = 'True'
    print(str1.isidentifier())  # True 关键字作为变量名检测不出来
    str2 = '3abc'
    print(str2.isidentifier())  # False
    str3 = 'username'
    print(str3.isidentifier())  # True

  • 如果字符串仅包含字母数字或下划线，则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格

  • isdecimal

  • 如果字符串是否只包含十进制字符返回True，否则返回False

    str1 = u"this2009"
    print(str1.isdecimal())  # False
    str2 = u"23443434"
    print(str2.isdecimal())  # True

  • 这种方法只存在于unicode对象

4. 计算出现次数

  • count

  • 返回 所查询字符串 在start和end之间 在 原字符串 里面出现的次数

  • ​​S.count(sub[, start[, end]]) -> int​​

    str1 = 'hello'
    print(str1.count('l'))  # 2
5. 替换内容

  • replace

  • 替换字符串中指定的内容，如果指定次数count，则替换不会超过count次

  • ​​replace(self, old, new, count)​​

    msg = '他很牛逼，他很秀，他很帅'
    msg1 = msg.replace('他', 'lucy')  # 默认全部替换
    msg2 = msg.replace('他', 'lucy', 2)  # 从左至右，替换前两个
    print(msg1)  # lucy很牛逼，lucy很秀，lucy很帅
    print(msg2)  # lucy很牛逼，lucy很秀，他很帅

  • 所要替换的字符不在字符串中也不会报错

    s1 = 'abcd'
    print(s1.replace('lucy', 'cc'))  # abcd

  • 整个过程中，实际上是创建了新的字符串，原字符串并没有改变。

6. 切割字符串

  • split

  • 可以将一个字符串切割成一个列表

  • 默认最大分割数为-1，表示无限制，可以省略；也可以自己指定最大分割数

    x = 'zhangsan-hahaha-tom-tony-lucy'
    y = x.split('-', -1)
    z = x.rsplit('-')
    print(y)  # ['zhangsan', 'hahaha', 'tom', 'tony', 'lucy']
    print(z)  # ['zhangsan', 'hahaha', 'tom', 'tony', 'lucy']
    x = 'zhangsan-hahaha-tom-tony-lucy'
    print(x.split('-', 2))  # ['zhangsan', 'hahaha', 'tom-tony-lucy']
    x = '-hahaha-tom-tony-lucy'
    y = x.split('-')

    print(y)  # ['', 'hahaha', 'tom', 'tony', 'lucy']

  • 默认按照空格、换行符、制表符分割

    s = 'my name is lucy'
    s1 = s.split()
    print(s1)  # ['my', 'name', 'is', 'lucy']

  • rsplit

  • 用法和split基本一致，只不过是从右往左分割

    x = 'zhangsan-hahaha-tom-tony-lucy'
    print(x.rsplit('-', 2))  # ['zhangsan-hahaha-tom', 'tony', 'lucy']

  • splitlines

  • 按照行分隔，返回一个包含各行作为元素的列表

    str1 = 'hello\nworld'
    print(str1.splitlines())  # ['hello', 'world']

  • partition

  • 指定一个字符串str作为分隔符，将原字符串分为三部分，str前，str，str后。这三部分组成一个元组

    print('agdaXhhXhjjs'.partition('X'))  # ('agda', 'X', 'hhXhjjs')

  • rpartition

  • 类似于partition()函数，不过是从右边开始

    print('agdaXhhXhjjs'.rpartition('X'))  # ('agdaXhh', 'X', 'hjjs')
7. 修改大小写

  • capitalize

  • 第一个单词的首字母大写

    mystr = 'hello world'
    print(mystr.capitalize()) # Hello world

  • title

  • 每个单词的首字母大写

    mystr = 'hello world'
    print(mystr.title()) # Hello World

  • lower

  • 所有都变成小写

    mystr = 'hElLo WorLD'
    print(mystr.lower()) # hello world

  • upper

  • 所有都变成大写

    mystr = 'hello world'
    print(mystr.upper())  #HELLO WORLD

  • ​​casefold()​​

  • 将字符串中的所有大写字母转换为小写字符

    s1 = 'I Love Python'
    print(s1.casefold())  # i love python

  • ​​swapcase()​​

  • 将字符串中小写转为大写，大写转为小写

    s1 = 'I Love Python'
    print(s1.swapcase())  # i lOVE pYTHON
8. 空格处理

  • ljust

  • 返回指定长度的字符串，并在右侧使用空白字符补全(左对齐)

    str = 'hello'
    print(str.ljust(10))  # hello     在右边补了五个空格

  • 如果本身长度大于指定长度，则不做任何处理

  • 可以指定填充字符，默认是空格

    print('lucy'.ljust(10, '+'))  # lucy++++++

  • rjust

  • 返回指定长度的字符串，并在左侧使用空白字符补全(右对齐)

    str = 'hello'
    print(str.rjust(10))  #      hello在左边补了五个空格

  • 可以指定填充字符，默认是空格

  • center

  • 返回指定长度的字符串，并在两端使用空白字符补全(居中对齐)

    str = 'hello'
    print(str.center(10))  #  hello   两端加空格，让内容居中

  • 可以指定填充字符，默认是空格

  • 去除前后空白，空白有：空格、\t（制表符）、\n（换行符）

  • lstrip

  • 删除字符串左边的空白字符

    mystr = '    he   llo      '
    print(str.lstrip())  #he   llo      只去掉了左边的空格，中间和右边的空格被保留

  • rstrip

  • 删除字符串右边的空白字符

    mystr = '    he   llo      '
    print(str.rstrip())  #    he   llo右边的空格被删除

  • strip

  • 删除字符串两边的空白字符

    str = '    he   llo      '
    print(str.strip())  #he   llo

  • 指定删除字符

    s = 'fgk太k白ser'
    s1 = s.strip('fkgres')  # 前后同时进行
    print(s1)  # 太k白

  • ​​expandtabs()​​

  • 把字符串中的 tab 符号(’\t’)转为空格，tab 符号(’\t’)默认的空格数是 8

    s1 = 'a\tbcd'
    print(s1)
    print(s1.expandtabs())
    print(s1.expandtabs(tabsize=4))
    print(s1.expandtabs(tabsize=0))
    # a bcd
    # a       bcd
    # a   bcd
    # abcd
9. 字符串拼接

  • join

  • ​​S.join(iterable)​​

    s = 'lucy'
    s1 = '+'.join(s)
    print(s1)  # l+u+c+y
    print('+'.join({'name': 'lucy', 'age': 18}))  # name+age

  • 作用：可以把列表或者元组快速的转变成为字符串，并且以指定的字符分隔

  • 前提：列表或者元组里面的元素必须都是 str 类型

    l1 = ['my', 'name', 'is', 'lucy']
    s1 = ' '.join(l1)
    print(s1)  # my name is lucy

  • 建议使用这种方式进行字符串拼接，效率比 str+str 高，因为 join 只创建一次字符串对象。

10. 加密解密(映射替换)

  • maketrans

    创建字符映射的转换表。

    ​​str.maketrans(intab, outtab，delchars)​​

    intab -- 字符串中要替代的字符组成的字符串。
    outtab -- 相应的映射字符的字符串。
    delchars -- 可选参数，表示字符串中的每个字符都会被映射为None

    intab和outtab都是字符串，且长度必须相等

  • translate

    根据​​maketrans()​​函数给出的转换表来转换字符串中的字符。

    注：先过滤（转为None），然后转换

in_str = 'afcxyo'
out_str = '123456'

# maketrans()生成转换表，必须使用str调用
# map_table的类型是字典
map_table = str.maketrans(in_str, out_str)

# 使用translate()进行转换
my_love = 'I love fairy'
new_my_love = my_love.translate(map_table)

print(new_my_love)  # I l6ve 21ir5
in_str = 'afcxyo'
out_str = '123456'

# maketrans()生成转换表，必须使用str调用
map_table = str.maketrans(in_str, out_str, 'yo')

# 使用translate()进行转换
my_love = 'I love fairy'
new_my_love = my_love.translate(map_table)

print(new_my_love)  # I lve 21ir
11. 字符串前补0

  • ​​zfill()​​

  • a = 3
    b = str(a).zfill(4)
    print(b)  # 0003

  • 字符串格式的数字在排序时跟我们预想的不太一样，比如11排在2前面，这样就带来了一些问题，比如合并一些用数字命名的文件时，合并文件的顺序可能就发生变化了，那么在数字前面填充0，让这些数字的长度保持一致，问题就解决了。

  • 使用场景

切片（slice）

切片：就是从字符串里复制一段指定的内容，​生成一个新的字符串​。

​​m[start:end:step]​​ 顾头不顾尾

  • step：步长。默认为1

    m = 'abcdefghigklmnopqrstuvwxyz'
    print(m[2:9])  # cdefghi

    步长不能为0，否则报错

    m = 'abcdefghigklmnopqrstuvwxyz'
    print(m[2:9:0])  # 报错

  • 步长为负数时，表示从右往左获取

    m = 'abcdefghigklmnopqrstuvwxyz'
    print(m[3:15:-1])  # 没有数据
    print(m[15:3:-1])  # ponmlkgihgfe

  • start和end如果是负数时，表示索引从右边数

    m = 'abcdefghigklmnopqrstuvwxyz'
    print(m[-9:-5])  # rstu

  • 倒序

    m = 'abcdefghigklmnopqrstuvwxyz'
    print(m[::-1])  # zyxwvutsrqponmlkgihgfedcba

  • 如果只设置了start，会“截取”到最后

    m = 'abcdefghigklmnopqrstuvwxyz'
    print(m[2:])  # cdefghigklmnopqrstuvwxyz

  • 如果只设置了end，会从头开始“截取”

    m = 'abcdefghigklmnopqrstuvwxyz'print(m[:9])  # abcdefghi

  • 如果 start 、end 不在 ​​[0, 字符串长度 - 1]​​ 这个范围内，也不会报错

    m = 'abcdefghigklmnopqrstuvwxyz'
    print(m[-100:-1])  # abcdefghigklmnopqrstuvwxy

字符串驻留机制

字符串驻留：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。

Python支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线（_）、字母和数字）会启用字符串驻留机制驻留机制。

>>> a = 'abc_123'
>>> b = 'abc_123'
>>> a is b
True
>>> c = 'abc#'
>>> d = 'abc#'
>>> c is d
False

可变字符串

在Python中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能创建新的字符串对象。但是，经常我们确实需要原地修改字符串，可以使用​​io.StringIO对象​​​或​​array模块​​，不会创建新的字符串。

>>> import io
>>> s = 'hello, Lucy'
>>> sio = io.StringIO(s)
>>> sio
<_io.StringIO object at 0x7f8bbfdd8948>
>>> sio.seek(4)
4
>>> sio.write('k')
1
>>> sio.getvalue()
'hellk, Lucy'