思维导图

字符串str - 图1

前言

请仔细阅读思维导图中的变量命名格式。有问题可以加V：qing_an_an，最后有习题赠送！
如果看不懂如下例子，那么请移步到学习：
1657106540296.jpg
注意代码详解部分出自于源码，这里都只是增加了例子，帮助理解如何运用。

代码详解

capitalize

第一个字母大写其他字符串小写

  1. a = 'qing an'
  2. print(a.capitalize())
  3. # Qing an

casefold

返回无大小写字符串

  1. b = 'Qing An'
  2. print(b.casefold())
  3. # qing an

center

此方法补全参数中的个数，例如下述例子，center(10,”-“)，如果c中字符串不足10个，则用-不全

  1. c = "QingAn"
  2. print(c.center(10,'-'))
  3. # --QingAn--

count

计数，可指定字符串在某字符串上出现的次数

  1. d = "QingAn An An"
  2. print(d.count('An'))
  3. # 3

encode

对字符串进行编码，同时也有对应的解码。编码不只一下两种！

  1. e = "我是清安"
  2. print(e.encode(encoding='utf8',errors='strict'))
  3. print(e.encode(encoding='gbk',errors='strict'))
  4. e1 = e.encode('utf8')
  5. print(e1.decode('utf8'))
  6. # b'\xe6\x88\x91\xe6\x98\xaf\xe6\xb8\x85\xe5\xae\x89'
  7. # b'\xce\xd2\xca\xc7\xc7\xe5\xb0\xb2'
  8. # 我是清安

endswith

作用巨大。判断以什么为结尾
S.endswith(suffix[, start[, end]]) -> bool
如果S以指定后缀结尾，则返回True，否则返回False。
可以选择起始以及结束的位置。
条件也可以是字符串的元组。

  1. f = "我是Qingan"
  2. # 检索是否以an字符串结尾
  3. print(f.endswith('an'))
  4. # 检索元组元素，存在f的字符串中返回True
  5. print(f.endswith(('我','n')))
  6. # 检索从下标0开始6结束的位置，是否以'是'结尾
  7. print(f.endswith('是',0,6))
  8. # 检索从下标0开始6结束的位置，是否以'g'结尾
  9. print(f[0:6].endswith('g'))
  10. # True
  11. # True
  12. # False
  13. # True

startswith

如果S以指定前缀开头，则返回True，否则返回False。可选定开始位置，结束位置，以及前缀为字符串的元组
注意startswith跟endsswith可以互相借鉴用法

  1. y = "你好,QINGAN "
  2. print(y.startswith('你'))
  3. print(y.startswith('好',1,8))
  4. print(y.startswith(',',1))
  5. print(y.startswith(('你','好'),0,9))
  6. # True
  7. # True
  8. # False
  9. # True

expandtabs

制表符都使用空格展开。如果未给出tabsize，默认tab大小为8个字符

  1. g = "我是Qing\tan"
  2. print(g.expandtabs())
  3. print(g.expandtabs(16))
  4. # 我是Qing  an
  5. # 我是Qing          an

find

如果包含子字符串返回开始的索引值，否则返回-1。 

  1. h = "我是Qingan"
  2. h1 = "an"
  3. # 查找a元素
  4. print(h.find('a'))
  5. # 查找'我'元素，从下标1开始，7结束
  6. print(h.find('我',1,7))
  7. # 在h中查找h1中的元素
  8. print(h.find(h1))
  9. # 6    -1    6

rfind

跟上述的ｆｉｎｄ类似

  1. e = "你好，清安"
  2. print(e.rfind("你",0,10))
  3. print(e.rfind("清"))

format

格式化输出，写法与print(f”{}”)无异

  1. i = "我是Qingan"
  2. i1 = 3.1415926
  3. print(f"{i}")
  4. print("{}".format(i))
  5. # 顺序位置，可以理解为按照命名空间来，先写的i，后写的i1
  6. print("{0}{1}".format(i,i1))
  7. print("{1}{0}".format(i,i1))
  8. # 保留小数
  9. print("{:.1f}".format(i1))
  10. print("{:.2f}".format(i1))

format_map

使用映射中的替换返回j的格式化版本。

  1. j = "我是{name}，考试考了{number}"
  2. j1 = {'name':'qingan','number':100}
  3. print(j.format_map(j1))
  4. # 我是qingan，考试考了100

index

