| from collections import deque | |
| import unittest | |
| from test import test_support, seq_tests | |
| import gc | |
| import weakref | |
| import copy | |
| import cPickle as pickle | |
| import random | |
| BIG = 100000 | |
| def fail(): | |
| raise SyntaxError | |
| yield 1 | |
| class BadCmp: | |
| def __eq__(self, other): | |
| raise RuntimeError | |
| class MutateCmp: | |
| def __init__(self, deque, result): | |
| self.deque = deque | |
| self.result = result | |
| def __eq__(self, other): | |
| self.deque.clear() | |
| return self.result | |
| class TestBasic(unittest.TestCase): | |
| def test_basics(self): | |
| d = deque(xrange(-5125, -5000)) | |
| d.__init__(xrange(200)) | |
| for i in xrange(200, 400): | |
| d.append(i) | |
| for i in reversed(xrange(-200, 0)): | |
| d.appendleft(i) | |
| self.assertEqual(list(d), range(-200, 400)) | |
| self.assertEqual(len(d), 600) | |
| left = [d.popleft() for i in xrange(250)] | |
| self.assertEqual(left, range(-200, 50)) | |
| self.assertEqual(list(d), range(50, 400)) | |
| right = [d.pop() for i in xrange(250)] | |
| right.reverse() | |
| self.assertEqual(right, range(150, 400)) | |
| self.assertEqual(list(d), range(50, 150)) | |
| def test_maxlen(self): | |
| self.assertRaises(ValueError, deque, 'abc', -1) | |
| self.assertRaises(ValueError, deque, 'abc', -2) | |
| it = iter(range(10)) | |
| d = deque(it, maxlen=3) | |
| self.assertEqual(list(it), []) | |
| self.assertEqual(repr(d), 'deque([7, 8, 9], maxlen=3)') | |
| self.assertEqual(list(d), range(7, 10)) | |
| self.assertEqual(d, deque(range(10), 3)) | |
| d.append(10) | |
| self.assertEqual(list(d), range(8, 11)) | |
| d.appendleft(7) | |
| self.assertEqual(list(d), range(7, 10)) | |
| d.extend([10, 11]) | |
| self.assertEqual(list(d), range(9, 12)) | |
| d.extendleft([8, 7]) | |
| self.assertEqual(list(d), range(7, 10)) | |
| d = deque(xrange(200), maxlen=10) | |
| d.append(d) | |
| test_support.unlink(test_support.TESTFN) | |
| fo = open(test_support.TESTFN, "wb") | |
| try: | |
| print >> fo, d, | |
| fo.close() | |
| fo = open(test_support.TESTFN, "rb") | |
| self.assertEqual(fo.read(), repr(d)) | |
| finally: | |
| fo.close() | |
| test_support.unlink(test_support.TESTFN) | |
| d = deque(range(10), maxlen=None) | |
| self.assertEqual(repr(d), 'deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])') | |
| fo = open(test_support.TESTFN, "wb") | |
| try: | |
| print >> fo, d, | |
| fo.close() | |
| fo = open(test_support.TESTFN, "rb") | |
| self.assertEqual(fo.read(), repr(d)) | |
| finally: | |
| fo.close() | |
| test_support.unlink(test_support.TESTFN) | |
| def test_maxlen_zero(self): | |
| it = iter(range(100)) | |
| deque(it, maxlen=0) | |
| self.assertEqual(list(it), []) | |
| it = iter(range(100)) | |
| d = deque(maxlen=0) | |
| d.extend(it) | |
| self.assertEqual(list(it), []) | |
| it = iter(range(100)) | |
| d = deque(maxlen=0) | |
| d.extendleft(it) | |
| self.assertEqual(list(it), []) | |
| def test_maxlen_attribute(self): | |
| self.assertEqual(deque().maxlen, None) | |
| self.assertEqual(deque('abc').maxlen, None) | |
| self.assertEqual(deque('abc', maxlen=4).maxlen, 4) | |
| self.assertEqual(deque('abc', maxlen=2).maxlen, 2) | |
| self.assertEqual(deque('abc', maxlen=0).maxlen, 0) | |
| with self.assertRaises(AttributeError): | |
| d = deque('abc') | |
| d.maxlen = 10 | |
| def test_count(self): | |
| for s in ('', 'abracadabra', 'simsalabim'*500+'abc'): | |
| s = list(s) | |
| d = deque(s) | |
| for letter in 'abcdefghijklmnopqrstuvwxyz': | |
| self.assertEqual(s.count(letter), d.count(letter), (s, d, letter)) | |
| self.assertRaises(TypeError, d.count) # too few args | |
| self.assertRaises(TypeError, d.count, 1, 2) # too many args | |
| class BadCompare: | |
| def __eq__(self, other): | |
| raise ArithmeticError | |
| d = deque([1, 2, BadCompare(), 3]) | |
| self.assertRaises(ArithmeticError, d.count, 2) | |
| d = deque([1, 2, 3]) | |
| self.assertRaises(ArithmeticError, d.count, BadCompare()) | |
| class MutatingCompare: | |
| def __eq__(self, other): | |
| self.d.pop() | |
| return True | |
| m = MutatingCompare() | |
| d = deque([1, 2, 3, m, 4, 5]) | |
| m.d = d | |
| self.assertRaises(RuntimeError, d.count, 3) | |
| # test issue11004 | |
| # block advance failed after rotation aligned elements on right side of block | |
| d = deque([None]*16) | |
| for i in range(len(d)): | |
| d.rotate(-1) | |
| d.rotate(1) | |
| self.assertEqual(d.count(1), 0) | |
| self.assertEqual(d.count(None), 16) | |
| def test_comparisons(self): | |
| d = deque('xabc'); d.popleft() | |
| for e in [d, deque('abc'), deque('ab'), deque(), list(d)]: | |
| self.assertEqual(d==e, type(d)==type(e) and list(d)==list(e)) | |
| self.assertEqual(d!=e, not(type(d)==type(e) and list(d)==list(e))) | |
| args = map(deque, ('', 'a', 'b', 'ab', 'ba', 'abc', 'xba', 'xabc', 'cba')) | |
| for x in args: | |
| for y in args: | |
| self.assertEqual(x == y, list(x) == list(y), (x,y)) | |
| self.assertEqual(x != y, list(x) != list(y), (x,y)) | |
| self.assertEqual(x < y, list(x) < list(y), (x,y)) | |
| self.assertEqual(x <= y, list(x) <= list(y), (x,y)) | |
| self.assertEqual(x > y, list(x) > list(y), (x,y)) | |
| self.assertEqual(x >= y, list(x) >= list(y), (x,y)) | |
| self.assertEqual(cmp(x,y), cmp(list(x),list(y)), (x,y)) | |
| def test_extend(self): | |
| d = deque('a') | |
| self.assertRaises(TypeError, d.extend, 1) | |
| d.extend('bcd') | |
| self.assertEqual(list(d), list('abcd')) | |
| d.extend(d) | |
| self.assertEqual(list(d), list('abcdabcd')) | |
| def test_iadd(self): | |
| d = deque('a') | |
| d += 'bcd' | |
| self.assertEqual(list(d), list('abcd')) | |
| d += d | |
| self.assertEqual(list(d), list('abcdabcd')) | |
| def test_extendleft(self): | |
| d = deque('a') | |
| self.assertRaises(TypeError, d.extendleft, 1) | |
| d.extendleft('bcd') | |
| self.assertEqual(list(d), list(reversed('abcd'))) | |
| d.extendleft(d) | |
| self.assertEqual(list(d), list('abcddcba')) | |
| d = deque() | |
| d.extendleft(range(1000)) | |
| self.assertEqual(list(d), list(reversed(range(1000)))) | |
| self.assertRaises(SyntaxError, d.extendleft, fail()) | |
| def test_getitem(self): | |
| n = 200 | |
| d = deque(xrange(n)) | |
| l = range(n) | |
| for i in xrange(n): | |
| d.popleft() | |
| l.pop(0) | |
| if random.random() < 0.5: | |
| d.append(i) | |
| l.append(i) | |
| for j in xrange(1-len(l), len(l)): | |
| assert d[j] == l[j] | |
| d = deque('superman') | |
| self.assertEqual(d[0], 's') | |
| self.assertEqual(d[-1], 'n') | |
| d = deque() | |
| self.assertRaises(IndexError, d.__getitem__, 0) | |
| self.assertRaises(IndexError, d.__getitem__, -1) | |
| def test_setitem(self): | |
| n = 200 | |
| d = deque(xrange(n)) | |
| for i in xrange(n): | |
| d[i] = 10 * i | |
| self.assertEqual(list(d), [10*i for i in xrange(n)]) | |
| l = list(d) | |
| for i in xrange(1-n, 0, -1): | |
| d[i] = 7*i | |
| l[i] = 7*i | |
| self.assertEqual(list(d), l) | |
| def test_delitem(self): | |
| n = 500 # O(n**2) test, don't make this too big | |
| d = deque(xrange(n)) | |
| self.assertRaises(IndexError, d.__delitem__, -n-1) | |
| self.assertRaises(IndexError, d.__delitem__, n) | |
| for i in xrange(n): | |
| self.assertEqual(len(d), n-i) | |
| j = random.randrange(-len(d), len(d)) | |
| val = d[j] | |
| self.assertIn(val, d) | |
| del d[j] | |
| self.assertNotIn(val, d) | |
| self.assertEqual(len(d), 0) | |
| def test_reverse(self): | |
| n = 500 # O(n**2) test, don't make this too big | |
| data = [random.random() for i in range(n)] | |
| for i in range(n): | |
| d = deque(data[:i]) | |
| r = d.reverse() | |
| self.assertEqual(list(d), list(reversed(data[:i]))) | |
| self.assertIs(r, None) | |
| d.reverse() | |
| self.assertEqual(list(d), data[:i]) | |
| self.assertRaises(TypeError, d.reverse, 1) # Arity is zero | |
| def test_rotate(self): | |
| s = tuple('abcde') | |
| n = len(s) | |
| d = deque(s) | |
| d.rotate(1) # verify rot(1) | |
| self.assertEqual(''.join(d), 'eabcd') | |
| d = deque(s) | |
| d.rotate(-1) # verify rot(-1) | |
| self.assertEqual(''.join(d), 'bcdea') | |
| d.rotate() # check default to 1 | |
| self.assertEqual(tuple(d), s) | |
| for i in xrange(n*3): | |
| d = deque(s) | |
| e = deque(d) | |
| d.rotate(i) # check vs. rot(1) n times | |
| for j in xrange(i): | |
| e.rotate(1) | |
| self.assertEqual(tuple(d), tuple(e)) | |
| d.rotate(-i) # check that it works in reverse | |
| self.assertEqual(tuple(d), s) | |
| e.rotate(n-i) # check that it wraps forward | |
| self.assertEqual(tuple(e), s) | |
| for i in xrange(n*3): | |
| d = deque(s) | |
| e = deque(d) | |
| d.rotate(-i) | |
| for j in xrange(i): | |
| e.rotate(-1) # check vs. rot(-1) n times | |
| self.assertEqual(tuple(d), tuple(e)) | |
| d.rotate(i) # check that it works in reverse | |
| self.assertEqual(tuple(d), s) | |
| e.rotate(i-n) # check that it wraps backaround | |
| self.assertEqual(tuple(e), s) | |
| d = deque(s) | |
| e = deque(s) | |
| e.rotate(BIG+17) # verify on long series of rotates | |
| dr = d.rotate | |
| for i in xrange(BIG+17): | |
| dr() | |
| self.assertEqual(tuple(d), tuple(e)) | |
| self.assertRaises(TypeError, d.rotate, 'x') # Wrong arg type | |
| self.assertRaises(TypeError, d.rotate, 1, 10) # Too many args | |
| d = deque() | |
| d.rotate() # rotate an empty deque | |
| self.assertEqual(d, deque()) | |
| def test_len(self): | |
| d = deque('ab') | |
| self.assertEqual(len(d), 2) | |
| d.popleft() | |
| self.assertEqual(len(d), 1) | |
| d.pop() | |
| self.assertEqual(len(d), 0) | |
| self.assertRaises(IndexError, d.pop) | |
| self.assertEqual(len(d), 0) | |
| d.append('c') | |
| self.assertEqual(len(d), 1) | |
| d.appendleft('d') | |
| self.assertEqual(len(d), 2) | |
| d.clear() | |
| self.assertEqual(len(d), 0) | |
| def test_underflow(self): | |
| d = deque() | |
| self.assertRaises(IndexError, d.pop) | |
| self.assertRaises(IndexError, d.popleft) | |
| def test_clear(self): | |
| d = deque(xrange(100)) | |
| self.assertEqual(len(d), 100) | |
| d.clear() | |
| self.assertEqual(len(d), 0) | |
| self.assertEqual(list(d), []) | |
| d.clear() # clear an emtpy deque | |
| self.assertEqual(list(d), []) | |
| def test_remove(self): | |
| d = deque('abcdefghcij') | |
| d.remove('c') | |
| self.assertEqual(d, deque('abdefghcij')) | |
| d.remove('c') | |
| self.assertEqual(d, deque('abdefghij')) | |
| self.assertRaises(ValueError, d.remove, 'c') | |
| self.assertEqual(d, deque('abdefghij')) | |
| # Handle comparison errors | |
| d = deque(['a', 'b', BadCmp(), 'c']) | |
| e = deque(d) | |
| self.assertRaises(RuntimeError, d.remove, 'c') | |
| for x, y in zip(d, e): | |
| # verify that original order and values are retained. | |
| self.assertTrue(x is y) | |
| # Handle evil mutator | |
| for match in (True, False): | |
| d = deque(['ab']) | |
| d.extend([MutateCmp(d, match), 'c']) | |
| self.assertRaises(IndexError, d.remove, 'c') | |
| self.assertEqual(d, deque()) | |
| def test_repr(self): | |
| d = deque(xrange(200)) | |
| e = eval(repr(d)) | |
| self.assertEqual(list(d), list(e)) | |
| d.append(d) | |
| self.assertIn('...', repr(d)) | |
| def test_print(self): | |
| d = deque(xrange(200)) | |
| d.append(d) | |
| test_support.unlink(test_support.TESTFN) | |
| fo = open(test_support.TESTFN, "wb") | |
| try: | |
| print >> fo, d, | |
| fo.close() | |
| fo = open(test_support.TESTFN, "rb") | |
| self.assertEqual(fo.read(), repr(d)) | |
| finally: | |
| fo.close() | |
| test_support.unlink(test_support.TESTFN) | |
| def test_init(self): | |
| self.assertRaises(TypeError, deque, 'abc', 2, 3); | |
| self.assertRaises(TypeError, deque, 1); | |
| def test_hash(self): | |
| self.assertRaises(TypeError, hash, deque('abc')) | |
| def test_long_steadystate_queue_popleft(self): | |
| for size in (0, 1, 2, 100, 1000): | |
| d = deque(xrange(size)) | |
| append, pop = d.append, d.popleft | |
| for i in xrange(size, BIG): | |
| append(i) | |
| x = pop() | |
| if x != i - size: | |
| self.assertEqual(x, i-size) | |
| self.assertEqual(list(d), range(BIG-size, BIG)) | |
| def test_long_steadystate_queue_popright(self): | |
| for size in (0, 1, 2, 100, 1000): | |
| d = deque(reversed(xrange(size))) | |
| append, pop = d.appendleft, d.pop | |
| for i in xrange(size, BIG): | |
| append(i) | |
| x = pop() | |
| if x != i - size: | |
| self.assertEqual(x, i-size) | |
| self.assertEqual(list(reversed(list(d))), range(BIG-size, BIG)) | |
| def test_big_queue_popleft(self): | |
| pass | |
| d = deque() | |
| append, pop = d.append, d.popleft | |
| for i in xrange(BIG): | |
| append(i) | |
| for i in xrange(BIG): | |
| x = pop() | |
| if x != i: | |
| self.assertEqual(x, i) | |
| def test_big_queue_popright(self): | |
| d = deque() | |
| append, pop = d.appendleft, d.pop | |
| for i in xrange(BIG): | |
| append(i) | |
| for i in xrange(BIG): | |
| x = pop() | |
| if x != i: | |
| self.assertEqual(x, i) | |
| def test_big_stack_right(self): | |
| d = deque() | |
| append, pop = d.append, d.pop | |
| for i in xrange(BIG): | |
| append(i) | |
| for i in reversed(xrange(BIG)): | |
| x = pop() | |
| if x != i: | |
| self.assertEqual(x, i) | |
| self.assertEqual(len(d), 0) | |
| def test_big_stack_left(self): | |
| d = deque() | |
| append, pop = d.appendleft, d.popleft | |
| for i in xrange(BIG): | |
| append(i) | |
| for i in reversed(xrange(BIG)): | |
| x = pop() | |
| if x != i: | |
| self.assertEqual(x, i) | |
| self.assertEqual(len(d), 0) | |
| def test_roundtrip_iter_init(self): | |
| d = deque(xrange(200)) | |
| e = deque(d) | |
| self.assertNotEqual(id(d), id(e)) | |
| self.assertEqual(list(d), list(e)) | |
| def test_pickle(self): | |
| d = deque(xrange(200)) | |
| for i in range(pickle.HIGHEST_PROTOCOL + 1): | |
| s = pickle.dumps(d, i) | |
| e = pickle.loads(s) | |
| self.assertNotEqual(id(d), id(e)) | |
| self.assertEqual(list(d), list(e)) | |
| ## def test_pickle_recursive(self): | |
| ## d = deque('abc') | |
| ## d.append(d) | |
| ## for i in range(pickle.HIGHEST_PROTOCOL + 1): | |
| ## e = pickle.loads(pickle.dumps(d, i)) | |
| ## self.assertNotEqual(id(d), id(e)) | |
| ## self.assertEqual(id(e), id(e[-1])) | |
| def test_deepcopy(self): | |
| mut = [10] | |
| d = deque([mut]) | |
| e = copy.deepcopy(d) | |
| self.assertEqual(list(d), list(e)) | |
| mut[0] = 11 | |
| self.assertNotEqual(id(d), id(e)) | |
| self.assertNotEqual(list(d), list(e)) | |
| def test_copy(self): | |
| mut = [10] | |
| d = deque([mut]) | |
| e = copy.copy(d) | |
| self.assertEqual(list(d), list(e)) | |
| mut[0] = 11 | |
| self.assertNotEqual(id(d), id(e)) | |
| self.assertEqual(list(d), list(e)) | |
| def test_reversed(self): | |
| for s in ('abcd', xrange(2000)): | |
| self.assertEqual(list(reversed(deque(s))), list(reversed(s))) | |
| def test_gc_doesnt_blowup(self): | |
| import gc | |
| # This used to assert-fail in deque_traverse() under a debug | |
| # build, or run wild with a NULL pointer in a release build. | |
| d = deque() | |
| for i in xrange(100): | |
| d.append(1) | |
| gc.collect() | |
| def test_container_iterator(self): | |
| # Bug #3680: tp_traverse was not implemented for deque iterator objects | |
| class C(object): | |
| pass | |
| for i in range(2): | |
| obj = C() | |
| ref = weakref.ref(obj) | |
| if i == 0: | |
| container = deque([obj, 1]) | |
| else: | |
| container = reversed(deque([obj, 1])) | |
| obj.x = iter(container) | |
| del obj, container | |
| gc.collect() | |
| self.assertTrue(ref() is None, "Cycle was not collected") | |
| class TestVariousIteratorArgs(unittest.TestCase): | |
| def test_constructor(self): | |
| for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): | |
| for g in (seq_tests.Sequence, seq_tests.IterFunc, | |
| seq_tests.IterGen, seq_tests.IterFuncStop, | |
| seq_tests.itermulti, seq_tests.iterfunc): | |
| self.assertEqual(list(deque(g(s))), list(g(s))) | |
| self.assertRaises(TypeError, deque, seq_tests.IterNextOnly(s)) | |
| self.assertRaises(TypeError, deque, seq_tests.IterNoNext(s)) | |
| self.assertRaises(ZeroDivisionError, deque, seq_tests.IterGenExc(s)) | |
| def test_iter_with_altered_data(self): | |
| d = deque('abcdefg') | |
| it = iter(d) | |
| d.pop() | |
| self.assertRaises(RuntimeError, it.next) | |
| def test_runtime_error_on_empty_deque(self): | |
| d = deque() | |
| it = iter(d) | |
| d.append(10) | |
| self.assertRaises(RuntimeError, it.next) | |
| class Deque(deque): | |
| pass | |
| class DequeWithBadIter(deque): | |
| def __iter__(self): | |
| raise TypeError | |
| class TestSubclass(unittest.TestCase): | |
| def test_basics(self): | |
| d = Deque(xrange(25)) | |
| d.__init__(xrange(200)) | |
| for i in xrange(200, 400): | |
| d.append(i) | |
| for i in reversed(xrange(-200, 0)): | |
| d.appendleft(i) | |
| self.assertEqual(list(d), range(-200, 400)) | |
| self.assertEqual(len(d), 600) | |
| left = [d.popleft() for i in xrange(250)] | |
| self.assertEqual(left, range(-200, 50)) | |
| self.assertEqual(list(d), range(50, 400)) | |
| right = [d.pop() for i in xrange(250)] | |
| right.reverse() | |
| self.assertEqual(right, range(150, 400)) | |
| self.assertEqual(list(d), range(50, 150)) | |
| d.clear() | |
| self.assertEqual(len(d), 0) | |
| def test_copy_pickle(self): | |
| d = Deque('abc') | |
| e = d.__copy__() | |
| self.assertEqual(type(d), type(e)) | |
| self.assertEqual(list(d), list(e)) | |
| e = Deque(d) | |
| self.assertEqual(type(d), type(e)) | |
| self.assertEqual(list(d), list(e)) | |
| s = pickle.dumps(d) | |
| e = pickle.loads(s) | |
| self.assertNotEqual(id(d), id(e)) | |
| self.assertEqual(type(d), type(e)) | |
| self.assertEqual(list(d), list(e)) | |
| d = Deque('abcde', maxlen=4) | |
| e = d.__copy__() | |
| self.assertEqual(type(d), type(e)) | |
| self.assertEqual(list(d), list(e)) | |
| e = Deque(d) | |
| self.assertEqual(type(d), type(e)) | |
| self.assertEqual(list(d), list(e)) | |
| s = pickle.dumps(d) | |
| e = pickle.loads(s) | |
| self.assertNotEqual(id(d), id(e)) | |
| self.assertEqual(type(d), type(e)) | |
| self.assertEqual(list(d), list(e)) | |
| ## def test_pickle(self): | |
| ## d = Deque('abc') | |
| ## d.append(d) | |
| ## | |
| ## e = pickle.loads(pickle.dumps(d)) | |
| ## self.assertNotEqual(id(d), id(e)) | |
| ## self.assertEqual(type(d), type(e)) | |
| ## dd = d.pop() | |
| ## ee = e.pop() | |
| ## self.assertEqual(id(e), id(ee)) | |
| ## self.assertEqual(d, e) | |
| ## | |
| ## d.x = d | |
| ## e = pickle.loads(pickle.dumps(d)) | |
| ## self.assertEqual(id(e), id(e.x)) | |
| ## | |
| ## d = DequeWithBadIter('abc') | |
| ## self.assertRaises(TypeError, pickle.dumps, d) | |
| def test_weakref(self): | |
| d = deque('gallahad') | |
| p = weakref.proxy(d) | |
| self.assertEqual(str(p), str(d)) | |
| d = None | |
| self.assertRaises(ReferenceError, str, p) | |
| def test_strange_subclass(self): | |
| class X(deque): | |
| def __iter__(self): | |
| return iter([]) | |
| d1 = X([1,2,3]) | |
| d2 = X([4,5,6]) | |
| d1 == d2 # not clear if this is supposed to be True or False, | |
| # but it used to give a SystemError | |
| class SubclassWithKwargs(deque): | |
| def __init__(self, newarg=1): | |
| deque.__init__(self) | |
| class TestSubclassWithKwargs(unittest.TestCase): | |
| def test_subclass_with_kwargs(self): | |
| # SF bug #1486663 -- this used to erroneously raise a TypeError | |
| SubclassWithKwargs(newarg=1) | |
| #============================================================================== | |
| libreftest = """ | |
| Example from the Library Reference: Doc/lib/libcollections.tex | |
| >>> from collections import deque | |
| >>> d = deque('ghi') # make a new deque with three items | |
| >>> for elem in d: # iterate over the deque's elements | |
| ... print elem.upper() | |
| G | |
| H | |
| I | |
| >>> d.append('j') # add a new entry to the right side | |
| >>> d.appendleft('f') # add a new entry to the left side | |
| >>> d # show the representation of the deque | |
| deque(['f', 'g', 'h', 'i', 'j']) | |
| >>> d.pop() # return and remove the rightmost item | |
| 'j' | |
| >>> d.popleft() # return and remove the leftmost item | |
| 'f' | |
| >>> list(d) # list the contents of the deque | |
| ['g', 'h', 'i'] | |
| >>> d[0] # peek at leftmost item | |
| 'g' | |
| >>> d[-1] # peek at rightmost item | |
| 'i' | |
| >>> list(reversed(d)) # list the contents of a deque in reverse | |
| ['i', 'h', 'g'] | |
| >>> 'h' in d # search the deque | |
| True | |
| >>> d.extend('jkl') # add multiple elements at once | |
| >>> d | |
| deque(['g', 'h', 'i', 'j', 'k', 'l']) | |
| >>> d.rotate(1) # right rotation | |
| >>> d | |
| deque(['l', 'g', 'h', 'i', 'j', 'k']) | |
| >>> d.rotate(-1) # left rotation | |
| >>> d | |
| deque(['g', 'h', 'i', 'j', 'k', 'l']) | |
| >>> deque(reversed(d)) # make a new deque in reverse order | |
| deque(['l', 'k', 'j', 'i', 'h', 'g']) | |
| >>> d.clear() # empty the deque | |
| >>> d.pop() # cannot pop from an empty deque | |
| Traceback (most recent call last): | |
| File "<pyshell#6>", line 1, in -toplevel- | |
| d.pop() | |
| IndexError: pop from an empty deque | |
| >>> d.extendleft('abc') # extendleft() reverses the input order | |
| >>> d | |
| deque(['c', 'b', 'a']) | |
| >>> def delete_nth(d, n): | |
| ... d.rotate(-n) | |
| ... d.popleft() | |
| ... d.rotate(n) | |
| ... | |
| >>> d = deque('abcdef') | |
| >>> delete_nth(d, 2) # remove the entry at d[2] | |
| >>> d | |
| deque(['a', 'b', 'd', 'e', 'f']) | |
| >>> def roundrobin(*iterables): | |
| ... pending = deque(iter(i) for i in iterables) | |
| ... while pending: | |
| ... task = pending.popleft() | |
| ... try: | |
| ... yield task.next() | |
| ... except StopIteration: | |
| ... continue | |
| ... pending.append(task) | |
| ... | |
| >>> for value in roundrobin('abc', 'd', 'efgh'): | |
| ... print value | |
| ... | |
| a | |
| d | |
| e | |
| b | |
| f | |
| c | |
| g | |
| h | |
| >>> def maketree(iterable): | |
| ... d = deque(iterable) | |
| ... while len(d) > 1: | |
| ... pair = [d.popleft(), d.popleft()] | |
| ... d.append(pair) | |
| ... return list(d) | |
| ... | |
| >>> print maketree('abcdefgh') | |
| [[[['a', 'b'], ['c', 'd']], [['e', 'f'], ['g', 'h']]]] | |
| """ | |
| #============================================================================== | |
| __test__ = {'libreftest' : libreftest} | |
| def test_main(verbose=None): | |
| import sys | |
| test_classes = ( | |
| TestBasic, | |
| TestVariousIteratorArgs, | |
| TestSubclass, | |
| TestSubclassWithKwargs, | |
| ) | |
| test_support.run_unittest(*test_classes) | |
| # verify reference counting | |
| if verbose and hasattr(sys, "gettotalrefcount"): | |
| import gc | |
| counts = [None] * 5 | |
| for i in xrange(len(counts)): | |
| test_support.run_unittest(*test_classes) | |
| gc.collect() | |
| counts[i] = sys.gettotalrefcount() | |
| print counts | |
| # doctests | |
| from test import test_deque | |
| test_support.run_doctest(test_deque, verbose) | |
| if __name__ == "__main__": | |
| test_main(verbose=True) |