Question

我有一个带有 iter 的类，pops（）并且每次从带有字母的双端队列产生一个项目，S_stack = deque（[“a”，“b”，“c”] ）和一个带整数的堆栈，I_stack =（[1,2,3]），我想把它与一个函数count_dict结合起来，它保存键值对，S_stack字母作为键，I_stack整数作为值。键，如果条件增加值+1。目前我通过生成器函数generator（）将所有项生成到count_dict中的嵌套dict中。相反，我想运行count_dict（），以便每次来自S_stack和I_stack的项目都在 iter 中弹出，例如来自S_stack的“a”和来自I_stack的1，并将其添加到nested_dict中在下一个项目之前count_dict，弹出“b”和2。所以通过 iter 运行count_dict一次使用下一个函数或类似的元素。

from collections import defaultdict
import collections
from collections import deque


I_stack = deque([1,2,3])
S_stack = deque(["a","b","c"])
def generator():


    for i in range(len(I_stack)):
        for j in range(len(S_stack)):


            yield (S_stack[j], I_stack[j])

        break


def count_dict(t):

    h = 1
    try:
        while True:
            if h == 1:
                k,v = (yield)
                v = v +1

                t['Left'][k]['h'] = v
                print t

            else:

                k,v = (yield)


                t['Left'][k]['h'] = v#  [k] = v
                print t



    except GeneratorExit:
        pass



#tally = defaultdict(int)
tally = defaultdict(lambda: defaultdict(dict))
c = count_dict(tally)
c.send(None)

#print [c.send(val) for val in generator1()]
do_all = deque(maxlen=0).extend
do_all(c.send(val) for val in generator())
for k in sorted(tally):
    print k, tally[k]

class StackHandler(list):
    """ a subclass for generating sequences in stacks"""
    def __init__(self, stop_key, list):
        self.stop_key = stop_key

        self.I_stack = deque([1, 2, 3, 4, 5, 6, 7, 8])
        self.S_stack = deque(["a","b","c"])
        super(StackHandler, self).__init__(list)



    def __iter__(self):

        while True:
            try:
                item = list.pop(self)


                self.S_stack.append(self.I_stack.popleft())
                self.I_stack.pop()
                self.S_stack.pop()




                yield self.I_stack



                if item is self.stop_key:
                    break
                else: 
                    yield item
            except:
                break


if __name__ == "__main__":
    I_stack = deque([1,2,3,4])

    ls = [
        {

            'stop_key' : 5,
            'stack_ls' : I_stack
            },
        {

            'stop_key' : 'c',
            'stack_ls' : deque(['a','b','c','d'])
            }
        ]



    for i in ls:
        ls = StackHandler(i['stop_key'],
                                      i['stack_ls'])

        n = 4
        print "test", i
        for j in range(n):
            for item in ls:
                print '(j:%i) %s' % (j, item)
            print '-' * 20
        print '\n', 

# Desired output:

#Run 1 - "a", 1 , S_stack, I_stack
#Run 2 - "b", 2
#Run 3 - "c", 3
# and so on

这些存储在嵌套的dict t中，例如t ['Left'] [k] ['h'] = v;

defaultdict（在0x48c6050＆gt;，{'左'：defaultdict（，{'a'：{'h'：2}}）}）在count_dict（）

中

如何使用_iter_和嵌套的dict生成器函数一次从两个堆栈中获取一个键 - 值对

0 个答案: