negative stride list slices

[David Abrahams]

Can anyone explain the logic behind the behavior of list slicing with
negative strides? For example:

print range(10)[:-3:-1]

[9,8]

I found this result very surprising, and would just like to see the
rules written down somewhere.

Thanks,
--
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com

[Reid Nichol]

David Abrahams wrote:

Can anyone explain the logic behind the behavior of list slicing with
negative strides? For example:

>>> print range(10)[:-3:-1]

[9,8]

I found this result very surprising, and would just like to see the
rules written down somewhere.

Thanks,
--
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com

http://www.python.org/doc/current/tu...00000000000000

[Russell Blau]

"Reid Nichol" <rn*********@ya hoo.com> wrote in message
news:r7******** **********@news 1.mts.net...

David Abrahams wrote:

Can anyone explain the logic behind the behavior of list slicing with
negative strides? For example:

>>> print range(10)[:-3:-1]

[9,8]

I found this result very surprising, and would just like to see the
rules written down somewhere.

http://www.python.org/doc/current/tu...00000000000000

You probably meant to reference the next section (that bookmark relates to
strings, the next one is lists), but in either case none of the examples in
the tutorial has yet been updated to deal with slices that include a
"stride" as a third parameter.
--
I don't actually read my hotmail account, but you can replace hotmail with
excite if you really want to reach me.

[Peter Otten]

David Abrahams wrote:

Can anyone explain the logic behind the behavior of list slicing with
negative strides? For example:

>>> print range(10)[:-3:-1] [9,8]

I found this result very surprising, and would just like to see the
rules written down somewhere.

Well, here is my attempt to emulate the algorithm. The trick seems to be to
substitute the start/stop parameters with 0 or length-1 depending on the
sign of step.

# no warranties!
def indices(length, start, stop, step):
if step is None:
step = 1
if step < 0:
if start is None:
start = length-1
elif start < 0:
start += length

if stop is None:
stop = -1
elif stop < 0:
stop += length
else:
if start is None:
start = 0
elif start < 0:
start += length

if stop is None:
stop = length
elif stop < 0:
stop += length

if start > stop:
while start > stop:
yield start
start += step
else:
while start < stop:
yield start
start += step

assert list(indices(10 , None, -3, -1)) == range(10)[:-3:-1]
assert list(indices(10 , None, -3, -2)) == range(10)[:-3:-2]
assert list(indices(10 , 9, -3, -2)) == range(10)[9:-3:-2]
assert list(indices(10 , None, None, None)) == range(10)[::]
assert list(indices(10 , None, 5, 2)) == range(10)[:5:2]

I have to admit (late but better than never) that Raymond Hettinger's new
builtin reversed() has some merits:

list(reversed(r ange(10)[-2:])) == range(10)[:-3:-1]

True

Peter

[Reid Nichol]

Russell Blau wrote:

"Reid Nichol" <rn*********@ya hoo.com> wrote in message
news:r7******** **********@news 1.mts.net...

David Abrahams wrote:

Can anyone explain the logic behind the behavior of list slicing with
negative strides? For example:

>>> print range(10)[:-3:-1]
[9,8]

I found this result very surprising, and would just like to see the
rules written down somewhere.

http://www.python.org/doc/current/tu...00000000000000

You probably meant to reference the next section (that bookmark relates to
strings, the next one is lists), but in either case none of the examples in
the tutorial has yet been updated to deal with slices that include a
"stride" as a third parameter.

This was the part that I was refering to:

+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
Does it not all work the same in practice?

[Shalabh Chaturvedi]

Reid Nichol wrote:

This was the part that I was refering to:

+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
Does it not all work the same in practice?

I'd like to add:

+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
| |
start end (defaults for +ve step)
end start (defaults for -ve step)

(Is this correct?)

David Abrahams wrote: Can anyone explain the logic behind the behavior of list slicing with
negative strides? For example:

>>> print range(10)[:-3:-1]

[9,8]

I found this result very surprising

What were you expecting?

Thanks,
Shalabh

[Peter Hansen]

Reid Nichol wrote:

This was the part that I was refering to:

+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1

Does it not all work the same in practice?

Can you explain how the above diagram explains David's
example then:

s = 'HelpA'
s[:-3:-1]

'Ap'

I don't find much connection between the diagram and
where the -3 is actually slicing either.

-Peter

[Julio Oña]

Slice has three arguments, [begin:end:step]

when doing s[:-3:-1] you are asking the las to elements of the list in
reversed order.

regards.

On Wed, 01 Sep 2004 17:15:51 -0400, Peter Hansen <pe***@engcorp. com> wrote:

Reid Nichol wrote:

This was the part that I was refering to:

+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1

Does it not all work the same in practice?

Can you explain how the above diagram explains David's
example then:

s = 'HelpA'
s[:-3:-1]

'Ap'

I don't find much connection between the diagram and
where the -3 is actually slicing either.

-Peter
--
http://mail.python.org/mailman/listinfo/python-list

--
Julio

[Julio Oña]

http://www.python.org/doc/2.3.4/what...on-slices.html

There is more information on extended slicing

Regards.

On Wed, 1 Sep 2004 17:23:18 -0400, Julio Oña <th******@gmail .com> wrote:

Slice has three arguments, [begin:end:step]

when doing s[:-3:-1] you are asking the las to elements of the list in
reversed order.

regards.



On Wed, 01 Sep 2004 17:15:51 -0400, Peter Hansen <pe***@engcorp. com> wrote:

Reid Nichol wrote:

This was the part that I was refering to:

+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1

Does it not all work the same in practice?

Can you explain how the above diagram explains David's
example then:

>> s = 'HelpA'
>> s[:-3:-1]

'Ap'

I don't find much connection between the diagram and
where the -3 is actually slicing either.

-Peter
--
http://mail.python.org/mailman/listinfo/python-list

--
Julio

--
Julio

[Russell Blau]

"Shalabh Chaturvedi" <sh*****@cafepy .com> wrote in message
news:ma******** *************** *************** @python.org...

Reid Nichol wrote:

This was the part that I was refering to:

+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
Does it not all work the same in practice?

I'd like to add:

+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
| |
start end (defaults for +ve step)
end start (defaults for -ve step)

(Is this correct?)

The tutorial says, "The slice from i to j consists of all characters between
the edges labeled i and j, respectively." So [1:3] starts at the left edge
of the character with index 1, and ends at the left edge of the character
with index 3, returning "el". However, a slice from 3:1:-1 starts at the
*right* edge of the character with index 3, and ends at the *right* edge of
the character with index 1, returning "pl". So the above diagram is not
correct for negative steps (the "backwards" slice consists of characters
between the edges labeled j+1 and i+1, in reverse order).

Is this difference intended, or a bug? (One consequence of this difference
is that a slice of [5:0:-1] returns something different from a slice of [5:
:-1]!)

--
I don't actually read my hotmail account, but you can replace hotmail with
excite if you really want to reach me.