Dave Python练习六--集合
view plaincopy to clipboardprint?#encoding=utf-8
#*************** 集合类型 ********************
#*********** Part 1： 集合 ***********************
#数学上， 把set 称做由不同的元素组成的集合，集合(set)的成员通常被称做集合元素(set
#elements)。Python 把这个概念引入到它的集合类型对象里。集合对象是一组无序排列的可哈希的值。
#是的，集合成员可以做字典中的键。数学集合转为Python 的集合对象很有效，集合关系测试和union、
#intersection 等操作符在Python 里也同样如我们所预想地那样工作。
#
#和其他容器类型一样，集合支持用 in 和 not in 操作符检查成员, 由 len() 内建函数得到集
#合的基数(大小), 用for 循环迭代集合的成员。但是因为集合本身是无序的，你不可以为集合创建
#索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值。
#
#集合(sets)有两种不同的类型，可变集合(set) 和 不可变集合(frozenset)。如你所想，对可
#变集合(set)，你可以添加和删除元素，对 不可变集合(frozenset)则不允许这样做。请注意，可变
#集合(set)不是可哈希的，因此既不能用做字典的键也不能做其他集合中的元素。不可变集合
#(frozenset)则正好相反，即，他们有哈希值，能被用做字典的键或是作为集合中的一个成员。
#创建集合类型和赋值
#集合与列表( [ ] )和字典( { } ) 不同，没有特别的语法格式。列表和字典可以分别用他们自
#己的工厂方法 list() 和 dict() 创建，这也是集合被创建的唯一方法 - 用集合的工厂方法 set()和 frozenset():
#s = set('cheeseshop')
#print(s)
#t = frozenset('bookshop')
#print(t)
#print(type(s))
#print(type(t))
#print('s: %s, t:%s ' %(len(s),len(t)))
#-->
#{'c', 'e', 'h', 'o', 'p', 's'}
#frozenset({'b', 'h', 'k', 'o', 'p', 's'})
#<class 'set'>
#<class 'frozenset'>
#s: 6, t:6
#访问集合中的值
#你可以遍历查看集合成员或检查某项元素是否是一个集合中的成员:
#s = set('Dave is DBA')
#t = frozenset('Dave come from anqing')
#for i in s:
# print(i)
#-->
#a
#
#B
#e
#D
#i
#s
#A
#v
#--注意这里是无序的
#print('l' in s)
#print('l' in t)
#-->
#False
#False
#更新集合
#用各种集合内建的方法和操作符添加和删除集合的成员:
#s = set('Dave is DBA')
#t = frozenset('Dave come from anqing')
#
#s.add('Oracle')
#print(s)
#-->{'a', ' ', 'B', 'e', 'D', 'i', 's', 'A', 'v', 'Oracle'}
#
#s.update('China')
#print(s)
#-->{'a', ' ', 'C', 'B', 'e', 'D', 'i', 'h', 'n', 's', 'A', 'v', 'Oracle'}
#--通过这个，我们可以看出add 和 update的区别， add 把内容作为一个元素添加进去，
#--而updte 是把内容分别放进去
#
#s.remove('D')
#print(s)
#-->{'a', ' ', 'C', 'B', 'e', 'i', 'h', 'n', 's', 'A', 'v', 'Oracle'}
#
#s -=set('China')
#print(s)
#-->{' ', 'B', 'e', 's', 'A', 'v', 'Oracle'}
#--这个是集合的相减操作
#只有可变集合能被修改。试图修改不可变集合会引发异常。
#t.add('Dave')
#-->
#AttributeError: 'frozenset' object has no attribute 'add'
#删除集合中的成员和集合
#删除集合本身，可以像删除任何Python 对象一样，令集合超出它的作用范围，或调用del 将他们直接清除出当前的名字空间。
#如果它的引用计数为零，也会被标记以便被垃圾回收。
# del s
#**************** Part 2： 集合类型操作符 **********************
###############标准类型操作符（所有的集合类型）
#成员关系 (in, not in)
#就序列而言，Python 中的in 和not in 操作符决定某个元素是否是一个集合中的成员。
#s = set('Dave is DBA')
#t = frozenset('Dave come from anqing')
#
#print('D' in s)
#print('D' not in s)
#-->
#True
#False
#集合等价/不等价
#等价/不等价被用于在相同或不同的集合之间做比较。两个集合相等是指，对每个集合而言，当
#且仅当其中一个集合中的每个成员同时也是另一个集合中的成员。
#你也可以说每个集合必须是另一个集合的一个子集， 即，s <= t 和 s >= t 的值均为真(True),
#或(s <= t and s>= t) 的值为真(True)。集合等价/不等价与集合的类型或集合成员的顺序无关，
#只与集合的元素有关。
#s=set('Dave come from anqing')
#s1=set('Dave')
#print(s==s1)
#-->False
#子集/超集
#Sets 用Python 的比较操作符检查某集合是否是其他集合的超集或子集。“小于”符号( <, <= )
#用来判断子集，“大于”符号( >, >= )用来判断超集。
#print(s1<s)
#-->
#True
###############集合类型操作符（所有的集合类型）
#联合( | )
#联合(union)操作和集合的OR(又称可兼析取(inclusive disjunction))其实是等价的，两个集
#合的联合是一个新集合，该集合中的每个元素都至少是其中一个集合的成员，即，属于两个集合其
#中之一的成员。联合符号有一个等价的方法，union().
#s=set('Dave come from anqing')
#s1=set('Dave')
#print(s|s1)
#-->
#{'a', ' ', 'c', 'e', 'D', 'g', 'f', 'i', 'm', 'o', 'n', 'q', 'r', 'v'}
#交集( & )
#你可以把交集操作比做集合的AND(或合取)操作。两个集合的交集是一个新集合，该集合中的每
#个元素同时是两个集合中的成员，即，属于两个集合的成员。交集符号有一个等价的方法，intersection().
#print(s&s1)
#-->{'a', 'e', 'D', 'v'}
#差补/相对补集( – )
#两个集合(s 和t)的差补或相对补集是指一个集合C，该集合中的元素，只属于集合s，而不属
#于集合t。差符号有一个等价的方法，difference().
#print(s-s1)
#-->{' ', 'c', 'g', 'f', 'i', 'm', 'o', 'n', 'q', 'r'}
#对称差分( ^ )
#和其他的布尔集合操作相似，对称差分是集合的XOR(又称”异或“ (exclusive disjunction)).
#两个集合(s 和t)的对称差分是指另外一个集合C,该集合中的元素，只能是属于集合s 或者集合t
#的成员，不能同时属于两个集合。对称差分有一个等价的方法，symmetric_difference().
#print(s^s1)
#-->{' ', 'c', 'g', 'f', 'i', 'm', 'o', 'n', 'q', 'r'}
###############集合类型操作符（仅适用于可变集合）
#(Union) Update ( |= )
#这个更新方法从已存在的集合中添加(可能多个)成员，此方法和update()等价.
#s=set('David')
#s1=set('Dai')
#s|=s1
#print(s)
#-->{'a', 'D', 'i', 'v', 'd'}
#保留/交集更新( &= )
#保留(或交集更新)操作保留与其他集合的共有成员。此方法和intersection_update()等价.
#s&=s1
#print(s)
#-->{'a', 'i', 'D'}
#差更新 ( –= )
#对集合s 和t 进行差更新操作s-=t，差更新操作会返回一个集合，该集合中的成员是集合s 去
#除掉集合t 中元素后剩余的元素。此方法和difference_update()等价.
#s-=s1
#print(s)
#-->{'d', 'v'}
#对称差分更新( ^= )
#对集合s 和t 进行对称差分更新操作(s^=t),对称差分更新操作会返回一个集合，该集合中的成
#员仅是原集合s 或仅是另一集合t 中的成员。此方法和symmetric_difference_update()等价.
#s^=s1
#print(s)
#-->{'d', 'v'}
#**************** Part 3： 内建函数 **********************
################标准类型函数
#len()
#把集合作为参数传递给内建函数len()，返回集合的基数(或元素的个数)。
#s=set('dave come from anqing')
#print(len(s))
#-->14
########### 集合类型工厂函数
#set() and frozenset()
#set()和 frozenset()工厂函数分别用来生成可变和不可变的集合。如果不提供任何参数，默认
#会生成空集合。如果提供一个参数，则该参数必须是可迭代的，
#即，一个序列，或迭代器，或支持迭代的一个对象，例如：一个文件或一个字典。
#**************** Part 4： 集合类型内建方法 **********************
###############方法（所有的集合方法）
#内建方法copy() 没有等价的操作符。
#方法名称 操作
#s.issubset(t) 如果s 是t 的子集，则返回True,否则返回False
#s.issuperset(t) 如果t 是s 的超集，则返回True,否则返回False
#s.union(t) 返回一个新集合，该集合是s 和t 的并集
#s.intersection(t) 返回一个新集合，该集合是s 和t 的交集
#s.difference(t) 返回一个新集合，该集合是s 的成员，但不是t 的成员
#s.symmetric_difference(t) 返回一个新集合，该集合是s 或t 的成员，但不是s 和t 共有的成员
#s.copy() 返回一个新集合，它是集合s 的浅复制
################# 操作符和内建方法比较
#很多内建的方法几乎和操作符等价。我们说"几乎等价"，意思是它们间是有一个
#重要区别： 当用操作符时，操作符两边的操作数必须是集合。 在使用内建方法时，对象也可以是
#迭代类型的。为什么要用这种方式来实现呢？ Python 的文档里写明： 采用易懂的
#set('abc').intersection('cbs') 可以避免用 set('abc') [and] 'cbs' 这样容易出错的构建方
#法。
##可变集合类型的方法
#方法名 操作
#s.update(t) 用t 中的元素修改s, 即，s 现在包含s 或t 的成员
#s.intersection_update(t) s 中的成员是共同属于s 和t 的元素。
#s.difference_update(t) s 中的成员是属于s 但不包含在t 中的元素
#s.symmetric_difference_update(t) s 中的成员更新为那些包含在s 或t 中，但不 是s和t 共有的元素
#s.add(obj) 在集合s 中添加对象obj
#s.remove(obj) 从集合s 中删除对象obj；如果obj 不是集合s 中的元素(obj not in s)，将引发KeyError 错误
#s.discard(obj) 如果obj 是集合s 中的元素，从集合s 中删除对象obj；
#s.pop() 删除集合s 中的任意一个对象，并返回它
#s.clear() 删除集合s 中的所有元素
作者“David Dai Oracle 笔记 -- 为安庆崛起而奋斗”