索引，查找 出某个值第一个匹配项的索引位置。 如果没有则会抛出异常

  1. j = "我是Qingan,欢迎一起学习"
  2. # 查找欢迎在某一位置
  3. print(j.index('欢迎'))    # 9
  4. # 在下标0，20中查找Qingan
  5. print(j.index('Qingan',0,20))    # 2
  6. print(f.index("，"))
  7. ＃　ValueError: substring not found

rindex

跟上述ｉｎｄｅｘ类似

  1. f = "你好，清安"
  2. print(f.rindex("，"))
  3. print(f.rindex("好",0,9))
  4. ＃　2
  5. ＃　1

isalnum

str中至少有一个字符且所有字符都是字母或数字则返回 True,否则返回 False 

  1. k = "我是Qingan,欢迎一起学习"
  2. k1 = "Qingan123"
  3. k2 = "Qingan"
  4. k3 = "123456"
  5. print(k.isalnum())
  6. print(k1.isalnum())
  7. print(k2.isalnum())
  8. print(k3.isalnum())
  9. # False        True    True    True

isalpha

只能检测英文，其余都是false

  1. l = "我是Qingan,欢迎一起学习"
  2. l1= "12"
  3. l2 = "HELLOQingan"
  4. l3 = "Qingan12"
  5. print(l.isalpha())
  6. print(l1.isalpha())
  7. print(l2.isalpha())
  8. print(l3.isalpha())
  9. #False    False    True    False

isascii

判断字符串中的所有字符都是ASCII，则返回True，否则返回False。

  1. l = "我是Qingan,欢迎一起学习"
  2. l1 = "1234"
  3. l2 = "Qingan"
  4. print(l.isascii())
  5. print(l1.isascii())
  6. print(l2.isascii())
  7. # False        True        True

isdecimal

判断所有字符串中是否为十进制

  1. m = "我是Qingan,欢迎一起学习"
  2. m1 = "1234"
  3. m2 = "Qingan"
  4. print(m.isdecimal())
  5. print(m1.isdecimal())
  6. print(m2.isdecimal())
  7. #False        True        False

isdigit

判断字符串是否为都为数字

  1. n = "我是Qingan,欢迎一起学习"
  2. n1 = "1234"
  3. n2 = "Qingan1"
  4. print(n.isdigit())
  5. print(n1.isdigit())
  6. print(n2.isdigit())
  7. # False        True        False

isidentifier

判断合法标识符

  1. o = "_Qingan"
  2. o1 = "1234"
  3. o2 = "Qingan1"
  4. print(o.isidentifier())
  5. print(o1.isidentifier())
  6. print(o2.isidentifier())
  7. # True        False        True

islower

判断字符串都是小写字符串

  1. p = "Qingan"
  2. p1 = "1234"
  3. p2 = "QINGAN"
  4. p3 = "qingan"
  5. print(p.islower())
  6. print(p1.islower())
  7. print(p2.islower())
  8. print(p3.islower())
  9. # False        False        False        True

isnumeric

判断字符串是否都为数字

  1. q = "Qingan"
  2. q1 = "1234"
  3. q2 = "QINGAN"
  4. q3 = "qingan"
  5. print(q.isnumeric())
  6. print(q1.isnumeric())
  7. print(q2.isnumeric())
  8. print(q3.isnumeric())
  9. # False        True        False        False

isprintable

判断字符串可打印或为空，确切的说判断字符串是否符合规范的字符串或为空则返回True

  1. r = "Qing\ran"
  2. r1 = "12\n34"
  3. r2 = "QING AN"
  4. r3 = "qin\tgan"
  5. r4 ="  "
  6. print(r.isprintable())
  7. print(r1.isprintable())
  8. print(r2.isprintable())
  9. print(r3.isprintable())
  10. print(r4.isprintable())
  11. # False        False    True    False        True

isspace

判断字符串是都为”空白字符串”

  1. s = "Qingan"
  2. s1 = "1234"
  3. s2 = "QING AN"
  4. s3 = ""
  5. s4 = " "
  6. print(s.isspace())
  7. print(s1.isspace())
  8. print(s2.isspace())
  9. print(s3.isspace())
  10. print(s4.isspace())
  11. # False        False    False    False        True

istitle

字符串是以标题格式开头的字符串，并且至少有一个字符大写。 大写字符只能跟在无大小写字符后面，而小写字符只能跟在大小写字符后面。 

  1. t = "Qing An"
  2. t1 = "Q1234"
  3. t2 = "QING AN"
  4. t3 = "Qingan"
  5. print(t.istitle())
  6. print(t1.istitle())
  7. print(t2.istitle())
  8. print(t3.istitle())
  9. # True        True    False    True

