python系列之：列表、元组、集合、字典用法详解_python 中序列、列表、元组、集合、字典的区别

一、列表、元组、集合、字典的区别

• 列表：长度可变有序的数据存储容器，可以通过下标索引取到相应的数据。
• 元组：固定长度不可变的顺序容器，访问效率高，适合存储一些常量数据，可以作为字典的键使用。
• 集合：无序，元素只出现一次，可以自动去重。
• 字典：长度可变的hash字典容器。存储的方式为键值对，可以通过相应的键获取相应的值。key支持多种类型，key必须是不可变类型且唯一。

列表和元组的主要区别如下：

• 列表上可以修改的，而元组不能修改。如果要增添和删除元素，只能用列表。元组被称为只读列表，即数据可以被查询，但不能被修改。若元组一旦被定义，长度和内容都是固定的，不能被修改，即不能对元组进行更新、增加和删除的操作。
• 列表用’[]'表示，元组用()表示
• 列表不能作为字典的可以，元组可以
• 如果元组中仅有一个元素，需要在元素后加上逗号。

二、for循环遍历列表、元组、字典和集合

1.遍历列表

testList = [4,2,3,1,4]

print("遍历list：",end='')
for items in testList:
    print(items,end=' ')
1
2
3
4
5

2.遍历元组

print()
print("遍历tuple：",end='')
testTuple = (5,2,1,3,4)
for items in testTuple:
    print(items,end=' ')
1
2
3
4
5

3.遍历字典

print()
print("遍历dict：",end='')
testDict = {'a':1,'b':2}
for key,value in testDict.items():
    print(key,value,end=' ')
1
2
3
4
5

4.遍历集合

print()
print('遍历set：',end='')
testSet = {12,4,6,5}
for items in testSet:
    print(items,end=' ')
1
2
3
4
5

输出如下所示：

遍历list：4 2 3 1 4 
遍历tuple：5 2 1 3 4 
遍历dict：a 1 b 2 
遍历set：4 12 5 6
1
2
3
4

三、列表、元组、集合和字典相互转换

1.列表元组转化为集合（去重）

#两个列表转集合，去重
list1 = [6,7,7,8,8,9]
set1 = set(list1)
print(set1)
1
2
3
4

输出如下所示：

{8, 9, 6, 7}
1

2.两个列表转字典

#两个列表转字典
list1 = ["key1","key2","key3"]
list2 = ["1","2","3"]
dict1 = dict(zip(list1,list2))
print(dict1)
1
2
3
4
5

输出如下所示：

{'key1': '1', 'key2': '2', 'key3': '3'}
1

3.嵌套列表转字典

#嵌套列表转字典
list3 = [["key1","valu1"],["key2",'value2'],['key3','value3']]
dict1 = dict(list3)
print(dict1)
1
2
3
4

输出如下所示：

{'key1': 'valu1', 'key2': 'value2', 'key3': 'value3'}
1

4.列表、元组转字符串

#列表、元组转字符串
list1 = ['s','a','b']
str1 = " ".join(list1)
print(str1)

tup1 = ('b','t','u')
str2 = "-".join(tup1)
print(str2)
1
2
3
4
5
6
7
8

输出如下所示：

s a b
b-t-u
1
2

5.字典转化为字符串

dic1 = {'a':1,"b":2}
str1 = str(dic1)
print(type(str1))
print(str1)
1
2
3
4

输出如下所示：

<class 'str'>
{'a': 1, 'b': 2}
1
2

6.字典key和value互相转换

#字典key和value互相转换

dic2 = {"a":1,"b":2}

dic3 = {value:key for key,value in dic2.items()}
print(dic3)
1
2
3
4
5
6

输出如下所示：

{1: 'a', 2: 'b'}
1

7.字符串转换为列表

#字符串转换为列表
s = 'dstewsg'
list1 = list(s)
print(list1)
1
2
3
4

输出如下所示：

['d', 's', 't', 'e', 'w', 's', 'g']
1

8.字符串转元组

#字符串转元组
s = "ugjhaga;w"
tu1 = tuple(s)
print(tu1)
1
2
3
4

输出如下所示：

('u', 'g', 'j', 'h', 'a', 'g', 'a', ';', 'w')
1

9.字符串转集合

#字符串转集合
dic2 = eval("{'a':1,'age':2}")
print(dic2)
1
2
3

输出如下所示：

{'a': 1, 'age': 2}
1

10.切分字符串

