Does anyone else use this little idiom?

[miller.paul.w]

Ruby has a neat little convenience when writing loops where you don't
care about the loop index: you just do n.times do { ... some
code ... } where n is an integer representing how many times you want
to execute "some code."

In Python, the direct translation of this is a for loop. When the
index doesn't matter to me, I tend to write it as:

for _ in xrange (1,n):
some code

An alternative way of indicating that you don't care about the loop
index would be

for dummy in xrange (1,n):
some code

But I like using _ because it's only 1 character and communicates well
the idea "I don't care about this variable."

The only potential disadvantages I can see are threefold:

1. It might be a little jarring to people not used to it. I do admit
it looks pretty strange at first.

2. The variable _ has special meaning at the interactive interpreter
prompt. There may be some confusion because of this.

5. Five is right out. (ob Holy Grail reference, of course. :-)

So, I guess I'm wondering if anyone else uses a similar idiom and if
there are any downsides to it that I'm not aware of.

Thanks

Paul

[Roy Smith]

In article
<e8**********************************@q39g2000hsf. googlegroups.com>,
mi***********@gmail.com wrote:

Ruby has a neat little convenience when writing loops where you don't
care about the loop index: you just do n.times do { ... some
code ... } where n is an integer representing how many times you want
to execute "some code."

In Python, the direct translation of this is a for loop. When the
index doesn't matter to me, I tend to write it as:

for _ in xrange (1,n):
some code

An alternative way of indicating that you don't care about the loop
index would be

for dummy in xrange (1,n):
some code

But I like using _ because it's only 1 character and communicates well
the idea "I don't care about this variable."

Not to me. If I read "for _ in ...", I wouldn't be quite sure what _ was.
Is it some magic piece of syntax I've forgotten about? Or something new
added to language while I wasn't paying attention (I still consider most
stuff added since 1.5 to be new-fangled :-)). If I see "dummy", I know it
means, "the language requires a variable here, but the value is not needed".

1. It might be a little jarring to people not used to it. I do admit
it looks pretty strange at first.

2. The variable _ has special meaning at the interactive interpreter
prompt. There may be some confusion because of this.

Wow, I didn't even know about #2. Now you see what I mean about "some
magic syntax"? Surely, between, "It looks strange", and "there may be some
confusion", that's enough reason not to use it?

But, more to the point, I'd try to find variable name which described why I
was looping, even if I didn't actually use the value in the loop body:

for number_that_you_shall_count_to in xrange(3):
print "Whaaaaaaa"

[Gabriel Genellina]

En Sun, 03 Feb 2008 01:03:43 -0200, James Matthews <ny*******@gmail.com>
escribió:

Sorry to be nitpicking, but people coming from other languages may get
confused by the wrong examples:

