（字符串列表字典元组集合）的常用内置方法

Posted 2021-01-07 angelyan

一、字符串：

lis=‘my name is maple‘
res=lis.count(‘m‘)#计算字符串内相同字符的个数
print(res)

lis=‘my name is maple‘
res=lis.split(‘ ‘)#按照制定的分隔字符，分隔开多个字符串，存放到一个列表中
print(res)

lis=‘   my name is maple   ‘
res=lis.strip(‘ ‘)#将字符串左右2遍的制定字符删除掉，碰到不是制定字符就停止删除
print(res)

lis=‘my name is maple‘
res=lis.isdigit()#判断字符串内是否是纯数字的类型，是为True,否为False
print(res)

lis=‘my name is {name}‘.format(name=‘maple‘)#format格式化
 print(lis)

lis=‘mynameismaple‘
res=lis.isalpha()#判断字符串内是否是纯字母或中文的类型，是为True,否为False
print(res)

lis=‘my name is maple‘
res=lis.replace(‘maple‘,‘ffm‘)#用新的字符替换掉原字符串中有的字符
print(res)

lis=‘my name is maple‘
res=lis.index(‘m‘)#按制定字符，从左到右寻找第一个符合字符的索引位置
print(res)

lis=‘my name is maple‘
res=lis.rindex(‘m‘)#按制定字符，从右到左寻找第一个符合字符的索引位置
（注意，索引大小还是左到右）
print(res)

lis=‘My name is Maple‘
res=lis.lower()#把字符串全部转换成小写
print(res)

lis=‘my name is maple‘
res=lis.upper()#把字符串全部转换成大写
print(res)

lis=‘my name is maple‘
res=lis.endswith(‘le‘)#用制定字符串判断字符串的末尾是否存在，是为True,否为False
print(res)

lis=‘my name is maple‘
res=lis.startswith(‘my‘)#用制定字符串判断字符串的开头是否存在，是为True,否为False
print(res)

lis=‘my name is maple‘
res=lis.split(‘ ‘)
res1=‘ ‘.join(res)#把split分隔开的列表，再用制定字符拼接起来，变为字符串
print(res1)
res=[‘may‘,‘i‘,‘can‘,‘help‘,‘you‘]
res1=‘ ‘.join(res)
print(res1)

二、列表：

lis=[‘my‘,‘name‘,‘is‘,‘maple‘]
res=lis.index(‘name‘)#按照字典内的元素，从左到右寻找所对应的索引位置
print(res)

lis=[‘my‘,‘name‘,‘is‘,‘maple‘]
res=lis.count(‘my‘)#计算按制定元素在列表内的个数
print(res)

lis=[‘my‘,‘name‘,‘is‘,‘maple‘]
res=lis.append(‘ffm‘)#在列表的最后面添加制定元素，返回值是None
print(res,lis)

lis=[‘my‘,‘name‘,‘is‘,‘maple‘]
res=lis.pop(0)#按照索引号，把元素从列表中取出来，返回该取出的值
print(res)

lis=[‘my‘,‘name‘,‘is‘,‘maple‘,‘my‘]
res=lis.remove(‘my‘)#按照制定元素把列表中相同的元素删除(从左到右只删第一个），返回值为None
print(lis,res)

lis=[‘my‘,‘name‘,‘is‘,‘maple‘]
res=lis.sort(reverse=True)#数字按从小到大，字母元素安照首字母大小排列,当reverse=True时，取反
print(res,lis)

lis=[‘my‘,‘name‘,‘is‘,‘maple‘]
res=lis.insert(0,‘first‘)#按制定索引位置添加制定元素，返回值为None
print(res,lis)

lis=[‘my‘,‘name‘,‘is‘,‘maple‘]
res=lis.extend([‘ffm‘,‘yan‘])#在列表末尾添加入制定元素，制定元素会用for循环的方法依次添加，返回值为None
print(res,lis)

lis=[‘my‘,‘name‘,‘is‘,‘maple‘]
res=lis.reverse()#把列表从尾到头，从新排列，返回值为None
print(res,lis)

三、元组类型：

 

tup=(‘my‘,‘name‘,‘is‘,[‘maple‘,‘ffm‘])
res=tup.count(‘my‘)#按制定元素值，计算元组内的个数，返回值为计算个数
print(res,tup)

tup=(‘my‘,‘name‘,‘is‘,[‘maple‘,‘ffm‘])
res=tup.index(‘name‘)#按制定元素，从左到右寻找所对应的索引号，不存在会报错
print(res,tup)

四、字典类型：

dic={‘name‘:‘maple‘,‘age‘:‘eighteen‘,‘sex‘:‘male‘}
res=dic.values()#按字典的value取值，返回取到的是一个value的母鸡,再用for循环取出
print(res,dic)

dic={‘name‘:‘maple‘,‘age‘:‘eighteen‘,‘sex‘:‘male‘}
res=dic.keys()#按字典的key取值，返回取到的是一个key的母鸡,再用for循环取出
print(res,dic)

