容器类型

1
2
3
4
5
4种内置数据结构（容器类型）
	列表：list=>[val1,val2,val3,val4]
	元组：tuple=>(val1,val2,val3,val4)
	字典：dict=>{key1:val1,key2:val2}
	集合：set=>{key1,key2,key3,key4}

一. 列表（list）

1
2
3
4
5
6
7
8
列表是处理一组有序项目的数据结构
列表是python中最具灵活性的有序集合对象类型
列表可以包含任何类型的对象：字符串、数字甚至其他列表
列表是可变的数据类型，即这种类型的值是可以被修改的
Example:表示一个购物清单
	goods=['牛奶'、'运动鞋'、'咖啡'、'手机'、'羊肉'、'葡萄'、'桔子']

列表通过方括号中用逗号分割的项目定义
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 示例
# 定义空列表
>>> lst = []
>>> type(lst)
<class 'list'>
>>> lst2 = list()		# 注：工厂函数
>>> type(lst2)
<class 'list'>
# 列表可装入python的任何对象：
>>> lst3 = list("abc")		# 注：字符串
>>> lst3 
['a', 'b', 'c']
>>> lst = [1,'abc',2.5,True]
>>> lst = [1,'abc',2.5,True,lst3]	# 注：其他列表
>>> lst
[1, 'abc', 2.5, True, ['a', 'b', 'c']]

列表基本操作

索引

​ 通过下标访问列表中的元素，下标从0开始计数，可取出一个元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 示例
>>> lst = [1,2,3]
>>> id(lst)
140078683813384
>>> lst += [4]
>>> id(lst)
140078683813384	# 注：内存地址不变
>>> lst[0]
1
>>> lst[0] = "a"	# 注：改变列表里的元素值
>>> id(lst)
140078683813384
# 下标不能越界（Index Error:list index out of range）
>>> lst
['b', 2, 3, 4]
>>> lst[4]		# 注：下标越界 会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

切片

1
2
3
4
5
6
切片是通过下标访问列表中的元素，切片可以取出一个子列表
起止区间：[ start,end )
step:默认=>1
start:默认=>step为正时，start为0；step为负时,start为-1
end:默认=>step为正时，end为列表结尾；step为负时,end为列表开始
注意：三个值都为选填项
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 示例：正切片
>>> a = [1,2,3,4,5,6]
>>> a[0:4]	# 注：切片，前4个
[1, 2, 3, 4]
>>> str = "123456"
>>> str[0:4]	# 注：切片，前4个
'1234'
>>> a[:4]		# 注：效果一样
[1, 2, 3, 4]

# 示例：负切片，步长为-1
>>> a = [1,2,3,4,5,6]
>>> a[-1:3:-1]	# 注：-1指向6， 3指向4，-1从右往左
[6, 5]
>>> a[-1:-4:-1]	# 注：-1指向6，-4指向3，-1从右往左
[6, 5, 4]
>>> a[-1:-44:-1]	# 注：-1指向6，-44越界，-1从右往左
[6, 5, 4, 3, 2, 1]
>>> a[-1:4:-1]	# 注：-1指向6,  4指向5，-1从右往左
[6]
>>> a[-3:4:-1]	# 注：-3指向4， 4指向5，4向左取不到5
[]				# 注：为空  起始位置有误时，切出来会是空(不会报错)
1
2
切片对象(slice函数)
	slice函数的用途：生成一个slice对象，相当于可以给要切的内容取个名字。
1
2
3
4
5
6
7
8
9
10
11
12
13
# 示例
>>> a = ["a","b","c","d"]
>>> a
['a', 'b', 'c', 'd']
>>> b = [1,2,3,4,5,6]
>>> s1 = slice(0,3,1)		# 注：引用时需要传参进去
>>> a[s1]					# 注：切片 前3个
['a', 'b', 'c']
>>> b[s1]					# 注：切片 前3个
[1, 2, 3]
>>> c = ["xx","yy","zz","ee"]	
>>> c[s1]					# 注：切片 前3个
['xx', 'yy', 'zz']

增加

