一、命名元组（namedtuple）
不可变数据结构元组tuple，对元组元素的访问需通过索引来完成。
1.创建命名元组
通过collections.namedtuple创建命名元组类，命名元组的构造函数接受两个参数typename，field_names：
typename：元组的名字；field_names：元组各个元素的名称，也就是属性名称。
collections.namedtuple("Point",["x","y"])
这样就创建了一个叫做Point的命名元组类，它拥有两个属性x，y。
第二个参数["x","y"]也可以写成"x y"或者"x,y"，即用空格或者逗号隔开属性名，即：
collections.namedtuple("Point","x y")collections.namedtuple("Point","x,y")
我们可以将其赋值给一个变量：
Point = collections.namedtuple("Point","x,y")
p = collections.namedtuple("Point","x,y") #变量名不一定要和第一个参数相同 以上得到的变量Point或者p并不直接是一个元组对象，它只是一个类，如果要创建它的实例，则需要像创建类实例一样调用它：
p1 = Point(x = 0, y = 0)
p2 = p(x = 1, y = 1) 这样就创建了两个实例p1，p2，他们的内容分别是x = 0,y = 0 ; x = 1,y = 1。
2.访问命名元组的元素
collections.namedtuple创建的命名元组类，实际上是元组类的子类，因此命名元组也可以通过索引访问元素：
print(p1[0])
print(p1[1])
#得到的结果
0
0当然，命名元组也可以通过属性访问：
print(p2.x)
print(p2.y)
#得到的结果
1
13.修改元素
修改元组的元素，需要调用成员函数_replace()，它会返回一个包含新值的新实例，比如：
p1 = p1._replace(x = 1) #将p1的x值从0换到1例：将函数Begin-End区间代码补充完整，使得程序能够正常运行并输出正确的结果
提示：后两个函数需要用到函数_replace()
编辑区的3个函数，将按照如下顺序被调用：
p = CreatePoint()
PrintPoint(p)
p = IncX(p)
PrintPoint(p)
p = IncY(p)
PrintPoint(p)
####测试说明
正确的补充代码后，应该得到的结果：
当前位置:x = 0,y = 0
当前位置:x = 1,y = 0
当前位置:x = 1,y = 1
import collections
def CreatePoint():
# ********** Begin ********** #
q = collections.namedtuple("text","x,y") #叫做text的命名元组类q
p = q(x=0,y=0) #实例p
return p #注意返回p
# ********** End ********** #
def IncX(p):
# ********** Begin ********** #
p = p._replace(x=1)
return p
# ********** End ********** #
def IncY(p):
# ********** Begin ********** #
p = p._replace(y=1)
return p
# ********** End ********** #
def PrintPoint(p):
print("当前位置:x = %d,y = %d" % p)二、计数器（Counter）
计数器是一个无序容器，用于记录各种值出现的次数。它采用键值对的形式存储，要记录的值作为key，这个值出现的次数作为value，value值可正可负。
1.创建计数器
①调用其无参构造函数（创建计数器实例）
c = collections.Counter()
这样就创建了一个空的计数器实例c。
②从list，tuple，dict，字符串等**可迭代对象(iterable)**创建
c = collections.Counter(['a','a','b','b','c']) #从list创建
c = collections.Counter(('a','a','b','b','c')) #从tuple创建
c = collections.Counter({'a':2,'b':2,'c':1}) #从dict创建
c = collections.Counter("aabbc") #从字符串创建
#上面四条语句创建出来的计数器c都是相同的：
{'a': 2, 'b': 2, 'c': 1}③直接指定键值对
c = collections.Counter(a=2,b=2,c=1)
创建出来的计数器c，与上面四条语句创建的计数器c是相同的。
2.访问元素
计数器是dict的子类，因此可以像使用dict那样访问计数器元素：
print(c['a'])
print(c['b'])
print(c.c)
#得到的结果
2
2
1 不过与dict不同的是，当访问计数器中不存在的元素的时候，不会产生异常，而是返回0，比如：
print(c['d']) #c中没有d元素，但不会发生异常
#此代码可以正常运行，并且结果是：03.增加计数与减少计数
①使用操作dict的方式：c.a = XXX（改变计数器中某一元素的值）
②update函数
update函数接受一个可迭代对象，然后将这个对象中各种值出现的次数加到计数器中，比如：
c.update("aabbcd") #字符串也是可迭代对象
#上面这行语句执行后，c的值从原来的：
{'a': 2, 'b': 2, 'c': 1}
#增加到了：
{'a': 4, 'b': 4, 'c': 2, 'd': 1}③ subtract函数
subtract函数与update函数类似，不过它是从计数器中减去可迭代对象中各种值出现的次数，比如：
c.subtract("aabbcd")
#上面这行语句执行后，c的值从原来的：
{'a': 4, 'b': 4, 'c': 2, 'd': 1}
#减少到了：
{'a': 2, 'b': 2, 'c': 1, 'd': 0}4.删除元素
当计数器中一个元素的值减少到0时，它并不会自动从计数器中删除，如果要删除元素，可以使用del函数：
del(c['d'])
#上面这行语句执行后，c的值从原来的：
{'a': 2, 'b': 2, 'c': 1, 'd': 0}
#变成了：
{'a': 2, 'b': 2, 'c': 1}
#即元素d被删除了5.TopN操作
计数器还提供了一个获取出现次数最多的n个元素的成员函数most_common，它返回包含这些元素的list，比如：
top1 = c.most_common(1) #出现次数最多的元素
print(top1)
top2 = c.most_common(2) #出现次数最多的两个元素
print(top2)
all = c.most_common() #不提供参数则返回所有元素
print(all)
#得到的结果是：
[('a', 2)]
[('a', 2), ('b', 2)]
[('a', 2), ('b', 2), ('c', 1)]注意：如果有多个元素的值相同，那么它们之间的顺序是不可确定的，不要在它们的顺序上作任何假设。
例：完成函数功能，函数需要读取6行输入，然后进行如下操作：
将偶数行的数据加到计数器中；
将奇数行的数据从计数器中减去。
注意：行数是从0开始的，最后输出计数器中的所有元素。
import collections
def Func():
c = collections.Counter()
for i in range(6):
data = input()
# ********** Begin ********** #
if i % 2 == 0:
c.update(data)
else:
c.subtract(data)
# ********** End ********** #
print(c.most_common())三、双向队列（deque）
双向队列是一种能在队列两端都进行入队、出队操作的数据结构，比普通的队列更加灵活也更加复杂。
1.创建双向队列
双向队列可以调用无参构造函数创建一个空队列，也可以使用可迭代对象创建，并初始化一个队列，比如：
d = collections.deque() #创建一个空队列
d = collections.deque(['a','b','c']) #从list创建
d = collections.deque(('a','b','c')) #从tuple创建
d = collections.deque({'a':0,'b':1,'c':2}) #从dict创建
d = collections.deque("abc") #从字符串创建 第一行语句创建一个空队列，下面四行语句创建了含有元素a，b，c的队列
注意：当从dict创建时，使用的是它的键key，而不是值value。
2.队列操作
append（）函数
向队列的右边增加元素
pop（）函数
从队列的右边删除并返回一个元素
d.append('d') #向右边增加一个元素'd'
print(d)
d.pop() #从右边删除一个元素
print(d)
#得到的结果：
deque(['a', 'b', 'c', 'd'])
deque(['a', 'b', 'c'])appendleft（）函数
向队列的左边增加元素
popleft（）函数
从队列的左边删除并返回一个元素
d.appendleft('+') #向左边增加一个元素'+'
print(d)
d.popleft() #从左边删除一个元素
print(d)
#得到的结果：
deque(['+', 'a', 'b', 'c'])
deque(['a', 'b', 'c'])extend（）函数
将一个可迭代对象的所有迭代值，依次加入到队列的右边
extendleft（）函数
将一个可迭代对象的所有迭代值，依次加入到队列的左边
d1 = collections.deque()
d1.extend("123")
print(d1)
d1 = collections.deque()
d1.extendleft("123")
print(d1)
#得到的结果是：
deque(['1', '2', '3'])
deque(['3', '2', '1'])可以注意到，上下两个结果的值的顺序是相反的。
例：完成函数功能，函数读取输入的一个数字n(n≥0)，然后输出一个有n个元素，元素从0到n-1的“震荡”的队列，“震荡”的定义见测试说明。
测试说明
当输入：3时，输出的“震荡”队列应该是：
deque([1, 0, 2])
当输入：5时，输出的“震荡”队列应该是：
deque([3, 1, 0, 2, 4])
import collections
def Func():
d = collections.deque()
n = int(input())
# ********** Begin ********** #
for i in range(n):
if i % 2 == 0: #0到n-1的数
d.append(i) #偶数加到右边，奇数加到左边
else:
d.appendleft(i)
# ********** End ********** #
print(d)四、有序字典（OrderedDict）
有序字典和普通的dict基本上是相似的，只有一点不同，那就是有序字典中键值对的顺序会保留插入时的顺序。
1.创建有序字典
有序字典的创建方法和普通的dict类似，不过由于多了保留顺序的功能，因此在使用可迭代对象创建有序字典时，可以对它先排个序，让创建出来的字典元素也是有序的：
data = [('a',1),('b',3),('c',2)]
od = collections.OrderedDict(sorted(data,key=lambda s:s[0]))#按数据中key值的大小排序
print(od)
od = collections.OrderedDict(sorted(data,key=lambda s:s[1]))#按数据中value值的大小排序
print(od)
#得到的结果：
OrderedDict([('a', 1), ('b', 3), ('c', 2)])
OrderedDict([('a', 1), ('c', 2), ('b', 3)])sorted函数
这里使用的sorted函数，它返回对一个可迭代对象排序后的结果，如果可迭代对象的元素不能直接进行比较（比如元素是一个list或tuple等），则需要指定key函数。
lambda表达式
这里使用lambda表达式lambda s:s[0]和lambda s:s[1]，分别指定key为data中每个元素（tuple类型）的第一个元素和第二个元素。
2.修改顺序
有序字典提供了一个move_to_end函数，这个函数可以将指定的键值对移动到最前面或者最后面，即最左边或最右边：
dt = collections.OrderedDict()
dt['a'] = 0
dt['b'] = 1
dt['c'] = 2
dt.move_to_end('b',last = False) #将`b`键值对移动到最前方
print(dt)
dt.move_to_end('b',last = True) #将`b`键值对移动到最后方
print(dt)
#得到的结果：
OrderedDict([('b', 1), ('a', 0), ('c', 2)])
OrderedDict([('a', 0), ('c', 2), ('b', 1)])例：实现函数功能：读取n(n>0)行输入，以每一行的数据为key，行号（从0开始）为value，建立n对键值对，然后将他们按照key排序后，放入一个有序字典，最后输出这个有序字典。
测试说明
测试输入：
3
a
c
b
预期输出：
OrderedDict([('a', 0), ('b', 2), ('c', 1)])
测试输入：
4
A
B
D
C
预期输出：
OrderedDict([('A', 0), ('B', 1), ('C', 3), ('D', 2)])
import collections
def Func():
pairs = []
n = int(input())
for s in range(n):
k = input()
# ********** Begin ********** #
# p = tuple([k,s]) #通过转变列表[k,s]创建一个元组
pairs.append((k,s)) #将元组p依次加入到列表pairs中，以完成嵌套
od = collections.OrderedDict(sorted(pairs,key=lambda s:s[0]))
# ********** End ********** #
print(od)五、默认字典（defaultdict）
默认字典的功能与dict基本相同，但在访问一个不存在的key时，默认字典会提供一个默认值，而不是引发异常。
创建默认字典
默认字典的构造函数接受一个工厂函数default_factory作为参数，可以将一个类型名看做是一个工厂函数，比如list，tuple，str等。
这个函数会在要生成默认值的时候无参调用，如果使用类型名作为工厂函数，则这个类型必须要有无参构造函数，比如：
dd = collections.defaultdict(int) #使用int作为工厂函数
print(dd['a']) #访问不存在的key:'a'
dd = collections.defaultdict(tuple) #使用tuple作为工厂函数
print(dd['a']) #访问不存在的key:'a'
dd = collections.defaultdict(str) #使用str作为工厂函数
print(dd['a']) #访问不存在的key:'a'
class Test:
def __init__(self,name): #只有一个构造函数，而且它有一个参数
print("init")
dd = collections.defaultdict(Test) #使用自定义类型Test作为工厂函数
print(dd['a']) #运行到这里就会出现异常，原因是Test类没有无参的构造函数
#直到最后一行语句之前，上面的结果是：
0
()
#第三行是字符串的默认值：空字符串。如果不提供工厂函数，那么默认值的功能就失效了，此时默认字典与普通dict表现的功能一致：
dd = collections.defaultdict()
print(dd['a']) #虽然dd是一个默认字典，但由于没有指定工厂函数，没办法产生一个默认值，因此还是会发生异常例：将函数Begin-End区间代码补充完整，使得程序能够正常运行并输出正确的结果。
右侧编辑器的4个函数会被依次调用，并产生4个默认字典，并会以类似如下的方式，获取并输出默认值：
1.dd = GetIntDefaultDict()
2.print("int默认字典的默认值：",dd['a'])
测试说明
正确的补充代码后应该得到的结果：
int默认字典的默认值： 0
list默认字典的默认值： []
tuple默认字典的默认值： ()
str默认字典的默认值：
import collections
def GetIntDefaultDict():
#返回一个空的int类型的默认字典
# ********** Begin ********** #
return collections.defaultdict(int)
# ********** End ********** #
def GetListDefaultDict():
#返回一个空的list类型的默认字典
# ********** Begin ********** #
return collections.defaultdict(list)
# ********** End ********** #
def GetTupleDefaultDict():
#返回一个空的tuple类型的默认字典
# ********** Begin ********** #
return collections.defaultdict(tuple)
# ********** End ********** #
def GetStrDefaultDict():
#返回一个空的str类型的默认字典
# ********** Begin ********** #
return collections.defaultdict(str)
# ********** End ********** #
313
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
