一、set集合的创建

#1、创建集合
示例1：创建

s = {1,2,3,1,2,3}
print(s,type(s))
#结果
{1, 2, 3} <class 'set'>
1
2
3
4

示例2：集合里面不能有其他变量

s = {1,2,3,[1,2,3]}
print(s,type(s))
#结果
TypeError: unhashable type: 'list'
1
2
3
4

注意：空集合得用set

s={}
print(s,type(s))         其结果为字典

k=set()
print(k,type(k))         set的结果才是集合
#结果
{} <class 'dict'>
set() <class 'set'>
1
2
3
4
5
6
7
8

二、集合的特性

因为集合是无序，不重复的，所以
不支持连接，重复，索引，切片
支持成员操作符（in ，not in)

三、常用操作

(1)、增加

1、add增加一个

s = {1,2,3}
s.add(100)
print(s)
#结果
{1, 2, 3, 100}
1
2
3
4
5

2、update一次增加多个

s = {1,2,3}
s.update({4,5,6})
print(s)
#结果
{1, 2, 3, 4, 5, 6}
1
2
3
4
5

(2)、删除

1、remove：删除（如果删除的数字没有则会报错）

s = {1,2,3}
s.remove(3)
print(s)
#结果
{1, 2}
1
2
3
4
5

2、discard：删除（如果数字没有则不进行操作）

s = {1,2,3}
s.discard(3)
print(s)
#结果
{1, 2}
1
2
3
4
5

3、pop：任意删除一个值（集合为空则删除）

s = {1,2,3,4,5}
s.pop()
print(s)
#结果
{2, 3, 4, 5}
1
2
3
4
5

(3)、查看

1、差集

s1={1,2,3,4}
s2={3,4}
print(s1-s2)
#结果
{1, 2}
1
2
3
4
5

2、交集

s1={1,2,3,4}
s2={3,4}
print(s1-s2)
print(s1 & s2)
#结果
{3, 4}
1
2
3
4
5
6

3、对称差分

s1={1,2,3}
s2={1,2,4}
print(s1^s2)
#结果
{3, 4}
1
2
3
4
5

4、并集

s1={1,2,3}
s2={1,2,4}
print(s1|s2)
#结果
{1, 2, 3, 4}
1
2
3
4
5

5、判断子集

s1={1,2,3}
s2={1,2,4}
print(s1.issubset(s2))       s1是s2的子集合吗
#结果
False
1
2
3
4
5

6、判断交集

s1={1,2,3}
s2={1,2,4}
print(s1.isdisjoint(s2))         s1与s2没有交集对吗
#结果
False
1
2
3
4
5

7、拓展：frozenset
不能增加，删除
s = frozenset({1,2,3})
print((s,type(s)))
#结果
(frozenset({1, 2, 3}), <class ‘frozenset’>)

四、练习

import random
NUMBER=set()
print(NUMBER,type(NUMBER))
for x in range(100):
    num = random.randint(1,1000)
    NUMBER.add(num)
print(NUMBER)
print(sorted(NUMBER,reverse=True))
1
2
3
4
5
6
7
8

五、dict字典的创建

1、字典的创建
key-value对或者键值对

d = {"name":"westos","age":18,"city":"西安"}
print(d,type(d))
#结果
{'name': 'westos', 'age': 18, 'city': '西安'} <class 'dict'>
1
2
3
4

2、创建空字典

d={}
print(d,type(d))
#结果
{} <class 'dict'>
1
2
3
4

六、字典的特性

和集合类似，不支持拼接，重复等
1、判断成员操作符

d = {"name":"westos","age":18,"city":"西安"}
print('name' in d)
print('westos' in d)                                   
#结果
True                               是判断key值的，因此答案是ture
False                              是westos不是key值的，因此答案是false
1
2
3
4
5
6

七、字典的常用方法

1、查看