1
2
3
4
增加列表元素的方式
	append:在末尾，作为整体追加，类型不限
	insert:在index位置插入元素
	extend:扩展列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 示例
# append
>>> a = ["apple", "orange", 123, 0.1111, "cali"]
>>> a.append("test")	# 注：追加字符串
>>> a
['apple', 'orange', 123, 0.1111, 'cali', 'test']
>>> lst = ['a','b','c']
>>> lst2 = [1,2,3]
>>> lst.append(lst2)	# 注：追加的类型是数组
>>> lst
['a', 'b', 'c', [1, 2, 3]]	# 注：追加的类型是数组
# insert
>>> lst = ['a','b','c']
>>> lst.insert(1,'d')		# 注：在第2个元素前插入数据
>>> lst
['a', 'd', 'b', 'c']
# extend
>>> a = [1,2,3]
>>> str = "abc"
>>> a.extend(str)		# 注：扩展字符串
>>> a
[1, 2, 3, 'a', 'b', 'c']
1
2
extend与+
	注意：只限可转为list的类型(str,list,tuple)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 示例
>>> a = ['a','b','c']
>>> a2 = [1,2,3]
>>> a.extend(a2)
>>> a
['a', 'b', 'c', 1, 2, 3]
>>> a + ["5"]				# 注：+ 法只能list 和 list 相加
['a', 'b', 'c', 1, 2, 3, '5']
>>> a
['a', 'b', 'c', 1, 2, 3]	# 注：+ 法 运行结束后 数组a没有变化
>>> b = a + ["5"]			# 注：赋值给数组b
>>> b					# 注：可以通过 赋值给数组b的方法来保存 变化
['a', 'b', 'c', 1, 2, 3, '5']
>>> id(a)
140273972677768
>>> a += ["6"]
>>> id(a)
140273972677768	# 注：a += ["6"] 	内存地址不变   对象不变，内容改变
>>> a = a + ["7"]
>>> id(a)
140273837551816	# 注：a = a + ["7"]内存地址改变

删除

1
2
3
4
5
6
删除列表元素的方式
	pop：删除元素，默认最后一个（指定index删除）
	remove：删除指定的元素（要删除的数据不存在时，会出错）
	del：根据下标删除
		del是python的一个关键字，用于删除变量(的引用)
	clear：清空列表
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
33
34
35
# 示例
# pop
>>> a.pop()	# 注：默认删除最后1个
'7'			# 注：返回值，删除的元素
>>> a.pop(2)	# 注：指定索引2 删除第3个元素
'c'
# remove
>>> a = ["xx","yy","xx"]
>>> a.remove("xx")		# 注：删除指定元素，只删除第1个
>>> a
['yy', 'xx']
>>> a
['yy', 'xx']
>>> a.remove("zz")		# 注：要删除的数据不存在时，会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
# del
>>> a = [1,2,3,"xx","yy","zz"]
>>> del a[3]		# 注：删除索引3  第4个
>>> a
[1, 2, 3, 'yy', 'zz']
>>> del a[0:2]	# 注：切片删除
>>> c = 1
>>> del c			# 注：del删除变量的引用
>>> c
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'c' is not defined
# clear
>>> a
[3, 'yy', 'zz']
>>> a.clear()
>>> a
[]			# 注：clear清空

修改

