从前慢现在也慢

这个屌丝很懒，什么也没留下！

热门标签

字符串相关的45个函数_串的所有函数

作者：从前慢现在也慢 | 2024-02-09 10:53:27

踩

串的所有函数

字符串相关的45个函数

capitalize: 将字符串第一位大写，其他小写

str1 = 'abcDef'
print(str1.capitalize())   # Abcdef
1
2

casefold：将字符串中的所有大写字母转换为小写字母（与lower相似）
```
str1 = 'abcDef'
print(str1.capitalize())   # Abcdef
1
2
```
center
返回一个长度为width,两边用fillchar(单字符)填充的字符串，
即字符串str居中，两边用fillchar填充。若字符串的长度大于width,则直接返回字符串str
```
str1 = 'abCDeF'
print(str1.center(20, '0'))  # 0000000abCDeF0000000
1
2
```
count
- str.count(sub, start= 0,end=len(string))
- 统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置
- sub – 搜索的子字符串
- start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
- end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
```
str1 = 'abcdefa'
print(str1.count('a'))    # 2
print(str1.count('c'))    # 1
print(str1.count('b', 3)) # 0
1
2
3
4
```
encode
- 以 encoding 指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案
encoding 参数可选，即要使用的编码，默认编码为 ‘utf-8’。
- 字符串编码常用类型有：utf-8,gb2312,cp936,gbk等。
- errors 参数可选，设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeEncodeError。
- 其它可能值有 ‘ignore’, ‘replace’, 'xmlcharrefreplace’以及通过 codecs.register_error() 注册其它的值。
```
str1 = 'abcdefa'
str2 = '我很丑'
print("utf-8编码为：", str1.encode(encoding='utf8', errors='strict'))  # b'abcdefa'
print("utf-8编码为：", str2.encode(encoding='utf8', errors='strict'))  # b'\xe6\x88\x91\xe5\xbe\x88\xe4\xb8\x91'
print("gbk编码：",str1.encode(encoding="gbk",errors="strict"))  # b'abcdefa'
print("gbk编码：",str2.encode(encoding="gbk",errors="strict"))  # b'\xce\xd2\xba\xdc\xb3\xf3'
1
2
3
4
5
6
```

endswith

str.endswith(suffix[, start[, end]])
用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。

可选参数"start"与"end"为检索字符串的开始与结束位置。

str1 = 'abcdefa'
print(str1.endswith('da'))          # False
print(str1.endswith('fa'))          # True
print(str1.endswith('cd'))          # False
print(str1.endswith('cd', 1, 4))    # False
1
2
3
4
5

expandtabs

把字符串中的 tab符号 \t 转为空格，tab符号 \t 默认的空格数是8,在第 0、8、16…等处给出制表符位置，
如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。
```
str1 = 'a\tb\tc'
print("默认TAB：", str1)                      # a b  c
print("TAB改为2个空格：", str1.expandtabs(2))  # a b c
1
2
3
```
find
- 检测字符串中是否包含子字符串 str ，
- 如果指定 beg（开始）和 end（结束）范围，则检查是否包含在指定范围内，
  如果包含子字符串返回开始的索引值，否则返回-1。
```
str1 = 'abcdefa'
print(str1.find('cd'))  # 2
print(str1.find('hh'))  # -1
1
2
3
```

format :字符串格式化函数用{}和：占位，代替以前的%

i = 20
print("i的值是：{}".format(20))    # i的值是：20
1
2

format_map
- 该方法类似于 str.format(**mapping) 都可以进行字符串格式化，
- 不同之处在于 format( ) 方法是一种所有情况都能使用的格式化方法，
- 而 str.format_map(mapping)方法仅适用于字符串格式中可变数据参数来源于字典等映射关系数据时。
  mapping 会被直接使用而不是复制到一个 dict。
