home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / pythonwin / python.exe / TEST_ITERTOOLS.PY < prev    next >
Encoding:
Python Source  |  2003-09-02  |  22.3 KB  |  620 lines
  1. import unittest
  2. from test import test_support
  3. from itertools import *
  4. import sys
  5. import operator
  6.  
  7. def onearg(x):
  8.     'Test function of one argument'
  9.     return 2*x
  10.  
  11. def errfunc(*args):
  12.     'Test function that raises an error'
  13.     raise ValueError
  14.  
  15. def gen3():
  16.     'Non-restartable source sequence'
  17.     for i in (0, 1, 2):
  18.         yield i
  19.  
  20. def isEven(x):
  21.     'Test predicate'
  22.     return x%2==0
  23.  
  24. def isOdd(x):
  25.     'Test predicate'
  26.     return x%2==1
  27.  
  28. class StopNow:
  29.     'Class emulating an empty iterable.'
  30.     def __iter__(self):
  31.         return self
  32.     def next(self):
  33.         raise StopIteration
  34.  
  35. def take(n, seq):
  36.     'Convenience function for partially consuming a long of infinite iterable'
  37.     return list(islice(seq, n))
  38.  
  39. class TestBasicOps(unittest.TestCase):
  40.     def test_chain(self):
  41.         self.assertEqual(list(chain('abc', 'def')), list('abcdef'))
  42.         self.assertEqual(list(chain('abc')), list('abc'))
  43.         self.assertEqual(list(chain('')), [])
  44.         self.assertEqual(take(4, chain('abc', 'def')), list('abcd'))
  45.         self.assertRaises(TypeError, chain, 2, 3)
  46.  
  47.     def test_count(self):
  48.         self.assertEqual(zip('abc',count()), [('a', 0), ('b', 1), ('c', 2)])
  49.         self.assertEqual(zip('abc',count(3)), [('a', 3), ('b', 4), ('c', 5)])
  50.         self.assertEqual(take(2, zip('abc',count(3))), [('a', 3), ('b', 4)])
  51.         self.assertRaises(TypeError, count, 2, 3)
  52.         self.assertRaises(TypeError, count, 'a')
  53.         c = count(sys.maxint-2)   # verify that rollover doesn't crash
  54.         c.next(); c.next(); c.next(); c.next(); c.next()
  55.  
  56.     def test_cycle(self):
  57.         self.assertEqual(take(10, cycle('abc')), list('abcabcabca'))
  58.         self.assertEqual(list(cycle('')), [])
  59.         self.assertRaises(TypeError, cycle)
  60.         self.assertRaises(TypeError, cycle, 5)
  61.         self.assertEqual(list(islice(cycle(gen3()),10)), [0,1,2,0,1,2,0,1,2,0])
  62.  
  63.     def test_ifilter(self):
  64.         self.assertEqual(list(ifilter(isEven, range(6))), [0,2,4])
  65.         self.assertEqual(list(ifilter(None, [0,1,0,2,0])), [1,2])
  66.         self.assertEqual(take(4, ifilter(isEven, count())), [0,2,4,6])
  67.         self.assertRaises(TypeError, ifilter)
  68.         self.assertRaises(TypeError, ifilter, lambda x:x)
  69.         self.assertRaises(TypeError, ifilter, lambda x:x, range(6), 7)
  70.         self.assertRaises(TypeError, ifilter, isEven, 3)
  71.         self.assertRaises(TypeError, ifilter(range(6), range(6)).next)
  72.  
  73.     def test_ifilterfalse(self):
  74.         self.assertEqual(list(ifilterfalse(isEven, range(6))), [1,3,5])
  75.         self.assertEqual(list(ifilterfalse(None, [0,1,0,2,0])), [0,0,0])
  76.         self.assertEqual(take(4, ifilterfalse(isEven, count())), [1,3,5,7])
  77.         self.assertRaises(TypeError, ifilterfalse)
  78.         self.assertRaises(TypeError, ifilterfalse, lambda x:x)
  79.         self.assertRaises(TypeError, ifilterfalse, lambda x:x, range(6), 7)
  80.         self.assertRaises(TypeError, ifilterfalse, isEven, 3)
  81.         self.assertRaises(TypeError, ifilterfalse(range(6), range(6)).next)
  82.  
  83.     def test_izip(self):
  84.         ans = [(x,y) for x, y in izip('abc',count())]
  85.         self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
  86.         self.assertEqual(list(izip('abc', range(6))), zip('abc', range(6)))
  87.         self.assertEqual(list(izip('abcdef', range(3))), zip('abcdef', range(3)))
  88.         self.assertEqual(take(3,izip('abcdef', count())), zip('abcdef', range(3)))
  89.         self.assertEqual(list(izip('abcdef')), zip('abcdef'))
  90.         self.assertEqual(list(izip()), [])
  91.         self.assertRaises(TypeError, izip, 3)
  92.         self.assertRaises(TypeError, izip, range(3), 3)
  93.         # Check tuple re-use (implementation detail)
  94.         self.assertEqual([tuple(list(pair)) for pair in izip('abc', 'def')],
  95.                          zip('abc', 'def'))
  96.         self.assertEqual([pair for pair in izip('abc', 'def')],
  97.                          zip('abc', 'def'))
  98.         ids = map(id, izip('abc', 'def'))
  99.         self.assertEqual(min(ids), max(ids))
  100.         ids = map(id, list(izip('abc', 'def')))
  101.         self.assertEqual(len(dict.fromkeys(ids)), len(ids))
  102.  
  103.     def test_repeat(self):
  104.         self.assertEqual(zip(xrange(3),repeat('a')),
  105.                          [(0, 'a'), (1, 'a'), (2, 'a')])
  106.         self.assertEqual(list(repeat('a', 3)), ['a', 'a', 'a'])
  107.         self.assertEqual(take(3, repeat('a')), ['a', 'a', 'a'])
  108.         self.assertEqual(list(repeat('a', 0)), [])
  109.         self.assertEqual(list(repeat('a', -3)), [])
  110.         self.assertRaises(TypeError, repeat)
  111.         self.assertRaises(TypeError, repeat, None, 3, 4)
  112.         self.assertRaises(TypeError, repeat, None, 'a')
  113.  
  114.     def test_imap(self):
  115.         self.assertEqual(list(imap(operator.pow, range(3), range(1,7))),
  116.                          [0**1, 1**2, 2**3])
  117.         self.assertEqual(list(imap(None, 'abc', range(5))),
  118.                          [('a',0),('b',1),('c',2)])
  119.         self.assertEqual(list(imap(None, 'abc', count())),
  120.                          [('a',0),('b',1),('c',2)])
  121.         self.assertEqual(take(2,imap(None, 'abc', count())),
  122.                          [('a',0),('b',1)])
  123.         self.assertEqual(list(imap(operator.pow, [])), [])
  124.         self.assertRaises(TypeError, imap)
  125.         self.assertRaises(TypeError, imap, operator.neg)
  126.         self.assertRaises(TypeError, imap(10, range(5)).next)
  127.         self.assertRaises(ValueError, imap(errfunc, [4], [5]).next)
  128.         self.assertRaises(TypeError, imap(onearg, [4], [5]).next)
  129.  
  130.     def test_starmap(self):
  131.         self.assertEqual(list(starmap(operator.pow, zip(range(3), range(1,7)))),
  132.                          [0**1, 1**2, 2**3])
  133.         self.assertEqual(take(3, starmap(operator.pow, izip(count(), count(1)))),
  134.                          [0**1, 1**2, 2**3])
  135.         self.assertEqual(list(starmap(operator.pow, [])), [])
  136.         self.assertRaises(TypeError, list, starmap(operator.pow, [[4,5]]))
  137.         self.assertRaises(TypeError, starmap)
  138.         self.assertRaises(TypeError, starmap, operator.pow, [(4,5)], 'extra')
  139.         self.assertRaises(TypeError, starmap(10, [(4,5)]).next)
  140.         self.assertRaises(ValueError, starmap(errfunc, [(4,5)]).next)
  141.         self.assertRaises(TypeError, starmap(onearg, [(4,5)]).next)
  142.  
  143.     def test_islice(self):
  144.         for args in [          # islice(args) should agree with range(args)
  145.                 (10, 20, 3),
  146.                 (10, 3, 20),
  147.                 (10, 20),
  148.                 (10, 3),
  149.                 (20,)
  150.                 ]:
  151.             self.assertEqual(list(islice(xrange(100), *args)), range(*args))
  152.  
  153.         for args, tgtargs in [  # Stop when seqn is exhausted
  154.                 ((10, 110, 3), ((10, 100, 3))),
  155.                 ((10, 110), ((10, 100))),
  156.                 ((110,), (100,))
  157.                 ]:
  158.             self.assertEqual(list(islice(xrange(100), *args)), range(*tgtargs))
  159.  
  160.         # Test stop=None
  161.         self.assertEqual(list(islice(xrange(10), None)), range(10))
  162.         self.assertEqual(list(islice(xrange(10), 2, None)), range(2, 10))
  163.         self.assertEqual(list(islice(xrange(10), 1, None, 2)), range(1, 10, 2))
  164.  
  165.         # Test invalid arguments
  166.         self.assertRaises(TypeError, islice, xrange(10))
  167.         self.assertRaises(TypeError, islice, xrange(10), 1, 2, 3, 4)
  168.         self.assertRaises(ValueError, islice, xrange(10), -5, 10, 1)
  169.         self.assertRaises(ValueError, islice, xrange(10), 1, -5, -1)
  170.         self.assertRaises(ValueError, islice, xrange(10), 1, 10, -1)
  171.         self.assertRaises(ValueError, islice, xrange(10), 1, 10, 0)
  172.         self.assertRaises(ValueError, islice, xrange(10), 'a')
  173.         self.assertRaises(ValueError, islice, xrange(10), 'a', 1)
  174.         self.assertRaises(ValueError, islice, xrange(10), 1, 'a')
  175.         self.assertRaises(ValueError, islice, xrange(10), 'a', 1, 1)
  176.         self.assertRaises(ValueError, islice, xrange(10), 1, 'a', 1)
  177.         self.assertEqual(len(list(islice(count(), 1, 10, sys.maxint))), 1)
  178.  
  179.     def test_takewhile(self):
  180.         data = [1, 3, 5, 20, 2, 4, 6, 8]
  181.         underten = lambda x: x<10
  182.         self.assertEqual(list(takewhile(underten, data)), [1, 3, 5])
  183.         self.assertEqual(list(takewhile(underten, [])), [])
  184.         self.assertRaises(TypeError, takewhile)
  185.         self.assertRaises(TypeError, takewhile, operator.pow)
  186.         self.assertRaises(TypeError, takewhile, operator.pow, [(4,5)], 'extra')
  187.         self.assertRaises(TypeError, takewhile(10, [(4,5)]).next)
  188.         self.assertRaises(ValueError, takewhile(errfunc, [(4,5)]).next)
  189.  
  190.     def test_dropwhile(self):
  191.         data = [1, 3, 5, 20, 2, 4, 6, 8]
  192.         underten = lambda x: x<10
  193.         self.assertEqual(list(dropwhile(underten, data)), [20, 2, 4, 6, 8])
  194.         self.assertEqual(list(dropwhile(underten, [])), [])
  195.         self.assertRaises(TypeError, dropwhile)
  196.         self.assertRaises(TypeError, dropwhile, operator.pow)
  197.         self.assertRaises(TypeError, dropwhile, operator.pow, [(4,5)], 'extra')
  198.         self.assertRaises(TypeError, dropwhile(10, [(4,5)]).next)
  199.         self.assertRaises(ValueError, dropwhile(errfunc, [(4,5)]).next)
  200.  
  201.     def test_StopIteration(self):
  202.         self.assertRaises(StopIteration, izip().next)
  203.  
  204.         for f in (chain, cycle, izip):
  205.             self.assertRaises(StopIteration, f([]).next)
  206.             self.assertRaises(StopIteration, f(StopNow()).next)
  207.  
  208.         self.assertRaises(StopIteration, islice([], None).next)
  209.         self.assertRaises(StopIteration, islice(StopNow(), None).next)
  210.  
  211.         self.assertRaises(StopIteration, repeat(None, 0).next)
  212.  
  213.         for f in (ifilter, ifilterfalse, imap, takewhile, dropwhile, starmap):
  214.             self.assertRaises(StopIteration, f(lambda x:x, []).next)
  215.             self.assertRaises(StopIteration, f(lambda x:x, StopNow()).next)
  216.  
  217. def R(seqn):
  218.     'Regular generator'
  219.     for i in seqn:
  220.         yield i
  221.  
  222. class G:
  223.     'Sequence using __getitem__'
  224.     def __init__(self, seqn):
  225.         self.seqn = seqn
  226.     def __getitem__(self, i):
  227.         return self.seqn[i]
  228.  
  229. class I:
  230.     'Sequence using iterator protocol'
  231.     def __init__(self, seqn):
  232.         self.seqn = seqn
  233.         self.i = 0
  234.     def __iter__(self):
  235.         return self
  236.     def next(self):
  237.         if self.i >= len(self.seqn): raise StopIteration
  238.         v = self.seqn[self.i]
  239.         self.i += 1
  240.         return v
  241.  
  242. class Ig:
  243.     'Sequence using iterator protocol defined with a generator'
  244.     def __init__(self, seqn):
  245.         self.seqn = seqn
  246.         self.i = 0
  247.     def __iter__(self):
  248.         for val in self.seqn:
  249.             yield val
  250.  
  251. class X:
  252.     'Missing __getitem__ and __iter__'
  253.     def __init__(self, seqn):
  254.         self.seqn = seqn
  255.         self.i = 0
  256.     def next(self):
  257.         if self.i >= len(self.seqn): raise StopIteration
  258.         v = self.seqn[self.i]
  259.         self.i += 1
  260.         return v
  261.  
  262. class N:
  263.     'Iterator missing next()'
  264.     def __init__(self, seqn):
  265.         self.seqn = seqn
  266.         self.i = 0
  267.     def __iter__(self):
  268.         return self
  269.  
  270. class E:
  271.     'Test propagation of exceptions'
  272.     def __init__(self, seqn):
  273.         self.seqn = seqn
  274.         self.i = 0
  275.     def __iter__(self):
  276.         return self
  277.     def next(self):
  278.         3/0
  279.  
  280. class S:
  281.     'Test immediate stop'
  282.     def __init__(self, seqn):
  283.         pass
  284.     def __iter__(self):
  285.         return self
  286.     def next(self):
  287.         raise StopIteration
  288.  
  289. def L(seqn):
  290.     'Test multiple tiers of iterators'
  291.     return chain(imap(lambda x:x, R(Ig(G(seqn)))))
  292.  
  293. class TestGC(unittest.TestCase):
  294.  
  295.     def makecycle(self, iterator, container):
  296.         container.append(iterator)
  297.         iterator.next()
  298.         del container, iterator
  299.  
  300.     def test_chain(self):
  301.         a = []
  302.         self.makecycle(chain(a), a)
  303.  
  304.     def test_cycle(self):
  305.         a = []
  306.         self.makecycle(cycle([a]*2), a)
  307.  
  308.     def test_ifilter(self):
  309.         a = []
  310.         self.makecycle(ifilter(lambda x:True, [a]*2), a)
  311.  
  312.     def test_ifilterfalse(self):
  313.         a = []
  314.         self.makecycle(ifilterfalse(lambda x:False, a), a)
  315.  
  316.     def test_izip(self):
  317.         a = []
  318.         self.makecycle(izip([a]*2, [a]*3), a)
  319.  
  320.     def test_imap(self):
  321.         a = []
  322.         self.makecycle(imap(lambda x:x, [a]*2), a)
  323.  
  324.     def test_islice(self):
  325.         a = []
  326.         self.makecycle(islice([a]*2, None), a)
  327.  
  328.     def test_starmap(self):
  329.         a = []
  330.         self.makecycle(starmap(lambda *t: t, [(a,a)]*2), a)
  331.  
  332.  
  333. class TestVariousIteratorArgs(unittest.TestCase):
  334.  
  335.     def test_chain(self):
  336.         for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
  337.             for g in (G, I, Ig, S, L, R):
  338.                 self.assertEqual(list(chain(g(s))), list(g(s)))
  339.                 self.assertEqual(list(chain(g(s), g(s))), list(g(s))+list(g(s)))
  340.             self.assertRaises(TypeError, chain, X(s))
  341.             self.assertRaises(TypeError, list, chain(N(s)))
  342.             self.assertRaises(ZeroDivisionError, list, chain(E(s)))
  343.  
  344.     def test_cycle(self):
  345.         for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
  346.             for g in (G, I, Ig, S, L, R):
  347.                 tgtlen = len(s) * 3
  348.                 expected = list(g(s))*3
  349.                 actual = list(islice(cycle(g(s)), tgtlen))
  350.                 self.assertEqual(actual, expected)
  351.             self.assertRaises(TypeError, cycle, X(s))
  352.             self.assertRaises(TypeError, list, cycle(N(s)))
  353.             self.assertRaises(ZeroDivisionError, list, cycle(E(s)))
  354.  
  355.     def test_ifilter(self):
  356.         for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
  357.             for g in (G, I, Ig, S, L, R):
  358.                 self.assertEqual(list(ifilter(isEven, g(s))), filter(isEven, g(s)))
  359.             self.assertRaises(TypeError, ifilter, isEven, X(s))
  360.             self.assertRaises(TypeError, list, ifilter(isEven, N(s)))
  361.             self.assertRaises(ZeroDivisionError, list, ifilter(isEven, E(s)))
  362.  
  363.     def test_ifilterfalse(self):
  364.         for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
  365.             for g in (G, I, Ig, S, L, R):
  366.                 self.assertEqual(list(ifilterfalse(isEven, g(s))), filter(isOdd, g(s)))
  367.             self.assertRaises(TypeError, ifilterfalse, isEven, X(s))
  368.             self.assertRaises(TypeError, list, ifilterfalse(isEven, N(s)))
  369.             self.assertRaises(ZeroDivisionError, list, ifilterfalse(isEven, E(s)))
  370.  
  371.     def test_izip(self):
  372.         for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
  373.             for g in (G, I, Ig, S, L, R):
  374.                 self.assertEqual(list(izip(g(s))), zip(g(s)))
  375.                 self.assertEqual(list(izip(g(s), g(s))), zip(g(s), g(s)))
  376.             self.assertRaises(TypeError, izip, X(s))
  377.             self.assertRaises(TypeError, list, izip(N(s)))
  378.             self.assertRaises(ZeroDivisionError, list, izip(E(s)))
  379.  
  380.     def test_imap(self):
  381.         for s in (range(10), range(0), range(100), (7,11), xrange(20,50,5)):
  382.             for g in (G, I, Ig, S, L, R):
  383.                 self.assertEqual(list(imap(onearg, g(s))), map(onearg, g(s)))
  384.                 self.assertEqual(list(imap(operator.pow, g(s), g(s))), map(operator.pow, g(s), g(s)))
  385.             self.assertRaises(TypeError, imap, onearg, X(s))
  386.             self.assertRaises(TypeError, list, imap(onearg, N(s)))
  387.             self.assertRaises(ZeroDivisionError, list, imap(onearg, E(s)))
  388.  
  389.     def test_islice(self):
  390.         for s in ("12345", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
  391.             for g in (G, I, Ig, S, L, R):
  392.                 self.assertEqual(list(islice(g(s),1,None,2)), list(g(s))[1::2])
  393.             self.assertRaises(TypeError, islice, X(s), 10)
  394.             self.assertRaises(TypeError, list, islice(N(s), 10))
  395.             self.assertRaises(ZeroDivisionError, list, islice(E(s), 10))
  396.  
  397.     def test_starmap(self):
  398.         for s in (range(10), range(0), range(100), (7,11), xrange(20,50,5)):
  399.             for g in (G, I, Ig, S, L, R):
  400.                 ss = zip(s, s)
  401.                 self.assertEqual(list(starmap(operator.pow, g(ss))), map(operator.pow, g(s), g(s)))
  402.             self.assertRaises(TypeError, starmap, operator.pow, X(ss))
  403.             self.assertRaises(TypeError, list, starmap(operator.pow, N(ss)))
  404.             self.assertRaises(ZeroDivisionError, list, starmap(operator.pow, E(ss)))
  405.  
  406.     def test_takewhile(self):
  407.         for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
  408.             for g in (G, I, Ig, S, L, R):
  409.                 tgt = []
  410.                 for elem in g(s):
  411.                     if not isEven(elem): break
  412.                     tgt.append(elem)
  413.                 self.assertEqual(list(takewhile(isEven, g(s))), tgt)
  414.             self.assertRaises(TypeError, takewhile, isEven, X(s))
  415.             self.assertRaises(TypeError, list, takewhile(isEven, N(s)))
  416.             self.assertRaises(ZeroDivisionError, list, takewhile(isEven, E(s)))
  417.  
  418.     def test_dropwhile(self):
  419.         for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
  420.             for g in (G, I, Ig, S, L, R):
  421.                 tgt = []
  422.                 for elem in g(s):
  423.                     if not tgt and isOdd(elem): continue
  424.                     tgt.append(elem)
  425.                 self.assertEqual(list(dropwhile(isOdd, g(s))), tgt)
  426.             self.assertRaises(TypeError, dropwhile, isOdd, X(s))
  427.             self.assertRaises(TypeError, list, dropwhile(isOdd, N(s)))
  428.             self.assertRaises(ZeroDivisionError, list, dropwhile(isOdd, E(s)))
  429.  
  430. class RegressionTests(unittest.TestCase):
  431.  
  432.     def test_sf_793826(self):
  433.         # Fix Armin Rigo's successful efforts to wreak havoc
  434.  
  435.         def mutatingtuple(tuple1, f, tuple2):
  436.             # this builds a tuple t which is a copy of tuple1,
  437.             # then calls f(t), then mutates t to be equal to tuple2
  438.             # (needs len(tuple1) == len(tuple2)).
  439.             def g(value, first=[1]):
  440.                 if first:
  441.                     del first[:]
  442.                     f(z.next())
  443.                 return value
  444.             items = list(tuple2)
  445.             items[1:1] = list(tuple1)
  446.             gen = imap(g, items)
  447.             z = izip(*[gen]*len(tuple1))
  448.             z.next()
  449.  
  450.         def f(t):
  451.             global T
  452.             T = t
  453.             first[:] = list(T)
  454.  
  455.         first = []
  456.         mutatingtuple((1,2,3), f, (4,5,6))
  457.         second = list(T)
  458.         self.assertEqual(first, second)
  459.  
  460.  
  461. libreftest = """ Doctest for examples in the library reference: libitertools.tex
  462.  
  463.  
  464. >>> amounts = [120.15, 764.05, 823.14]
  465. >>> for checknum, amount in izip(count(1200), amounts):
  466. ...     print 'Check %d is for $%.2f' % (checknum, amount)
  467. ...
  468. Check 1200 is for $120.15
  469. Check 1201 is for $764.05
  470. Check 1202 is for $823.14
  471.  
  472. >>> import operator
  473. >>> for cube in imap(operator.pow, xrange(1,4), repeat(3)):
  474. ...    print cube
  475. ...
  476. 1
  477. 8
  478. 27
  479.  
  480. >>> reportlines = ['EuroPython', 'Roster', '', 'alex', '', 'laura', '', 'martin', '', 'walter', '', 'samuele']
  481. >>> for name in islice(reportlines, 3, None, 2):
  482. ...    print name.title()
  483. ...
  484. Alex
  485. Laura
  486. Martin
  487. Walter
  488. Samuele
  489.  
  490. >>> def enumerate(iterable):
  491. ...     return izip(count(), iterable)
  492.  
  493. >>> def tabulate(function):
  494. ...     "Return function(0), function(1), ..."
  495. ...     return imap(function, count())
  496.  
  497. >>> def iteritems(mapping):
  498. ...     return izip(mapping.iterkeys(), mapping.itervalues())
  499.  
  500. >>> def nth(iterable, n):
  501. ...     "Returns the nth item"
  502. ...     return list(islice(iterable, n, n+1))
  503.  
  504. >>> def all(pred, seq):
  505. ...     "Returns True if pred(x) is True for every element in the iterable"
  506. ...     return False not in imap(pred, seq)
  507.  
  508. >>> def some(pred, seq):
  509. ...     "Returns True if pred(x) is True for at least one element in the iterable"
  510. ...     return True in imap(pred, seq)
  511.  
  512. >>> def no(pred, seq):
  513. ...     "Returns True if pred(x) is False for every element in the iterable"
  514. ...     return True not in imap(pred, seq)
  515.  
  516. >>> def quantify(pred, seq):
  517. ...     "Count how many times the predicate is True in the sequence"
  518. ...     return sum(imap(pred, seq))
  519.  
  520. >>> def padnone(seq):
  521. ...     "Returns the sequence elements and then returns None indefinitely"
  522. ...     return chain(seq, repeat(None))
  523.  
  524. >>> def ncycles(seq, n):
  525. ...     "Returns the sequence elements n times"
  526. ...     return chain(*repeat(seq, n))
  527.  
  528. >>> def dotproduct(vec1, vec2):
  529. ...     return sum(imap(operator.mul, vec1, vec2))
  530.  
  531. >>> def window(seq, n=2):
  532. ...     "Returns a sliding window (of width n) over data from the iterable"
  533. ...     "   s -> (s0,s1,...s[n-1]), (s1,s2,...,sn), ...                   "
  534. ...     it = iter(seq)
  535. ...     result = tuple(islice(it, n))
  536. ...     if len(result) == n:
  537. ...         yield result
  538. ...     for elem in it:
  539. ...         result = result[1:] + (elem,)
  540. ...         yield result
  541.  
  542. >>> def take(n, seq):
  543. ...     return list(islice(seq, n))
  544.  
  545. This is not part of the examples but it tests to make sure the definitions
  546. perform as purported.
  547.  
  548. >>> list(enumerate('abc'))
  549. [(0, 'a'), (1, 'b'), (2, 'c')]
  550.  
  551. >>> list(islice(tabulate(lambda x: 2*x), 4))
  552. [0, 2, 4, 6]
  553.  
  554. >>> nth('abcde', 3)
  555. ['d']
  556.  
  557. >>> all(lambda x: x%2==0, [2, 4, 6, 8])
  558. True
  559.  
  560. >>> all(lambda x: x%2==0, [2, 3, 6, 8])
  561. False
  562.  
  563. >>> some(lambda x: x%2==0, [2, 4, 6, 8])
  564. True
  565.  
  566. >>> some(lambda x: x%2==0, [1, 3, 5, 9])
  567. False
  568.  
  569. >>> no(lambda x: x%2==0, [1, 3, 5, 9])
  570. True
  571.  
  572. >>> no(lambda x: x%2==0, [1, 2, 5, 9])
  573. False
  574.  
  575. >>> quantify(lambda x: x%2==0, xrange(99))
  576. 50
  577.  
  578. >>> list(window('abc'))
  579. [('a', 'b'), ('b', 'c')]
  580.  
  581. >>> list(window('abc',5))
  582. []
  583.  
  584. >>> list(islice(padnone('abc'), 0, 6))
  585. ['a', 'b', 'c', None, None, None]
  586.  
  587. >>> list(ncycles('abc', 3))
  588. ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
  589.  
  590. >>> dotproduct([1,2,3], [4,5,6])
  591. 32
  592.  
  593. >>> take(10, count())
  594. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  595.  
  596. """
  597.  
  598. __test__ = {'libreftest' : libreftest}
  599.  
  600. def test_main(verbose=None):
  601.     test_classes = (TestBasicOps, TestVariousIteratorArgs, TestGC,
  602.                     RegressionTests)
  603.     test_support.run_unittest(*test_classes)
  604.  
  605.     # verify reference counting
  606.     if verbose and hasattr(sys, "gettotalrefcount"):
  607.         import gc
  608.         counts = [None] * 5
  609.         for i in xrange(len(counts)):
  610.             test_support.run_unittest(*test_classes)
  611.             gc.collect()
  612.             counts[i] = sys.gettotalrefcount()
  613.         print counts
  614.  
  615.     # doctest the examples in the library reference
  616.     test_support.run_doctest(sys.modules[__name__], verbose)
  617.  
  618. if __name__ == "__main__":
  619.     test_main(verbose=True)
  620.