修改元素主要是利用下标和切片来修改或增加、删除

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
33
34
35
36
37
38
39
40
41
# 示例
>>> a = [1,2,3,'a','b','c']
>>> a
[1, 2, 3, 'a', 'b', 'c']
>>> a[2] = "x"	# 注：修改元素
>>> a
[1, 2, 'x', 'a', 'b', 'c']
>>> a[1:1]		# 注：[1,1)
[]				# 注：为空
>>> a[1:1] = "abc"	# 注：在起始位置 索引为1 处之前 增加列表 str类型转换为列表
>>> a
[1, 'a', 'b', 'c', 2, 'x', 'a', 'b', 'c']
>>> b = ["a","b","c"]
>>> b[2:2] = ["x","y"]		# 注：索引为2处之前  增加列表
>>> b
['a', 'b', 'x', 'y', 'c']
>>> b[2:4] = ["x","y","z"]	# 注：索引2、3 的值 替换
>>> b
['a', 'b', 'x', 'y', 'z', 'c']
>>> b[1:5] = "12"		# 注：切出来后，再转换为列表。str类型转换为列表
>>> b				# 注：索引1、2、3、4 的值 替换 为 ‘1’‘2’
['a', '1', '2', 'c']
>>> b
['a', '1', '2', 'c']
>>> b[5:-3]			
[]
>>> b[3:-3]			# 注：获取不到
[]
>>> b[3:-3] = "xy"		# 注：这个位置开始(start位置开始)，替换成其他的list
>>> b				# 注：看 找出的元素是否为空
['a', '1', '2', 'x', 'y', 'c']
>>> c = ["a","b","c","d","1"]
>>> c[1:4] = "hello"	# 注：找出b c d  把bcd 替换成h e l l o
>>> c
['a', 'h', 'e', 'l', 'l', 'o', '1']
>>> c = ['a', 'h', 'e', 'l', 'l', 'o', '1']
>>> c[5:3]				# 注：获取不到
[]
>>> c[5:3] = ["x","y"]		# 注：c[5:3]为空，在 o (下标5)处插入x y
>>> c
['a', 'h', 'e', 'l', 'l', 'x', 'y', 'o', '1']

反转

​ 反转列表-reverse 或 切片

1
2
3
4
5
6
7
8
9
10
11
12
13
# 示例
# 1.负切片 实现反转，输出的值反转
>>> a = [1,2,3,4]
>>> a[::-1]			# 注：负切片
[4, 3, 2, 1]
>>> a				# 注：a本身的值 没有反转
[1, 2, 3, 4]
# 2.reverse 字符串的反转
>>> a
[1, 2, 3, 4]
>>> a.reverse()
>>> a		# 注：a本身的值 反转
[4, 3, 2, 1]

排序

​ 列表排序-sort

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
# 示例
>>> a
[4, 3, 2, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]			# 注：排序后  a本身的值发生改变
# 反向排序
a.sort(reverse=True)
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)	# 注：反向排序，升序变成降序
>>> a
[4, 3, 2, 1]				# 注：从大到小排序
# 不支持int和str混合 的排序：
>>> a = ["a",1,"b",2]
>>> a.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'
>>> a = ["a","1","b","2"]
>>> a.sort()
>>> a
['1', '2', 'a', 'b']
# 按 编码排序
>>> a = ["a","1","b","2","A"]
>>> a
['a', '1', 'b', '2', 'A']

统计

​ len、count、index

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
# 示例
# len 总长度
>>> a
['a', '中', '序', '排', '文']
>>> len(a)
5
>>> a.append([1,2,3])
>>> len(a)
6
>>> a
['a', '中', '序', '排', '文', [1, 2, 3]]
>>> a.extend([1,2,3])
>>> len(a)
9
# count统计元素出现的次数
>>> a
['a', '中', '序', '排', '文', [1, 2, 3], 1, 2, 3]
>>> a.count("a")
1
>>> a.count(1)
1
# index返回元素所在的索引位置
>>> a = ["x","y","x",1]
>>> a.count("x")
2
>>> a.index("x")
0
>>> a.index("z")		# 注：index通过元素找索引，如果没有会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'z' is not in list

遍历

​ 遍历：依次取出对象中的每一项数据

​ list是一个可迭代对象（iterable），可以直接用for遍历

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
# 1.for i in a:
>>> a
['x', 'y', 'x', 1]
>>> for i in a:
...     print(f"item is --->{i}")
... 
item is --->x
item is --->y
item is --->x
item is --->1

# 2.enumerate()函数  
# 特点：会返回元组，元组里包含每一个下标和值
# 注：用1个i去遍历，获取的是元组
>>> for i in enumerate(a):
...     print(f"item is --->{i}")
... 
item is --->(0, 'x')
item is --->(1, 'y')
item is --->(2, 'x')
item is --->(3, 1)
# 用2个临时变量，获取enumerate(a)元组的返回
>>> for i,j in enumerate(a):
...     print(f"{i}-->{j}")
... 
0-->x
1-->y
2-->x
3-->1