isupper

判断字符串中是否都是大写，如果不是则判断是否有一个是大写(纯英文除外，可以是数字)

  1. u = "Qing An"
  2. u1 = "Q1234"
  3. u2 = "QING AN"
  4. u3 = "Qingan"
  5. u4 = "1234Q"
  6. print(u.isupper())
  7. print(u1.isupper())
  8. print(u2.isupper())
  9. print(u3.isupper())
  10. print(u4.isupper())
  11. # False        True    True    False    True

join

连接任意数量的字符串。调用其方法的字符串插入到每个给定字符串之间。结果将作为新字符串返回。

  1. v = " "
  2. v1 = "-"
  3. v2 = "*"
  4. v3 = "~"
  5. print(v.join('你好,QingAn'))
  6. print(v1.join(['你','好']))
  7. print(v2.join(("清","安")))
  8. print(v3.join({"name":"清安","age":"5"}))
  9. # 你 好 , Q i n g A n
  10. # 你-好
  11. # 清*安
  12. # name~age

ljust

类似于填充的作用，但是以左对齐。如果填充长度小于字符串长度，则保持原字符串

  1. w = "清安"
  2. w1 = "学习使我快乐"
  3. w2 = "学习使我快乐"
  4. print(w.ljust(10,'*'))
  5. print(w1.ljust(10,'~'))
  6. print(w2.ljust(4,"*"))
  7. ＃　清安********
  8. ＃　学习使我快乐~~~~
  9. ＃　学习使我快乐

rjust

与ｌｊｕｓｔ相反，用法类似

  1. w = "清安"
  2. w1 = "学习使我快乐"
  3. w2 = "学习使我快乐"
  4. print(w.rjust(4,"*"))
  5. print(w1.rjust(10,"~"))
  6. print(w2.rjust(4,"*"))
  7. ＃　**清安
  8. ＃　~~~~学习使我快乐
  9. ＃　学习使我快乐

lower

返回转换为小写的字符串，注意：两个字符串不是同一个字符串了

  1. x = "你好QINGAN"
  2. print(x.lower())
  3. ＃　你好qingan

upper

返回转换为大写的字符串的副本

  1. test = "my home 清安.com"
  2. print(test.upper())
  3. # MY HOME 清安.COM

strip

返回删除前导和尾随空格的字符串副本。注意：两个字符串不是同一个字符串了

  1. y = " 你好,QINGAN "
  2. y1 = "清安 你好"
  3. print(y.strip())
  4. print(y1.strip())
  5. # 你好,QINGAN
  6. # 清安 你好

lstrip

返回删除字符串前面的空格的字符串副本。注意：两个字符串不是同一个字符串了

  1. y = " 你好QINGAN"
  2. y1 = "Qing an"
  3. y2 = " "
  4. print(y.lstrip())
  5. print(y1.lstrip())
  6. print(y2.lstrip())
  7. ＃　你好QINGAN
  8. ＃　Qing an
  9. ＃

rstrip

返回删除尾随空格的字符串副本。注意：两个字符串不是同一个字符串了

  1. y = " 你好QINGAN "
  2. y1 = "Qing an "
  3. y2 = " "
  4. print(y.rstrip())
  5. print(y1.rstrip())
  6. print(y2.rstrip())

maketrans

如果只有一个参数，则它必须是映射Unicode的字典，序号（整数）或字符到Unicode序号、字符串或None。然后，字符键将转换为序数。
如果有两个参数，则它们必须是长度相等的字符串，并且在生成的字典中，x中的每个字符都将映射到字符在y中的相同位置。
如果有第三个参数，则必须是字符串，其字符将在结果中映射为“None”。

  1. z = {"a":1,"b":2,"c":3}
  2. z1 = "QingAn"
  3. z2 = "AnQing"
  4. z3 = "H"
  5. print(str.maketrans({"a":"清","b":"安","c":"安"}))
  6. print(str.maketrans(z1,z2))
  7. print(str.maketrans(z1,z2,z3))
  8. ＃　{97: '清', 98: '安', 99: '安'}
  9. ＃　{81: 65, 105: 110, 110: 103, 103: 105, 65: 110}
  10. ＃　{81: 65, 105: 110, 110: 103, 103: 105, 65: 110, 72: None}

translate