What i do is a simple range call. for i in range(number of times i want
to repeat something)
I guess it comes from my C days for(i=0;i<100;i++) { or in python for i
in range(99):

Should be `for i in range(100)` to match exactly the C loop. Both iterate
100 times, with i varying from 0 to 99 inclusive.

> mi***********@gmail.com wrote:

Ruby has a neat little convenience when writing loops where you don't
care about the loop index: you just do n.times do { ... some
code ... } where n is an integer representing how many times you want
to execute "some code."

In Python, the direct translation of this is a for loop. When the
index doesn't matter to me, I tend to write it as:

for _ in xrange (1,n):
some code

Should be `for _ in xrange(n)` to match the Ruby example. Both iterate n
times.

On Feb 3, 2008 3:34 AM, Roy Smith <ro*@panix.comwrote:

>But, more to the point, I'd try to find variable name which described
why I was looping, even if I didn't actually use the value in theloop
body:

Me too. Government don't collect taxes by the number of variable names
used (yet).

--
Gabriel Genellina

[Ben Finney]

"Gabriel Genellina" <ga*******@yahoo.com.arwrites:

Should be `for _ in xrange(n)` to match the Ruby example. Both
iterate n times.

Only until Python 3.0, since the 'xrange' implementation will become
'range' at that time.

<URL:http://wiki.python.org/moin/Py3kDeprecated#head-343618ffa0887790ed12c3f9cf278cd7ca7eef51-2>

--
\ "Prediction is very difficult, especially of the future." |
`\ —Niels Bohr |
_o__) |
Ben Finney

[Steven D'Aprano]

On Sat, 02 Feb 2008 18:03:54 -0800, miller.paul.w wrote:

for _ in xrange (1,n):
some code

....

So, I guess I'm wondering if anyone else uses a similar idiom and if
there are any downsides to it that I'm not aware of.

Sometimes, but not often.

If I'm writing a use-once-then-throw-away script, it's too much trouble
to press the Shift key to get an underscore *wink*, so I tend to just use
i or x for the loop variable.

If I'm writing something I intend to keep, but don't care too much about,
I'll use _, i or x about equal numbers of times, depending on whim.

If I was writing something important I expected others to read, I'd use
dummy.

I wouldn't go so far as to say "Don't use that idiom!", but it's not
something I use often.
--
Steven

[Arnaud Delobelle]

On Feb 3, 2:03*am, [e-mail] wrote:

Ruby has a neat little convenience when writing loops where you don't
care about the loop index: you just do n.times do { ... some
code ... } where n is an integer representing how many times you want
to execute "some code."

In Python, the direct translation of this is a for loop. *When the
index doesn't matter to me, I tend to write it as:

for _ in xrange (1,n):
* *some code

[...]

If 'some code' is a function (say f) you can write (with repeat from
itertools):

for action in repeat(f, n): action()

I don't know how 'Pythonic' this would be...

--
Arnaud

[Robert Kern]

James Matthews wrote:

Because 0 is counted therefore i only have to do it 99 times

No, Gabriel is correct. range(n) creates a list of integers starting at 0 and
going to n-1 (inclusive), not n.
In [1]: range(9)
Out[1]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [2]: len(range(9))
Out[2]: 9

In [3]: len(range(1, 9))
Out[3]: 8

In [4]: range(10)
Out[4]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [5]: len(range(10))
Out[5]: 10

On Feb 3, 2008 4:38 AM, Gabriel Genellina <ga*******@yahoo.com.ar
<mailto:ga*******@yahoo.com.ar>wrote:

En Sun, 03 Feb 2008 01:03:43 -0200, James Matthews
<ny*******@gmail.com <mailto:ny*******@gmail.com>>
escribió:

Sorry to be nitpicking, but people coming from other languages may get
confused by the wrong examples:

What i do is a simple range call. for i in range(number of times

i want

to repeat something)
I guess it comes from my C days for(i=0;i<100;i++) { or in python

for i

in range(99):

Should be `for i in range(100)` to match exactly the C loop. Both
iterate
100 times, with i varying from 0 to 99 inclusive.

> mi***********@gmail.com <mailto:mi***********@gmail.comwrote:
>>
Ruby has a neat little convenience when writing loops where

you don't

care about the loop index: you just do n.times do { ... some
code ... } where n is an integer representing how many times

you want

to execute "some code."
>
In Python, the direct translation of this is a for loop. When the
index doesn't matter to me, I tend to write it as:
>
for _ in xrange (1,n):
some code

Should be `for _ in xrange(n)` to match the Ruby example. Both iterate n
times.

On Feb 3, 2008 3:34 AM, Roy Smith <ro*@panix.com

<mailto:ro*@panix.com>wrote:

>

>But, more to the point, I'd try to find variable name which

described

>why I was looping, even if I didn't actually use the value in

theloop

>body:

Me too. Government don't collect taxes by the number of variable names
used (yet).

--
Gabriel Genellina

--
Robert Kern

"I have come to believe that the whole world is an enigma, a harmless enigma
that is made terrible by our own mad attempt to interpret it as though it had
an underlying truth."
-- Umberto Eco

[Steve Holden]

Gabriel Genellina wrote:
[...]

>On Feb 3, 2008 3:34 AM, Roy Smith <ro*@panix.comwrote:

>>But, more to the point, I'd try to find variable name which described
why I was looping, even if I didn't actually use the value in theloop
body:

Me too. Government don't collect taxes by the number of variable names
used (yet).

And if they did I'd pay the tax to retain my sanity.

no-taxation-without-repr()-ly y'rs - steve
--
Steve Holden [phone] [phone]
Holden Web LLC http://www.holdenweb.com/

[Stef Mientki]

be careful, "_" is thé translation function used in Il8N, Il10N
localization / internationalization
e.g.
print _( "hello" )

cheers,
Stef

mi***********@gmail.com wrote:

Ruby has a neat little convenience when writing loops where you don't
care about the loop index: you just do n.times do { ... some
code ... } where n is an integer representing how many times you want
to execute "some code."

In Python, the direct translation of this is a for loop. When the
index doesn't matter to me, I tend to write it as:

for _ in xrange (1,n):
some code

An alternative way of indicating that you don't care about the loop
index would be

for dummy in xrange (1,n):
some code

But I like using _ because it's only 1 character and communicates well
the idea "I don't care about this variable."

The only potential disadvantages I can see are threefold:

1. It might be a little jarring to people not used to it. I do admit
it looks pretty strange at first.

2. The variable _ has special meaning at the interactive interpreter
prompt. There may be some confusion because of this.

5. Five is right out. (ob Holy Grail reference, of course. :-)

So, I guess I'm wondering if anyone else uses a similar idiom and if
there are any downsides to it that I'm not aware of.

Thanks

Paul

[Zentrader]

Not to me. If I read "for _ in ...", I wouldn't be quite sure what _ was.

Is it some magic piece of syntax I've forgotten about? Or something new
added to language while I wasn't paying attention (I still consider most
stuff added since 1.5 to be new-fangled :-)).

+1 to forgotten about
+1 to new-fangled=added since 1.5 When 3000 comes out I'll have to
break down and buy a new Python book. Also, it's amazing how much
posting space is spent here replying to someone who is too lazy to key
in a variable name. Damn!

[miller.paul.w]

On Feb 3, 11:20 am, Paul McGuire <[e-mail]:

[... some code... some words ... more code, etc. ...]

But this still seems like a lot of work to avoid "for x in range(n):".

I agree. The point of me using "for _ in xrange (n)" isn't to avoid
the for loop at all. What I wanted was a pythonic way to express only
the necessary components of the loop, like the Ruby version "n.times
do { stuff }" does. There's no explicit index in the Ruby code,
because you don't care about it.

Now, if you could monkeypatch built-ins, I'd *almost* consider adding
a .times method to integers. But, of course, monkeypatching is evil. :-

>

[Troels Thomsen]

>for action in repeat(f, n): action()
I don't know how 'Pythonic' this would be...

agree,
or this:

import itertools

def f1():
print "hello"

[f() for f in itertools.repeat(f1,6)]
tpt

[Marc 'BlackJack' Rintsch]

On Sun, 03 Feb 2008 15:13:14 +1100, Ben Finney wrote:

"Gabriel Genellina" <ga*******@yahoo.com.arwrites:

>Should be `for _ in xrange(n)` to match the Ruby example. Both
iterate n times.

Only until Python 3.0, since the 'xrange' implementation will become
'range' at that time.

The point wasn't `range` vs. `xrange` but the arguments (1,n) vs. (n).

Ciao,
Marc 'BlackJack' Rintsch

[Paul Rubin]

mi***********@gmail.com writes:

where n is an integer representing how many times you want
to execute "some code." ... I tend to write it as:

for _ in xrange (1,n):
some code

But this does it n-1 times, not n times.

[=?ISO-8859-1?Q?BJ=F6rn_Lindqvist?=]

In Python, the direct translation of this is a for loop. When the

index doesn't matter to me, I tend to write it as:

for _ in xrange (1,n):
some code

An alternative way of indicating that you don't care about the loop
index would be

for dummy in xrange (1,n):
some code

I usually use _ when I know that i18n doesn't matter. dummy is just to
long when unpacking sequences:

for dummy, email, dummy, dummy in persons:
sendmail(email)

for _, email, _, _ in persons:
sendmail(email)
--
mvh Björn

[Bob Martin]

in 332496 20080204 102153 "=?ISO-8859-1?Q?BJ=F6rn_Lindqvist?=" <bj*****@gmail.comwrote:

>In Python, the direct translation of this is a for loop. When the
index doesn't matter to me, I tend to write it as:

for _ in xrange (1,n):
some code

An alternative way of indicating that you don't care about the loop
index would be

for dummy in xrange (1,n):
some code

I usually use _ when I know that i18n doesn't matter. dummy is just to
long when unpacking sequences:

for dummy, email, dummy, dummy in persons:
sendmail(email)

for _, email, _, _ in persons:
sendmail(email)

Rexx's method is the way to do it : "do 50"

[Steven D'Aprano]

On Mon, 04 Feb 2008 15:08:44 +0000, Bob Martin wrote:

Rexx's method is the way to do it : "do 50"

I tried writing Rexx code and executing it in Python, but I got
unexpected results, mostly SyntaxError exceptions. Is that a bug in
Python?

No-I'm-not-really-serious-ly yours,
--
Steven

[Nick Craig-Wood]

mi***********@gmail.com <mi***********@gmail.comwrote:

Ruby has a neat little convenience when writing loops where you don't
care about the loop index: you just do n.times do { ... some
code ... } where n is an integer representing how many times you want
to execute "some code."

In Python, the direct translation of this is a for loop. When the
index doesn't matter to me, I tend to write it as:

for _ in xrange (1,n):
some code

An alternative way of indicating that you don't care about the loop
index would be

for dummy in xrange (1,n):
some code

I use pychecker a lot. It views variables called [ '_', 'unused',
'empty', 'dummy' ] as names to ignore if they haven't been used.

So according to pychecker '_' and 'dummy' would both be OK.

As for me personally, I usually use '_' but sometimes use 'dummy'
depending on the surrounding code.

Note that this idiom is fairly common in python too

wanted, _, _, _, also_wanted = a_list

which looks quite neat to my eyes.

--
Nick Craig-Wood <ni**@craig-wood.com-- http://www.craig-wood.com/nick

[Eduardo O. Padoan]

On Feb 5, 2008 1:30 PM, Nick Craig-Wood <ni**@craig-wood.comwrote:

mi***********@gmail.com <mi***********@gmail.comwrote:

Ruby has a neat little convenience when writing loops where you don't
care about the loop index: you just do n.times do { ... some
code ... } where n is an integer representing how many times you want
to execute "some code."

In Python, the direct translation of this is a for loop. When the
index doesn't matter to me, I tend to write it as:

for _ in xrange (1,n):
some code

An alternative way of indicating that you don't care about the loop
index would be

for dummy in xrange (1,n):
some code

I use pychecker a lot. It views variables called [ '_', 'unused',
'empty', 'dummy' ] as names to ignore if they haven't been used.

So according to pychecker '_' and 'dummy' would both be OK.

As for me personally, I usually use '_' but sometimes use 'dummy'
depending on the surrounding code.

Note that this idiom is fairly common in python too

wanted, _, _, _, also_wanted = a_list

which looks quite neat to my eyes.

BTW and FWIW, in Py3k you can do:

wanted, *_, also_wanted = a_list

http://www.python.org/dev/peps/pep-3132/

--
http://www.advogato.org/person/eopadoan/
Bookmarks: http://del.icio.us/edcrypt