判断成员关系

​ 判断列表中是否有某个数据

1
2
3
4
5
6
7
8
9
# 示例
>>> lst = ['a','b','c','d']
>>> print('a' in lst)
True
>>> print('x' in lst)
False
>>> s = 'a'
>>> print(s, '在' if s in lst else '不在','列表里')
a 在 列表里

类型转换

​ 字符串(str)转列表(list)

1
2
3
4
# 示例
>>> str = 'abc 123'
>>> list(str)
['a', 'b', 'c', ' ', '1', '2', '3']

二. 元组（tuple）

1
2
3
4
5
6
元组是处理一组有序项目的数据结构
元组和字符串一样是不可变的,即你不能修改元组
元组可以包含任何类型的对象：字符串、数字甚至其他列表
适应场景：性别选择，数据库的查询结果
Example:表示一个购物清单
	goods=('牛奶'、'运动鞋'、'咖啡'、'手机'、'羊肉'、'葡萄'、'桔子')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 示例
# 元组通过圆括号中用逗号分割的项目定义
>>> a = ()
>>> type(a)
<class 'tuple'>
>>> a = (1)			# 注：括号还可以代表集合
>>> type(a)
<class 'int'>
# 元组中只有一个元素的时候，需要在元素后面加个，区分这个括号是表示结合还是表示元组
>>> a = (1,)			# 注：元组中只有1个元素时，需要加逗号(,)表示元组
>>> type(a)
<class 'tuple'>
>>> a = tuple()		# 注：定义空元组
>>> type(a)
<class 'tuple'>
>>> a
()
# 元组可装入python的任何对象
>>> a = ("a",1,1.2,True,print)
>>> a
('a', 1, 1.2, True, <built-in function print>)

元组基本操作

索引

​ 通过下标访问列表中的元素，下标从0开始计数，可取出一个元素

1
2
3
4
5
6
7
8
9
10
11
12
# 示例
>>> a = ("a",1,1.2,True,print)
>>> a[4]
<built-in function print>
>>> a[3]
True
# 下标不能越界，越界会报错
>>> a = ("a",1,1.2,True,print)
>>> a[5]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: tuple index out of range

切片

1
2
3
4
5
6
切片是通过下标访问元组中的元素，切片可以取出一个子元组
起止区间：[start,end)
step:默认=>1
start:默认=>step为正时，start为0；step为负时,start为-1
end:默认=>step为正时，end为列表结尾；step为负时,end为列表开始
注意：三个值都为选填项
1
2
3
4
# 示例
>>> a = ("a",1,1.2,True,print)
>>> a[1:3]
(1, 1.2)

不可变性

1
2
3
4
5
6
7
8
9
10
11
12
# 示例
>>> a
('a', 1, 1.2, True, <built-in function print>)
>>> a[0] = 1					# 注：报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> tu1 = (1,2)
>>> tu2 = (3,4)
>>> tu3 = tu1 + tu2
>>> tu3
(1, 2, 3, 4)

统计

1
2
3
4
# 示例
>>> a = ('a','b','c')
>>> print(len(a))
3

遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 示例
>>> a = [1,2,3]
>>> for i in enumerate(a):
...     print(i)
... 
(0, 1)		# 注：返回值 是 元组
(1, 2)
(2, 3)
>>> for i,j in enumerate(a):
...     print(f"{i}---{j}")		# 注：用两个参数 来接收 返回值
... 
0---1
1---2
2---3

成员关系

​ 成员关系： in , not in

1
2
3
4
5
6
# 示例
>>> a = ("a","b","c")
>>> "a" in a
True
>>> "d" not in a
True

三. 字典（dict）

1
2
3
4
5
6
7
字典是Python中一个键值映射的数据结构
字典是无序的
字典是可变对象
key必须是唯一的,so天生去重
example:
	singer={key1:value,key2:value}
	singer={"李圣杰":'痴心绝对','张韶涵':'阿刁','汪峰':'普通迪斯高'}
