Python学习之str 以及常用的命令

目录

• str 字符串
• str 里有一些常用的命令
• 1、capitalize
• 2、casefold和lower
• 3、center
• 4、count
• 5、endswith和startswith
• 6、expandtabs
• 7、find
• 8、format
• 9、format_map
• 10、isalnum
• 11、isalpha
• 12、isdecimal、isdigit、isnumeric
• 13、isidentifier
• 14、islower、lower、isupper、upper
• 15、isprintable
• 16、isspace
• 17、istitle、title
• 18、join
• 19、ljus、rjust、center、zfill
• 20、lstrip 、rstrip、strip
• 21、translate、maketrans
• 22、partition、rpartition、split、rsplit、splitlines() 、splitlines(True) 、splitlines(Fales)
• 23、swapcase
• 24、replace
• 总结

str 字符串

例如：

name = "adam"
name1 = "周大福"

命令语句的条件参数配置格式

center(self,width,fillchar= None)

self:可以直接忽略

width:必须有参数

fillchar= None:可以不用单独设置参数

凡有参数 = None的 都可以理解为 可以不用单独设置此参数

str 里有一些常用的命令

1、capitalize

首字母大写

name = "adam"
v = name.capitalize()	#name内的字符串首字母大写
print(type(v),v)

2、casefold和lower

所有变小写

name = "aDam"
v = name.casefold()	#name内的字符串变成小写（它可以处理不同的语种内的字母大小写）
print(type(v),v)
name = "aDam"
v2 = name.lower()	#name内的字符串变成小写（它只能处理英文）
print(type(v2),v2)

3、center

设置字符串长度并将内容剧中，空白位置进行填充并且何可设置填充的符号默认填充空格

name = "adam"
v = name.center(25,"+")		#在name赋值的字符串的前后各增加加号 ，使得整体字符串占一共有8个字符之前name的赋值字符串剧中，并且赋值给v
print(type(v),v)

4、count

寻找字符串中的子序列或字符出现的次数，并可以设置起始的寻找位数

name = "adam"
v = name.count('a',2,4) #计算a在name赋值的字符串内 出现过多少次,不写（，2，4）的话默认是冲头到位找，写了就是从地2到4位寻找
print (v)

5、endswith和startswith

endswith 判断结尾的字符是什么 可以设置 起始位置

startswith 判断开头的字符是什么 可以设置 起始位置 注意设置的开始位置要前移一个单位

name = "adam"
v = name.endswith('d',1,2) #判断 name赋值的字符串 从第一个字符到第二个字符结束 结尾的字母是不是d
v1 = name.startswith('a',0,2)#判断name赋值的字符串，从第0位到第2位 是不是以 字母a开头
print (v)
print (v1)

6、expandtabs

将\t 前面字符位数用空格补至x位 ，如\t 前字符位数等于x 则 直接用x个空格替换\t 如\t前字符位数大于x 则在前面字符最末尾补x余数个空格(输出结果不再显示\t)

test = '12345\t6789'
v = test.expandtabs(8)
v1 = test.expandtabs(3)
v2 = test.expandtabs(5)
print(v)
print(v1)
print(v2)
#应用实例：
test = '姓名\t性别\t身高\n张三\t男\t180\n张三\t男\t180\n张三\t男\t180'
v = test.expandtabs(10)
print(v)

7、find

从头往后找到第一个子序列获取其前面有多少个字符,也可以规定寻找范围，设定的搜索范围逻辑关系位 起始位数 <= 被搜索范围 <结束位置。

name = "adamadamadam"	#创建变量name并赋值adamadamadam
v = name.find('ma',6,9) 	#设定搜索ma子序列从6到8位
print (v)	#显示v的值
#结果为：7

PS：当find找不到目标子序列的时候会赋值位-1而另一个寻找命令index在找不到目标子序列时会直接程序报错，所以推荐使用find命令

8、format

格式化，将一个字符串中的占位符替换为指定的值“大括号内的就是占位符”

