On Sat, Nov 10, 2018 at 10:58:02PM -0700, Nicholas Harrison wrote:
[...]
> (start:stop:step)
>
>
> Meet a range/slice object. Parentheses are required. (Its syntax in this
> regard follows exactly the same rules as a generator expression.) I say
> both range and slice because it can be used in either role.
Ranges and slices are conceptually different things. Even if they have
similar features, they are very different:
- range is a lazy sequence, which produces its values on demand;
- it supports (all? most?) of the Sequence ABC, including
membership testing and len();
- but its values are intentionally limited to integers;
- slice objects, on the other hand, are an abstraction referring
to a context-sensitive sequence of abstract indices;
- those indices can be anything you like:
py> s = slice("Surprise!", range(1, 100, 3), slice(None))
py> s.start
'Surprise!'
py> s.stop
range(1, 100, 3)
py> s.step
slice(None, None, None)
- they don't support membership testing, len() or other Sequence
operations;
- most importantly, because they are context-sensitive, we don't
even know how many indexes are included in a slice until we know
what we're slicing.
That last item is why slice objects have an indices() method that takes
a mandatory length parameter.
If slices were limited to single integer indices, then there would be an
argument that they are redundant and we could use range objects in their
place; but they aren't.
[...]
> Why is it useful? I at least find its syntax to be simple, intuitive, and
> concise -- more so than the range(...) or slice(...) alternatives.
Concise, I will grant, but *intuitive*?
I have never forgot the first time I saw Python code, and after being
told over and over again how "intuitive" it was I was utterly confused
by these mysterious list[:] and list[1:] and similar expressions. I had
no idea what they were or what they were supposed to do. I didn't even
have a name I could put to them.
At least range(x) was something I could *name* and ask sensible
questions about. I didn't even have a name for this strange
square-bracket and colon syntax, and no context for understanding what
it did. There's surely few things in Python more cryptic than
mylist = mylist[:]
until you've learned what slicing does and how it operates.
Your proposal has the same disadvantages: it is cryptic punctuation that
is meaningless until the reader has learned what it means, without even
an obvious name they can refer to.
Don't get me wrong: slice syntax is great, *once you have learned it*.
But it is a million miles from intuitive. If this proposal is a winner,
it won't be because it will make Python easier for beginners.
[...]
> sum(1:6) # instead of sum(range(1, 6))
That looks like you tried to take a slice of a sequence called "sum" but
messed up the brackets, using round instead of square.
> list(1:6)
Same.
> for i in (1:6):
Looks like a tuple done wrong.
I think this is not an improvement, unless you're trying to minimize the
number of characters in an expression.
> It also makes forming reusable slices clearer and easier:
>
> my_slice = (:6:2) # instead of slice(None, 6, 2)
"Easier" in the sense of "fewer characters to type", but "clearer"? I
don't think so.
[...]
> So here's the part that requires a little more thought.
Are you saying that so far you haven't put any thought into this
proposal?
*wink*
(You don't have to answer this part, it was just my feeble attempt at
humour.)
--
Steve
_______________________________________________
Python-ideas mailing list
Python-ideas@python.org
https://mail.python.org/mailman/listinfo/python-ideas
Code of Conduct: http://python.org/psf/codeofconduct/
