字符串 巩固

Python字符串内建函数：

注：汉字属于字符（既是大写又是小写）、数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。

1.capitalize( )：

将字符串第一个字母大写

# 使用 字符串.capitalize() 方法将字符串首字母大写
strs = 'abc'
print(strs.capitalize())
# Abc

2.center(width[,fillchar]) ：

让字符串在 width 长度居中，两边填充 fillchar 字符(默认是空格)

# center(width,fillchar)
# 使用 字符串.center() 方法，将字符串在 width 长度居中，两边补充 fillchar
strs = 'abcdefgh'
print(strs.center(20,'-'))
#------abcdefgh------

3.count(str,start=0,end=len(string))：

返回 str 在字符串从 start 到 end 范围内出现的次数(不包含end)。

# 使用 字符串.count(str) 方法，返回 str 在 字符串中出现的次数
strs = 'abcdefghabcd'
print(strs.count('c'))
#2

# 使用 字符串.count(str) 方法，返回 str 在 字符串中出现的次数
strs = 'abcdefghabcd' # a 的索引位置为 0,8
print(len(strs)) # 12
print(strs.count('a',2,8))
# 0
print(strs.count('a',2,9))
# 1

4.bytes.decode(encoding="UTF-8")：

将字节码转换为字符串

strs_bytes = b'\xe6\xac\xa2\xe8\xbf\x8e'
print(strs_bytes.decode(encoding='UTF-8'))
# 欢迎

5.encode(encoding='UTF-8')：

将字符串转换为字节码

strs = '欢迎'
print(strs.encode(encoding='UTF-8'))
# b'\xe6\xac\xa2\xe8\xbf\x8e'

6.endswith(str[,start[,end]])：

判断字符串在 start 到 end 是否以 str结尾

# 字符串.endswith(str[,start[,end]])
strs = 'ABCDEFG'
print(strs.endswith('G'))
# True
print(strs.endswith('F',0,6))
# True

7.expandtabs(tabsize = 4)：

将字符串中的 tab 符号转换为空格，tabsize 为替换的空格数

# 字符串.expandtabs(tabsize = 4)
# 将字符串中的 tab 符号转换为空格，tabsize 为替换的空格数
strs = 'ABCD    EFG'
print(strs.expandtabs(tabsize = 4))
# ABCD    EFG

8.find(str,start = 0,end = len(string))：

在 start 到 end 范围内寻找 str 元素，如果找到则返回 str 元素的索引位置，否则返回 -1。

# find(str,start = 0,end = len(string))：
# 在 start 到 end 范围内寻找 str 元素，如果找到则返回 str 元素的索引位置，否则返回 -1
strs = 'ABCDEFG' #索引位置，从 0 开始
print(strs.find('E'))
# 4
print(strs.find('K'))
# -1

9.index(str,start = 0,end = len(string))：

在 start 到 end 范围内寻找 str 元素，如果找到则返回 str 元素的索引位置，找不到则会报错。

# index(str,start = 0,end = len(string))：
# 在 start 到 end 范围内寻找 str 元素，如果找到则返回 str 元素的索引位置，找不到则返回-1。
strs = 'ABCDEFG'
print(strs.index('F'))
# 5

10.isalnum( )：

如果字符串所有字符都是 字母 或者 数字 则返回 True，否则返回 False。

# isalnum( )：
# 如果字符串所有字符都是 字母 或者 数字 则返回 True，否则返回 False。
strs = 'abcd123'
print(strs.isalnum())
# True

strs = '好的'
print(strs.isalnum())
# True

strs = 'abc_'
print(strs.isalnum())
# False

11.isalpha( )：

 

如果字符串中所有字符都是字母则返回 True，否则返回 False。

# isalpha( )：
# 如果字符串中所有字符都是字母则返回 True，否则返回 False。
strs = 'ABCD汉字'
print(strs.isalpha())
# True