name = "adam"	#创建变量name并赋值为adam
xingBie = "男"	#创建变量xingBie并赋值为"男"
xianShi = "I am {name1},{xingBie1}" 	#创建变量xianShi并赋值为"I am {name1},{xingBie1}"
print(xianShi)	#显示xianShi
#结果：I am {name1},{xingBie1}
v = xianShi.format(name1 = name ,xingBie1 = xingBie) #使用变量name和xingBie替换xianShi变量中的name1和xingBie1，并且赋值给v
print(v)	#显示v
#结果：I am adam,男

format的另一种书写格式，可以使用数字占位，并且在赋值的时候程序会默认依次对数字赋值，创建占位符号时需要从0开始使用数字占位

name = "adam"	#创建变量name并赋值为adam
xingBie = "男"	#创建变量xingBie并赋值为"男"
xianShi = "I am {0},{1}" #创建变量xianShi并赋值为"I am {0},{1}"
print(xianShi)	#显示xianShi
#结果：I am {0},{1}
v1 = xianShi.format(name ,xingBie) #使用变量name 和 xingBie的值替换xianShi中的 0 和 1的值，并且赋值给v1
print(v1) #显示v1
#结果：I am adam,男

9、format_map

（字典）。。。。。

name = "adam"	#创建变量name并赋值为adam
xingBie = "男"	#创建变量xingBie并赋值为"男"
xianShi = "I am {name1},{xingBie1}" 	#创建变量xianShi并赋值为"I am {name1},{xingBie1}"
print(xianShi)	#显示xianShi
v = xianShi.format(name1 = name ,xingBie1 = xingBie) #使用变量name和xingBie替换xianShi变量中的name1和xingBie1，并且赋值给v
print(v)	#显示v
#结果：I am adam,男
v1 = xianShi.format_map({'name1':name,'xingBie1':xingBie})	#使用format_map的格式给v1赋值
print(v1)	#显示v1
#结果：I am adam,男

10、isalnum

判断字符串中是否只有字母 或 数字，输出布尔值

name = 'adam123'   #给变量name赋值adam
name1 = 'adam+'   #给name1赋值adam+
name2 = 'adam'
name3 = '123'
v = name.isalnum()   #判断name中是否只含有字母或数字，并把布尔值赋值给v
v1 = name1.isalnum()    #判断name1中是否只含有字母或数字，并把布尔值赋值给v1
v2 = name2.isalnum()
v3 = name3.isalnum()
print(v)
print(v1)
print(v2)
print(v3)

11、isalpha

判断字符串中是否只含有字母 或 汉字，输出布尔值

name = 'adam123'   #给变量name赋值adam123
name1 = 'adam+'   #给name1赋值adam+
name2 = 'adam'   #给name2赋值adam
name3 = '张三'    #给name3赋值张三
v = name.isalpha()
v1 = name1.isalpha()
v2 = name2.isalpha()
v3 = name3.isalpha()
print(v)
print(v1)
print(v2)
print(v3)

12、isdecimal、isdigit、isnumeric

他们时用来判断字符串是否只是数字输出布尔值

isdecimal ：只能判断阿拉伯数字为 真 （推荐用这个比较准）

isdigit：阿拉伯数字和符号数“123和③” 为真

isnumeric：阿拉伯数字、符号数字、罗马数字、汉字数，均为真“123、③、Ⅲ、四”

test1 =  '123'  #赋值
test2 = '1a'    #这个也可以是16进制数
test3 = '②'    #符号数字 ②
test4 = 'Ⅲ' #罗马数字3,这是一个字符
test5 = '四'    #汉字数字四
vecimal1 = test1.isdecimal()    #判断字符串是否为数字
vecimal2 = test2.isdecimal()
vecimal3 = test3.isdecimal()
vecimal4 = test4.isdecimal()
vecimal5 = test5.isdecimal()
vigit1 = test1.isdigit()    #判断字符串是否为数字
vigit2 = test2.isdigit()
vigit3 = test3.isdigit()
vigit4 = test4.isdigit()
vigit5 = test5.isdigit()
vnumeric1 = test1.isnumeric()
vnumeric2 = test2.isnumeric()
vnumeric3 = test3.isnumeric()
vnumeric4 = test4.isnumeric()
vnumeric5 = test5.isnumeric()
print(vecimal1, vecimal2, vecimal3, vecimal4, vecimal5)  #打印isdecimal判断的结果
print(vigit1, vigit2, vigit3, vigit4, vigit5)  #打印isdigit判断的结果
print(vnumeric1, vnumeric2, vnumeric3, vnumeric4, vnumeric5)

