def map(func, *collections):
"""map(function, sequence[, sequence, ...]) -> list
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)."""
if not collections:
raise TypeError("map() requires at least two arguments")
num_collections = len(collections)
none_func = func is None
if num_collections == 1:
if none_func:
return list(collections[0])
# Special case for the really common case of a single collection,
# this can be eliminated if we could unroll that loop that creates
# `args` based on whether or not len(collections) was constant
seq = collections[0]
with _ManagedNewlistHint(operator._length_hint(seq, 0)) as result:
for item in seq:
result.append(func(item))
return result
# Gather the iterators (pair of (iter, has_finished)) and guess the
# result length (the max of the input lengths)
iterators = []
max_hint = 0
for seq in collections:
iterators.append((iter(seq), False))
max_hint = max(max_hint, operator._length_hint(seq, 0))
with _ManagedNewlistHint(max_hint) as result:
while True:
cont = False
args = []
for idx, (iterator, has_finished) in enumerate(iterators):
val = None
if not has_finished:
try:
val = next(iterator)
except StopIteration:
iterators[idx] = (None, True)
else:
cont = True
args.append(val)
args = tuple(args)
if cont:
if none_func:
result.append(args)
else:
result.append(func(*args))
else:
return result
def zip(*sequences):
"""zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]
Return a list of tuples, where each tuple contains the i-th element
from each of the argument sequences. The returned list is truncated
in length to the length of the shortest argument sequence."""
l = len(sequences)
if l == 2:
# A very fast path if the two sequences are lists
seq0 = sequences[0]
seq1 = sequences[1]
try:
return specialized_zip_2_lists(seq0, seq1)
except TypeError:
pass
# This is functionally the same as the code below, but more
# efficient because it unrolls the loops over 'sequences'.
# Only for two arguments, which is the most common case.
iter0 = iter(seq0)
iter1 = iter(seq1)
hint = min(
100000000, # max 100M
operator._length_hint(seq0, 0),
operator._length_hint(seq1, 0))
with _ManagedNewlistHint(hint) as result:
while True:
try:
item0 = next(iter0)
item1 = next(iter1)
except StopIteration:
return result
result.append((item0, item1))
if l == 0:
return []
# Gather the iterators and guess the result length (the min of the
# input lengths). If any of the iterators doesn't know its length,
# we use 0 (instead of ignoring it and using the other iterators;
# see lib-python's test_builtin.test_zip).
iterators = []
hint = 100000000 # max 100M
for seq in sequences:
iterators.append(iter(seq))
hint = min(hint, operator._length_hint(seq, 0))
with _ManagedNewlistHint(hint) as result:
while True:
try:
items = [next(it) for it in iterators]
except StopIteration:
return result
result.append(tuple(items))
def zip(*sequences):
"""zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]
Return a list of tuples, where each tuple contains the i-th element
from each of the argument sequences. The returned list is truncated
in length to the length of the shortest argument sequence."""
l = len(sequences)
if l == 2:
# A very fast path if the two sequences are lists
seq0 = sequences[0]
seq1 = sequences[1]
try:
return specialized_zip_2_lists(seq0, seq1)
except TypeError:
pass
# This is functionally the same as the code below, but more
# efficient because it unrolls the loops over 'sequences'.
# Only for two arguments, which is the most common case.
iter0 = iter(seq0)
iter1 = iter(seq1)
hint = min(100000000, # max 100M
operator._length_hint(seq0, 0),
operator._length_hint(seq1, 0))
with _ManagedNewlistHint(hint) as result:
while True:
try:
item0 = next(iter0)
item1 = next(iter1)
except StopIteration:
return result
result.append((item0, item1))
if l == 0:
return []
# Gather the iterators and guess the result length (the min of the
# input lengths). If any of the iterators doesn't know its length,
# we use 0 (instead of ignoring it and using the other iterators;
# see lib-python's test_builtin.test_zip).
iterators = []
hint = 100000000 # max 100M
for seq in sequences:
iterators.append(iter(seq))
hint = min(hint, operator._length_hint(seq, 0))
with _ManagedNewlistHint(hint) as result:
while True:
try:
items = [next(it) for it in iterators]
except StopIteration:
return result
result.append(tuple(items))
def test_repeat_len(self):
import itertools
import operator
r = itertools.repeat('a', 15)
next(r)
raises(TypeError, "len(itertools.repeat('xkcd'))")
r = itertools.repeat('a', -3)
assert operator._length_hint(r, 3) == 0
def test_repeat_len(self):
import itertools
import operator
r = itertools.repeat('a', 15)
r.next()
raises(TypeError, "len(itertools.repeat('xkcd'))")
r = itertools.repeat('a', -3)
assert operator._length_hint(r, 3) == 0
def map(func, *collections):
"""map(function, sequence[, sequence, ...]) -> list
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)."""
if not collections:
raise TypeError("map() requires at least two arguments")
num_collections = len(collections)
none_func = func is None
if num_collections == 1:
if none_func:
return list(collections[0])
# Special case for the really common case of a single collection
seq = collections[0]
with _ManagedNewlistHint(operator._length_hint(seq, 0)) as result:
for item in seq:
result.append(func(item))
return result
# Gather the iterators into _Cons objects and guess the
# result length (the max of the input lengths)
c = None
max_hint = 0
for seq in collections:
c = _Cons(c, iter(seq))
max_hint = max(max_hint, operator._length_hint(seq, 0))
with _ManagedNewlistHint(max_hint) as result:
while True:
args, stop = c.fetch()
if stop:
return result
if none_func:
result.append(args)
else:
result.append(func(*args))
def map(func, *collections):
"""map(function, sequence[, sequence, ...]) -> list
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)."""
if not collections:
raise TypeError("map() requires at least two arguments")
num_collections = len(collections)
none_func = func is None
if num_collections == 1:
if none_func:
return list(collections[0])
# Special case for the really common case of a single collection
seq = collections[0]
with _ManagedNewlistHint(operator._length_hint(seq, 0)) as result:
for item in seq:
result.append(func(item))
return result
# Gather the iterators into _Cons objects and guess the
# result length (the max of the input lengths)
c = None
max_hint = 0
for seq in collections:
c = _Cons(c, iter(seq))
max_hint = max(max_hint, operator._length_hint(seq, 0))
with _ManagedNewlistHint(max_hint) as result:
while True:
args, stop = c.fetch()
if stop:
return result
if none_func:
result.append(args)
else:
result.append(func(*args))
def filter(func, seq):
"""filter(function or None, sequence) -> list, tuple, or string
Return those items of sequence for which function(item) is true. If
function is None, return the items that are true. If sequence is a tuple
or string, return the same type, else return a list."""
if func is None:
func = bool
if isinstance(seq, str):
return _filter_string(func, seq, str)
elif isinstance(seq, unicode):
return _filter_string(func, seq, unicode)
elif isinstance(seq, tuple):
return _filter_tuple(func, seq)
with _ManagedNewlistHint(operator._length_hint(seq, 0)) as result:
for item in seq:
if func(item):
result.append(item)
return result
def length_hint(obj, default=0):
"""Returns a yp_int instead of int, and ensures obj is from nohtyP"""
assert isinstance(obj, ypObject)
return yp_int(_length_hint(obj, default))