可配合maketrans使用。根据字符映射表对字符串进行删除和替换操作 。下述例子“将字母m转换为清，将字母y转换为安”

  1. y = "my"
  2. y1 = "清安"
  3. y2 = '.com'
  4. test = "my home 清安.com"
  5. t = str.maketrans(y,y1)        # 创建字符映射转换表
  6. t1 = str.maketrans(y,y1,y2)    # 创建字符映射转换表，并删除指定字符
  7. print(test.translate(t))
  8. print(test.translate(t1))
  9. # 清安 ho清e 清安.co清
  10. # 安 he 清安

上述看的模糊可以看如下：

  1. test = "my home 清安.com"
  2. t1 = str.maketrans("my",'清安')
  3. print(test.translate(t1))
  4. # 清安 ho清e 清安.co清

partition

使用给定的分隔符将字符串分成三部分。
如果找到分离器，返回一个3元组，其中包含分隔符之前的部分，即分隔符它本身和它后面的部分。
如果未找到分隔符，则返回包含原始字符串的3元组和两个空字符串。

  1. a = "清安，你好"
  2. b = "学习IT，你可以吗"
  3. print(str.partition(a,"，"))
  4. print(str.partition(b,"IT"))
  5. print(str.partition(b,"?"))
  6. ＃　('清安', '，', '你好')
  7. ＃　('学习', 'IT', '，你可以吗')
  8. ＃　('学习IT，你可以吗', '', '')

rpartition

与partition类似

  1. a = "清安，你好"
  2. b = "学习IT，你可以吗"
  3. print(str.rpartition(a,"，"))
  4. print(str.rpartition(b,"IT"))
  5. print(str.rpartition(b,"?"))
  6. # ('清安', '，', '你好')
  7. # ('学习', 'IT', '，你可以吗')
  8. # ('', '', '学习IT，你可以吗')

removeprefix

去除指定字符串前缀。此方法需要手敲
否则，返回原始字符串的副本。

  1. c = "QING"
  2. c1 = "清安"
  3. print(c.removeprefix('Q'))
  4. print(c.removeprefix('A'))
  5. print(c1.removeprefix('清'))
  6. ＃　ING
  7. ＃　QING
  8. ＃　安

removesuffix

去除指定字符串后缀。此方法需要手敲
否则，返回原始字符串的副本。

  1. c = "QING"
  2. c1 = "清安 "
  3. print(c.removesuffix('G'))
  4. print(c.removesuffix('A'))
  5. print(c1.removesuffix('清'))
  6. ＃　QIN
  7. ＃　QING
  8. ＃　安

replace

替换字符串中的某个值，如果没有，则返回原字符串的副本。

  1. d = "你好，清安"
  2. print(d.replace("你好","HELLO"))
  3. print(d.replace("好你","HELLO"))
  4. ＃　HELLO，清安
  5. ＃　你好，清安

split

默认以空格作为分隔符，可以指定分隔次数，分隔的符号。且最后返回列表

  1. y = " 你好,QING,AN "
  2. y1 = "Qing an "
  3. # 以,分隔符
  4. print(y.split(","))
  5. # 以,分隔符，分隔一次
  6. print(y.split(',',1))
  7. print(y1.split())
  8. # [' 你好', 'QING', 'AN ']
  9. #  [' 你好', 'QING,AN ']
  10. # ['Qing', 'an']

rsplit

默认以空格作为分隔符，可以指定分隔次数，分隔的符号。且最后返回列表。从右边开始
也可以用于去除两端空格

  1. y = " 你好,QING,AN "
  2. y1 = "Qing an "
  3. print(y.rsplit(","))
  4. print(y.rsplit(',',1))
  5. print(y1.rsplit())
  6. # [' 你好', 'QING', 'AN ']
  7. # [' 你好,QING', 'AN ']
  8. # ['Qing', 'an']

splitlines

可去除换行符，并返回一个列表

  1. y = "你\r好\n,QING\tAN "
  2. # str.splitlines(y) 跟 y.splitlines()一致
  3. print(str.splitlines(y))
  4. print(y.splitlines(keepends=True))
  5. # ['你', '好', ',QING\tAN ']
  6. # ['你\r', '好\n', ',QING\tAN ']

swapcase

大小写互转

  1. y = " Hellp,QINGan "
  2. print(y.swapcase())
  3. #  hELLP,qingAN

title

将字符串首字母都大写

  1. y = " hello,Qing An "
  2. y1 = "wo shi qing an"
  3. print(y.title())
  4. print(y1.title())
  5. #  Hello,Qing An 
  6. # Wo Shi Qing An

zfill

左边用零填充数字字符串，以填充给定宽度的字段。

  1. y = "清安"
  2. print(y.zfill(8))
  3. # 000000清安