13、isidentifier

测试字符串是不是以 字母数字下划线组成并且不以字母或下划线开头

PS:这个命令不会因为 字符串是python的关键字 就判断为假

print( "if".isidentifier() )
print( "def".isidentifier() )
print( "class".isidentifier() )
print( "_a".isidentifier() )
print( "中国123a".isidentifier() )
print( "123".isidentifier() )
print( "3a".isidentifier() )
print( "".isidentifier() )

14、islower、lower、isupper、upper

islower 判断字符串是否全部为小写

lower 把字符串内所有字符所有字符变成小写

isupper 判断字符串是否全部为大写

upper 把字符串内所有字符所有字符变成大写

name = 'Adam'
name1 = 'ADAM'
name2 = 'adaM'
name3 = 'aDam'
v = name.islower()
v1 = name1.islower()
v2 = name2.islower()
v3 = name3.islower()
print('Adam',v,'ADAM',v1,'adaM',v2,'aDam',v3)
x = name.lower()
x1 = name1.lower()
x2 = name2.lower()
x3 = name3.lower()
print('Adam',x,'ADAM',x1,'adaM',x2,'aDam',x3)
n = name.isupper()
n1 = name1.isupper()
n2 = name2.isupper()
n3 = name3.isupper()
print('Adam',n,'ADAM',n1,'adaM',n2,'aDam',n3)
k = name.upper()
k1 = name1.upper()
k2 = name2.upper()
k3 = name3.upper()
print('Adam',k,'ADAM',k1,'adaM',k2,'aDam',k3)

15、isprintable

判断字符串中是否含有不可见或不可打印的 字符比如 \n \t 等

print('\tabc'.isprintable())
print('abc\n'.isprintable())
print('\tabc\n'.isprintable())
print('abc'.isprintable())

16、isspace

判断字符串是否全部都是空格

test = '  '
test1 = '  a'
test2 = ' a '
test3 = ''
v = test.isspace()
v1 = test1.isspace()
v2 = test2.isspace()
v3 = test3.isspace()
print(v,v1,v2,v3)    #True False False False

17、istitle、title

istitle 判断是否为标题（所有单词首字母均为大写）

title 将字符串转换成标题也就是把所有字母的 首字母转换成大写

test = 'wo shi zhang san , wo ba sui le '
v = test.istitle()
print(v)    #False
v1 = test.title()
print(v1)    #Wo Shi Zhang San , Wo Ba Sui Le
v2 = v1.istitle()
print(v2)    #True

18、join

在字符与字符 中间加上 设置好的间隔符当变量值中只有一个字符的时候则什么都不做，可以设置添加的符号

test = '我是张三，我八岁了'
test1 = '我'
print(test) #我是张三，我八岁了
x = ' '
v = x.join(test)
print(v)    #我 是 张 三 ， 我 八 岁 了
v1 = x.join(test1)
print(v1)    #我

19、ljus、rjust、center、zfill

ljust 字符串靠左对齐 不够位数的用设置的字符补齐

rjust 字符串靠右对齐 不够位数的用设置的字符补齐

center 字符串剧中对齐 不够位数的用设置的字符补齐，如果只需要补1个字符，则补在字符串左侧

zfill 只能在字符串左侧填充0

name = 'adam'
v = name.ljust(6,'*') #文字左对齐 不至6位用*补位
v1 = name.rjust(6,'*') #文字右对齐 不至6位用*补位
v2 = name.center(6,'*')  #文字剧中 不至6位用*补位
v3 = name.zfill(6)    #文字右对齐 不至6位用*补位
print(v,v1,v2,v3)  #adam** **adam *adam* 00adam

20、lstrip 、rstrip、strip

lstrip 从左向右匹配删除空格，直到遇到不匹配的那个字符

