> I fixed a couple typos, but have a few (more subjective) comments:
Thanks for the rapid review.
>
> * islice() - The description seems a bit confusing to me - perhaps a
> simple example would be useful.
I'll clarify the docs and add simple examples for each function.
islice is one of the more powerful functions:
for line in islice(afile, 10, 20, 2):
print line # Starting with line 10, prints every other line
# upto but not including line 20.
nth = lambda iterable, n: islice(iterable,n,n+1).next() # get the nth item
> * takewhile()/dropwhile() - I assume these only return a prefix of their
> iterable arguments. Dropwhile()'s help suggests that, but
> takewhile()'s description is more vague about the notion.
I'll clarify the docs and add clear examples.
> * imap() - It's not clear to me why it differs from map() other than the
> fact that it's an iterator.
The other differences are that it stops with the shortest iterable
and doesn't accept None for a func argument.
> Can you motivate why it stops when the
> shortest iterable is exhausted and doesn't accept Non for its func
> arg?
Because one or more useful inputs are potentially infinite, filling in
Nones is less useful than stopping with the shortest iterator.
The function doesn't accept None for a function argument for
1) simplicity
2) we have zip() for that purpose
OTOH, if it is important to someone, I can easily re-embed that
functionality.
> * loopzip() - It's not clear why its next() method should return a list
> instead of a tuple (again, a seemingly needless distiction with its
> builtin counterpart, zip()).
I've wrestled with the one.
The short answer is that zip() already does a pretty good job
and that the only use for loopzip() is super high speed looping.
To that end, reusing a single list instead of allocating and building
tuples is *much* faster.
> * starmap() - How does it differ from imap() and map()?
for computing a operator.pow,
if your data looks like this: b=[2,3,5] p=[3,5,7],
then use imap(operator.pow, a, b)
OTOH, if your data looks like this: c =[(2,3), (3,5), (5,7)],
then use starmap(operator.pow, c)
Essentially, it's the difference between f(a,b) and f(*c).
> * times() - Why not declare times to take an optional argument to be
> returned?
The use case is for looping when you don't care about the value:
for i in itertools.times(3):
print "hello"
> (In general, it seems like count(), repeat() and times()
> overlap heavily. Examples of their usage might be helpful in
> understanding when to use them, or at least when they are commonly
> used in their Haskell/SML roots environments.)
Yes. I opted for using the atomic combinable building blocks
rather than constructing the more elaborate things like tabulate(f)
which can easily be made from the basic pieces: imap(f,count())
I'll add more examples so that the usage becomes more obvious.
Thanks again for the review.
Raymond
#################################################################
#################################################################
#################################################################
#####
#####
#####
#################################################################
#################################################################
#################################################################
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4