strs_two = 'ABCD123'
print(strs_two.isalpha())
# False

12.isdigit( )：

如果字符串中所有字符都是数字则返回True，否则返回 False。

# isdigit( )：
# 如果字符串中所有字符都是数字则返回True，否则返回 False。
# 注: ① 也是数字
strs = '①②12'
print(strs.isdigit())
# True

strs_two = 'ABCD123'
print(strs_two.isdigit())
# False

13.islower( )：

如果字符串中所有能够区分大小写的字符都是小写的，则返回True。否则返回 False。

# islower( )：
# 如果字符串中所有字符都是小写的，则返回True。否则返回 False。
strs = 'abcd'
print(strs.islower())
# True
strs_two = 'abc123'
print(strs.islower())
# True
strs_three = 'Abcd'
print(strs_three.islower())
# False

14.isnumeric( )：

如果字符串只包含数字字符，则返回 True。否则返回 False。

# isnumeric( )：
# 如果字符串只包含数字字符，则返回 True。否则返回 False。
strs = '123456'
print(strs.isnumeric())
#True
strs_two = '½⅓123①②ⅡⅣ❶❷'
print(strs_two.isnumeric())
# True
strs_three = 'abc123A'
print(strs_three.isnumeric())
# False

15.isspace( )：

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

# isspace( )：
# 如果字符串只包含空格，则返回True。否则返回False。
strs = '    '
print(strs.isspace())
# True

strs = '    1'
print(strs.isspace())
# False

16.istitle( )：

如果所有被空格分割成的子字符串的首字母都大写，则返回 True。否则返回 False。

# istitle( )
# 如果所有被空格分割成的子字符串的首字母都大写，则返回 True。否则返回 False。
strs = 'Hello World'
print(strs.istitle())
# True
strs_two = 'Welcome to Harbin'
print(strs_two.istitle())
# False
strs_three = 'World T12'
print(strs_three.istitle())
# True

17.isupper( ) ：

如果字符串中所有能够区分大小写的字符都是大写的，则返回True。否则返回 False。

# isupper( ) ：
# 如果字符串中所有能够区分大小写的字符都是大写的，则返回True。否则返回 False。
strs = 'ABCD123汉字'
print(strs.isupper())
# True

strs_two = 'ABCabc汉字'
print(strs_two.isupper())
# False

18.join(str) ：

使用调用的字符串对 str 进行分割，返回值为字符串类型

# join(str) ：
# 使用调用的字符串对 str 进行分割。
strs = "Hello"
strs_two = ' '.join(strs)
print(strs_two)
# H e l l o
print(','.join(strs))
# H,e,l,l,o

19.len(string)：

返回字符串的长度

# len(string)：
# 返回字符串的长度

strs = 'happy'
print(len(strs))
# 5 

20.ljust(width[,fillchar])：   之前的是 center 函数，也可以进行填充。

字符串左对齐，使用 fillchar 填充 width 的剩余部分。

# ljust(width[,fillchar])：
# 字符串左对齐，使用 fillchar 填充 width 的剩余部分。
strs = 'Hello'
print(strs.ljust(20,'-'))
# Hello---------------

# fillchar 默认为空
print(strs.ljust(20))
# Hello               

21.lower( )：注：使用了  lower 函数后，原来的字符串不变。

将字符串所有能够区分大小写的字符都转换为小写字符。

# lower( )：
# 将字符串所有能够区分大小写的字符都转换为小写字符。
strs = 'Hello 123'
print(strs.lower())
# hello 123

print(type(strs.lower()))
# <class 'str'>

# 原来的字符串没有发生改变
print(strs)
# Hello 123

# 使用字符串接收 lower 函数的返回值
strs = strs.lower()
print(strs)
# hello 123

22.lstrip(str)：

将字符串最左面的 str 部分去除，输出剩余的部分(str 默认为空格)。

#lstrip( )：
# 将字符串左面的空格部分去除，输出剩余的部分。
strs = '      hello'
print(strs.lstrip())
# hello
print(strs)
#       hello