rstrip 从右向左匹配删除空格，直到遇到不匹配的那个字符

strip 去掉两侧的空格

PS：他们还可以去掉 /t /n这样的功能符（默认下），还可以指定去掉任意字符，匹配原则是 优先最多匹配原则

name = ' ad am '
v = name.lstrip()     #去掉左侧的空格直到遇到其他字符
v1 = name.rstrip()    #去掉右侧的空格直到遇到其他字符
v2 = name.strip()     #去掉两侧的空格直到遇到其他字符
print(v)    #ad am
print(v1)   # ad am
print(v2)   #ad am

21、translate、maketrans

translate：执行映射转换

maketrans：创建映射转换关系，先写入原字符表，再写入要转换成的字符表，也可以再定义一个需要删除的字符表

yuanZiFu = 'abcde'	#定义原始匹配字符
bianGengZiFu = '12345'	#定义匹配后变更的字符
shanChuZiFu = 'fghij'  #定义原始匹配删除的字符
zhuanHuanBiao = str.maketrans(yuanZiFu,bianGengZiFu)	#创建字符映射转换表（匹配yuanZiFu转换成bianGengZiFu）
zhuanHuanShanChuBiao = str.maketrans(yuanZiFu,bianGengZiFu,shanChuZiFu)	#创建字符映射转换删除表（匹配yuanZiFu转换成bianGengZiFu删除shanChuZiFu）
yuanShiZiFuChuan = 'a1b2c3d4e5fagbhcidje' 	#创建原始字符串
print(yuanShiZiFuChuan.translate(zhuanHuanBiao))    #1122334455f1g2h3i4j5
print(yuanShiZiFuChuan.translate(zhuanHuanShanChuBiao))    #112233445512345

22、partition、rpartition、split、rsplit、splitlines() 、splitlines(True) 、splitlines(Fales)

partition 把字符串分割为3份 从字符串的左侧向右寻找 设置的分隔符号 进行分割，分割符号会被单独分割成中间的那部分

rpartition 把字符串分割为3份 从字符串的右侧向左寻找 设置的分隔符号 进行分割，分割符号会被单独分割成中间的那部分

ps partition和rpartition需要设置分割符

split 可以指定分割的块数 左侧向右寻找分割符号 默认是匹配的所有分割符号 全部都进行分割 且分割符号并不会出现在结果中

rsplit 可以指定分割的块数 右侧向左寻找分割符号 默认是匹配的所有分割符号 全部都进行分割 且分割符号并不会出现在结果中

ps：分割符默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

splitlines() 默认根据换行符号\n 进行分割 且不会保留换行符号

splitlines(True) 根据换行符号\n 进行分割 且保留换行符号 换行符号出现在被分割模块的右侧splitlines(Fales) 根据换行符号\n 进行分割 且不会保留换行符号

x1 = '123\n45\t123\n45\t123\n45\t123\n45'
print(x1.partition('5'))    #('123\n4', '5', '\t123\n45\t123\n45\t123\n45')
print(x1.rpartition('5'))   #('123\n45\t123\n45\t123\n45\t123\n4', '5', '')
print(x1.split('\n',3))   #['123', '45\t123', '45\t123', '45\t123\n45']
print(x1.rsplit('\t',2))  #['123\n45\t123\n45', '123\n45', '123\n45']
print(x1.splitlines())  #['123', '45\t123', '45\t123', '45\t123', '45']
print(x1.splitlines(True))  #['123\n', '45\t123\n', '45\t123\n', '45\t123\n', '45']
print(x1.splitlines(False)) #['123', '45\t123', '45\t123', '45\t123', '45']

23、swapcase

大小写转换 ,把字符串里面的大小写全部转换

name = 'Adam'
v = name.swapcase()
print(v)    #aDAM

24、replace

替换，从左往右寻找匹配的子序列，然后全部进行替换，可以设定替换几个，（"原变量中的子序列","替换后的子序列"，替换几个子序列）

name = 'adamadamadam'
v = name.replace('da','yyy')
print(v)    #ayyymayyymayyym

PS：匹配原则最长公共子序列 两个或多个字符串内 最长的相同的子序列

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我们的更多内容！