d = {"name":"westos","age":18,"city":"西安"}
print(d.keys())             	  	 			 查看所有可以、值
print(d.values())          						 查看所有value
print(d.items())            					 查看所有元素
print(d['name'])            					 查看name对应的value值
print(d.get('province'))   			 			 查看省份、对应返还value值，如果存在则返还，如果不存在则返还为None
print(d.get('province','陕西'))      			 查看身份，如果没有则返还默认值
#结果
dict_keys(['name', 'age', 'city'])
dict_values(['westos', 18, '西安'])
dict_items([('name', 'westos'), ('age', 18), ('city', '西安')])
westos
陕西
1
2
3
4
5
6
7
8
9
10
11
12
13

2、增加和修改

d = {"name":"westos","age":18,"city":"西安"}
print(d)
d['privince']='陕西'                                          如果没有则增加
print(d)
d['privince']='山东'                                          如果有则修改
print(d)
#结果
{'name': 'westos', 'age': 18, 'city': '西安'}
{'name': 'westos', 'age': 18, 'city': '西安', 'privince': '陕西'}
{'name': 'westos', 'age': 18, 'city': '西安', 'privince': '山东'}
1
2
3
4
5
6
7
8
9
10

{'name': 'westos', 'age': 18}
d.setdefault('city','西安')                      如果没有则添加
print(d)
d.setdefault('city','北京')                      如果有key值，则不做操作
print(d)
#结果
{'name': 'westos', 'age': 18, 'city': '西安'}
{'name': 'westos', 'age': 18, 'city': '西安'}
1
2
3
4
5
6
7
8

3、删除

d = {'name': 'westos', 'age': 18}
del d['name']
print(d)
#结果
{'age': 18}
1
2
3
4
5

d = {'name': 'westos', 'age': 18}
d.pop('name')
print(d)
#结果
{'age': 18}
1
2
3
4
5

4、遍历
一般的遍历只会遍历出key值

d = {"name":"westos","age":18,"city":"西安"}
for items in d:
    print(items)
#结果
name
age
city
1
2
3
4
5
6
7

遍历出所有

d = {"name":"westos","age":18,"city":"西安"}
for item in d.items():
    print(item)
#结果
('name', 'westos')
('age', 18)
('city', '西安')
1
2
3
4
5
6
7

分别遍历出key和value（很重要）

d = {"name":"westos","age":18,"city":"西安"}
for key,value in d.items():
    print(f'key={key},value={value}')
#结果
key=name,value=westos
key=age,value=18
key=city,value=西安
1
2
3
4
5
6
7

5、默认字典
(1)、int整型
设置默认的value值，这里定义int整型

from  collections import  defaultdict
d = defaultdict(int)
print(d)
print(d['views'])
#结果
defaultdict(<class 'int'>, {})            
0
1
2
3
4
5
6
7

采用这种方式可以直接进行补充

from  collections import  defaultdict
d = defaultdict(int)
d['view'] +=1
d['transfer'] +=1
print(d)
#结果
defaultdict(<class 'int'>, {'view': 1, 'transfer': 1})
1
2
3
4
5
6
7

(2)、list类型
这里设置为列表类型，可以用列表的append进行追加

d = defaultdict(list)
d['allow_users'].append('westos')
d['deny_users'].extend('ck1,ck2')
print(d)
#结果
defaultdict(<class 'list'>, {'allow_users': ['westos'], 'deny_users': ['ck1', 'ck2']})
1
2
3
4
5
6

(3)、set集合类型

defaultdict(<class ‘set’>, {‘love_movies’: {‘前任3’, ‘电影xxx’, ‘黑客帝国’}})

八、总结

有序序列拥有的特性：索引，切片，链接操作符，重复操作符以及成员操作符的部分特性。
1、可变和不可变（a赋值b，a改变值后，b地址是否能改变）
可变数据类型：list，set，dict
不可变数据类型：数值，元组
2、序列
见ppt