# 使用 lstrip('过滤的参数') 函数，将最左面的 a 过滤掉
strs = 'abcd'
print(strs.lstrip('a'))
# bcd

23.maketrans(参数1，参数2)：调用后，使用字符串.translate函数对字符串进行替换。

创建字符映射的转换表。

　　参数 1 是需要转换的字符

　　参数 2 是转换的目标

# maketrans(参数1，参数2)：
# 创建字符映射的转换表。
# 　　参数 1 是需要转换的字符
# 　　参数 2 是转换的目标
# 将 abcd 使用 1234 替换
keys = 'abcd'
values = '1234'
tran = str.maketrans(keys,values)
print(type(tran)) #<class 'dict'>
# 使用 字符串.translate(接收了 maketrans 函数的对象)
strs = 'abcdef'
print(strs.translate(tran))
# 1234ef

24.max(str)：

返回 str 中最大的字母，小写字母的 Unicode 编码比大写字母的 Unicode 编码大。

# max(str)：
# 返回 str 中最大的字母
strs = 'abcABC'
print(max(strs))
# c
strs = 'ABCDE'
print(max(strs))
# E

25.min(str)：

返回 str 中最小的字母，大写字母的 Unicode 编码比小写字母的 Unicode 编码小。

# min(str)：
# 返回 str 中最小的字母
strs = 'abcABC'
print(min(strs))
# A
strs = 'ABCDE'
print(min(strs))
# A

26.replace(old,new[,num])：

将旧字符串替换为新的字符串，num 为最多替换的次数。(默认为全部替换)

# replace(old,new[,num])：
# 将旧字符串替换为新的字符串，num 为替换的次数。
strs = 'abc abc abc abc'
print(strs.replace('abc','ABC'))
# ABC ABC ABC ABC

# 替换 3 次
print(strs.replace('abc','ABC',3))
# ABC ABC ABC abc

27.rfind(str,start = 0,end = len(string))：

从字符串的最右面查找 str

# rfind(str,start = 0,end = len(string))：
# 从字符串的最右面查找 str，不包含end
strs = 'happy happy' # h 的索引位置分别为 0,6
print(strs.rfind('h'))
# 6
# y 的索引位置分别为 4,10
# 在 索引位置 2 到 11 之间进行查找
print(strs.rfind('y',2,11))
# 10

28.rindex(str,start = 0,end = len(string))：

从字符串右面开始寻找 str ，返回索引值、找不到则报错。

# rindex(str,start = 0,end = len(string))：
# 从字符串右面开始寻找 str ，返回索引值
strs = 'happy happy' # a 的索引位置为 1,7
print(strs.rindex('a'))
# 7

29.rjust(width[,fillchar])：
返回一个以字符串右对齐，使用 fillchar 填充左面空余的部分的字符串

# rjust(width[,fillchar])：
# 返回一个以字符串右对齐，使用 fillchar 填充左面空余的部分的字符串
strs = 'hello'
print(strs.rjust(20))
#                hello
print(strs.rjust(20,'*'))
# ***************hello

30.rstrip(str)：

删除字符串最右面的 str 字符，str默认为空格

注：遇到不是 str 字符才停止删除

# rstrip(str)：
# 删除字符串最右面的 str 字符，str默认为空格
strs = 'hello          '
print(strs.rstrip())
# hello

strs = 'hello aaaaa'
print(strs.rstrip('a'))
# hello

31.split(str,num)：

对字符串使用 str 进行分割，如果 num有指定值，则分割 num次(默认为全部分割)

# split(str=" ",num=string.count(str))：
# 对字符串使用 str 进行分割，如果 num有指定值，则分割 num次(默认为全部分割)
strs = 'hahahah'
print(strs.split('a'))
# ['h', 'h', 'h', 'h']

