python进阶学习——第三天

　　一.set集合

　　　　set是一个无序且不重复的元素集合

＃['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__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 = ['1','2','3']
l2 = ['4','5','6']

s1 = set(l1) #将一组可迭代数据传入set集合
print(s1)

s1.add('33')  #给s1添加一个元素后，s1直接更新成如下输出结果
print(s1)

s1.add('33')  #给s1传人一个相同元素后，对比输出结果二和三，结果并未改变，可见s1集合是一个无序且不重合的元素集合，但是每次同一次执行输出的结果相同元素顺序是不变
print(s1)

#{'2', '3', '1'}   #第一次输出
#{'33', '2', '3', '1'}  #第二次输出
#{'33', '2', '3', '1'}  #第三次输出

l1 = ['1','2','3']
l2 = ['4','5','6']

s1 = set(l1)  #传入一个集合
print(s1)   # 第一次输出
s1.add('33')  # 添加一个元素
print(s1)  # 第二次输出
s1.add('33')  # 添加一个相同元素

s1.clear()  # 使用clear属性
print(s1)  # 最终返回一个空的集合


#{'1', '3', '2'}
#{'33', '1', '3', '2'}
#set()

l1 = ['1','2','3']
l2 = ['4','5','6']

s1 = set(l1)  #传入一个集合
print(s1)   # 第一次输出
s1.add('33')  # 添加一个元素
print(s1)  # 第二次输出
s1.add('33')  # 添加一个相同元素

print(s1)  

s3 = s1.copy()

print(s3)
print(id(s1))
print(id(s3))


#{'3', '2', '1'}
#{'3', '2', '1', '33'}
#{'3', '2', '1', '33'}
#{'3', '2', '1', '33'}
#4312944424  #通过观察两次的id可发现，集合的拷贝是深拷贝操作
#4303350696

l1 = ['1','2','3','4']
l2 = ['4','5','6']

s1 = set(l1)  #传入一个集合

s2 = s1.difference(*l2)

print(s1)  原集合并未改变
print(s2)  # 最终返回一个新的集合，

# 这个属性是通过对象本身与传入的元素进行对比，只要对象本身没有与传入元素相同的元素，则返回这个元素，最终组合成新的元素集合

l1 = ['1','2','3','4','6']
l2 = ['4','5','6']

s1 = set(l1)
s2 = s1.difference_update(*l2)

print(s1)
print(s2)

#通过观察返回结果可知，这个方法是直接更新对象本身，就存在相同的元素剔除，并不会返回剔除元素，剔除规则，对象本身与传入元素对比，如果对象本身的元素在传入的元素里面，则删除这个元素
#{'3', '1', '2'}  
#None

l1 = ['1','2','3','4','6']
l2 = ['4','5','6']

s1 = set(l1)
print(s1)
s2 = s1.discard('1')
print(s1)
print(s2)


#通过传入一个元素，对象本身则将这个元素删除，如果对象本身不存在这个元素则没有任何变化，也没有错误信息，该操作是直接操作对象本身，且没有返回值
#{'3', '2', '6', '4', '1'}
#{'3', '2', '6', '4'}
#None

l1 = ['1','2','3','4','6']
l2 = ['4','5','6']

s1 = set(l1)
s2 = set(l2)
print(s1)
s3 = s1.intersection(s2)
print(s1)
print(s2)
print(s3)


#{'1', '2', '4', '3', '6'}  第一次原始集合
#{'1', '2', '4', '3', '6'}  集合s1和s2进行交集判断后的输出结果，并没有改变对象本身
#{'4', '5', '6'}    s2的集合也并未发生改变
#{'4', '6'}  通过交集比较，返回了一个新的元素集合，返回的是s1和s2共同拥有的元素集合

l1 = ['1','2','3','4','6']
l2 = ['4','5','6']

s1 = set(l1)
s2 = set(l2)
print(s1)

s3 = s1.intersection_update(s2)
print(s1)
print(s3)


#通过输出结果可以看出，s1是直接更新了自己，把与传入的集合，与集合里面不相同的元素删除，且没有返回值
#{'6', '3', '4', '1', '2'}
#{'6', '4'}
#None

l1 = ['1','12']
l2 = ['4','6']

s1 = set(l1)
s2 = set(l2)
print(s1)

s3 = s1.isdisjoint(s2)
print(s1)
print(s3)

#{'12', '1'}
#{'12', '1'}
#True

#当两个集合之间没有任何交集时，则返回True

l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])

s1 = set(l1)
s2 = set(l2)
print(s1)

print(s1.issubset(s2))  #  输出为False说明s1不是s2的子集
print(s1.issubset(s3))  #  输出false说明 s1不是 s3的子集
print(s3.issubset(s1))  # 输出true，说明s3是s1的子集

l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])

s1 = set(l1)
s2 = set(l2)
print(s1)

print(s1.issuperset(s3))  #输出True,说明s1是s3的父集
print(s3.issuperset(s1))  #输出false，说明s3不是s1的父集

l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])

s1 = set(l1)
s2 = set(l2)
print(s1)

