集合

集合 set

  集合是可变的容器
  集合内的数据对象都是唯一的(不能重复多次的)
  集合是无序的存储结构,集合中的数据没有先后关系
  集合内的元素必须是不可变对象
  集合是可迭代对象
  集合是相当于只有键没有值的字典(键则是集合的数据)

创建空的集合:

  set()  

创建非空的集合的字面值:

  s = {1, 2, 3}

集合的构造函数:

 set()  创建一个空的集合(不能用{ } 来创建空集合)
set(iterable) 用可迭代对象创建一个新的集合

示例:

 s = set()
 s = {2,3,5,7}
 s = set("ABC")  					# s = {'A', 'B', 'C'}
 s = set("ABCCBA")  	# s = {'A', 'B', 'C'}集合内的数据对象都是唯一的(不能重复多次的)

 s = set({1:"1", 2:'2', 5:'5'})    # s = {1, 2, 5}集合是相当于只有键没有值的字典(键则是集合的数据)
 s = set(('ABC', '123', True))
 s = {True, None, "ABC", (1, 2, 3)}

python3 中不可变数据类型

  bool, int, float, complex, str, tuple, frozenset,bytes

可变数据类型

list, dict, set, bytearray

集合的运算:

  交集&  并集|  补集-  对称补集^  子集<  超集 >

& 用于生成两个集合的交集

	  s1 = {1, 2, 3}
	  s2 = {2, 3, 4}
	  s1 & s2  			# {2, 3}

| 生成两个集合的并集

  s1 = {1, 2, 3}
  s2 = {2, 3, 4}
  s1 | s2  			# {1, 2, 3, 4}

• 生成两个集合的补集

  s1 = {1, 2, 3}
  s2 = {2, 3, 4}
  s1 - s2  					# {1}  # 生成属于s1, 但属于 s2的所元素的集合
  

^ 生成两个集合的对称补集

  s1 = {1, 2, 3}
  s2 = {2, 3, 4}
  s1 ^ s2  					# {1, 4}

判断一个集合是另一个集合的超集
< 判断一个集合是别一个集合的子集
s1 = {1, 2, 3}
s2 = {2, 3}
s1 > s2 # True
s2 < s1 # True
S1 < S2 # false

== 　　!= 集合相同/不同
s1 = {1, 2, 3}
s2 = {3, 2, 1}
s1 == s2 # True

in / not in 运算

   in 同列表和字典的in运算符规则相同,如果存在于集合中返回 True,否则返回False

示例:

  2 in {1, 2, 3} 				# True

用于集合的函数

  len(x)  返回集合的长度
  max(x)  返回集合的最大值元素
  min(x)  返回集合的最小值元素
  sum(x)  返回集合中所有元素的和
  any(x)  真值测试，规则与列表相同
  all(x)  真值测试，规则与列表相同

集合是可迭代对象,可以用于for语句中

练习:
经理有: 曹操，刘备，孙权
技术员有: 曹操，孙权，张飞，关羽
用集合求:
1. 即是经理也是技术员的有谁?
2. 是经理，但不是技术人员的都有谁?
3. 是技术人员，但不是经理的都有谁?
4.　张飞是经理吗？
　　　　5. 身兼一职的人都有谁?
6. 经理和技术员共有几个人?

答案：

a = {'曹操', '刘备', '孙权'}
b = {'曹操', '孙权', '张飞', '关羽'}

print("即是经理也是技术员的有:", a & b)
print("是经理，但不是技术人员的都有:", a - b)
print("是技术人员，但不是经理的都有:", b - a)
if '张飞' in  a :
    print("张飞是经理")
else:
    print("张飞不是经理")

print("身兼一职的人都有", a ^ b)
print("经理和技术员共有%d个人" % len(a | b))

集合的方法:

S.add(e) 	在集合中添加一个新的元素e；如果元素已经存在，则不添加
S.remove(e) 	从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误
S.discard(e) 	从集合S中移除一个元素e,在元素e不存在时什么都不做;
S.clear() 	清空集合内的所有元素
S.copy() 	将集合进行一次浅拷贝
S.pop() 	从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常
S.update(s2) 	等同于 S
	
S.difference(s2) 	S - s2 补集运算，返回存在于在S中，但不在s2中的所有元素的集合
S.difference_update(s2) 	等同于 S -= s2
S.intersection(s2) 	等同于 S & s2
S.intersection_update(s2) 	等同于S &= s2
S.isdisjoint(s2) 	如果S与s2交集为空返回True,非空则返回False
S.issubset(s2) 	如果S与s2交集为非空返回True,空则返回False
S.issuperset(...) 	如果S为s2的子集返回True,否则返回False
S.symmetric_difference(s2) 	返回对称补集, 等同于 S ^ s2
S.symmetric_difference_update(s2) 	等同于 S ^= s2, 用 S 与 s2 的对称补集更新 S
S.union(s2) 	生成 S 与 s2的全集, 等同于 S

集合推导式:

  是用可迭代对象创建集合的表达式　

语法:

{表达式 for 变量　in 可迭代对象　[if 真值表达式]}

[] 部分代表可省略

示例:

numbers = [1, 3, 5, 7, 9, 3, 4, 5, 6, 7]
s = {x ** 2 for x in numbers if x % 2 == 1}
print(s)

固定集合 frozenset

固定集合是不可变的，无序的，含有唯一元素的集合

作用:

	固定集合可以作为字典的键，也可以作为集合的值

固定集合的构造函数 frozenset

frozenset()  创建一个空的固定集合
frozenset(iterable) 用可迭代对象创建一个新的固定集合

示例:
  fz = frozenset()
  fz = frozenset("ABCAB")
  fz = frozenset([1, 2, 3, 4, 5])

固定集合的运算:
& 交集
| 　并集

• 补集
  ^ 对称补集
  in / not in运算

= < <= == !=
(以上运算等同于集合的运算)

固定集合的方法:

  相当于集合的全部方法去掉修改集合的方法

阶段总结:

  数据类型:
    不可变数据类型:
       bool, int, float, complex, str, tuple, frozenset,bytes
    可变的数据类型:
       list, dict, set, bytearray

    值:
      None, False, True, ....  

运算符:

+ - * / // % **
<　<= > >= == !=
is , is not
in , not in
not  and   or
&  |  ^  ~ << >>
+(正号)  -(负号)

表达式:

  100
  100 + 200
  max(1,2,3)  # 函数调用也是表达式
  条件表达式  x if x > y else y
  全部的推导式:
      列表，字典，集合推导式(只有三种)

语句:

  表达式 语句:
    print("hello world!")
    '''这是字符串'''
  赋值语句:
    a = 100
    b = c = d = 200
    x, y = 100, 200
列表[整数表达式]　= 表达式
字典[键]　= 表达式