slice notation as values?

[Antoon Pardon]

Now slices are objects in python, I was wondering if slice
notation will be usable outside subscribtion in the future.

Will it ever be possible to write things like:

a = 4:9
for key, value in tree.items('alf a.': 'beta.'):

--
Antoon Pardon

[Antoon Pardon]

Op 2005-12-11, Bengt Richter schreef <bo**@oz.net> :

On 10 Dec 2005 12:07:12 -0800, "Devan L" <de****@gmail.c om> wrote:

Antoon Pardon wrote:

On 2005-12-10, Duncan Booth <du**********@i nvalid.invalid> wrote:

[snip]

>> I also think that other functions could benefit. For instance suppose
>> you want to iterate over every second element in a list. Sure you
>> can use an extended slice or use some kind of while. But why not
>> extend enumerate to include an optional slice parameter, so you could
>> do it as follows:
>>
>> for el in enumerate(lst,: :2)
>
> 'Why not'? Because it makes for a more complicated interface for something
> you can already do quite easily.

Do you think so? This IMO should provide (0,lst[0]), (2,lst[2]),
(4,lst[4]) ...

I haven't found a way to do this easily. Except for something like:

start = 0:
while start < len(lst):
yield start, lst[start]
start += 2

But if you accept this, then there was no need for enumerate in the
first place. So eager to learn something new, how do you do this
quite easily?

> lst = ['ham','eggs','b acon','spam','f oo','bar','baz']
> list(enumerate( lst))[::2]

[(0, 'ham'), (2, 'bacon'), (4, 'foo'), (6, 'baz')]

No changes to the language necessary.

Or, without creating the full list intermediately,

lst = ['ham','eggs','b acon','spam','f oo','bar','baz']
import itertools
list(itertools. islice(enumerat e(lst), 0, None, 2))

[(0, 'ham'), (2, 'bacon'), (4, 'foo'), (6, 'baz')]

As far as I understand use of this idiom can turn an O(n)
algorithm into an O(n^2) algorithm.

Suppose I have a list with 10 000 elements and I want
the sum of the first 100, the sum of the second 100 ...

One way to do that would be:

for i in xrange(0,10000, 100):
sum(itertools.i slice(lst, i, i+100))

But itertools.islic e would each time start from the begining
of the list and iterate over i elements before giving 100
elements to sum. Which would make this implementation O(n^2)
instead of O(n).

--
Antoon Pardon

[bonono]

Antoon Pardon wrote:

Suppose I have a list with 10 000 elements and I want
the sum of the first 100, the sum of the second 100 ...

One way to do that would be:

for i in xrange(0,10000, 100):
sum(itertools.i slice(lst, i, i+100))

But itertools.islic e would each time start from the begining
of the list and iterate over i elements before giving 100
elements to sum. Which would make this implementation O(n^2)
instead of O(n).

Can you use iter for this situation ?

a=iter(lst)
for i in xrange(0,10000, 100):
sum(itertools.i slice(a,100))

[Bengt Richter]

On 12 Dec 2005 08:34:37 GMT, Antoon Pardon <ap*****@forel. vub.ac.be> wrote:

Op 2005-12-10, Devan L schreef <de****@gmail.c om>:

Antoon Pardon wrote:

On 2005-12-10, Duncan Booth <du**********@i nvalid.invalid> wrote:

[snip]

>> I also think that other functions could benefit. For instance suppose
>> you want to iterate over every second element in a list. Sure you
>> can use an extended slice or use some kind of while. But why not
>> extend enumerate to include an optional slice parameter, so you could
>> do it as follows:
>>
>> for el in enumerate(lst,: :2)
If you are willing to use square brackets, you can spell it
for el in enoomerate[lst, ::2]: print el,
(see below ;-)
>
> 'Why not'? Because it makes for a more complicated interface for something
> you can already do quite easily.

Do you think so? This IMO should provide (0,lst[0]), (2,lst[2]),
(4,lst[4]) ...

I haven't found a way to do this easily. Except for something like:

start = 0:
while start < len(lst):
yield start, lst[start]
start += 2

But if you accept this, then there was no need for enumerate in the
first place. So eager to learn something new, how do you do this
quite easily?

