Rename ifilterfalse() to filterfalse() and izip_longest() to zip_longest().
This commit is contained in:
Raymond Hettinger
parent
a6c6037f88
commit
b0002d2a07
|
|
@ -233,13 +233,13 @@ loops that truncate the stream.
|
|||
self.currkey = self.keyfunc(self.currvalue)
|
||||
|
||||
|
||||
.. function:: ifilterfalse(predicate, iterable)
|
||||
.. function:: filterfalse(predicate, iterable)
|
||||
|
||||
Make an iterator that filters elements from iterable returning only those for
|
||||
which the predicate is ``False``. If *predicate* is ``None``, return the items
|
||||
that are false. Equivalent to::
|
||||
|
||||
def ifilterfalse(predicate, iterable):
|
||||
def filterfalse(predicate, iterable):
|
||||
if predicate is None:
|
||||
predicate = bool
|
||||
for x in iterable:
|
||||
|
|
@ -292,16 +292,16 @@ loops that truncate the stream.
|
|||
|
||||
:func:`izip` should only be used with unequal length inputs when you don't
|
||||
care about trailing, unmatched values from the longer iterables. If those
|
||||
values are important, use :func:`izip_longest` instead.
|
||||
values are important, use :func:`zip_longest` instead.
|
||||
|
||||
|
||||
.. function:: izip_longest(*iterables[, fillvalue])
|
||||
.. function:: zip_longest(*iterables[, fillvalue])
|
||||
|
||||
Make an iterator that aggregates elements from each of the iterables. If the
|
||||
iterables are of uneven length, missing values are filled-in with *fillvalue*.
|
||||
Iteration continues until the longest iterable is exhausted. Equivalent to::
|
||||
|
||||
def izip_longest(*args, **kwds):
|
||||
def zip_longest(*args, **kwds):
|
||||
fillvalue = kwds.get('fillvalue')
|
||||
def sentinel(counter = ([fillvalue]*(len(args)-1)).pop):
|
||||
yield counter() # yields the fillvalue, or raises IndexError
|
||||
|
|
@ -313,7 +313,7 @@ loops that truncate the stream.
|
|||
except IndexError:
|
||||
pass
|
||||
|
||||
If one of the iterables is potentially infinite, then the :func:`izip_longest`
|
||||
If one of the iterables is potentially infinite, then the :func:`zip_longest`
|
||||
function should be wrapped with something that limits the number of calls (for
|
||||
example :func:`islice` or :func:`takewhile`).
|
||||
|
||||
|
|
@ -568,7 +568,7 @@ which incur interpreter overhead. ::
|
|||
|
||||
def all(seq, pred=None):
|
||||
"Returns True if pred(x) is true for every element in the iterable"
|
||||
for elem in ifilterfalse(pred, seq):
|
||||
for elem in filterfalse(pred, seq):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ Functions:
|
|||
import os
|
||||
import stat
|
||||
import warnings
|
||||
from itertools import ifilterfalse, izip
|
||||
from itertools import filterfalse, izip
|
||||
|
||||
__all__ = ["cmp","dircmp","cmpfiles"]
|
||||
|
||||
|
|
@ -133,8 +133,8 @@ class dircmp:
|
|||
a = dict(izip(map(os.path.normcase, self.left_list), self.left_list))
|
||||
b = dict(izip(map(os.path.normcase, self.right_list), self.right_list))
|
||||
self.common = list(map(a.__getitem__, filter(b.__contains__, a)))
|
||||
self.left_only = list(map(a.__getitem__, ifilterfalse(b.__contains__, a)))
|
||||
self.right_only = list(map(b.__getitem__, ifilterfalse(a.__contains__, b)))
|
||||
self.left_only = list(map(a.__getitem__, filterfalse(b.__contains__, a)))
|
||||
self.right_only = list(map(b.__getitem__, filterfalse(a.__contains__, b)))
|
||||
|
||||
def phase2(self): # Distinguish files, directories, funnies
|
||||
self.common_dirs = []
|
||||
|
|
@ -276,7 +276,7 @@ def _cmp(a, b, sh, abs=abs, cmp=cmp):
|
|||
# Return a copy with items that occur in skip removed.
|
||||
#
|
||||
def _filter(flist, skip):
|
||||
return list(ifilterfalse(skip.__contains__, flist))
|
||||
return list(filterfalse(skip.__contains__, flist))
|
||||
|
||||
|
||||
# Demonstration and testing.
|
||||
|
|
|
|||
|
|
@ -324,16 +324,16 @@ class TestBasicOps(unittest.TestCase):
|
|||
self.assertRaises(TypeError, ifilter, isEven, 3)
|
||||
self.assertRaises(TypeError, next, ifilter(range(6), range(6)))
|
||||
|
||||
def test_ifilterfalse(self):
|
||||
self.assertEqual(list(ifilterfalse(isEven, range(6))), [1,3,5])
|
||||
self.assertEqual(list(ifilterfalse(None, [0,1,0,2,0])), [0,0,0])
|
||||
self.assertEqual(list(ifilterfalse(bool, [0,1,0,2,0])), [0,0,0])
|
||||
self.assertEqual(take(4, ifilterfalse(isEven, count())), [1,3,5,7])
|
||||
self.assertRaises(TypeError, ifilterfalse)
|
||||
self.assertRaises(TypeError, ifilterfalse, lambda x:x)
|
||||
self.assertRaises(TypeError, ifilterfalse, lambda x:x, range(6), 7)
|
||||
self.assertRaises(TypeError, ifilterfalse, isEven, 3)
|
||||
self.assertRaises(TypeError, next, ifilterfalse(range(6), range(6)))
|
||||
def test_filterfalse(self):
|
||||
self.assertEqual(list(filterfalse(isEven, range(6))), [1,3,5])
|
||||
self.assertEqual(list(filterfalse(None, [0,1,0,2,0])), [0,0,0])
|
||||
self.assertEqual(list(filterfalse(bool, [0,1,0,2,0])), [0,0,0])
|
||||
self.assertEqual(take(4, filterfalse(isEven, count())), [1,3,5,7])
|
||||
self.assertRaises(TypeError, filterfalse)
|
||||
self.assertRaises(TypeError, filterfalse, lambda x:x)
|
||||
self.assertRaises(TypeError, filterfalse, lambda x:x, range(6), 7)
|
||||
self.assertRaises(TypeError, filterfalse, isEven, 3)
|
||||
self.assertRaises(TypeError, next, filterfalse(range(6), range(6)))
|
||||
|
||||
def test_izip(self):
|
||||
# XXX This is rather silly now that builtin zip() calls izip()...
|
||||
|
|
@ -366,25 +366,25 @@ class TestBasicOps(unittest.TestCase):
|
|||
]:
|
||||
target = [tuple([arg[i] if i < len(arg) else None for arg in args])
|
||||
for i in range(max(map(len, args)))]
|
||||
self.assertEqual(list(izip_longest(*args)), target)
|
||||
self.assertEqual(list(izip_longest(*args, **{})), target)
|
||||
self.assertEqual(list(zip_longest(*args)), target)
|
||||
self.assertEqual(list(zip_longest(*args, **{})), target)
|
||||
target = [tuple((e is None and 'X' or e) for e in t) for t in target] # Replace None fills with 'X'
|
||||
self.assertEqual(list(izip_longest(*args, **dict(fillvalue='X'))), target)
|
||||
self.assertEqual(list(zip_longest(*args, **dict(fillvalue='X'))), target)
|
||||
|
||||
self.assertEqual(take(3,izip_longest('abcdef', count())), list(zip('abcdef', range(3)))) # take 3 from infinite input
|
||||
self.assertEqual(take(3,zip_longest('abcdef', count())), list(zip('abcdef', range(3)))) # take 3 from infinite input
|
||||
|
||||
self.assertEqual(list(izip_longest()), list(zip()))
|
||||
self.assertEqual(list(izip_longest([])), list(zip([])))
|
||||
self.assertEqual(list(izip_longest('abcdef')), list(zip('abcdef')))
|
||||
self.assertEqual(list(zip_longest()), list(zip()))
|
||||
self.assertEqual(list(zip_longest([])), list(zip([])))
|
||||
self.assertEqual(list(zip_longest('abcdef')), list(zip('abcdef')))
|
||||
|
||||
self.assertEqual(list(izip_longest('abc', 'defg', **{})),
|
||||
self.assertEqual(list(zip_longest('abc', 'defg', **{})),
|
||||
list(izip(list('abc')+[None], 'defg'))) # empty keyword dict
|
||||
self.assertRaises(TypeError, izip_longest, 3)
|
||||
self.assertRaises(TypeError, izip_longest, range(3), 3)
|
||||
self.assertRaises(TypeError, zip_longest, 3)
|
||||
self.assertRaises(TypeError, zip_longest, range(3), 3)
|
||||
|
||||
for stmt in [
|
||||
"izip_longest('abc', fv=1)",
|
||||
"izip_longest('abc', fillvalue=1, bogus_keyword=None)",
|
||||
"zip_longest('abc', fv=1)",
|
||||
"zip_longest('abc', fillvalue=1, bogus_keyword=None)",
|
||||
]:
|
||||
try:
|
||||
eval(stmt, globals(), locals())
|
||||
|
|
@ -394,13 +394,13 @@ class TestBasicOps(unittest.TestCase):
|
|||
self.fail('Did not raise Type in: ' + stmt)
|
||||
|
||||
# Check tuple re-use (implementation detail)
|
||||
self.assertEqual([tuple(list(pair)) for pair in izip_longest('abc', 'def')],
|
||||
self.assertEqual([tuple(list(pair)) for pair in zip_longest('abc', 'def')],
|
||||
list(zip('abc', 'def')))
|
||||
self.assertEqual([pair for pair in izip_longest('abc', 'def')],
|
||||
self.assertEqual([pair for pair in zip_longest('abc', 'def')],
|
||||
list(zip('abc', 'def')))
|
||||
ids = list(map(id, izip_longest('abc', 'def')))
|
||||
ids = list(map(id, zip_longest('abc', 'def')))
|
||||
self.assertEqual(min(ids), max(ids))
|
||||
ids = list(map(id, list(izip_longest('abc', 'def'))))
|
||||
ids = list(map(id, list(zip_longest('abc', 'def'))))
|
||||
self.assertEqual(len(dict.fromkeys(ids)), len(ids))
|
||||
|
||||
def test_product(self):
|
||||
|
|
@ -659,7 +659,7 @@ class TestBasicOps(unittest.TestCase):
|
|||
|
||||
self.assertRaises(StopIteration, next, repeat(None, 0))
|
||||
|
||||
for f in (ifilter, ifilterfalse, imap, takewhile, dropwhile, starmap):
|
||||
for f in (ifilter, filterfalse, imap, takewhile, dropwhile, starmap):
|
||||
self.assertRaises(StopIteration, next, f(lambda x:x, []))
|
||||
self.assertRaises(StopIteration, next, f(lambda x:x, StopNow()))
|
||||
|
||||
|
|
@ -690,9 +690,9 @@ class TestGC(unittest.TestCase):
|
|||
a = []
|
||||
self.makecycle(ifilter(lambda x:True, [a]*2), a)
|
||||
|
||||
def test_ifilterfalse(self):
|
||||
def test_filterfalse(self):
|
||||
a = []
|
||||
self.makecycle(ifilterfalse(lambda x:False, a), a)
|
||||
self.makecycle(filterfalse(lambda x:False, a), a)
|
||||
|
||||
def test_izip(self):
|
||||
a = []
|
||||
|
|
@ -840,14 +840,14 @@ class TestVariousIteratorArgs(unittest.TestCase):
|
|||
self.assertRaises(TypeError, ifilter, isEven, N(s))
|
||||
self.assertRaises(ZeroDivisionError, list, ifilter(isEven, E(s)))
|
||||
|
||||
def test_ifilterfalse(self):
|
||||
def test_filterfalse(self):
|
||||
for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
|
||||
for g in (G, I, Ig, S, L, R):
|
||||
self.assertEqual(list(ifilterfalse(isEven, g(s))),
|
||||
self.assertEqual(list(filterfalse(isEven, g(s))),
|
||||
[x for x in g(s) if isOdd(x)])
|
||||
self.assertRaises(TypeError, ifilterfalse, isEven, X(s))
|
||||
self.assertRaises(TypeError, ifilterfalse, isEven, N(s))
|
||||
self.assertRaises(ZeroDivisionError, list, ifilterfalse(isEven, E(s)))
|
||||
self.assertRaises(TypeError, filterfalse, isEven, X(s))
|
||||
self.assertRaises(TypeError, filterfalse, isEven, N(s))
|
||||
self.assertRaises(ZeroDivisionError, list, filterfalse(isEven, E(s)))
|
||||
|
||||
def test_izip(self):
|
||||
for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
|
||||
|
|
@ -861,11 +861,11 @@ class TestVariousIteratorArgs(unittest.TestCase):
|
|||
def test_iziplongest(self):
|
||||
for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
|
||||
for g in (G, I, Ig, S, L, R):
|
||||
self.assertEqual(list(izip_longest(g(s))), list(zip(g(s))))
|
||||
self.assertEqual(list(izip_longest(g(s), g(s))), list(zip(g(s), g(s))))
|
||||
self.assertRaises(TypeError, izip_longest, X(s))
|
||||
self.assertRaises(TypeError, izip_longest, N(s))
|
||||
self.assertRaises(ZeroDivisionError, list, izip_longest(E(s)))
|
||||
self.assertEqual(list(zip_longest(g(s))), list(zip(g(s))))
|
||||
self.assertEqual(list(zip_longest(g(s), g(s))), list(zip(g(s), g(s))))
|
||||
self.assertRaises(TypeError, zip_longest, X(s))
|
||||
self.assertRaises(TypeError, zip_longest, N(s))
|
||||
self.assertRaises(ZeroDivisionError, list, zip_longest(E(s)))
|
||||
|
||||
def test_imap(self):
|
||||
for s in (range(10), range(0), range(100), (7,11), range(20,50,5)):
|
||||
|
|
@ -1001,7 +1001,7 @@ class RegressionTests(unittest.TestCase):
|
|||
class SubclassWithKwargsTest(unittest.TestCase):
|
||||
def test_keywords_in_subclass(self):
|
||||
# count is not subclassable...
|
||||
for cls in (repeat, izip, ifilter, ifilterfalse, chain, imap,
|
||||
for cls in (repeat, izip, ifilter, filterfalse, chain, imap,
|
||||
starmap, islice, takewhile, dropwhile, cycle):
|
||||
class Subclass(cls):
|
||||
def __init__(self, newarg=None, *args):
|
||||
|
|
@ -1085,7 +1085,7 @@ Samuele
|
|||
|
||||
>>> def all(seq, pred=None):
|
||||
... "Returns True if pred(x) is true for every element in the iterable"
|
||||
... for elem in ifilterfalse(pred, seq):
|
||||
... for elem in filterfalse(pred, seq):
|
||||
... return False
|
||||
... return True
|
||||
|
||||
|
|
|
|||
|
|
@ -2059,28 +2059,28 @@ static PyTypeObject combinations_type = {
|
|||
};
|
||||
|
||||
|
||||
/* ifilterfalse object ************************************************************/
|
||||
/* filterfalse object ************************************************************/
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
PyObject *func;
|
||||
PyObject *it;
|
||||
} ifilterfalseobject;
|
||||
} filterfalseobject;
|
||||
|
||||
static PyTypeObject ifilterfalse_type;
|
||||
static PyTypeObject filterfalse_type;
|
||||
|
||||
static PyObject *
|
||||
ifilterfalse_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
||||
filterfalse_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
||||
{
|
||||
PyObject *func, *seq;
|
||||
PyObject *it;
|
||||
ifilterfalseobject *lz;
|
||||
filterfalseobject *lz;
|
||||
|
||||
if (type == &ifilterfalse_type &&
|
||||
!_PyArg_NoKeywords("ifilterfalse()", kwds))
|
||||
if (type == &filterfalse_type &&
|
||||
!_PyArg_NoKeywords("filterfalse()", kwds))
|
||||
return NULL;
|
||||
|
||||
if (!PyArg_UnpackTuple(args, "ifilterfalse", 2, 2, &func, &seq))
|
||||
if (!PyArg_UnpackTuple(args, "filterfalse", 2, 2, &func, &seq))
|
||||
return NULL;
|
||||
|
||||
/* Get iterator. */
|
||||
|
|
@ -2088,8 +2088,8 @@ ifilterfalse_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|||
if (it == NULL)
|
||||
return NULL;
|
||||
|
||||
/* create ifilterfalseobject structure */
|
||||
lz = (ifilterfalseobject *)type->tp_alloc(type, 0);
|
||||
/* create filterfalseobject structure */
|
||||
lz = (filterfalseobject *)type->tp_alloc(type, 0);
|
||||
if (lz == NULL) {
|
||||
Py_DECREF(it);
|
||||
return NULL;
|
||||
|
|
@ -2102,7 +2102,7 @@ ifilterfalse_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|||
}
|
||||
|
||||
static void
|
||||
ifilterfalse_dealloc(ifilterfalseobject *lz)
|
||||
filterfalse_dealloc(filterfalseobject *lz)
|
||||
{
|
||||
PyObject_GC_UnTrack(lz);
|
||||
Py_XDECREF(lz->func);
|
||||
|
|
@ -2111,7 +2111,7 @@ ifilterfalse_dealloc(ifilterfalseobject *lz)
|
|||
}
|
||||
|
||||
static int
|
||||
ifilterfalse_traverse(ifilterfalseobject *lz, visitproc visit, void *arg)
|
||||
filterfalse_traverse(filterfalseobject *lz, visitproc visit, void *arg)
|
||||
{
|
||||
Py_VISIT(lz->it);
|
||||
Py_VISIT(lz->func);
|
||||
|
|
@ -2119,7 +2119,7 @@ ifilterfalse_traverse(ifilterfalseobject *lz, visitproc visit, void *arg)
|
|||
}
|
||||
|
||||
static PyObject *
|
||||
ifilterfalse_next(ifilterfalseobject *lz)
|
||||
filterfalse_next(filterfalseobject *lz)
|
||||
{
|
||||
PyObject *item;
|
||||
PyObject *it = lz->it;
|
||||
|
|
@ -2152,19 +2152,19 @@ ifilterfalse_next(ifilterfalseobject *lz)
|
|||
}
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(ifilterfalse_doc,
|
||||
"ifilterfalse(function or None, sequence) --> ifilterfalse object\n\
|
||||
PyDoc_STRVAR(filterfalse_doc,
|
||||
"filterfalse(function or None, sequence) --> filterfalse object\n\
|
||||
\n\
|
||||
Return those items of sequence for which function(item) is false.\n\
|
||||
If function is None, return the items that are false.");
|
||||
|
||||
static PyTypeObject ifilterfalse_type = {
|
||||
static PyTypeObject filterfalse_type = {
|
||||
PyVarObject_HEAD_INIT(NULL, 0)
|
||||
"itertools.ifilterfalse", /* tp_name */
|
||||
sizeof(ifilterfalseobject), /* tp_basicsize */
|
||||
"itertools.filterfalse", /* tp_name */
|
||||
sizeof(filterfalseobject), /* tp_basicsize */
|
||||
0, /* tp_itemsize */
|
||||
/* methods */
|
||||
(destructor)ifilterfalse_dealloc, /* tp_dealloc */
|
||||
(destructor)filterfalse_dealloc, /* tp_dealloc */
|
||||
0, /* tp_print */
|
||||
0, /* tp_getattr */
|
||||
0, /* tp_setattr */
|
||||
|
|
@ -2181,13 +2181,13 @@ static PyTypeObject ifilterfalse_type = {
|
|||
0, /* tp_as_buffer */
|
||||
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
|
||||
Py_TPFLAGS_BASETYPE, /* tp_flags */
|
||||
ifilterfalse_doc, /* tp_doc */
|
||||
(traverseproc)ifilterfalse_traverse, /* tp_traverse */
|
||||
filterfalse_doc, /* tp_doc */
|
||||
(traverseproc)filterfalse_traverse, /* tp_traverse */
|
||||
0, /* tp_clear */
|
||||
0, /* tp_richcompare */
|
||||
0, /* tp_weaklistoffset */
|
||||
PyObject_SelfIter, /* tp_iter */
|
||||
(iternextfunc)ifilterfalse_next, /* tp_iternext */
|
||||
(iternextfunc)filterfalse_next, /* tp_iternext */
|
||||
0, /* tp_methods */
|
||||
0, /* tp_members */
|
||||
0, /* tp_getset */
|
||||
|
|
@ -2198,7 +2198,7 @@ static PyTypeObject ifilterfalse_type = {
|
|||
0, /* tp_dictoffset */
|
||||
0, /* tp_init */
|
||||
0, /* tp_alloc */
|
||||
ifilterfalse_new, /* tp_new */
|
||||
filterfalse_new, /* tp_new */
|
||||
PyObject_GC_Del, /* tp_free */
|
||||
};
|
||||
|
||||
|
|
@ -2691,7 +2691,7 @@ typedef struct {
|
|||
static PyTypeObject iziplongest_type;
|
||||
|
||||
static PyObject *
|
||||
izip_longest_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
||||
zip_longest_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
||||
{
|
||||
iziplongestobject *lz;
|
||||
Py_ssize_t i;
|
||||
|
|
@ -2704,7 +2704,7 @@ izip_longest_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|||
fillvalue = PyDict_GetItemString(kwds, "fillvalue");
|
||||
if (fillvalue == NULL || PyDict_Size(kwds) > 1) {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"izip_longest() got an unexpected keyword argument");
|
||||
"zip_longest() got an unexpected keyword argument");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
|
@ -2722,7 +2722,7 @@ izip_longest_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|||
if (it == NULL) {
|
||||
if (PyErr_ExceptionMatches(PyExc_TypeError))
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"izip_longest argument #%zd must support iteration",
|
||||
"zip_longest argument #%zd must support iteration",
|
||||
i+1);
|
||||
Py_DECREF(ittuple);
|
||||
return NULL;
|
||||
|
|
@ -2758,7 +2758,7 @@ izip_longest_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|||
}
|
||||
|
||||
static void
|
||||
izip_longest_dealloc(iziplongestobject *lz)
|
||||
zip_longest_dealloc(iziplongestobject *lz)
|
||||
{
|
||||
PyObject_GC_UnTrack(lz);
|
||||
Py_XDECREF(lz->ittuple);
|
||||
|
|
@ -2768,7 +2768,7 @@ izip_longest_dealloc(iziplongestobject *lz)
|
|||
}
|
||||
|
||||
static int
|
||||
izip_longest_traverse(iziplongestobject *lz, visitproc visit, void *arg)
|
||||
zip_longest_traverse(iziplongestobject *lz, visitproc visit, void *arg)
|
||||
{
|
||||
Py_VISIT(lz->ittuple);
|
||||
Py_VISIT(lz->result);
|
||||
|
|
@ -2777,7 +2777,7 @@ izip_longest_traverse(iziplongestobject *lz, visitproc visit, void *arg)
|
|||
}
|
||||
|
||||
static PyObject *
|
||||
izip_longest_next(iziplongestobject *lz)
|
||||
zip_longest_next(iziplongestobject *lz)
|
||||
{
|
||||
Py_ssize_t i;
|
||||
Py_ssize_t tuplesize = lz->tuplesize;
|
||||
|
|
@ -2848,10 +2848,10 @@ izip_longest_next(iziplongestobject *lz)
|
|||
return result;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(izip_longest_doc,
|
||||
"izip_longest(iter1 [,iter2 [...]], [fillvalue=None]) --> izip_longest object\n\
|
||||
PyDoc_STRVAR(zip_longest_doc,
|
||||
"zip_longest(iter1 [,iter2 [...]], [fillvalue=None]) --> zip_longest object\n\
|
||||
\n\
|
||||
Return an izip_longest object whose .__next__() method returns a tuple where\n\
|
||||
Return an zip_longest object whose .__next__() method returns a tuple where\n\
|
||||
the i-th element comes from the i-th iterable argument. The .__next__()\n\
|
||||
method continues until the longest iterable in the argument sequence\n\
|
||||
is exhausted and then it raises StopIteration. When the shorter iterables\n\
|
||||
|
|
@ -2861,11 +2861,11 @@ defaults to None or can be specified by a keyword argument.\n\
|
|||
|
||||
static PyTypeObject iziplongest_type = {
|
||||
PyVarObject_HEAD_INIT(NULL, 0)
|
||||
"itertools.izip_longest", /* tp_name */
|
||||
"itertools.zip_longest", /* tp_name */
|
||||
sizeof(iziplongestobject), /* tp_basicsize */
|
||||
0, /* tp_itemsize */
|
||||
/* methods */
|
||||
(destructor)izip_longest_dealloc, /* tp_dealloc */
|
||||
(destructor)zip_longest_dealloc, /* tp_dealloc */
|
||||
0, /* tp_print */
|
||||
0, /* tp_getattr */
|
||||
0, /* tp_setattr */
|
||||
|
|
@ -2882,13 +2882,13 @@ static PyTypeObject iziplongest_type = {
|
|||
0, /* tp_as_buffer */
|
||||
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
|
||||
Py_TPFLAGS_BASETYPE, /* tp_flags */
|
||||
izip_longest_doc, /* tp_doc */
|
||||
(traverseproc)izip_longest_traverse, /* tp_traverse */
|
||||
zip_longest_doc, /* tp_doc */
|
||||
(traverseproc)zip_longest_traverse, /* tp_traverse */
|
||||
0, /* tp_clear */
|
||||
0, /* tp_richcompare */
|
||||
0, /* tp_weaklistoffset */
|
||||
PyObject_SelfIter, /* tp_iter */
|
||||
(iternextfunc)izip_longest_next, /* tp_iternext */
|
||||
(iternextfunc)zip_longest_next, /* tp_iternext */
|
||||
0, /* tp_methods */
|
||||
0, /* tp_members */
|
||||
0, /* tp_getset */
|
||||
|
|
@ -2899,7 +2899,7 @@ static PyTypeObject iziplongest_type = {
|
|||
0, /* tp_dictoffset */
|
||||
0, /* tp_init */
|
||||
0, /* tp_alloc */
|
||||
izip_longest_new, /* tp_new */
|
||||
zip_longest_new, /* tp_new */
|
||||
PyObject_GC_Del, /* tp_free */
|
||||
};
|
||||
|
||||
|
|
@ -2915,8 +2915,8 @@ repeat(elem [,n]) --> elem, elem, elem, ... endlessly or up to n times\n\
|
|||
\n\
|
||||
Iterators terminating on the shortest input sequence:\n\
|
||||
izip(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ... \n\
|
||||
izip_longest(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ... \n\
|
||||
ifilterfalse(pred, seq) --> elements of seq where pred(elem) is False\n\
|
||||
zip_longest(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ... \n\
|
||||
filterfalse(pred, seq) --> elements of seq where pred(elem) is False\n\
|
||||
islice(seq, [start,] stop [, step]) --> elements from\n\
|
||||
seq[start:stop:step]\n\
|
||||
starmap(fun, seq) --> fun(*seq[0]), fun(*seq[1]), ...\n\
|
||||
|
|
@ -2947,7 +2947,7 @@ inititertools(void)
|
|||
&islice_type,
|
||||
&starmap_type,
|
||||
&chain_type,
|
||||
&ifilterfalse_type,
|
||||
&filterfalse_type,
|
||||
&count_type,
|
||||
&izip_type,
|
||||
&iziplongest_type,
|
||||
|
|
|
|||
Loading…
Reference in New Issue