一.set集合
set是一个无序且不重复的元素集合
print(dir(set)) #['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
l1 = ['', '', '',]
l2 = ['', '', '', ] s1 = set(l1) #将一组可迭代的数据传入set集合
print(s1) s1.add('alex') #给s1添加一个新元素alex,
print(s1) s1.add('alex') #给s1传入一个相同的元素后，对比输出结果二和三，结果并没有改变，由此可见s1集合是一个无序且不重复的元素集合
print(s1) #{'11', '33', '22'} #第一次输出
#{'11', '33', '22', 'alex'} #第二次输出
#{'11', '33', '22', 'alex'} #第三次输出
add 添加不重复的元素
#difference生成一个新的集合，将新传入的集合移除掉，不能对原来的集合进行修改，需要重新赋值给一个变量 s2 = set(['alex', 'eric', 'tony', ])
s3 = s2.difference(['alex', 'eric'])
print(s3)
#结果输出 {'tony'}
difference 差异比较
s2 = set(['alex', 'eric', 'tony', 'alex'])
s4 = s2.difference_update(['alex', 'eric','jack'])
print(s2) #结果输出 {'tony'}
print(s4) #结果输出 None #difference_update将原来的集合修改，difference_update和difference都是将新传入的集合删掉，不同之处在于difference是生成一个新的集合，difference_update是对原来的集合进行修改，不会生成一个新的集合
difference_update 差异更新
s2 = set(['alex', 'eric', 'tony',])
s3 = s2.discard('eric')
print(s2) #结果输出{'tony', 'alex'}
discard删除一个元素
#pop随机删除一个元素，并获取删除的这个元素，可将删除的这个元素赋值给变量 s2 = set(['alex', 'eric', 'tony',])
ret = s2.pop()
print(s2) #结果输出{'alex', 'eric'}
print(ret) #从新赋值给变量ret ,结果输出 tony
pop 随机删除元素
#remove移除元素，需要指定参数，remove没有返回值 s2 = set(['alex', 'eric', 'tony',])
s2.remove('eric')
print(s2) #结果输出 {'alex', 'tony'}
remove移除指定元素
l1 = ['alex', 'eric', 'jack', 'laiying',]
l2 = ['jack', 'tom', 'laiying',]
s1 = set(l1)
s2 = set(l2)
print(s1)
s3 = s1.intersection(s2)
print(s1)
print(s2)
print(s3) #{'eric', 'alex', 'laiying', 'jack'} 第一次原始集合
#{'eric', 'alex', 'laiying', 'jack'} 集合s1和s2进行交集判断后的输出结果，并没有改变对象本身
#{'laiying', 'tom', 'jack'} s2集合没有发送改变
#{'laiying', 'jack'} 通过交集比较，返回了一个新的元素集合，返回的是s1和s2共同拥有的元素集合
intersection取交集元素集合
l1 = ['alex', 'eric', 'jack', 'laiying',]
l2 = ['jack', 'tom', 'laiying',]
s1 = set(l1)
s2 = set(l2)
print(s1) s3 = s1.intersection_update(s2)
print(s1)
print(s3) #通过输出结果可以看出，s1直接更新了自己，把与传入的集合，与集合里面不相同的元素删掉，且没有返回值
{'laiying', 'eric', 'alex', 'jack'}
{'laiying', 'jack'}
None
indersection_update 交集更新
l1 = ['alex', 'eric',]
l2 = ['tom', 'jack',]
s1 = set(l1)
s2 = set(l2)
print(s1) s3 = s1.isdisjoint(s2)
print(s1)
print(s3) #{'eric', 'alex'}
#{'eric', 'alex'}
#True #当两个集合之间没有任何交集时，就返回True，否则就返回False
isdisjoint判断是否没有交集
l1 = ['alex', 'eric', 'jack',]
l2 = ['tom','laiying',]
s1 = set(l1)
s2 = set(l2)
s3 = set(['alex', 'jack',]) print(s1.issubset(s2)) #输出为False说明s1不是s2的子集
print(s1.issubset(s3)) #输出False说明不是s3的子集
print(s3.isdisjoint(s1)) #输出True说明s3是s1的子集 #结果输出
#False
#False
#True
issubset 是否是子集
l1 = ['alex', 'eric', 'jack',]
l2 = ['tom','laiying',]
s1 = set(l1)
s2 = set(l2)
s3 = set(['alex', 'jack',]) print(s1.issuperset(s3)) #结果输出True，说明s1是s3的父集
print(s3.issuperset(s1)) #结果输出False，说明s3不是s1的父集
issuperset是否是父集
#symmetric_difference，该对象返回一个新的集合，传入的元素与对象本身比较，如果传入的元素里面有的元素，而对象本身没有，则添加到对象本身集合内，最终返回一个新的集合 l1 = ['alex', 'eric', 'jack',]
l2 = ['tom','laiying',]
s1 = set(l1)
s2 = set(l2)
s3 = set(['alex', 'jack',])
print(s1)
#结果输出 {'eric', 'alex', 'jack'}
s4 = s1.symmetric_difference(s2) print(s1)
#结果输出 {'eric', 'alex', 'jack'}
print(s4)
#结果输出{'eric', 'alex', 'tom', 'laiying', 'jack'}
symmetric_difference 差集对比
#symmetric_difference_update差集更新,直接扩展对象本身与传入集合的没有交集的元素 l1 = ['alex', 'eric', 'jack',]
l2 = ['tom','laiying',]
s1 = set(l1)
s2 = set(l2) print(s1) #s1原始集合，结果输出 {'eric', 'alex', 'jack'}
s4 = s1.symmetric_difference_update(s2)
print(s1) #s1差集后的结果输出{'laiying', 'eric', 'alex', 'jack', 'tom'}
print(s4) #该方法没有返回值 None
s1.symmetric_difference_update 差集更新
#union返回新集合，j将对象本身与传入的集合元素比较，把所有的元素重新组合成一个新的集合返回
l1 = ['alex', 'eric', 'jack',]
l2 = ['tom','laiying',]
s1 = set(l1)
s2 = set(l2)
s4 = s1.union(s2) print(s1) #结果输出{'eric', 'alex', 'jack'}，对象本身没有变化
print(s4) #结果输出{'laiying', 'jack', 'alex', 'tom', 'eric'}
union 返回新集合
#update更新集合，将会对集合本身进行扩展，如果对象本身不存在这个传入的元素，则添加到对象本身的元素集合
dic1 = {'k1':'v1', 'k2':'v2'}
dic2 = {'k1':'v1', 'k2':'v2', 'k3':'v3'}
s1 = set(dic1)
print(s1) #结果输出{'k1', 'k2'}
s2 = s1.update(dic2)
print(s1) #结果输出 {'k3', 'k1', 'k2'}
update更新集合
二.collections
2.1counter计数器
#创建一个Counter对象
import collections
obj = collections.Counter('Hello World !')
print(obj)
#结果输出
#Counter({'l': 3, 'o': 2, ' ': 2, '!': 1, 'd': 1, 'r': 1, 'e': 1, 'W': 1, 'H': 1}) #Counter会对传入参数所有元素出现的次数
import collections
a = collections.Counter('LaiYingaaa')
print(a)
#Counter({'a': 4, 'i': 2, 'L': 1, 'Y': 1, 'g': 1, 'n': 1}) b = a.elements() #该方法返回的是一个迭代器，只能通过循环获取
print(b)
for i in a:
print(i) #打印的是所有不重复的传入参数，也就是计数器对应类似字典的key
#i
#a
#L
#Y
#g
#n
elements 只显示不重复的元素
import collections
obj = collections.Counter('Hello World !')
print(obj) ret = obj.most_common(4) #这里仅返回出现次数最多的前4个对象
print(ret) #Counter({'l': 3, ' ': 2, 'o': 2, 'H': 1, 'r': 1, 'd': 1, 'W': 1, 'e': 1, '!': 1})
#[('l', 3), (' ', 2), ('o', 2), ('H', 1)]
most_common 仅返回出现次数最多的前几个对象
import collections
obj = collections.Counter(['', '','']) #创建一个counter对象
obj.subtract(['eric', '', '']) #使用该属性，可以g更新技术器对象个数，如果原来有这个对象，则会减少这个对象，原来没有这个对象则返回-1,如果减少两次没有的这个对象，则返回-2，一吃类推
print(obj) #Counter({'22': 1, '33': 1, '11': 1})
#Counter({'33': 1, '22': 1, '11': -1, 'eric': -1})
subtract减少对应的元素
#update 更新，添加 import collections
obj = collections.Counter(['', '',''])
print(obj)
obj.update(['eric', '', ''])
print(obj) #Counter({'11': 1, '33': 1, '22': 1})
#Counter({'11': 3, '33': 1, '22': 1, 'eric': 1})
2.2 OrderedDict 有序字典
#字典是无序的，排列顺序随时都可以改变 #有序字典继承了dict所有的属性方法，是针对字典类进行了扩展的一个类，可以将字典转换为有序字典
import collections
dic = collections.OrderedDict() #将字典转换为有序字典
# dic = dict() #字典是无序的，排列顺序随时都可更改
dic['k1'] = 'v1'
dic['k2'] = 'v2'
dic['k3'] = 'v3'
print(dic)
#OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')]) 当字典转换为有序字典以后，排列顺序就不会改变