Python 元组和集合
什么是元组
- 不可变序列与可变序列
- 不可变序列:字符串、元组
- 可变序列:列表、字典
- 可变序列:可以对序列执行增、删、改操作，对象地址不发生更改
1
2
3
4
5
6
7
8
9
10
11
12
13
| ''' 不可变序列，可变序列'''
'''可变序列 列表，字典'''
lst=[10,20,45]
print(id(lst))
lst.append(300)
print(id(lst))
'''不可变序列 字符串、元组'''
s='hello'
print(id(s))
s=s+' world'
print(id(s))
print(s)
|
元组的创建方式
元组的创建方式
直接小括号
使用内置函数tuple()
1
| t=tuple(('Python','hello',90))
|
只包含一个元素的元组需要使用逗号和小括号
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| '''元组的创建方式'''
'''第一种；使用小括号()'''
t=('Python','world',98)
print(t)
print(type(t))
t1=tuple(('Python','world',98))
print(t1)
print(type(t1))
t2='Python','world',98
print(t2)
print(type(t2))
t3='Python',
print(t3)
print(type(t3))
'''空元组的创建方式'''
lst=[]
lst1=list()
d={}
d2=dict()
t4=()
t5=tuple()
print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)
|
为什么要将元组设计成不可变序列
为什么要将元组设置成不可变序列
在多任务环境下,同时操作对象时不需要加锁
因此,在程序中尽量使用不可变序列
注意事项:元组中存储的是对象的引用
- 如果元组中对象本身不可变对象，则不能在引用其他对象
- 如果元组中对象是可变对象，则可变对象的引用不允许改变，但数据可以改变
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| t=(10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
'''尝试将t[1]修改为100'''
print(id(100))
'''由于[20,30]是列表，而类表是可变序列，所以可以向列表中添加元素,而列表的内存地址不变'''
t[1].append(100)
print(t,id(t[1]))
|
元组的遍历
1
2
3
4
5
6
7
8
9
10
11
12
| '''元组的遍历'''
t=('Python','world',98)
'''第一种获取元组的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
'''遍历元组'''
for item in t:
print(item)
|
什么是集合
- 集合
- Python语言提供的内置数据结构
- 与列表、字典一样都属于可变类型的序列
- 集合是没有value的字典
集合的创建方式
直接{}
s={'Python','hello',90}
使用内置函数set()
1
2
3
4
| s=set(range(6))
print(s)
print(set(List[1,2,3]))
print(set((1,2,3)))
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| '''集合的创建方式使用{}'''
s={2,3,4,5,6,7,7}
print(s)
'''第二种创建方式 使用内置函数set()'''
s1=set(range(6))
print(s1,type(s1))
s2=set([1,2,3,4,5,6,7,8])
print(s2,type(s2))
s3=set((1,2,3,4,5,5))
print(s3,type(s3))
s4=set('Python')
print(s4,type(s4))
s5=set({1,2,3,4,4})
print(s5,type(s5))
s6={}
print(s6,type(s6))
s7=set()
print(s7,type(s7))
|
集合的相关操作
- 集合元素的判断操作
- 集合元素的新增操作
- 调用add()方法,一次添中一个元素
- 调用update()方法至少添加一个元素
- 集合元素的删除操作
- 调用remove()方法,一次删除一个指定元素,如果指定的元素不存在抛出KeyError
- 调用discard()方法,一次删除一个指定元素,如果指定的元素不存在不抛异常
- 调用pop()方法,一次只删除一个任意元素
- 调用clear()方法,清空集合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| '''集合的相关操作'''
s={10,20,30,40,50}
'''集合元素的判断操作'''
print(10 in s)
print(100 not in s)
'''集合元素的新增操作'''
s.add(80)
print(s)
s.update({100,200})
print(s)
s.update([300,400])
s.update((500,600))
print(s)
'''集合元素的删除操作'''
s.remove(100)
s.discard(500)
print(s)
s.pop()
print(s)
s.clear()
print(s)
|
集合间的关系
- 两个集合是否相等
- 一个集合是否是另一个集合的子集
- 两个集合是否没有交集
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| '''两个集合是否相等'''
s={10,20,30,40}
s2={20,10,40,30}
print(s==s2)
'''一个集合是否是另一个集合的子集'''
s1={10,20,30,40,50,60}
s2={10,20,30,40,50}
s3={10,20,30,90}
print(s2.issubset(s1))
print(s3.issubset(s1))
'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2))
'''两个集合是否含有交集'''
print(s2.isdisjoint(s3))
s4={200,300}
print(s1.isdisjoint(s4))
|
集合的数学操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
s1={10,20,30,40}
s2={20,30,40,50,60,70}
print(s1.intersection(s2))
print(s1 & s2)
print(s1.union(s2))
print(s1 | s2)
print(s1)
print(s2)
print(s1.difference(s2))
print(s1-s2)
print(s1)
print(s2)
print(s1.symmetric_difference(s2))
print(s1^s2)
|
集合生成式
051
2
3
4
5
6
7
8
|
lst=[i*i for i in range(6)]
print(lst)
s={i*i for i in range(6)}
print(s)
|
列表、字典、元组、集合总结
需要注意的是：
可变数据类型：List,Dictionary,Set （两层引用，一层指向首地址，第二层指向真实地址）
不可变数据类类型：Number,String,Tuple,None （一层引用，一层指向真实地址）
在深度学习应用时，应该避免使用newlst = lst[:]，这种方式是浅拷贝，对原lst修改会影响newlst，应该用copy.deepcopy
1
2
3
4
5
6
7
8
9
10
| >>> lst = [[1,2,3]]
>>> newlst = lst[:]
>>> print(newlst)
[[1, 2, 3]]
>>> lst[0].append(4)
>>> print(lst)
[[1, 2, 3, 4]]
>>> print(newlst)
[[1, 2, 3, 4]]
>>>
|