1
2
3
4
字典的定义
	字典的key必须是可hash对象
	python中所有字符串、数字、元组、布尔值、None都是可hash对象
	字典的value可以是任何值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 示例
# 定义空字典
# 方法1：
>>> a = {}		# 注：定义空字典
# 方法2：
>>> b = dict()	# 注：定义空字典，工厂函数
>>> type(a)
<class 'dict'>
>>> type(b)
<class 'dict'>

# 示例
>>> c = [('root','123456'),('admin','admin')]
>>> d = dict(c)		# 注：列表转换成字典  工厂函数
>>> d
{'root': '123456', 'admin': 'admin'}
>>> e = [1,2,3]
>>> e
[1, 2, 3]
>>> dict(e)			# 注：转换的对象要有 键值映射 的格式
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot convert dictionary update sequence element #0 to a sequence

字典基本操作

取值

1
2
用法1：dicts[key]=>当key不存在时，会引了KeyError错误
用法2：dicts.get(key,default)=>当key不存在时，返回default值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 示例
>>> a = {"a":4,"b":2}
>>> a['a']=3			# 注：修改key=”a”的 value 值
>>> a
{'a': 3, 'b': 2}
>>> a['c']=4			# 注：增加键值对
>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a['c']			# 注：取值
4
>>> a['d']			# 注：key不存在，报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'd'
# 推荐使用get
>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a.get('d')		# 注：不报错
>>> c = a.get('d')
>>> print(c)
None					# 注：默认值没有设置

增加/修改

1
2
3
用法：dicts[key]=value
	当key不存在时，表示增加一个键值对
	当key存在时，表示修改对应的value值
1
2
3
4
5
6
7
8
9
10
# 示例：修改
>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a['a'] = 5
>>> a
{'a': 5, 'b': 2, 'c': 4}
# 示例：新增
>>> a['d'] = False
>>> a
{'a': 5, 'b': 2, 'c': 4, 'd': False}

删除

1
2
用法1：dicts.pop(key)
用法2：dicts.popitem()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 示例：dicts.pop(key)
>>> a = {'a':5,'b':2,'c':4,'d':False}
>>> a.pop('a')		# 注：删除 key=‘a’ 的元素
5					# 注：pop有返回值
>>> c = a.pop('b')		# 注：获取返回值
>>> c
2
>>> a
{'c': 4, 'd': False}
# 示例：dicts.popitem()
# python3里面删除的是最后一个
>>> a = {"x":1,"y":2,"z":3}
>>> a.popitem()
('z', 3)
>>> a.popitem()
('y', 2)
>>> a.popitem()
('x', 1)

合并

1
2
用法1：dict1.update(dict2)=>将dict2合并到dict1
用法2：dict(dict1,**dict2)=>将dict1与dict2合并生成一个新字典
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 示例：dict1.update(dict2)
>>> a = {"x":1,"y":3}
>>> b = {"q":2,"w":3}
>>> a.update(b)	# 注：a自带的属性
>>> a
{'x': 1, 'y': 3, 'q': 2, 'w': 3}
>>> b
{'q': 2, 'w': 3}
# 示例：dict(dict1, **dict2)
>>> a = {"x":1,"y":3}
>>> b = {"q":2,"w":3}
>>> dict(a,**b)	# 注：工厂函数，返回一个字典  a和b的合并
{'x': 1, 'y': 3, 'q': 2, 'w': 3}
>>> a	# 注：a本身没有改变
{'x': 1, 'y': 3}
>>> dict()
{}
>>> c = dict(a,**b)
>>> c
{'x': 1, 'y': 3, 'q': 2, 'w': 3}

成员关系

1
2
3
用法：
	item in dicts
	item not in dicts
1
2
3
4
5
6
7
8
9
10
# 示例
>>> a = {"x":1,"y":2,"z":3}
>>> a
{'x': 1, 'y': 2, 'z': 3}
>>> 'x' in a		# 注：in  默认 对比的是key值
True
>>> 2 in a
False
>>> 2 in a.values()		# 注：a.values()对比的是value值
True

