初识Python第三天（一）

一.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')]) 当字典转换为有序字典以后，排列顺序就不会改变