Python字符串操作、函数整理

字符串操作整理

字符串操作

• + 字符串连接操作
• * 字符串复制操作
• [] 字符串索引操作，通过索引访问指定位置的字符，索引从0开始
• [::] 字符串取片操作
• 完整格式：[开始索引:结束索引:间隔值]
• [:结束索引] 从开头截取到结束索引之前
• [开始索引:] 从开始索引截取到字符串的最后
• [开始索引：结束索引] 从开始索引截取到结束索引之前
• [:] 截取所有字符串
• [开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取字符
• r'字符串' 元字符串，所有字符串中的转义字符不会转义，当作普通字符

var1 = '012345678'
var2 = 'abcdefghi'
#字符串连接操作
print(var1)
print(var1 + var2)
复制代码

012345678
012345678abcdefghi
复制代码

#字符串复制操作
print(var1)
print(var1 * 3)
复制代码

012345678
012345678012345678012345678
复制代码

#索引操作
print(var1)
print(var1[0])
print(var1[-1])
复制代码

012345678
0
8
复制代码

# [::] 字符串取片操作
print(var1)
print(var1[0:3])#输出0,1,2位置的字符，包含前面不包含后面
复制代码

012345678
012
复制代码

# 完整格式：[开始索引:结束索引:间隔值]
print(var1)
print(var1[0:6:2])
print(var1[0::2])
复制代码

012345678
024
02468
复制代码

#  [:结束索引]  从开头截取到结束索引之前
print(var1)
print(var1[:4])#
复制代码

012345678
0123
复制代码

#  [开始索引:]  从开始索引截取到字符串的最后
print(var1)
print(var1[-1:])
复制代码

012345678
8
复制代码

# [开始索引：结束索引]  从开始索引截取到结束索引之前
print(var1)
print(var1[1:4])
复制代码

012345678
123
复制代码

#  [:]  截取所有字符串
print(var1)
print(var1[:])
复制代码

012345678
012345678
复制代码

# r'字符串'   元字符串，所有字符串中的转义字符不会转义，当作普通字符
var2 = r'这是\n第一个\'字符\"串'
print(var2)
复制代码

这是\n第一个\'字符\"串
复制代码

var1 = '012345678'
print('var1:'.ljust(15,' '),var1)
print('var1[::-1]:'.ljust(15,' '),var1[::-1])#倒序输出，步长决定间隔，步长为1，取出数据下标差为1，步长为-1，取出下标差为-1的数
print('var1[-1:2:-1]:'.ljust(15,' '),var1[-1:2:-1])#从-1位置向前数到2位置，但不包含2位置的数
print('var1[1:4:-1]:'.ljust(15,' '),var1[1:4:-1])#从1位置向前数到4位置，无法数到4位置，所以为空字符串
print('var1[1:1]:'.ljust(15,' '),var1[1:1])#空字符串
print('var1[:2:-1]:'.ljust(15,' '),var1[:2:-1])#从最后位置向前数到2位置，但不包含2位置的数
print('var1[3::-1]:'.ljust(15,' '),var1[3::-1])#从3位置向前数到开头的位置
复制代码

var1:           012345678
var1[::-1]:     876543210
var1[-1:2:-1]:  876543
var1[1:4:-1]:   
var1[1:1]:      
var1[:2:-1]:    876543
var1[3::-1]:    3210
复制代码

字符串函数

• var1 = 'Hello World'
• var.capitalize() 首字母大写,其他字母变小写，返回处理后的字符串，原字符串不变 Hello world，如果首字母是*、空格等字符，则将其他字符至为小写
• var.title() 每个单词首字母大写，其余字母变小写，原字符串不变 Hello World,如果首字母是*、空格等字符,依然将首个字母大写 *Hello World
• var.upper() 所有字母转换成大写,没有参数，返回处理后的字符串，原字符串不变 HELLO WORLD
• var.lower() 所有字母转换为小写,没有参数，返回处理后的字符串，原字符串不变 hello world
• var.swapcase() 大写转换为小写，小写转换为大写,没有参数，返回处理后的字符串，原字符串不变 HELLO WORLD
• len(var) 计算容器长度，参数为要求长度（元素个数）的（字符串、列表、元组、集合【会去除重复数据】、字典），返回整数值
• var = 'efefefe'
• var.count('efe',0,-1) = 1计算指定字符串出现的次数，字符串.count(查找字符串[,开始索引[,结束索引]])，严格区分大小写,包含开头不包含结尾
• var.find('lo',3,7) 查找某个字符串在字符串指定范围中第一次出现的位置，找不到返回-1，指定范围找到位置仍是在原字符串中的位置
• var.index('lo',3,7)与find功能相同，找不到时报错

var1 = ' Hello World'
# capitalize()  首字母大写
print(var1.capitalize())
print(var1)
复制代码

 hello world
 Hello World
复制代码

# title()     每个单词首字母大写
var1 = ' *hello worlD'
print(var1.title())
print(var1)
复制代码

 *Hello World
 *hello worlD
复制代码

# upper()     所有字母转换成大写
var1 = ' *hello worlD'
print(var1.upper())
print(var1)
复制代码

 *HELLO WORLD
 *hello worlD
复制代码

# lower()     所有字母转换为小写
var1 = ' *hello worlD'
print(var1)
print(var1.lower())
print(var1)
复制代码

 *hello worlD
 *hello world
 *hello worlD
复制代码

# swapcase()   大写转换为小写，小写转换为大写
var1 = ' *hello worlD'
print(var1)
print(var1.swapcase())
print(var1)
复制代码

 *hello worlD
 *HELLO WORLd
 *hello worlD
复制代码

# len()       计算容器长度
var1 = ' *hello worlD'
print(var1)
print(len(var1),type(len(var1)))
print(var1)
print('列表:',len([1,2,3,4,2]))
print('元组:',len((1,2,3,4,2)))
print('集合:',len({1,2,3,4,2}))#集合会去除重复数据
print('字典:',len({1:2,3:4}))
复制代码

 *hello worlD
13 <class 'int'>
 *hello worlD
列表: 5
元组: 5
集合: 4
字典: 2
复制代码

# count()     计算字符串中某个自符的个数
var1 = 'hello worlD'
print(var1)
print(var1.count('l'))
print(var1[2:7])
print(var1.count(' ',2,7))#查找指定范围内的指定字符的个数
print(var1.count('l',2,7))#查找指定范围内的指定字符的个数
var = 'efefefe'
print(var.count('efe',0,-1)) 
复制代码

hello worlD
3
llo w
1
2
1
复制代码

# find()      查找某个字符在字符串指定范围中第一次出现的位置，找不到返回-1
var1 = 'hello worlD'
print(var1)
print(var1.find('lo'))#找lo第一次出现的位置
print(var1.find('L'))#严格区分大小写
print(var1[3:7])#
print(var1.find('l',3,7))#查找指定范围内的指定字符的第一次出现的位置
#该位置是在原字符串中的位置
复制代码

hello worlD
3
-1
lo w
3
复制代码

# index()     与find功能相同，找不到时报错
print(var1)
print(var1.index('l'))
print(var1[3:7])#
print(var1.index('l',3,7))#查找指定范围内的指定字符的第一次出现的位置
#该位置是在原字符串中的位置
print(var1.index('d',3,7))
复制代码

hello world
2
lo w
3



---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-54-5b7535a7e914> in <module>()
      5 print(var1.index('l',3,7))#查找指定范围内的指定字符的第一次出现的位置
      6 #该位置是在原字符串中的位置
----> 7 print(var1.index('d',3,7))


ValueError: substring not found
复制代码

检测类函数返回布尔型

• var.satrtswith('He') 检测字符串是否以某个字符串开头的，区分大小写
• var.endswith('ld') 检测字符串是否以某个字符串结尾的，区分大小写
• var.isupper() 检测字符串是否全部大写
• var.islower() 检测字符串是否全部小写
• var.istitle() 检测字符串是否符合title格式,符合的格式（'Hello World'，' Hello World'，'*Hello World','Hello&World'）
• var.isalnum() 检测是否由数字、字符（包含文字字母，不包含空格等字符）
• var.isalpha() 检测字符串是否以字符（包含汉字、字母组成，不包含空格等字符）
• var.isdigit() 检测字符串是否以10进制数字组成
• var.isnumeric() 检测字符串是否以数字组成
• var.isdecimal() 检测字符串是否以数字组成
• var.isspace() 检测字符串是否以空格组成 #tab也会认为是空格，是否和系统有关？

# satrtswith()  检测字符串是否以某个字符串开头的,严格区分大小写
print(var1.startswith('hel'))
print(var1.startswith('Hel'))
复制代码

True
False
复制代码

# endswith()   检测字符串是否以某个字符串结尾的
print(var1)
print(var1.endswith('rld'))
print(var1.endswith('rlD'))
复制代码

hello world
True
False
复制代码

# isupper()    检测字符串是否全部大写
print(var1.isupper())
复制代码

False
复制代码

# islower()    检测字符串是否全部小写
print(var1.islower())
复制代码

True
复制代码

# istitle()    检测字符串是否符合title格式
var1 = 'HelloWorld'
print(var1.istitle())
var1 = 'Hello World'
print(var1.istitle())
var1 = '*Hello World'
print(var1.istitle())
var1 = 'Hello*World'
print(var1.istitle())
var1 = 'Hello&World'
print(var1.istitle())
复制代码

False
True
True
True
True
复制代码

# isalnum()    检测是否由数字、字符（包含文字字母）,空格不算字母，只是字符
var1 = 'Hello World'
print(var1)
print(var1.isalnum())
print('helloworld'.isalnum())
复制代码

Hello World
False
True
复制代码

# isalpha()    检测字符串是否以字符（包含汉字、字母组成）
print(var1)
print(var1.isalpha())
print('helloworld'.isalpha())
复制代码

Hello World
False
True
复制代码

# isdigit()    检测字符串是否以10进制数字组成
var1 = '3215 436'
print(var1)
print(var1.isdigit())
print('010232'.isdigit())
复制代码

3215 436
False
True
复制代码

# isnumeric()   检测字符串是否以数字组成
print(var1)
print(var1.isnumeric())
print('132432543'.isnumeric())
复制代码

hello world
False
True
复制代码

# isdecimal()  检测字符串是否以数字组成
print(var1)
print(var1.isdecimal())
print('132432543'.isdecimal())
复制代码

hello world
False
True
复制代码

# isspace()   检测字符串是否以空格组成
print(var1)
print(var1.isspace())
print('     '.isspace())#tab也会认为是空格，是否和系统有关？
复制代码

hello world
False
True
复制代码

字符串分割、填充

• var = ' hello,world '
• var.split(',w') 将字符串进行切割操作,返回列表
• var.splitlines(True\False) 按照指定字符（回车\r,\n,\r\n "三引号中的换行"）将字符串进行切割操作,True保留切割的字符
• 将容器中的字符串使用指定的字符进行连接成一个字符串，（字符串、列表、元组、集合、字典）都可以使用，字典保留key
• var.join(var2、list、tuple、dict)，只有一个参数
• var.zfill(10) 0填充函数 125 -—》0000000125 ,参数只有一个，填充后的长度
• var.center(10,'@') 使用指定的字符将字符串填充至指定的长度，原字符串居中显示，奇数个字符前面短后面长,参数只能是单个字符，空字符多字符都报错
• var.ljust(10,'@') 使用指定字符将字符串填充至指定的长度，元数据左对齐,
• var.rjust(10,'@') 使用指定字符将字符串填充至指定长度，元数据右对齐
• var.strip('ab') 去掉左右两侧的指定的字符串，不指定字符串删除空格，参数为'ab'，则会去除a和b，没有顺序
• var.lstrip('ab') 去掉左侧指定的连续的字符，不指定字符删除空格，同上
• var.rstrip('ab') 去掉右侧指定的连续的字符，不指定删除空格，同上
• var.maketrans() 指定字典
• var.translate() 替换操作
• 使用指定字符串替换指定的字符串中的字符串，1：old、2：new、3：替换的数量0不替换>0替换指定数量的从前向后替换<0所有的
• var.replace('ll','LL',2)
• var = 'abc***abc'
• zd = str().maketrans('abc*','def0') #创建字典
• result = var.translate(zd) #使用字典替换 #不改变原来的字符串

var1 = '   hello,world   '
# split()     将字符串进行切割操作
print(var1)
print(var1.split(',w',True))
print(var1)
复制代码

   hello,world   
['   hello', 'orld   ']
   hello,world   
复制代码

var1 = '   he\rl\r\nlo\nworld   '
var2 = '''   he\rl\r\nlo\nwor
ld   '''
# splitlines()  按照指定字符（回车\r,\n,\r\n "三引号中的换行"）将字符串进行切割操作，返回列表
print(var1)
print(var1.splitlines())
print(var1.splitlines(True))#保留\n

print('var2:')
print(var2)
print(var2.splitlines())
print(var2.splitlines(True))#保留\n
复制代码

l
lo
world   
['   he', 'l', 'lo', 'world   ']
['   he\r', 'l\r\n', 'lo\n', 'world   ']
var2:
l
lo
wor
ld   
['   he', 'l', 'lo', 'wor', 'ld   ']
['   he\r', 'l\r\n', 'lo\n', 'wor\n', 'ld   ']
复制代码

# join()      将容器中的字符串使用指定的字符进行连接成一个字符串
var1 = '*'
var2 = ['a','b','c','d','e']
# split()     将字符串进行切割操作
print(var1)
print(var1.join(var2))
var2 = {'a','b','c','d','e'} 
print(var1.join(var2))      #集合每次都不一样
var2 = {'a':'b','c':'d'}    #字典保留key
print(var1.join(var2))      
var2 = ['a','b','c','d','e']
print(''.join(var2))#使用空字符串连接
print(str().join(var2))#str()返回空字符串
var2 = 'abcde'
print(var1.join(var2))
print(var1)
复制代码

*
a*b*c*d*e
d*a*c*b*e
a*c
abcde
abcde
*
复制代码

# zfill()     0填充函数 125 -—》0000000125
var1 = '*'
print(var1.zfill(10))
print(var1)
复制代码

000000000*
*
复制代码

# center()    使用指定的字符将字符串填充至指定的长度，原字符串居中显示，奇数个字符前面短后面长
var1 = '*'
print(var1.center(10,'a'))
print(var1)
复制代码

aaaa*aaaaa
*
复制代码

# ljust()     使用指定字符串填充至指定的长度，元数据左对齐
var1 = 'a'
print(var1.ljust(10,'*'))#第二个参数只能是一个字符
print(var1)
复制代码

a*********
a
复制代码

# rjust()     使用指定字符串填充至指定长度，元数据右对齐
var1 = 'a'
print(var1.rjust(10,'*'))
print(var1)
复制代码

*********a
a
复制代码

# strip()     去掉左右两侧的指定的字符串，不指定字符串删除空格,也不影响原字符串
var1 = '***a***'
print(var1.strip())
print(var1)
var1 = 'efefefafefefe'
print(var1.strip('ef'))
print(var1)
复制代码

***a***
***a***
a
efefefafefefe
复制代码

# lstrip()    去掉左侧指定的连续的字符，不指定字符删除空格
var1 = 'efefefa***'
print(var1.lstrip('ef'))
print(var1)

var1 = 'efefefa***'
print(var1.lstrip('fe'))#容器中的字符全部会找到并删除
print(var1)
复制代码

a***
efefefa***
a***
efefefa***
复制代码

# rstrip()    去掉右侧指定的连续的字符，不指定删除空格
var1 = 'efefa***efdef'
print(var1.rstrip('fe'))#容器中的字符全部会找到并删除
print(var1)
复制代码

efefa***efd
efefa***efdef
复制代码

# maketrans()  指定字典
# translate()  替换操作
var = 'abc***abc'
zd = str().maketrans('abc*','def0')
result = var.translate(zd)
print(result)
复制代码

def000def
复制代码

转载于:https://juejin.im/post/5a2d00de51882560e3569246