Python TreeDict.pop方法代码示例

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import pop [as 别名]
    def testIterators_13_Large(self):

        n_iter = 300
        n_node = 300

        tml = random_node_list(122, n_node, 0.75)

        random.seed(0)

        p = TreeDict()
        
        p.update(dict((t, 1) for t in tml))

        # set up a list of iterators
        def newIter():
            recursive = random.random() < 0.7
            brv = random.random()
            if 0 <= brv <= 0.33:
                branch_mode = "all"
            elif 0.33 < brv <= 0.66:
                branch_mode = "only"
            else:
                branch_mode = "none"

            irv = random.random()
            if 0 <= brv <= 0.33:
                return p.iterkeys(recursive, branch_mode)
            elif 0.33 < brv <= 0.66:
                return p.itervalues(recursive, branch_mode)
            else:
                return p.iteritems(recursive, branch_mode)

        iter_list = [newIter() for i in xrange(n_iter)]

        while len(iter_list) > 0:

            del_queue = []

            for i, it in enumerate(iter_list):
                try:
                    it.next()
                except StopIteration:
                    self.assert_(p._iteratorRefCount() <= len(iter_list))
                    del_queue.append(i)

            for i in sorted(del_queue, reverse=True):
                del iter_list[i]

        # Now make sure that everything is cool
        self.assert_(p._iteratorRefCount() == 0, p._iteratorRefCount())

        for tm in tml:
            p.pop(tm)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import pop [as 别名]
    def testpruning_02(self):
        p = TreeDict('prunetest')
        p.a.b.c = 123
        h1 = p.hash()

        self.assert_('a.b.c' in p)

        p.pop('a.b.c', prune_empty=True)

        self.assert_('a.b' not in p)

        h2 = p.hash()

        p.a.b.c = 123
        h3 = p.hash()

        self.assert_(h1 != h2)
        self.assert_(h1 == h3)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import pop [as 别名]
    def testIterators_12_Deletion(self):
        p = TreeDict()

        p.a = 1
        p.b = 2
        p.c = 3
        p.d = 4 
        p.e = 5

        it = p.iterkeys()
        
        self.assertRaises(RuntimeError, lambda: p.pop('a'))
        it.next()
        self.assertRaises(RuntimeError, lambda: p.pop('a'))
        
        del it

        p.pop('a')

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import pop [as 别名]
    def testDetach_07_nonbranch(self):
        # Test to make sure the behavior is like pop() (perhaps we
        # should chang the name ??)

        p = TreeDict()
        p.a = 1

        v = p.pop('a')

        self.assert_(v == 1)
        self.assert_('a' not in p)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import pop [as 别名]
    def testDetach_06_complex_key(self):
        p = TreeDict()
        p.a.b.c.d = 1
        b = p.a.b

        bd = p.pop('a.b')

        self.assert_(b is bd)
        self.assert_('a' in p)
        self.assert_('a.b' not in p)
        self.assert_(b.parentNode() == None)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import pop [as 别名]
    def testDetach_08_nonbranch_complex(self):
        # Test to make sure the behavior is like pop() (perhaps we
        # should chang the name ??)

        p = TreeDict()
        p.a.b.c = 1

        v = p.pop('a.b.c')

        self.assert_(v == 1)
        self.assert_('a' in p)
        self.assert_('a.b' in p)
        self.assert_('a.b.c' not in p)
        self.assert_('c' not in p.a.b)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import pop [as 别名]
    def testDetaching_02(self):

        # This covers the corner case of no elements remaining.
        p1 = TreeDict('root')
        p1.node.a = 123
        p1copy = deepcopy(p1)

        p2 = p1.node

        p3 = p1.pop("node")

        self.assert_(p2 is p3)
        self.assert_(p3.rootNode() is p3)
        self.assert_("node" not in p1)
        self.assert_(p2 == p1copy.node)
        self.assert_(p1 != p1copy)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import pop [as 别名]
    def testDetaching_01(self):
        p1 = TreeDict('root')
        p1.node.a = 123
        p1.node.b = "12312321"
        p1.node2.a = 13
        p1.node3.a = "123312"
        p1.node4 = 123

        p1copy = deepcopy(p1)

        p2 = p1.node

        p3 = p1.pop("node")

        self.assert_(p2 is p3)
        self.assert_(p3.rootNode() is p3)
        self.assert_("node" not in p1)
        self.assert_(p2 == p1copy.node)
        self.assert_(p1 != p1copy)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import pop [as 别名]
if __name__ == '__main__':
    import labrad
    cxn = labrad.connect()
    import time
    from treedict import TreeDict
    params = test_parameters.parameters
    d = TreeDict()
    #make a treedictionary out of the parameters
    for (collection,param), value in test_parameters.parameters.iteritems():
        d['{0}.{1}'.format(collection, param)] = value
        if not (collection,param) in tested_sequence.required_parameters:
            print 'parameter not listed among requirments', collection, param
    for key in d.keys():
        a = TreeDict()
        a.update(d)
        a.pop(key)
        try:
            sequence = tested_sequence(a)
        except Exception:
            pass
        else:
            print 'key not needed', key
    tinit = time.time()
    cs = tested_sequence(d)
    cs.programSequence(cxn.pulser)
    print 'to program', time.time() - tinit
#    cxn.pulser.start_number(10)
#    cxn.pulser.wait_sequence_done()
#    cxn.pulser.stop_sequence()
    dds = cxn.pulser.human_readable_dds()
    ttl = cxn.pulser.human_readable_ttl()

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import pop [as 别名]
# pop

from treedict import TreeDict
t = TreeDict()
t.b.c.d.e.y = 2
t.b.c.d.e.pop('y')
"b.c.d.e.y" in t
"b.c.d.e" in t
t.b.c.d.e.pop()
"b.c.d.e" in t
"b.c.d" in t
t.b.c.d.pop(prune_empty = True)
"b.c.d" in t
"b.c" in t
t.isEmpty()
t.pop('nothere')
t.pop('nothere', silent=True)

########################################
# size

from treedict import TreeDict
t = TreeDict() ; t.set('b.x', 1, 'b.c.y', 2, x = 1)
print t.makeReport()
t.size()
t.size(recursive=False)
t.size(recursive=False, branch_mode='none')
t.size(recursive=False, branch_mode='only')
t.size(recursive=False, branch_mode='all')
t.size(recursive=True, branch_mode='only')
t.size(recursive=True, branch_mode='all')