> lst = ['ham','eggs','b acon','spam','f oo','bar','baz']
> list(enumerate( lst))[::2]

[(0, 'ham'), (2, 'bacon'), (4, 'foo'), (6, 'baz')]

It is not about what is needed, but about convenience.

Now let me see, in order to just iterate over the even elements
of a list with the index of the element, you turned an iterator
into a list, which you use to create an other list which you
will finaly iterate over.

If this is the proposed answer, I wonder why iterators were introduced
in the first place. I thought iterator were went to avoid the need
to construct and copy list when all you want is iterate and when
I ask how to get a specific iterator you come with a construct that
makes rather heavily use of list constructions.

Just for you ;-)

import itertools
class enoomerate(obje ct): ... def __getitem__(sel f, seq):
... if isinstance(seq, tuple):
... seq, slc = seq
... else:
... slc = slice(None)
... if not isinstance(slc, slice): slc = slice(None, slc)
... return itertools.islic e(enumerate(seq ), slc.start or 0, slc.stop, slc.step or 1)
... enoomerate = enoomerate()

import string
lst = list(string.asc ii_lowercase) # legit list, though could use the string
for el in enoomerate[lst, ::2]: print el, ...
(0, 'a') (2, 'c') (4, 'e') (6, 'g') (8, 'i') (10, 'k') (12, 'm') (14, 'o') (16, 'q') (18, 's') (
20, 'u') (22, 'w') (24, 'y') for el in enoomerate[lst, 3::3]: print el, ...
(3, 'd') (6, 'g') (9, 'j') (12, 'm') (15, 'p') (18, 's') (21, 'v') (24, 'y') for el in enoomerate[lst, 3]: print el, ...
(0, 'a') (1, 'b') (2, 'c') for el in enoomerate[lst, 3:6]: print el, ...
(3, 'd') (4, 'e') (5, 'f') for el in enoomerate[lst, 3:6:2]: print el,

...
(3, 'd') (5, 'f')

Regards,
Bengt Richter

[Antoon Pardon]

Op 2005-12-12, Bengt Richter schreef <bo**@oz.net> :

On 12 Dec 2005 08:34:37 GMT, Antoon Pardon <ap*****@forel. vub.ac.be> wrote:

Op 2005-12-10, Devan L schreef <de****@gmail.c om>:

Antoon Pardon wrote:
On 2005-12-10, Duncan Booth <du**********@i nvalid.invalid> wrote:
[snip]
>> I also think that other functions could benefit. For instance suppose
>> you want to iterate over every second element in a list. Sure you
>> can use an extended slice or use some kind of while. But why not
>> extend enumerate to include an optional slice parameter, so you could
>> do it as follows:
>>
>> for el in enumerate(lst,: :2)
If you are willing to use square brackets, you can spell it
Hmm, I have to think about that.

for el in enoomerate[lst, ::2]: print el,
(see below ;-)

[ ... ]

Just for you ;-)

Thank you.

import itertools
class enoomerate(obje ct): ... def __getitem__(sel f, seq):
... if isinstance(seq, tuple):
... seq, slc = seq
... else:
... slc = slice(None)
... if not isinstance(slc, slice): slc = slice(None, slc)
... return itertools.islic e(enumerate(seq ), slc.start or 0, slc.stop, slc.step or 1)
... enoomerate = enoomerate()

import string
lst = list(string.asc ii_lowercase) # legit list, though could use the string
for el in enoomerate[lst, ::2]: print el,

I am wondering a bit. Could this be turned into a decorator?

I don't have much experience with decorators, so I'll have to
think this through for a wgile. The idea would be a class
to be used as decorator that would turn a function returning
an iterator in a slicable iterator. Something like the following
maybe:

class SliceIterator(o bject):

def __init__(self,f unc):
self.func = func

def __getitem__(sel f, args):
if isinstance(args , tuple)
return self.func(*args )
else:
return self.func(args)

def __iter__(self):
return self.func(slice (None, None, None))

I could then write something like:

@SliceIterator
def srange(sl):
v = sl.stop
while v < sl.start:
yield v
v += sl.step
And use it as:

for i in srange[23:67:3]:
...

Hmm, I have to play with this a bit. Thanks for the idea.

--
Antoon Pardon