- 通常和字典搭配使用
```
str1 = '{name}的月薪是{money}元'
person_dict = {'name': '小明', 'money': 10000}
print(str1.format_map(person_dict))   # 小明的月薪是10000元
1
2
3
```
index
- 检测字符串中是否包含子字符串 str ，
- 如果指定 beg（开始）和 end（结束）范围，则检查是否包含在指定范围内，
- 该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常
```
str1 = 'abcdefa'
print(str1.index('cd'))  # 2
# print(str1.index('hh'))  # ValueError: substring not found
1
2
3
```

isalnum :检测字符串是否由’字母’和’数字’组成

str1 = 'abcdefa'
str2 = 'sad2333'
str3 = 'aw13$21'
print(str1.isalnum())  # True
print(str2.isalnum())  # True
print(str3.isalnum())  # False
1
2
3
4
5
6

isalpha :检测字符串中是否只由’字母’组成

str1 = 'abcdefa'
str2 = 'adcd123'
str3 = '1215545'
print(str1.isalpha())  # True
print(str2.isalpha())  # False
print(str3.isalpha())  # False
1
2
3
4
5
6

isascii
- 检测字符串中所有字符是否都为有效的ASCII字符
- 当字符串为空或字符串中的所有字符都是 ASCII则返回 True，否则返回 False
```
str1 = 'abcdefa'
str2 = 'adc哈23'
print(str1.isascii())   # True
print(str2.isascii())   # False
1
2
3
4
```
isdecimal

检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。
注意:定义一个十进制字符串，只需要在字符串前添加 ‘u’ 前缀即可
```
str1 = '12345'
str2 = '12ab3'
print(str1.isdecimal())  # True
print(str2.isdecimal())  # False
1
2
3
4
```

isdigit :检测字符串是否只由数字组成

str1 = '12345'
str2 = '12ab3'
print(str1.isdigit())   # True
print(str2.isdigit())   # False
1
2
3
4

isidentifier：检查字符串是否是有效标识符

str1 = 'abcde'
str2 = '12abc'
print(str1.isidentifier())  # True
print(str2.isidentifier())  # False
1
2
3
4

islower: 测字符串是否由小写字母组成

str1 = 'abcde'
str2 = 'Abcde'
print(str1.islower())  # True
print(str2.islower())  # False
1
2
3
4

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

str1 = '12345'
str2 = '12ab3'
print(str1.isnumeric())     # True
print(str2.isnumeric())     # False
1
2
3
4

isprintable: 判断字符串中所有字符是否都是可打印字符或字符串为空

str1 = '12345'
str2 = ''
print(str1.isprintable())  # True
print(str2.isprintable())  # True
1
2
3
4

isspace: 检测字符串是否只由空格组成

str1 = '12345'
str2 = '     '
print(str1.isspace())      # False
print(str2.isspace())      # True
1
2
3
4

istitle: 检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写

str1 = 'Abcde12'
str2 = 'abcde12'
print(str1.istitle())  # True
print(str2.istitle())  # False
1
2
3
4

isupper: 检测字符串中所有的字母是否都为大写

str1 = 'ABCDE12'
str2 = 'AbCde12'
print(str1.isupper())  # True
print(str2.isupper())  # False
1
2
3
4

join: 用于将序列中的元素以指定的字符连接生成一个新的字符串

list1 = ['a', 'b', 'c', 'd']
print(list1)            # ['a', 'b', 'c', 'd']
print(''.join(list1))   # abcd
1
2
3

ljust:
返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。
如果指定的长度小于原字符串的长度则返回原字符串
```
str1 = 'abcd'
print(str1.ljust(10,'哈'))  # abcd哈哈哈哈哈哈
1
2
```

lower: 转换字符串中所有大写字符为小写

str1 = 'ABcd'
print(str1.lower())    # abcd
1
2

lstrip: 用于截掉字符串左边的空格或指定字符

str1 = '   saasd'
str2 = '***saasd'
print(str1.lstrip())     # saasd
print(str2.lstrip('*'))  # saasd
1
2
3
4

maketrans

