Python学习7

python学习7

数据类型

集合

1. 集合的定义和特性

集合的定义

s1 = set()  #空集合
print(s1,type(s1))  

s1 = {1,2,3,4}
print(s1,type(s1))

集合是无序的

s1 = {1,2,3,4}              #{1, 2, 3, 4} <class 'set'>
s1 = {4,3,2,1}              #{1, 2, 3, 4} <class 'set'>
s1 = {"张三","李四","王五"}   #{'李四', '张三', '王五'} <class 'set'>
s1 = {"张三","王五","李四"}   #{'张三', '李四', '王五'} <class 'set'>
print(s1,type(s1))

集合中的元素是不重复的

s1 = {1,2,3,4,4}
print(s1) #自动去重（去除重复）   {1, 2, 3, 4}

集合：只能存放不可变元素 (key)

s1 = {2.0,True,1,"abc"}             #字典也可以存放多种数据类型
s1 = {2.0,True,1,"abc",{"id":1}}    #报错：TypeError: unhashable type: 'dict'
s1 = {2.0,True,1,"abc",[3,4]}       #报错：TypeError: unhashable type: 'list'
s1 = {2.0,True,1,"abc",(3,4)}         #可以
print(s1,type(s1))

小结：集合中只能存放不可变的类型，列表（list）和字典（dict）不能放到集合中

2. 常用操作：

操作名称	操作方法	举例
遍历集合	通过for循环	for i in set1: print(i)
更新集合	update方法	set1.update(set2)
向集合添加新元素	add方法	set1.add(5)
移除集合中的元素	remove方法	set1.remove(5)
弹出元素	pop方法	val = set1.pop()
清除元素	clear方法	set1.clear()
删除集合	del	del set1

#[增]:add
s1 = {1,2,3,4,5}
print(s1,id(s1))

s1.add(6)
print(s1,id(s1))

#将指定的序列,依次加入到集合中
s1.update("abcd")
print(s1,id(s1))

s1 = {1,2,3,4,5}
s2 = ["aa","bb","cc"]
s1.update(s2)
print(s1,id(s1))

#[删]:clear、remove、pop、discard
s1 = {"a","b","c","d"}

s1.clear()      #清空集合中的元素
x = s1.pop()    #pop随机弹出一个元素,每次执行结果不一定相同
print(x,s1)

s1.remove("e")      #只能通过元素内容来删除,如果没有找到指定元素，报错：KeyError
print(s1)
s1.discard("a")     #如果没有找到指定元素,不做任何操作  
print(s1)

#[改]:变相删除,先删后增
s1 = {"a","b","c","d"}
s1.remove("b")
s1.add("e")
print(s1)

#[查]
#遍历
s1 = {"a","b","c","d"}
for i in s1:
    print(i)
#包含 in,not in
s1 = {"a","b","c","d"}
res = "a" not in s1
print(res)

操作名称	操作方法
获取集合长度	len()
获取最大的元素	max()
获取最小的元素	min()
其它类型对象转换成集合	set()

3. 集合的运算

集合的运算：交、差、并、反交
在对集合做运算时，不会影响原来的集合，而是返回一个运算结果

#创建两个集合
s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# 交集运算 （& 或者intersection)
result = s1 & s2 # {3, 4, 5} #两个集合中都有的部分
result = s1.intersection(s2)
print("result=",result)


# 并集运算 (| 或 union)
result = s1 | s2 # {1,2,3,4,5,6,7} #两个集合中出现的全部数据（去重:去掉重复)
result = s1.union(s2)
print('result =',result)

#差集 (- 或 difference)
result = s1 - s2 # {1, 2} #保留的是被减数的部分
result = s1.difference(s2)
result = s2 - s1 # {6, 7}
print('result =',result)

# 异或集 或称作 对称差集 (^ 或 symmetric_difference)
result = s1 ^ s2 # {1, 2, 6, 7} #获取只在一个集合中出现的元素
result = s1.symmetric_difference(s2)
print('result =',result)

# 子集或超集
# <= 检查一个集合是否是另一个集合的子集
# 如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集，b集合是a集合超集

a = {1,2,3}
b = {1,2,3,4,5}

result = a <= b
print(a.issubset(b))
print(b.issuperset(a))
# result = {1,2,3} <= {1,2,3}
result = {1,2,3,4,5} <= {1,2,3}
print('result =',result)


# < 检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中所有元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集
result = {1,2,3} < {1,2,3} # False
print('result =',result)
result = {1,2,3} < {1,2,3,4,5} # True
print('result =',result)


# 不相交 isdisjoint
result = a.isdisjoint(b) #不相交：True； 相交：False
print("result=",result)

#应用：
#列表去重：
num = [1,1,2,2,3,3,4,4]
s = set(num)        #注意：顺序可能会被打乱
res = list(s)
print(res,type(res))


#冰冻集合 frozenset（了解）
#冰冻集合，可以强制转化为容器类型：冰冻集合
#冰冻集合一旦创建，不能进行任何修改，只能用于集合运算操作
s = frozenset()     #定义一个空的冰冻集合
print(s,type(s))


s1 = [1,2,3,4,5,"abc"]
s1 = "abcde"
s2 = frozenset(s1)
print(s2,type(s2))

#s2.add("f")        #报错：冰冻集合不能做修改

s3 = frozenset("aef") #可以进行结合运算
print(s2 & s3)

小结

	是否有序	是否可变类型	元素重复与否
列表[ ]	有序	可变类型	可重复
元组( )	有序	不可变，元素不能修改	可重复
字典{ }	无序	可变（键只能增删，不可修改）	key不重复
集合{ }	无序	可变（通过增删实现修改）	不重复（自动去重）

简单理解：因为“有序”，可以通过索引（下标）访问元素，所以可以“重复”
                  因为“无序”，只能通过内容访问元素，所以“不可重复"