s4 = s1.pop()
print(s1)   #对象本身被随机删除一个元素
print(s4)   #  随机删除的元素会返回被随机删除的元素

l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])

s1 = set(l1)
s2 = set(l2)
print(s1)
s4 = s1.remove('12')
print(s1)  #直接移除指定元素，并更新对象本身，如果指定元素不存在，则抛出异常
print(s4)  #  该属性没有返回值

l1 = ['1','12','13']
l2 = ['4','6','1']
s3=set(['1','13'])

s1 = set(l1)
s2 = set(l2)
print(s1)
s4 = s1.symmetric_difference(s2)

print(s1)  #该方法并不会更新对象本身的值
print(s4)  #该对象返回一个新的集合，传入的元素与对象本身比较，如果传入的元素里面有的元素，而对象本身没有，则添加到对象本身的集合内，最终返回一个新的集合

l1 = ['1','12','13']
l2 = ['4','6','1']
s3=set(['1','13'])

s1 = set(l1)
s2 = set(l2)
print(s1)
s4 = s1.symmetric_difference_update(s2)

print(s1)  #直接扩展对象本身与传入集合的没有交集的元素
print(s4)  #该方法没有返回值

#效果与差异更新类似，只是这个是返回一个新的集合，而差异更新是更新对象本身，不返回新集合
l1 = ['1','12','13']
l2 = ['4','6','1']
s3=set(['1','13'])

s1 = set(l1)
s2 = set(l2)
s4 = s1.union(s2)
print(s1)  #对象本身没有变化
print(s4)  #将对象本身与传入的集合元素比较，把所有的元素重现组合成一个新的集合返回

dic1 ={'k1':'v1','k2':'v2'}
dic2 ={'k1':'vv','k2':'v2','k3':'v3'}
s1 = set(dic1)
print(s1)
s2 = s1.update(dic2)
print(s1)  #将会对集合本身进行扩展，如果对象本身不存在这个传入的元素，则添加到对象本身的元素集合

 

　　二.collections

　　　　2.1 counter 计数器

创建一个counter对象

import collections

c1 = collections.Counter("asadgiuokasgiuwgiuqguyfudfssdguysfdus")  #创建一个counter对象
print(c1)
c2 = c1.copy()  # 重新拷贝一个计数器对象
print(id(c1))
print(id(c2))

print(c2)


#通过下面对应的输出结果可以看出，这是一个深拷贝操作
#Counter({'u': 7, 's': 6, 'g': 5, 'd': 4, 'a': 3, 'f': 3, 'i': 3, 'y': 2, 'o': 1, 'w': 1, 'k': 1, 'q': 1})
#4302803656
#4323186952
#Counter({'u': 7, 's': 6, 'g': 5, 'd': 4, 'a': 3, 'i': 3, 'f': 3, 'y': 2, 'o': 1, 'k': 1, 'w': 1, 'q': 1})

import collections

c1 = collections.Counter("asadgiuokasgiuwgiuqguyfudfssdguysfdus")  #创建一个counter对象
print(c1)


c3 = c1.elements()  #该方法返回的是一个迭代器，只能通过循环获取

print(c3)

for el in c1:
    print(el)  #打印的是所有的不重复的传入的参数，也就是计数器对应的类似字典的key

import collections

c1 = collections.Counter("asadgiuokasgiuwgiuqguyfudfssdguysfdus")  #创建一个counter对象
print(c1)

c3 = c1.most_common(4)  #这里仅返回出现次数最多的前4个对象
print(c3)


#Counter({'u': 7, 's': 6, 'g': 5, 'd': 4, 'i': 3, 'a': 3, 'f': 3, 'y': 2, 'o': 1, 'q': 1, 'w': 1, 'k': 1})
#[('u', 7), ('s', 6), ('g', 5), ('d', 4)]

import collections

c1 = collections.Counter("asadgiuokasgiuwgiuqguyfudfssdguysfdus")  #创建一个counter对象
print(c1)

c1.subtract('ussuum')  #使用该属性，可以更新计数器对象个数，如果原来有这个对象，则会减少这个对象，取决于传入参数时，传入了几次，这里传入三次u，将会对计数器上面的u的次数减少3次，也就是删除三个u，如果不存在，如果传入1次不存在的对象，则对应次数为-1，两次则-2以此类推，
print(c1)


#Counter({'u': 7, 's': 6, 'g': 5, 'd': 4, 'a': 3, 'i': 3, 'f': 3, 'y': 2, 'o': 1, 'w': 1, 'q': 1, 'k': 1})
#Counter({'g': 5, 'u': 4, 's': 4, 'd': 4, 'a': 3, 'i': 3, 'f': 3, 'y': 2, 'o': 1, 'w': 1, 'q': 1, 'k': 1, 'm': -1})

import collections

c1 = collections.Counter("asadgiuokasgiuwgiuqguyfudfssdguysfdus")  #创建一个counter对象
print(c1)

c1.update('uuusss')  #传入一个迭代器，最终c1对应的u和s元素个数会增加3次
print(c1)