str.maketrans(intab, outtab)
用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
- 注：两个字符串的长度必须相同，为一一对应的关系
- 通常与str.translate搭配使用
```
intab = 'you'
outtab = '520'
trans_tab = intab.maketrans(intab, outtab)
str1 = 'youhh'
print(str1.translate(trans_tab))    # 520hh
1
2
3
4
5
```
partition
- 用来根据指定的分隔符将字符串进行分割。
- 如果字符串包含指定的分隔符，则返回一个3元的元组，
- 第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串
```
str1 = 'www.baidu.com'
print(str1.partition('.'))  # ('www', '.', 'baidu.com')
1
2
```
replace: 把字符串中的 old（旧字符串）替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次
- str.replace(old, new[, max])
- old – 将被替换的子字符串。
- new – 新字符串，用于替换old子字符串。
- max – 可选字符串, 替换不超过 max 次
```
str1 = 'yyh is pig'
print(str1.replace('yyh', 'ly'))  # ly is pig
1
2
```

rfind: 返回字符串最后一次出现的位置，如果没有匹配项则返回 -1

str1 = 'hahabcdhaha'
print(str1.rfind('haha'))     # 7
print(str1.rfind('hahaha'))   # -1
1
2
3

rindex：返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常

str1 = 'hahabcdhaha'
print(str1.rindex('haha'))     # 7
# print(str1.rindex('hahaha'))   # 报错，ValueError: substring not found
1
2
3

rjust：返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
```
str1 = 'abcd'
print(str1.rjust(10,'*'))  # ******abcd
1
2
```
rpartition: 类似于 partition() 方法，只是该方法是从目标字符串的末尾也就是右边开始搜索分割符

如果字符串包含指定的分隔符，则返回一个3元的元组，
第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串
- str.rpartition(str)
```
str1 = 'www.baidu.com'
print(str1.rpartition('.'))     # ('www.baidu', '.', 'com')
1
2
```
rsplit
- 通过指定分隔符对字符串进行分割并返回一个列表，默认分隔符为所有空字符，
  包括空格、换行(\n)、制表符(\t)等。类似于 split() 方法，
  只不过是从字符串最后面开始分割。
```
str1 = 'yyh is pig'
print(str1.rsplit(' '))  # ['yyh', 'is', 'pig']
1
2
```

rstrip: string 字符串末尾的指定字符（默认为空格）

str1 = 'abcd   '
str2 = 'defg***'
print(str1.rsplit())        # ['abcd']
print(str2.rsplit('*'))     # ['defg', '', '', '']
1
2
3
4

split: 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串
```
str1 = 'ly is pig'
print(str1.split(' '))      # ['ly', 'is', 'pig']
1
2
```
splitlines: 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，
如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
- str.splitlines([keepends])
- keepends – 在输出结果里是否保留换行符(’\r’, ‘\r\n’, \n’)，
- 默认为 False，不包含换行符，如果为 True，则保留换行符。
```
str1 = 'ab c \nef\rgh\n'
print(str1.splitlines())        # ['ab c ', 'ef', 'gh']
print(str1.splitlines(True))    # ['ab c \n', 'ef\r', 'gh\n']
1
2
3
```
startswith:
- 用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。
- 如果参数 beg 和 end 指定值，则在指定范围内检查。
```
str1 = 'abcde'
print(str1.startswith('a'))     # True
print(str1.startswith('c', 2))  # True
print(str1.startswith('a', 1))  # False
1
2
3
4
```
strip: 用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列
```
str1 = '*abcd*'
print(str1.strip('*'))     # abcd
1
2
```

swapcase: 字符串的大小写字母进行转换

str1 = 'AbCd'
print(str1.swapcase())   # aBcD
1
2

title: 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写
```
str1 = 'my name is justin'
print(str1.title())  # My Name Is Justin
1
2
```
translate:
- 根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中
- 通常与 str.maketrans(intab, outtab)搭配使用

upper：将字符串中的小写字母转为大写字母

str1 = 'abcd'
print(str1.upper())     # ABCD
1
2

zfill: 返回指定长度的字符串，原字符串右对齐，前面填充0
```
str1 = 'abcd'
print(str1.zfill(10))   # 000000abcd
1
2
```

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/71571