under the proposal we have:
s[i:j:k] == s[i:j][::k]
[Terry Reedy]
I think where we went wrong with strides was to have the sign of the stride affect the interpretation of i and j (in analogy with ranges).
I think that's right :-)
The change is to correct this by decoupling steps 1. and 2. below. The result is that i and j would mean left and right ends of the slice, rather than 'start' and 'stop' ends of the slice.
Right.
I presume s[::-k], k a count, would continue to mean 'reverse and take every kth' (ie, take every kth item from the right instead of the left):
That's not what the proposal said, but it's a reasonable alternative. Maybe that's better because it's "more compatible" with what happens today. The hangup for me is that I have no use cases for negative strides other than -1, so have no real basis for picking one over the other. OTOH, since I _don't_ have any use cases, I don't care either what happens then ;-)
s[i:j:-k] == s[i:j:-1][::k]
That's a nice form of symmetry too. Sold ;-)
(And one would continue to write the alternative, 'take every kth and reverse' explicitly as s[i:j:k][::-1].)
Whether selecting or replacing, this proposal makes the rule for indicating an arithmetic subsequence to be:
1. indicate the contiguous slice to work on with left and right endpoints (left end i, right end j, i <= j after normalization with same rules as at present);
2. indicate the starting end and direction of movement, left to right (default) or right to left (negate k);
3. indicate whether to pick every member of the slice (k=1, default) or every kth (k > 1), starting with the first item at the indicated end (if there is one) and moving in the appropriate direction.
Yup!
--- My quick take on slicing versus indexing. The slice positions of a single item are i:(i+1). The average is i.5. Some languages (0-based, like Python) round this down to i, others (1-based) round up to i+1.
I think they all round down. For example, Icon uses 1-based indexing, and supports slicing. "abc"[1] is "a" in Icon, and so is "abc"[1:2]. 0 isn't a valid index in Icon, can be used in slicing, where it means "the position just after the last element".
String 'indexing' is really unit slicing: s[i] == s[i:i+1]. Any sequence can sliced. True indexing requires that the members of the sequence either be Python objects (tuples, lists) or usefully convert to such (bytes, other arrays, which convert integer members to Python ints).