enumerate(iterable[, start]) --> iterator for index, value of iterable
Return an enumerate object. iterable must be another object(a sequence, an iterator, or some other object) that supports iteration. The enumerate object yields pairs containing a count (from start, which defaults to zero) and a value yielded by the iterable argument. enumerate is useful for obtaining an indexed list: (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
Equivalent to:
def enumerate(sequence, start=0): n = start for elem in sequence: yield n, elem n += 1
Example:
>>> a = [1, 3, 5, 7, 9] >>> for index, value in enumerate(a, 1): print(index, value) >>> 1 1 2 3 3 5 4 7 5 9
zip(iter1 [,iter2 [...]]) --> zip object
Return a zip object whose .__next__() method returns a tuple where the i-th element comes from the i-th iterable argument. The .__next__() method continues until the shortest iterable in the argument sequence is exhausted and then it raises StopIteration.With a single iterable argument, it returns an iterator of 1-tuples. With no arguments, it returns an empty iterator.
The left-to-right evaluation order of the iterables is guaranteed. This makes possible an idiom for clustering a data series into n-length groups using zip(*[iter(s)]*n). This repeats the same iterator n times so that each output tuple has the result of n calls to the iterator. This has the effect of dividing the input into n-length chunks.
zip() 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 itertools.zip_longest() instead.
Equivalent to:
def zip(*iterables): # zip('ABCD', 'xy') --> Ax By sentinel = object() iterators = [iter(it) for it in iterables] while iterators: result = [] for it in iterators: elem = next(it, sentinel) if elem is sentinel: return result.append(elem) yield tuple(result)
Example:
>>> a = [1, 2, 3] >>> b = [4, 5 ,6, 7] >>> c = [8, 9] >>> for x, y, z in zip(a, b, c) prin(x, y, z) >>> 1 4 8 2 5 9
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2) # return True
map(func, *iterables) --> map object
Return an iterator that applies function to every item of iterable, yielding the results. If additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted. For cases where the function inputs are already arranged into argument tuples, see itertools.starmap().
Example:
>>> int_1 = [1, 2, 3, 4, 5] >>> int_2 = [6, 7, 8, 9, 10] >>> ','.join(map(str, int_1)) # return '1,2,3,4,5' >>> sum(map(operator.mul, int_1, int_2)) # return 130
map(function, sequence[, sequence, ...]) -> list ---->Python2
Return a list of the results of applying the function to the items of the argument sequence(s). If more than one sequence is given, the function is called with an argument list consisting of the corresponding item of each sequence, substituting None for missing values when not all sequences have the same length. If the function is None, return a list of the items of the sequence (or a list of tuples if more than one sequence).
Example:
>>> map(None, [1, 3, 5], [2, 4, 6]) # return [(1, 2), (3, 4), (5, 6)] >>> map(None, 'ace123', 'bdf') # return [('a', 'b'), ('c', 'd'), ('e', 'f'), ('1', None), ('2', None), ('3', None)]
filter(function or None, iterable) --> filter object
Return an iterator yielding those items of iterable for which function(item) is true. If function is None, return the items that are true.
Note that filter(function, iterable) is equivalent to the generator expression (item for item in iterable if function(item)) if function is not None and (item for item in iterable if item) if function is None.
See itertools.filterfalse() for the complementary function that returns elements of iterable for which function returns false.
Example:
>>> L = [1, 2, 3, 4, 5, 6, 7] >>> list(filter(lambda x: x>4, L)) # return [5, ,6 ,7]
以上函数实现方法：
__getattribute__ __iter__ __new__ __next__ __reduce__