Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > Sorted Returns List and Reversed Returns Iterator

Reply
Thread Tools

Sorted Returns List and Reversed Returns Iterator

 
 
++imanshu
Guest
Posts: n/a
 
      08-22-2008
Hi,

Is there a reason why two similarly named functions Sorted and
Reversed return different types of data or is it an accident.

Thanks,
++imanshu
 
Reply With Quote
 
 
 
 
John Machin
Guest
Posts: n/a
 
      08-22-2008
On Aug 22, 12:12*pm, "++imanshu" <(E-Mail Removed)> wrote:
> Hi,
>
> * * *Is there a reason why two similarly named functions Sorted and
> Reversed return different types of data or is it an accident.


You seem to have an interesting notion of "similarly named".
name0[-2:] == name1[-2:], perhaps? The two functions (eventually, in
the case of "reversed") return data in the order one would expect from
their names.

>>> x = [1, 3, 5, 2, 4, 6]
>>> sorted(x)

[1, 2, 3, 4, 5, 6]
>>> reversed(x)

<listreverseiterator object at 0x00AA5550>
>>> list(reversed(x))

[6, 4, 2, 5, 3, 1]
>>>




 
Reply With Quote
 
 
 
 
John Machin
Guest
Posts: n/a
 
      08-22-2008
On Aug 22, 1:35*pm, John Machin <(E-Mail Removed)> wrote:
> On Aug 22, 12:12*pm, "++imanshu" <(E-Mail Removed)> wrote:
>
> > Hi,

>
> > * * *Is there a reason why two similarly named functions Sorted and
> > Reversed return different types of data or is it an accident.

>
> You seem to have an interesting notion of "similarly named".
> name0[-2:] == name1[-2:], perhaps? The two functions (eventually, in
> the case of "reversed") return data in the order one would expect from
> their names.
>
> >>> x = [1, 3, 5, 2, 4, 6]
> >>> sorted(x)

> [1, 2, 3, 4, 5, 6]
> >>> reversed(x)

>
> <listreverseiterator object at 0x00AA5550>
>
>
>
> >>> list(reversed(x))

> [6, 4, 2, 5, 3, 1]-


Sorry; having re-read the message subject:

reversed came later; returning an iterator rather than a list provides
more flexibility.

Cheers,
John
 
Reply With Quote
 
++imanshu
Guest
Posts: n/a
 
      08-22-2008
On Aug 22, 8:40*am, John Machin <(E-Mail Removed)> wrote:
> On Aug 22, 1:35*pm, John Machin <(E-Mail Removed)> wrote:
>
>
>
> > On Aug 22, 12:12*pm, "++imanshu" <(E-Mail Removed)> wrote:

>
> > > Hi,

>
> > > * * *Is there a reason why two similarly named functions Sorted and
> > > Reversed return different types of data or is it an accident.

>
> > You seem to have an interesting notion of "similarly named".
> > name0[-2:] == name1[-2:], perhaps? The two functions (eventually, in
> > the case of "reversed") return data in the order one would expect from
> > their names.

>
> > >>> x = [1, 3, 5, 2, 4, 6]
> > >>> sorted(x)

> > [1, 2, 3, 4, 5, 6]
> > >>> reversed(x)

>
> > <listreverseiterator object at 0x00AA5550>

>
> > >>> list(reversed(x))

> > [6, 4, 2, 5, 3, 1]-

>
> Sorry; having re-read the message subject:
>
> reversed came later; returning an iterator rather than a list provides
> more flexibility.
>
> Cheers,
> John


I agree. Iterator is more flexible. Together and both might have
returned the same types.

Thanks,
++imanshu
 
Reply With Quote
 
Peter Otten
Guest
Posts: n/a
 
      08-22-2008
++imanshu wrote:

> On Aug 22, 8:40*am, John Machin <(E-Mail Removed)> wrote:
>> On Aug 22, 1:35*pm, John Machin <(E-Mail Removed)> wrote:
>>
>>
>>
>> > On Aug 22, 12:12*pm, "++imanshu" <(E-Mail Removed)> wrote:

>>
>> > > Hi,

>>
>> > > Is there a reason why two similarly named functions Sorted and
>> > > Reversed return different types of data or is it an accident.

>>
>> > You seem to have an interesting notion of "similarly named".
>> > name0[-2:] == name1[-2:], perhaps? The two functions (eventually, in
>> > the case of "reversed") return data in the order one would expect from
>> > their names.

>>
>> > >>> x = [1, 3, 5, 2, 4, 6]
>> > >>> sorted(x)
>> > [1, 2, 3, 4, 5, 6]
>> > >>> reversed(x)

>>
>> > <listreverseiterator object at 0x00AA5550>

>>
>> > >>> list(reversed(x))
>> > [6, 4, 2, 5, 3, 1]-

>>
>> Sorry; having re-read the message subject:
>>
>> reversed came later; returning an iterator rather than a list provides
>> more flexibility.
>>
>> Cheers,
>> John

>
> I agree. Iterator is more flexible. Together and both might have
> returned the same types.


It's easy to generate a reversed sequence on the fly but impractical for a
sorted one. Python is taking the pragmatic approach here.

