Velocity Reviews (http://www.velocityreviews.com/forums/index.php)
-   Python (http://www.velocityreviews.com/forums/f43-python.html)
-   -   Arithmetic sequences in Python (http://www.velocityreviews.com/forums/t353447-arithmetic-sequences-in-python.html)

 Gregory Petrosyan 01-16-2006 09:01 AM

Arithmetic sequences in Python

As you can see, PEP 204 was rejected, mostly because of not-so-obvious
syntax. But IMO the idea behind this pep is very nice. So, maybe
like

[1,3..10] --> [1,3,5,7,9]
(1,3..10) --> same values as above, but return generator instead of
list
[1..10] --> [1,2,3,4,5,6,7,8,9,10]
(1 ..) --> 'infinite' generator that yield 1,2,3 and so on
(-3,-5 ..) --> 'infinite' generator that yield -3,-5,-7 and so on

So,
1) "[]" means list, "()" means generator
2) the "start" is required, "step" and "end" are optional.

Also, this can be nicely integrated with enumerations (if they will
appear in python). Haskell is also example of such integration.

 Bas 01-16-2006 09:17 AM

Re: Arithmetic sequences in Python

I like the use of the colon as in the PEP better: it is consistant with
the slice notation and also with the colon operator in Matlab.

I like the general idea and I would probably use it a lot if available,
but the functionality is already there with range and irange.

Bas

 Paul Rubin 01-16-2006 09:26 AM

Re: Arithmetic sequences in Python

"Gregory Petrosyan" <gregory.petrosyan@gmail.com> writes:
> As you can see, PEP 204 was rejected, mostly because of not-so-obvious
> syntax. But IMO the idea behind this pep is very nice. So, maybe

I like this with some issues: Python loops tend to be 0-based, so
while it's convenient to express the sequence [1..n], what you usually
want is [0..(n-1)] which is uglier.

If you want to count down from f(n) to zero, in Haskell you might say

[b, b-1 .. 0] where b=f(n)

There's no "where" in Python, so what do you do?

[f(n)-1, f(n)-2 .. 0]

evaluates f twice (and might not even get the same result both times),

xrange(f(n)-1, -1, -1)

only evaluates it once but is IMO repulsive.

Anyway I've never liked having to use range or xrange to control
Python loops. It's just kludgy and confusing. So I think your idea
has potential but there's issues that have to be worked out.

 Gregory Petrosyan 01-16-2006 09:28 AM

Re: Arithmetic sequences in Python

_Consistentsy_ is what BDFL rejects, if I understand pep right. As for
me, it's not too god to have similar syntax for really different tasks.
And [1:10] is really not obvious, while [1..10] is.

 Steven D'Aprano 01-16-2006 10:52 AM

Re: Arithmetic sequences in Python

On Mon, 16 Jan 2006 01:01:39 -0800, Gregory Petrosyan wrote:

>
> As you can see, PEP 204 was rejected, mostly because of not-so-obvious
> syntax. But IMO the idea behind this pep is very nice. So, maybe
> like
>
> [1,3..10] --> [1,3,5,7,9]

-1 on the introduction of new syntax. Any new syntax.

(I reserve the right to change my mind if somebody comes up with syntax
that I like, but in general, I'm *very* negative on adding to Python's
clean syntax.)

solutions like range and xrange. The only added feature this proposal
introduces is infinite iterators, and they aren't particularly hard to
make:

def arithmetic_sequence(start, step=1):
yield start
while 1:
start += step
yield start

The equivalent generator for a geometric sequence is left as an exercise

If your proposal included support for ranges of characters, I'd be more
interested.

--
Steven.

 Paul Rubin 01-16-2006 10:58 AM

Re: Arithmetic sequences in Python

Steven D'Aprano <steve@REMOVETHIScyber.com.au> writes:
> solutions like range and xrange.

Oh come on, [5,4,..0] is much easier to read than range(5,-1,-1).

> The only added feature this proposal
> introduces is infinite iterators, and they aren't particularly hard to
> make:
>
> def arithmetic_sequence(start, step=1):
> yield start
> while 1:
> start += step
> yield start

Well, that would be itertools.count(start, step) but in general a simple
expression is nicer than 5 lines of code.

> If your proposal included support for ranges of characters, I'd be more
> interested.

There's something to be said for that. Should ['a'..'z'] be a list or
a string?

 Xavier Morel 01-16-2006 11:51 AM

Re: Arithmetic sequences in Python

Paul Rubin wrote:
> There's something to be said for that. Should ['a'..'z'] be a list or
> a string?

To me, the most obvious result would be either a range object as a
result, or always a list/generator of objects (to stay perfectly
consistent). If a range of numbers translate into a list of numbers,
then a range of characters should likewise translate to a list of
characters, and a join would be required to get a regular string. This
also adds more consistency between the two proposals of the initial post
(e.g. list-based range and generator-based range), for while the
list-based range could be expanded into a string a generator-based one
couldn't/shouldn't, and the abstraction breaks (because two constructs
that should be more or less equivalent become extremely different and
can't be swapped transparently).

This would also be consistent with other languages providing a native
"range" object such as Ruby or or Ada ranges.

The only thing that bothers me about the initial proposal is that there
would not, in fact, be any "range object", but merely a syntactic sugar
for list/generator creation. Not that I really mind it, but, well,
syntactic sugar for the purpose of syntactic sugar really doesn't bring
much to the table.

For those who'd need the (0..n-1) behavior, Ruby features something that
I find quite elegant (if not perfectly obvious at first), (first..last)
provides a range from first to last with both boundaries included, but
(first...last) (notice the 3 periods) excludes the end object of the
range definition ('a'..'z') is the range from 'a' to 'z' while
('a'...'z') only ranges from 'a' to 'y').

 bearophileHUGS@lycos.com 01-16-2006 03:24 PM

Re: Arithmetic sequences in Python

Ranges of letters are quite useful, they are used a lot in Delphi/Ada
languages:
"a", "b", "c", "d", "e"...

I like the syntax [1..n], it looks natural enough to me, but I think
the Ruby syntax with ... isn't much natural.
To avoid bugs the following two lines must have the same meaning:
[1..n-1]
[1..(n-1)]

If you don't want to change the Python syntax then maybe the
range/xrange can be extended for chars too:

xrange("a", "z")
range("z", "a", -1)

But for char ranges I think people usually don't want to stop to "y"
(what if you want to go to "z" too? This is much more common than
wanting to stop to "y"), so another possibility is to create a new
function like xrange that generates the last element too:

interval("a", "c") equals to iter("abc")
interval(1, 3) equals to iter([1,2,3])
interval(2, 0, -1) equals to iter([2,1,0])

I have created such interval function, and I use it now and then.

Bye,
bearophile

 Steven D'Aprano 01-16-2006 04:14 PM

Re: Arithmetic sequences in Python

On Mon, 16 Jan 2006 12:51:58 +0100, Xavier Morel wrote:

> For those who'd need the (0..n-1) behavior, Ruby features something that
> I find quite elegant (if not perfectly obvious at first), (first..last)
> provides a range from first to last with both boundaries included, but
> (first...last) (notice the 3 periods)

No, no I didn't.

Sheesh, that just *screams* "Off By One Errors!!!". Python deliberately
uses a simple, consistent system of indexing from the start to one past
the end specifically to help prevent signpost errors, and now some folks
want to undermine that.

--
Steven.

 Alex Martelli 01-16-2006 04:30 PM

Re: Arithmetic sequences in Python

Paul Rubin <http://phr.cx@NOSPAM.invalid> wrote:
...
>
> xrange(f(n)-1, -1, -1)
>
> only evaluates it once but is IMO repulsive.

Yep, reversed(range(f(n))) is MUCH better.

Alex

All times are GMT. The time now is 11:04 PM.