#切分字符串
a = 'a b c'
a = a.split(' ')
print(a)
1
2
3
4

输出如下所示：

['a', 'b', 'c']
1

四、删除一个列表重复元素

1.使用集合set方式

#利用set中的元素不可重复性来去重
elements = ['a','b','e','c','b','d','a','c','f']

e = list(set(elements))
print(e)
1
2
3
4
5

输出如下所示：

['d', 'c', 'b', 'a', 'f', 'e']
1

要保持列表元素的原来顺序，可以利用list类的sort方法

#利用list的sort方法保持列表原来顺序
e.sort(key=elements.index)
print(e)
1
2
3

输出如下所示：

['a', 'b', 'e', 'c', 'd', 'f']
1

2.使用字典的方式，利用字典key的唯一性

#使用字典的方式
#利用了字典的键的唯一性
elements = ['a','b','e','c','b','d','a','c','f']
e = list({}.fromkeys(elements).keys())
print(e)
1
2
3
4
5

python函数dict.fromkey(seq,[,value])用于创建一个新字典以序列seq中元素做字典的键，value为字典所有键对应的初始值

#python函数dict.fromkey(seq,[,value])用于创建一个新字典
#以序列seq中元素做字典的键，value为字典所有键对应的初始值
seq = ['a','b','c']
dict1 = dict.fromkeys(seq,[9,4,3])
print(dict1)
1
2
3
4
5

输出如下所示：

{'a': [9, 4, 3], 'b': [9, 4, 3], 'c': [9, 4, 3]}
1

3.列表推导的方式

#方式三：列表推导的方式
elements = ['a','b','e','c','b','d','a','c','f']
e = []
for i in elements:
    if not i in e:
        e.append(i)
print(e)
1
2
3
4
5
6
7

以上代码也可以使用列表生成式简写成

#以上代码也可以使用列表生成式简写成
elements = ['a','b','e','c','b','d','a','c','f']
e = []
[e.append(i) for i in elements if i not in e]
print(e)
1
2
3
4
5

4.reduce函数

• reduce函数的定义：
• reduce(function, sequence[, initial]) -> value
• function参数是一个有两个参数的函数，reduce依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function。

#reduce函数
from functools import reduce

# reduce函数的定义：
# reduce(function, sequence[, initial]) -> value
# function参数是一个有两个参数的函数，reduce依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function。

elements = ['a','b','e','c','b','d','a','c','f']
print([[]]+elements)  #[[], 'a', 'b', 'e', 'c', 'b', 'd', 'a', 'c', 'f']
v = reduce(lambda x,y:x if y in x else x+[y],[[]]+elements)
print(v)
1
2
3
4
5
6
7
8
9
10
11

输出如下所示：

[[], 'a', 'b', 'e', 'c', 'b', 'd', 'a', 'c', 'f']
['a', 'b', 'e', 'c', 'd', 'f']
1
2

五、求两个列表的交集、差集或并集

1.for循环

a = [1,2,3,4,5]
b = [2,4,5,6,7]

#交集
result = [i for i in a if i in b]
print('a与b的交集：',result)

#差集，在a中但不在b中

result = [i for i in a if i not in b]
print('a与b的差集：',result)

#并集
result = a
for r in b:
    if r not in result:
        result.append(r)
