python3 列表，元组，字典，集合中常见的操作方法汇锦

python3列表，元组，字典，集合中常见的操作方法汇锦：

【1.以下的字典，列表，集合用于数据存储处理的这几个对象，如果没有返回值一般都是直接修改原有对象，如果有返回值那么原对象值不变。】

【2. 有返回值的一般都需要使用变量接收返回值，没有返回值的一般都不能直接打印并改变原有对象的值。】

【3.索引跟元素：像list、tuple这类有索引的是可以直接通过索引(索引也就是下标)进行访问，其中list通过索引跟元素对其进行操作（元组不能增删改所以元组不能操作！）；而字典则必须通过键值对的方式进行访问跟操作，集合除外！】

【4.以下四大数据类型举例中没有列出tuple：因为tuple不能增删改，所以操作函数比较少，但是tuple有索引，元组使用索引访问元素的方式跟list一样！】

【5.除了集合，剩下的三个（list，tuple，dic）都支持嵌套！】

一. 列表的操作：

概念：有索引有下标！列表是这四个数据类型中比较灵活的，竟可以通过下标访问也可以通过索引访问元素

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次

# 3

9.复制对象：.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：也可以对字符串操作！

# 5

min(obj)语法: min(obj)

举例：

list8=[1,2,3,4,4,4,3,5]

list9=min(list8)

print(list9)

# 结果：ps：也可以对字符串操作！

# 1

11.适用list，tuple，set中数字对象的总和：ps：不能操作str，还有字典这样的！

语法：sum(obj)

举例：

list8=(1,2,3,4,4,4,3,5)

list9=sum(list8)

print(list9)

# 结果：26

12.移除对象中的某一元素：适用于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值：boy

4.将列表装换成字典 ：

方法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.集合不支持嵌套。

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()【移除某个元素,如果元素不存在会报错】,clear()【清空整个对集合】，pop()【删除第一个元素！】加discard() 【如果元素不存在不会报错】即可。

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)

# 结果：返回True

8. 判断两个集合中是否不存在相同的元素：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]

最后

以上就是无聊服饰为你收集整理的python3 列表，元组，字典，集合中常见的操作方法汇锦的全部内容，希望文章能够帮你解决python3 列表，元组，字典，集合中常见的操作方法汇锦所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。