#输出结果如下

#Counter({'u': 7, 's': 6, 'g': 5, 'd': 4, 'f': 3, 'a': 3, 'i': 3, 'y': 2, 'w': 1, 'q': 1, 'o': 1, 'k': 1})
#Counter({'u': 10, 's': 9, 'g': 5, 'd': 4, 'f': 3, 'a': 3, 'i': 3, 'y': 2, 'w': 1, 'q': 1, 'o': 1, 'k': 1})

 

　　　　2.2 namedtuple  可命名元组

import collections

Point = collections.namedtuple('Point',['x','y','z'])  #创建一个类,类名为Point

myPoint = Point(11,22,33)
print(myPoint)
print(myPoint.x)  #直接通过命名元素去访问元组对应的元素,
print(myPoint[0])  #等同于上面这种方式,但是没有上面这种方式可读性强
print(myPoint.y)
print(myPoint.z)



#Point(x=11, y=22, z=33)
#11
#11
#22
#33

 

　　　　2.3 OrderedDict  排序字典

　　排序字典继承了dict所有的属性方法，是针对字典类进行了扩展的一个类

import collections


mydic = collections.OrderedDict(name='zcy',age='25',job='IT')
print(mydic)

print(mydic.keys())
print(mydic.values())
mydic.update(name='hello')
mydic.update(time='2016')
print(mydic)

#OrderedDict([('age', '25'), ('name', 'zcy'), ('job', 'IT')])

#odict_keys(['age', 'name', 'job'])
#odict_values(['25', 'zcy', 'IT'])
#OrderedDict([('age', '25'), ('name', 'hello'), ('job', 'IT'), ('time', '2016')])

 

　　　　2.4 defaultdict 默认字典

 

import collections

mydic = collections.defaultdict(list)
print(mydic)

mydic['k1']
print(mydic)
print(mydic.keys())
print(mydic.values())  #默认值为一个列表类型

newdic={}
newdic.setdefault('k1',list)
newdic['k1']

print(newdic)
print(newdic['k1'])
print(newdic.values())


#defaultdict(<class 'list'>, {})
#defaultdict(<class 'list'>, {'k1': []})
#dict_keys(['k1'])
#dict_values([[]])
#{'k1': <class 'list'>}
#<class 'list'>
#dict_values([<class 'list'>])

 

 

　　　　2.4 deque 双向队列

import collections
newqueue = collections.deque(['a','b','c'])

print(newqueue)
newqueue.append(['d1','d2'])  #追加一个元素到队列
print(newqueue)

newqueue.appendleft('a1')  #追加一个元素到队列左侧
newqueue.appendleft('a2') #追加一个元素到队列左侧
print(newqueue)

newc = newqueue.count('a')  #对队列某个元素进行计数
print(newc)

newqueue.extend(['e','f','g'])  #扩展队列元素
print(newqueue)

newqueue.extendleft(['a11','a22','a33'])  #从左侧开始扩展队列
print(newqueue)

newqueue.insert(2,'aa22')  #插入到下标2的位置
print(newqueue)

newqueue.reverse()  #顺序反转
print(newqueue)

newqueue.rotate(4)  #将队列末尾4个元素反转到队列左侧
print(newqueue)



#deque(['a', 'b', 'c'])
#deque(['a', 'b', 'c', ['d1', 'd2']])
#deque(['a2', 'a1', 'a', 'b', 'c', ['d1', 'd2']])
#1
#deque(['a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g'])
#deque(['a33', 'a22', 'a11', 'a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g'])
#deque(['a33', 'a22', 'aa22', 'a11', 'a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g'])
#deque(['g', 'f', 'e', ['d1', 'd2'], 'c', 'b', 'a', 'a1', 'a2', 'a11', 'aa22', 'a22', 'a33'])
#deque(['a11', 'aa22', 'a22', 'a33', 'g', 'f', 'e', ['d1', 'd2'], 'c', 'b', 'a', 'a1', 'a2'])

 

　　　　2.5 queue

　　　　　　2.5.1 deque 双向队列

　　　　该对象与collections 的deque实质是完全一样的效果，这里就不作多演示了

　　　　使用方式

　　　　　　

import queue
newqueue = queue.deque(['a','b','c'])

#单向队列是FIFO工作模式


import queue
newqueue = queue.Queue(2)  #设置队列长度为2,也就是队列里只有两个任务
newqueue.put(['1','2'])  # 放入一个任务
newqueue.put(2)  # 放入第二个任务
isempty = newqueue.empty()  #判断队列是否空
isfull = newqueue.full()  # 判断队列是否满了
get1 = newqueue.get()  #获取第一个任务
get2 = newqueue.get() #获取第二个任务
print(get1)  
print(get2)
isfull2 = newqueue.full()  #判断队列是否满了,因为已经把任务取出来了,所以这时队列应该是没有满
isempty2 = newqueue.empty()  #判断队列是否为空
print(isfull)
print(isfull2)
print(isempty)
print(isempty2)



#['1', '2']
#2
#True
#False
#False
#True