# 对字符串进行切割两次
print(strs.split('a',2))
# ['h', 'h', 'hah']

32.splitlines(is_keep)：

按照 回车\r 、换行\n 对字符串进行分割。

　　is_keep ：当 is_keep 为 True 时，返回值保留换行符。

　　　　　　  当 is_keep 为 False 时，返回值不包留换行符。

# splitlines(is_keep)：
#
# 按照 回车\r 、换行\n 对字符串进行分割。
# 　　is_keep ：当 is_keep 为 True 时，返回值保留换行符。
# 　　　　　　   当 is_keep 为 False 时，返回值不包留换行符。
strs = "a\r\nb\nc"
# True则保留换行符和回车，False则不保存
print(strs.splitlines(True))
# ['a\r\n', 'b\n', 'c']
print(strs.splitlines())
# ['a', 'b', 'c']

33.startswith(str,start = 0,end = len(string))：

查看在字符串的 start 到 end-1 的区间中，是否以 str 开头。

# startswith(str,start = 0,end = len(string))：
# 查看在字符串的 start 到 end-1 的区间中，是否以 str 开头。
strs = 'hello , hey , world'
print(strs.startswith('hello'))
# True
print(strs.startswith('hey',8,13))
# True
print(strs[8:13])
# hey ,

34.strip(str)：

返回在最左端和最右端都删除 str 的字符串。

注：遇到其他字符则停止。

# strip(str)：
# 返回在最左端和最右端都删除 str 的字符串。
# 注：遇到其他字符则停止,只要是 str 进行删除、不限次数。
strs = 'ABCDEABCD'
print(strs.strip('A'))
# BCDEABCD
# 右端字符因为遇到了D,所以停止了。

strs = 'ABCDEABCDAAA'
print(strs.strip('A'))
# BCDEABCD

strs = 'ABCDEABCD'
# 如果最左和最右两端都没有 str ，则不进行删除
print(strs.strip('E'))
# ABCDEABCD

35.swapcase( )：

将能够区分大小写的字符，大小写互换。

# swapcase( )：
# 将能够区分大小写的字符，大小写互换。
strs = 'ABCDabcdefg'
print(strs.swapcase())
# abcdABCDEFG

36.title( )：

将字符串变为每一个单词都是大写字母开头，其余字母为小写或数字。

# title( )：
# 将字符串变为每一个单词都是大写字母开头，其余字母为小写或数字。
strs = 'hello  world  abc123'
print(strs.title())
# Hello  World  Abc123

37.translate(字典 或 接收了字符串.maketrans(被替换元素,替换元素)的对象)：

将字符串按照参数进行转换

# translate(字典 或 接收了字符串.maketrans(被替换元素,替换元素)的对象)：
# 将字符串按照参数进行转换
keys = 'abcd'
values = '1234'
tran = str.maketrans(keys,values)
print(type(tran)) #<class 'dict'>
# 使用 字符串.translate(接收了 maketrans 函数的对象)
strs = 'abcdef'
print(strs.translate(tran))
# 1234ef

38.upper( )：

将所有能够区分大小写的字符都转换为大写

# upper()：
# 将所有能够区分大小写的字符都转换为大写
strs = 'hello World'
print(strs.upper())
# HELLO WORLD

39.zfill(width)：

返回长度为 width 的字符串，在左端填充 0

# zfill(width)：
# 返回长度为 width 的字符串，在左端填充 0
strs = 'hello'
print(strs.zfill(10))
# 00000hello

40.isdecimal( )：

字符串是否只包含十进制数，其余进制都返回False。

# isdecimal( )：
# 字符串是否只包含十进制数
# 二进制
strs_bin = '0b11'
print(strs_bin.isdecimal())
# False
# 八进制
strs_oct = '0o56'
print(strs_oct.isdecimal())
# 十六进制
strs_hex = '0xa4'
print(strs_hex.isdecimal())
# False
strs_int = '123'
print(strs_int.isdecimal())
# True