Peter
 
Reply With Quote
 
Fredrik Lundh
Guest
Posts: n/a
 
      08-22-2008
John Machin wrote:

> reversed came later; returning an iterator rather than a list provides
> more flexibility.


As in flexibility for the implementer, the day someone invents a sort
algorithm that doesn't have to look at all source items before it starts
producing output?

Because I fail to see how returning an object that supports forward
iteration only is more flexible for the *user* than returning an object
that supports random access, mutation, restartable iteration, *and*
forward iteration.

</F>

 
Reply With Quote
 
Terry Reedy
Guest
Posts: n/a
 
      08-22-2008


Peter Otten wrote:
> ++imanshu wrote:


>> I agree. Iterator is more flexible.


I disagree. Neither is more flexible. You can iter the list returned
by sorted and list the iter returned by reversed. Both do the minimum
work necessary. See below.

> Together and both might have returned the same types.


True, but only by doing potentially unnecessary work and requiring the
caller to do potentially unnecessary work that might even prevent the
program from working. This is less flexible.

Suppose sorted now returns alist with 50 million items. Suppose it
instead returned iter(alist) but the caller wants to randomly index the
items. Since the caller could not access the existing 50 million item
list, the caller would have to make another 50 million item copy. This
is non-trivial and might not even work do to memory limitations.

> It's easy to generate a reversed sequence on the fly but impractical for a
> sorted one. Python is taking the pragmatic approach here.


To expand on this: sorting and reversing are algorithmically different
operations. Sorting requires that one have all items in hand in a
mutable sequence (list) for arbitrary re-ordering. Sorted works on any
iterable and starts by making a new list. There is no point to not
returning that list after it is sorted. It would be more work and less
useful to do more.

sorted(iterable, key=None, reverse=False):
newlist = list(iterable)
newlist.sort(key, reverse)
return newlist

Iterating over a concrete sequence in reverse order, on the other hand,
is trivial. It would be more work and less useful to do more.

def _reversed(seq): # 'hidden' generator function
n = len(seq)
while n:
n -= 1
yield seq[n]

def reversed(seq):
if hasattr(seq, '__reversed__'):
return seq.__reversed__() # I presume this is tried first
else:
return _reversed(seq) # generic fall-back

Terry Jan Reedy

 
Reply With Quote
 
++imanshu
Guest
Posts: n/a
 
      08-23-2008
On Aug 22, 12:36*pm, Terry Reedy <(E-Mail Removed)> wrote:
> Peter Otten wrote:
> > ++imanshu wrote:
> >> I agree. Iterator is more flexible.

>
> I disagree. *Neither is more flexible. *You can iter the list returned
> by sorted and list the iter returned by reversed. *Both do the minimum
> work necessary. *See below.
>
> *> Together and both might have returned the same types.
>
> True, but only by doing potentially unnecessary work and requiring the
> caller to do potentially unnecessary work that might even prevent the
> program from working. *This is less flexible.
>
> Suppose sorted now returns alist with 50 million items. *Suppose it
> instead returned iter(alist) but the caller wants to randomly index the
> items. *Since the caller could not access the existing 50 million item
> list, the caller would have to make another 50 million item copy. *This
> is non-trivial and might not even work do to memory limitations.
>
> > It's easy to generate a reversed sequence on the fly but impractical for a
> > sorted one. Python is taking the pragmatic approach here.

>
> To expand on this: sorting and reversing are algorithmically different
> operations. * Sorting requires that one have all items in hand in a
> mutable sequence (list) for arbitrary re-ordering. *Sorted works on any
> iterable and starts by making a new list. *There is no point to not
> returning that list after it is sorted. *It would be more work and less
> useful to do more.
>
> sorted(iterable, key=None, reverse=False):
> * *newlist = list(iterable)
> * *newlist.sort(key, reverse)
> * *return newlist
>
> Iterating over a concrete sequence in reverse order, on the other hand,
> is trivial. *It would be more work and less useful to do more.
>
> def _reversed(seq): # 'hidden' generator function
> * *n = len(seq)
> * *while n:
> * * *n -= 1
> * * *yield seq[n]
>
> def reversed(seq):
> * *if hasattr(seq, '__reversed__'):
> * * *return seq.__reversed__() # I presume this is tried first
> * *else:
> * * *return _reversed(seq) # generic fall-back
>
> Terry Jan Reedy


Thanks for giving the 'behind the scenes' reasons. It looks
reasonable now.

Thank You,
++imanshu
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
List iterator assignment fails, assert iterator not dereferencable David Bilsby C++ 5 10-09-2007 02:05 PM
Sorted and reversed on huge dict ? vd12005@yahoo.fr Python 13 11-06-2006 03:33 PM
Convert (sorted) list of dics to nested list ? shearichard@gmail.com Python 2 03-22-2006 09:34 PM
How to convert from std::list<T*>::iterator to std::list<const T*>::iterator? PengYu.UT@gmail.com C++ 6 10-30-2005 03:31 AM
Sorted iterator for an unsorted list Gyruss Java 1 04-11-2005 02:25 PM



Advertisments