python3列表，元组，字典，集合中常见的操作方法汇锦：
【1.以下的字典，列表，集合用于数据存储处理的这几个对象，如果没有返回值一般都是直接修改原有对象，如果有返回值那么原对象值不变。】
【2.有返回值的一般都需要使用变量接收返回值，没有返回值的一般都不能直接打印并改变原有对象的值。】
【3.索引跟下标：下标指元素的位置，索引指元素名称，访问像set、dict、list、tuple这样的类型数据一般使用都是使用下标跟索引来访问！】
【4.以下四大数据类型中没有列出tuple：因为tuple不能增删改，所以操作函数比较少，但是tuple有索引也有下标，跟列表一样！】
【5.都支持嵌套！】
一. 列表的操作：
概念：有索引有下标！列表是这四个数据类型中比较灵活的，竟可以通过下标访问也可以通过索引访问元素
1.替换/添加列表元素，也可以说更新
语法：list[obj_index] = obj 解析：list，列表名字；index，索引
举例：
list1=[1,2,3,4,5]
list1 [4] = 2020
print(list1)
# 结果：
# [1,2,3,4,2020]2.删除列表元素
语法：del list5[index] 解析：del == delete，删除；list，列表名字；index，需要删除的元素索引位置。ps：没有返回值
举例：
list2 = [1,2,3,4,5]
del list2[3]
print(list)
# 结果：
# [1,2,3,5]3.向列表添加元素
语法：list3.inster（index,object） 解析：list3.inster ，调用函数inster（）；index，元素添加的索引位置；object，需要添加的对象
举例：
list3=[1,2,3,4,5]
list3.inster(2,2020)
print(list)
# 结果：
# [1,2,2020,3,4,5]4.向列表的结束位置添加元素（当不知道列表元素多少个的时候使用，不然用inster（）感觉也够用了
语法：list4.append(object) 解析：list4.append ，调用函数append()； object ，需要向列表中添加的对象
举例：
list4=[1,2,3,4,5]
list4.append(2020)
print(list4)
# 结果：
# [1,2,3,4,5,2020]5.移除列表的中的元素。默认最后一个 （ 会返回被移除的元素) ， ps： 适用于dcit，set，list
语法：list5.pop(index) 解析：list5.pop(),调用函数pop() ; index ,可以指定需要移除元素的索引值，如果添加索引，默认为移除最后一个元素，
举例：
list5=[1,2,3,4,5]
list5.pop()/list5.pop(1) # / 表示或，注意区分!
print(list5)
# 结果：
# [1,2,3,4]/[1,3,4,5,] # / 表示或，注意区分! 6.按顺序排列lsit ：
负下标排序法：（只能反转字符适用于所有可迭代对象)
举例：
list6=[1,2,3,4,5,5,4,6]
print(list6[::-1])使用内置函数排序：sort(), ps：没有返回值
方式1：
list6=[1,2,3,4,5,6]
list1.sort(reverse=True)
print(list6)
# 结果：[6, 5, 4, 3, 2, 1]细节提示：list6=[1,'2','3',4,5,6]
list1.sort(reverse=True)
print(list6)
# 报错：因为数字是不能跟字符串同时排序的！使用可迭代对象函数排序：ps：可对一切可迭代对象使用！,这两个方法没有返回值
就是使用sorted()跟reverse()下面有具体解析！
7.清空对象：.clear()，ps：可对一切可迭代对象（比如：list，dict这样的，元组除外元组不能增删改）使用！,该方法没有返回值
语法：obj.clear()
举例：
list7=[1,2,3,4,5]
list7.clear() #不能在清空的时候直接打印！
print(list7)
# 结果：空列表
# [ ]8.统计元素在该对象中出现的次数：count() ，索引值也就是下标从1开始！ps：可对一切对象使用！该方法没有返回值
语法：obj.count()
举例：
list8=[1,2,3,4,4,4,3,5]
list8.count(4)
print(list8)
# 结果：4总共在list8里出现过3次
# 39.复制对象：.copy() , ps：可对一切对象使用！该方法没有返回值！
语法：obj.copy()
dict1 = {"name":"tyc","age":18,"sex":"boy"}
dict2=dict1.copy()
print(dict2)
# result：{"name":"tyc","age":18,"sex":"boy"}
10.最大值，最小值：max(obj) ; min(obj)；ps：可对数字跟str使用！不适用于像字典(dict)这样！
max(obj)语法：max(obj)
举例：
list8=[1,2,3,4,4,4,3,5]
list9=max(list8)
print(list9)
# 结果：ps：也可以对字符串操作！
# 5min(obj)语法: min(obj)
举例：
list8=[1,2,3,4,4,4,3,5]
list9=min(list8)
print(list9)
# 结果：ps：也可以对字符串操作！
# 111.适用list，tuple，set中数字对象的总和：ps：不能操作str，还有字典这样的！
语法：sum(obj)
举例：
list8=(1,2,3,4,4,4,3,5)
list9=sum(list8)
print(list9)
# 结果：2612.移除对象中的某一元素：适用于dict，list，set。ps：默认移除第一个（set除外），该方法没有返回值。
语法：object.remove(要移除的元素/元素位置)
举例：
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.remove(list1[1])
print ("列表现在为 : ", list1)
# 结果：列表现在为 : ['Google', 'Taobao', 'Baidu']二. 字典（dict）的操作：
概念：字典也是跟集合一样无序的，但有索引，不能通过下标访问，只能通过索引(key)来访问。
1.打印出dict（字典）的所有键（key）：
语法：obejct.keys()； 字典.keys()
举例:
dict = {"name":"tyc","age":18,"sex":"boy"}
mun = dict.keys()
print(mun)2.打印出dict（字典）的所有值（value）:
语法: object.values() ; 字典.value()
举例:
dict1 = {"name":"tyc","age":18,"sex":"boy"}
mun1 = dcit1.values()
print(mun1)3.以列表（list）形式返回字典（dict）的键跟值：
语法: object.items(); 解析: items() 字典操作函数（返回字典的键跟值）
举例:
dict2 = {"name":"tyc","age":18,"sex":"boy"}
mun2 = dict2.items()
print(mun2)
# 结果：dict_items([('name', 'tyc'), ('age', 18), ('sex', 'boy')])还可以使用for循环遍历键跟值:
dict2 = {"name":"tyc","age":18,"sex":"boy"}
i=0
for key,value in dict2.items():
i+=1
print(f"这是dict的第{i}键：{key}，这是dict的第{i}值：{value}")
# 结果:
# 这是dict的第1键：name，这是dict的第1值：tyc
# 这是dict的第2键: age，这是dict的第2值：18
# 这是dict的第3键：sex，这是dict的第3值：boy4.将列表装换成字典 ：
方法1：使用dict.fromkeys() ps：该方法只能给所有key指定一个默认value，不能给每个key，指定不同的value
举例：
list1 = ['name','age','sex']
x ='18'
list2 = dict.fromkeys(list1,x)
print(list2)
# result: {'name': '18', 'age': '18', 'sex': '18'}
方法2：使用 dict(zip())
举例：
list3 = ['name','age','sex']
list4 = ['adi','18','boy']
list5 =dict(zip(list3,list4))
print(list5)
# result: {'name': 'adi', 'age': '18', 'sex': 'boy'}5.指定字典的key跟value：dict.fromkeys(keys,value) ，参数value不能传入整个列表！
语法：变量 = dict.fromkeys(keys,初始化的值)
举例：
list1= ['Google', 'Runoob', 'Taobao', 'Baidu']
list2=[1,2,3,4]
dict1= dict.fromkeys(list1,None )
# dict1= dict.fromkeys(list1,list2) # 注意：如果把另一个list做值，value就是整个list2列表！
print ("列表现在为 : ",dict1)
# 结果：列表现在为 : {'Google': None, 'Runoob': None, 'Taobao': None, 'Baidu': None}6.往字典添加键和值： ps：默认添加位置是后面！
语法：字典对象.['键名']=‘值’
举例：
dict3 = {"name":"tyc","age":18,"sex":"boy"}
dict3['adi']='千灯'
print('dict3')
# 结果：
# {"name":"tyc","age":18,"sex":"boy","adi" : "千灯" }
三. 集合的操作与概念：
概念：在python中集合是无序的，没有索引没有下标。不能通过下标或者索引访问其中的元素。
特别之处：1.无法通过索引下标访问特定的元素！2.set中的元素不能重复出现！3.不支持运算符将两个集合相加！
4.可以使用笨方法学py书中的【if obj in set：】来判断元素是否存在于集合set中——第四点适用于所有类型。
1.向集合中添加元素：add()：只能一次添加一个；updata([obj_list])：可以一次添加多个，以list形式添加；【ps：这两个方法没有返回值！】
语法：obj.add()
举例：
friends = {'dog','cat'}
friends.add('duck')
print(friends) # 因为set是无序的所以添加元素位置也是随机的（ps：不能指定位置添加）！
# 结果：{'dog', 'duck', 'cat'}语法：obj.updata([obj_list])
举例：
friends = {'dog','cat'}
friends.update(['duck','Cattle'])
print(friends) # 因为set是无序的所以添加元素位置也是随机的（ps：不能指定位置添加）！
# 结果：{'cat', 'dog', 'duck', 'Cattle'}2.删除集合中的元素：
使用前面列表中学过的remove()【移除某个元素】,关键词：del obj【删除某个元素】,clear()【清空整个对象】 三个函数即可，ps：三个都没有返回值
3.多个集合相加： .obj.union() , 因为前面说过集合不能使用运算符相加，所以只能使用指定方法相加，如果两个集合有相同元素，相加之后只会出现一个！
语法：变量= obj.union(参数1，参数2……) # 有返回值！
举例：
friends = {'dog','cat'}
friends1={'duck','cat'}
friends2 = friends.union(friends1) # 这是集合的并集操作
print(friends2) # 因为集合元素不会重复的特点所以之后保留一个cat，日常也可以使用这一特点去重
# 结果：{'cat', 'dog', 'duck'}4.找出多个集合中的交集（也就是相同的元素）：.object.intersection()，也就是找出两个或者多个集合中相同的元素！
语法：变量 = object.intersection(params1，params2……) # 有返回值
举例：
friends = {'dog','cat'}
friends1={'duck','cat'}
friends2 = friends.intersection(friends1)
print(friends2)
# 结果：{'cat'}5.找出多个集合中的差集并返回其中其中一个的差值：.object.difference()，就是找出多个set中不相同的元素，任何返回其中你想要的其中一个set的不同元素。
语法： 变量 = 要返回的set_obj.difference(params1，params2……) # 有返回值
举例：
friends = {'dog','cat'}
friends1={'duck','cat'}
friends2 = friends1.difference(friends)
print(friends2)
# 结果：{'duck'} # 返回了friends1中的差集值6. 找出多个集合中的差集并返回所有集合的差集：.sysmmetric_difference()，找出多个set中不同的元素，然后返回所有集合的差集值。
语法：变量 = 要返回的set_obj.sysmmetric_difference(params1，params2……) #有返回值
举例：
friends = {'dog','cat'}
friends1={'duck','cat'}
friends2 = friends1.symmetric_difference(friends)
print(friends2)
# 结果：{'duck', 'dog'} # 返回了friends1跟friends中的差集值7. 一个集合所有元素是否包含于另外一个集合中：obj.issuperset()
语法：变量 = 包含的set_obj.issuperset(被包含的set_obj) # 有返回值 -- 返回True,False
举例：
friends = {'dog','cat','duck'}
friends1={'duck','cat'}
friends2 = friends.issuperset(friends1)
print(friends2)
# 结果：返回True8. 判断两个集合中是否不存在相同的元素：obj_set1.isdisjoint(set2_obj)
语法：变量 = obj_set1.isdisjoint(set2_obj) #有返回值：如果不存在返回False，如果存在返回True
举例：
friends = {'dog','cat','duck'}
friends1={'duck','cat'}
friends2 = friends.isdisjoint(friends1)
print(friends2)
# 结果： 返回False
# 因为friends跟friends1存在相同的元素：“cat”使用sorted()跟reverse()对所有可迭代对象排序：
sorted() 函数对所有可迭代的对象进行排序操作 ：
sorted 语法：
sorted(iterable, key=None, reverse=False)
参数说明：
- iterable -- 可迭代对象。(可迭代对象表示可以遍历的对象！原本列表有一个排序函数sort()，但是sort()是列表操作函数，只对列表有效，像其他可以迭代的对象如字典，集合等不能进行排序）
L=[('b',2),('a',1),('c',3),('d',4)]
def adi(x,y):
if x>y:
return True
elif x<y:
return -1
else:
return False
adi = adi(L[1],L[1])
print(adi)
if adi ==-1:
reverse_test = L
else:
reverse_test = sorted(L,reverse=adi)
print(reverse_test)
# 结果：
# False
# [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
看你输入的对比值是什么！其实没有什么两样。- key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
【adi：key-- 可以指定哪个值放在首位！】
- reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
a = [5,7,6,3,4,1,2]
b = sorted(a) # 保留原列表
a [5, 7, 6, 3, 4, 1, 2]
b [1, 2, 3, 4, 5, 6, 7]
L=[('b',2),('a',1),('c',3),('d',4)]
sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数,没啥用，返回0表示false，返回0表示false，返回-1表示保留原来的模样 [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
sorted(L, key=lambda x:x[1]) # 利用key，按第一个（x[1]也就是L[1]）开始排序 [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2]) # 按年龄排序 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
sorted(students, key=lambda s: s[2], reverse=True) # 按降序,按第2个（s[2]也就是students[2]）开始排序 [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]reverse() 函数用于倒序可迭代对象中元素：（如果是字符串则直接反转！不进行排序！排序只对数值排序！）
reverse()方法语法：list.reverse()
举例1：
list1 = [, 'xyz', 'zara', 'abc', 'xyz']
list1.reverse()
print(list1)
# result ： ['xyz', 'abc', 'zara', 'xyz', 123]
举例2：
list1 = [1, 2, 4, 3, 5]
list1.reverse()
print(list1)
# result ： [5, 3, 4, 2, 1]