Python-字符串学习笔记（完）南枝向暖北枝寒-

字符串

基本特点

字符串的本质是：字符序列。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 morning' print(k)  # good morning 

字符串拼接

• 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 = 'abctdef' 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 = 'hellonworld' 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 = 'atbcd' 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()

  • 返回指定长度的字符串，原字符串右对齐，前面填充 0

  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'