print('a与b的并集：',result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出如下所示：

a与b的交集： [2, 4, 5]
a与b的差集： [1, 3]
a与b的并集： [1, 2, 3, 4, 5, 6, 7]
1
2
3

2.用set操作

#用set操作
a = [1,2,3,4,5]
b = [2,4,5,6,7]

#交集
result = list(set(a).intersection(set(b)))
print('a与b的交集：',result)

#差集 在a中但不在b中
result = list(set(a).difference(set(b)))
print("a与b的差集：",result)

#并集
result = list(set(a).union(set(b)))
print('a与b的交集:',result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出如下所示：

a与b的交集： [2, 4, 5]
a与b的差集： [1, 3]
a与b的交集: [1, 2, 3, 4, 5, 6, 7]
1
2
3

六、反序地迭代一个序列

对序列反序，可以利用内置函数reversed()或range()来实现，也可以用扩展切片[::-1]的形式实现。序列是列表，还可以使用列表自带的reverse()方法。

1. reversed()是python内置函数，参数可以是字符串、列表或元组等序列

2. 利用range()方法生成序列宕反序索引，然后从最后的元素遍历到开始的元素，就可以反序输出序列的元素。range(start,stop[,step])方法的参数说明

   • start：计数从start开始，默认是从0开始
   • end：计数到end结束，但不包括end
   • step：步长，默认为1

3. sea[::-1]扩展切片方法是利用粱序列宕切片操作，切片是序列的高级特性。seq[::-1]表示反向获取seq中的所有元素，并且每次取一个。-1表示从序列宕最后一个元素反向遍历获取。

4. 如果是列表序列，还可以直接用列表的reverse()方法

1.reversed()内置的函数方法

seq = "Hello World"

#reversed()内置的函数方法
for s in reversed(seq):
    print(s,end='')

#输出换行
print()
1
2
3
4
5
6
7
8

输出如下所示：

dlroW olleH
1

2.range()函数方法

#range()函数方法
for i in range(len(seq)-1,-1,-1):
    s = seq[i]
    print(s,end='')
#输出换行
print()
1
2
3
4
5
6

3.[::-1]扩展切片方法

#[::-1]扩展切片方法
for s in seq[::-1]:
    print(s,end='')
#输出换行
print()
1
2
3
4
5

4.list自带的reverse()方法

#list自带的reverse()方法
seq = [1,2,3,4,5,6]
seq.reverse()
for s in seq:
    print(s,end='')
print()
1
2
3
4
5
6

输出如下所示：

654321
1

七、列表的sort方法和sorted方法

• sort是列表方法，只可用来对列表进行排序，是在原序列上进行修改，不会产生新的序列
• 内置的sorted方法可以用于任何迭代的对象(字符串、列表、元组、字典等)会产生一个新的序列，旧的对象依然存在，不需要旧的序列可以采用sort方法

1.sort()方法

seq = [1,3,5,4,2,6]
seq.sort()
print(seq)
1
2
3

输出如下所示：

[1, 2, 3, 4, 5, 6]
1

2.sorted()方法

seq = [1,3,5,4,2,6]
s = sorted(seq)
print(s)
1
2
3

输出如下所示：

[1, 2, 3, 4, 5, 6]
1

3.按列表a1中字典元素的键age由大到小排序

a1 = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]

print(sorted(a1,key=lambda x:x['age'],reverse=True))
1
2
3

输出如下所示：

[{'name': 'b', 'age': 30}, {'name': 'c', 'age': 25}, {'name': 'a', 'age': 20}]
1

八、列表中常用的方法

• list可以看作一个对象，对象有很多中方法，调用方法是：对象.方法，append是这个对象的方法
• 对象可以理解为人，方法append类似这个人可以跑步、吃饭、打球

#list可以看作一个对象，append是这个对象的方法
# 对象可以理解为人，方法append类似这个人可以跑步、吃饭、打球
list1 = ['a','b','c']

list1.append('d')

print(list1)

list1.extend(['1','2','3'])
print(list1)
1
2
3
4
5
6
7
8
9
10

输出如下所示：

['a', 'b', 'c', 'd']
['a', 'b', 'c', 'd', '1', '2', '3']
1
2

九、列表生成式

用来创建列表的表达式就是列表生成式，也被称为列表推导式。

• 每个列表生成式都在for之后跟一个表达式，然后有零到多个for或if子句。返回结果是一个根据表达从其后的for和if上下文环境中生成出来的列表。
• 列表生成式的语法：[表达式 for 循环]

list1 = [x+1 for x in range(1,8)]
print(list1)
1
2

输出如下所示：

[2, 3, 4, 5, 6, 7, 8]
1

十、字典内置函数

使用pop和del删除字典中的name字段

dic = {"name":"刘备","age":19}
dic.pop("name")
print(dic)

dic = {"name":"刘备","age":19}
del dic["name"]
print(dic)
1
2
3
4
5
6
7

输出如下所示：

{'age': 19}
{'age': 19}
1
2

合并两个字典

dic1 = {"name":"刘备","age":19}

dic2 = {"hobby":"足球","money":100}

dic1.update(dic2)
print(dic1)
1
2
3
4
5
6

输出如下所示：

{'name': '刘备', 'age': 19, 'hobby': '足球', 'money': 100}
1

十一、集合常见内置方法

集合常见内置方法如下表所示：

给定两个列表找出相同的元素和不同的元素

list1 = [1,2,3]
list2 = [3,4,5]

set1 = set(list1)
set2 = set(list2)

print(set1&set2)
print(set1^set2)
1
2
3
4
5
6
7
8

输出如下所示：

{3}
{1, 2, 4, 5}
1
2