遍历

​ 默认遍历的是 key

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
33
34
35
36
37
38
39
40
41
42
43
# 示例
>>> a
{'x': 1, 'y': 2, 'z': 3}

# 遍历key值
>>> for i in a:
...     print(i)
... 
x              # 注：遍历key值
y
z

# 遍历value值
>>> for i in a.values():
...     print(i)
... 
1               # 注：遍历value值
2
3

# 既想获得key  也想获得value
# items返回的是元组
# 方式1
>>> for i in a.items():
...     print(i)
... 
('x', 1)
('y', 2)
('z', 3)
# 方式2
>>> for i,j in a.items():	# 注：2个参数获取返回值key,value
...     print(f"key is {i}, value is {j}")
... 
key is x, value is 1
key is y, value is 2
key is z, value is 3
# 方式3
>>> for i in a.items():
...     print(f"key is {i[0]}, value is {i[1]}")	# 注：索引获取参数
... 
key is x, value is 1
key is y, value is 2
key is z, value is 3

四. 集合（set）

1
2
集合是一个无序的，不重复的数据组合
集合是一个只含有key的字典
1
2
3
4
5
集合的作用
	去重：把一个列表变成集合，就自动去重了
	关系测试：测试两组数据之前的交集、差集、并集等关系
	example:
		singer={"李圣杰",'张韶涵','汪峰'}
1
2
3
4
集合的定义
	集合通过花括号中，而各个元素用逗号分割
	集合元素必须是可hash对象，跟字典一样
	set和dict的唯一区别仅在于没有存储对应的value
1
2
3
4
5
6
7
8
9
10
# 示例
# 定义空集合（2种方式）
>>> a = {1,2,3}	# 注：第1种方式
>>> type(a)
<class 'set'>
>>> a = set()		# 注：第2种方式
>>> a
set()
>>> type(a)
<class 'set'>

集合基本操作

添加

1
2
用法：s.add(item)=>添加一项
用法：s.update(someitems)=>添加多项
1
2
3
4
5
6
7
8
9
10
11
# 示例
>>> s = {1,2,3}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.update("str")	# 注：str被扩展进来，是一个一个被扩展进来的
>>> s
{1, 2, 3, 4, 't', 'r', 's'}
>>> s.update({"x":1,"y":2})	# 注：字典  扩展的是 key值
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 'r', 's'}

移除

1
2
用法1：s.remove(item)=>移除一项(item不存在会出错KeyError)
用法2：s.discard(item)=>移除一项(item不存在则什么也不做)
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
# 示例
# remove
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 'r', 's'}
>>> s.remove('r')
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 's'}
>>> s.remove('p')	# 注：“p”不存在，报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'p'
# discard
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 's'}
>>> s.discard('o')	# 注：不存在 不报错  什么也不做
>>> s.discard('x')
>>> s
{1, 2, 3, 4, 't', 'y', 's'}
# pop
>>> a={"a","b","c"}
>>> a.pop()
'c'
>>> a.pop()
'a'
>>> a.pop()
'b'

集合操作

1
2
3
4
并集：t和s的并集,返回一个新的set包含s和t中的每一个元素
交集:t和s的交集,返回一个新的set包含s和t中的公共元素
差集:返回一个新的set包含s中有但是t中没有的元素
对称差集:返回一个新的set包含s和t中不重复的元素（在t或s中，但不会同时出现在二者中）
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
33
34
35
36
# 示例
# 创建集合
>>> set('hello')
{'e', 'o', 'l', 'h'}

# 并集
>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 | s2
{1, 2, 3, 4}
>>> s1.union(s2)
{1, 2, 3, 4}

# 交集
>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 & s2
{2, 3}
>>> s1.intersection(s2)
{2, 3}

# 差集
>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 - s2
{1}
# 注：s1里面有的,s2里面没有的
>>> s2 - s1
{4}

# 对称差集
>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 ^ s2
{1, 4}
# 注：除了交集 的部分