dic = {‘name‘: ‘maple‘, ‘age‘: ‘eighteen‘, ‘sex‘: ‘male‘}
res=dic.items()#按字典的key:value取值，返回取到的是一个key:value的母鸡,再用for循环取出
print(res,dic)

dic = {‘name‘: ‘maple‘, ‘age‘: ‘eighteen‘, ‘sex‘: ‘male‘}
res=dic.pop(‘name‘)#按制定key值,删除此key:value,返回一个此key对应的value值
print(res,dic)

dic = {‘name‘: ‘maple‘, ‘age‘: ‘eighteen‘, ‘sex‘: ‘male‘}
res=dic.popitem()#按制定key值,删除此key:value,返回一个以元组形式的（key,value)
print(res,dic)

dic = {‘name‘: ‘maple‘, ‘age‘: ‘eighteen‘, ‘sex‘: ‘male‘}
res=dic.setdefault(‘grade‘)#按指定key:value的形式添加到字典的最后面，
# 如不指定value就添加一个None
print(res,dic)

dic = {‘name‘: ‘maple‘, ‘age‘: ‘eighteen‘, ‘sex‘: ‘male‘}
res=dic.get(‘grade‘)#按指定key值，取到对应的value值，如没有此key值也不会报错，返回一个None
print(res,dic)

dic = {‘name‘: ‘maple‘, ‘age‘: ‘eighteen‘, ‘sex‘: ‘male‘}
res=dic.fromkeys(dic)#快速制造一个新字典，新字典中的key为原字典的key，value全部为None
print(res,dic)

dic = {‘name‘: ‘maple‘, ‘age‘: ‘eighteen‘, ‘sex‘: ‘male‘}
dic_new={‘grade‘:‘six‘,‘weight‘:‘heavy‘,‘name‘:‘ffm‘}
res=dic.update(dic_new)#将一个新字典中的key:value加到原字典中去，如原字典中已有的key会更换value值
print(res,dic)

五、集合类型:

pythons={‘egon‘,‘张铁蛋‘,‘李铜蛋‘,‘赵银弹‘,‘王金蛋‘,‘艾里克斯‘}
linuxs={‘欧德博爱‘,‘李铜蛋‘,‘艾里克斯‘,‘lsb‘,‘ysb‘,‘wsb‘}
print(pythons&linuxs)#交集：取2者的共同部分
print(pythons.intersection(linuxs))##交集：取2者的共同部分

pythons={‘egon‘,‘张铁蛋‘,‘李铜蛋‘,‘赵银弹‘,‘王金蛋‘,‘艾里克斯‘}
linuxs={‘欧德博爱‘,‘李铜蛋‘,‘艾里克斯‘,‘lsb‘,‘ysb‘,‘wsb‘}
print(pythons | linuxs)#并集：取2者的总共
print(pythons.union(linuxs))#并集：取2者的总共

pythons={‘egon‘,‘张铁蛋‘,‘李铜蛋‘,‘赵银弹‘,‘王金蛋‘,‘艾里克斯‘}
linuxs={‘欧德博爱‘,‘李铜蛋‘,‘艾里克斯‘,‘lsb‘,‘ysb‘,‘wsb‘}
print(pythons - linuxs)#差集：取2者的不同的部分，只取前者
print(pythons.difference(linuxs))#差集：取2者的不同的部分，只取前者

pythons={‘egon‘,‘张铁蛋‘,‘李铜蛋‘,‘赵银弹‘,‘王金蛋‘,‘艾里克斯‘}
linuxs={‘欧德博爱‘,‘李铜蛋‘,‘艾里克斯‘,‘lsb‘,‘ysb‘,‘wsb‘}
print(pythons ^ linuxs)#对称差集：取2者的不同的部分，2者都取
print(pythons.symmetric_difference(linuxs))#对称差集：取2者的不同的部分，2者都取

s1={1,2,3}
s2={1,2}
print(s1 >= s2)#父子集：s1是s2的父集，s2是s1的子集
print(s1.issuperset(s2))

s1={1,2,3}
s2={1,2,3}
print(s1 == s2)#当s1==s2时，s1和s2相互成为父子集

s1={‘1‘,2,3}
s1.update({3,4,5})#把一个新集合里的每个元素添加到原集合中去，集合有自动去重效果
print(s1)
res=s1.pop()#随机把集合当中的某一个元素删除，并返回该删除值
print(res,s1)
print(type(res))

s1={‘1‘,2,3}
res=s1.remove(‘1‘)#将指定集合中的元素删除掉，返回一个None
print(s1,res)

s1={‘1‘,2,3}
res=s1.add(4)#将指定一个不可变元素加入到集合中，返回一个None
print(s1,res)

s1={‘1‘,2,3}
res=s1.discard(‘1‘)#将指定某个元素删除掉，如此元素不在集合中也不会报错，返回一个None
print(res,s1)