初识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 = ['11', '22', '33',]
l2 = ['44', '55', '66', ]

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'} #第三次输出

#difference生成一个新的集合，将新传入的集合移除掉，不能对原来的集合进行修改，需要重新赋值给一个变量

s2 = set(['alex', 'eric', 'tony', ])
s3 = s2.difference(['alex', 'eric'])
print(s3)   
#结果输出 {'tony'}

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是对原来的集合进行修改，不会生成一个新的集合

s2 = set(['alex', 'eric', 'tony',])
s3 = s2.discard('eric')
print(s2)    

#结果输出{'tony', 'alex'}

#pop随机删除一个元素，并获取删除的这个元素，可将删除的这个元素赋值给变量

s2 = set(['alex', 'eric', 'tony',])
ret = s2.pop()
print(s2)  #结果输出{'alex', 'eric'}
print(ret)  #从新赋值给变量ret ,结果输出 tony

#remove移除元素，需要指定参数，remove没有返回值

s2 = set(['alex', 'eric', 'tony',])
s2.remove('eric')  
print(s2)   #结果输出 {'alex', 'tony'}

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共同拥有的元素集合

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

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

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

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的父集

#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_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

#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'}

#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'}

二.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

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)]

import collections
obj = collections.Counter(['11', '22','33']) #创建一个counter对象
obj.subtract(['eric', '11', '11'])  #使用该属性，可以g更新技术器对象个数，如果原来有这个对象，则会减少这个对象，原来没有这个对象则返回-1,如果减少两次没有的这个对象，则返回-2，一吃类推
print(obj)

#Counter({'22': 1, '33': 1, '11': 1})
#Counter({'33': 1, '22': 1, '11': -1, 'eric': -1})

 #update 更新，添加

import collections
obj = collections.Counter(['11', '22','33'])
print(obj)
obj.update(['eric', '11', '11']) 
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')]) 当字典转换为有序字典以后，排列顺序就不会改变