一、字符串：

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)

（字符串、列表、字典、元組、集合）的常用內置方法