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************ *************** *******@q39g200 0hsf.googlegrou ps.com>,
mi***********@g mail.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*******@gmai l.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***********@g mail.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.comw rote:

>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*******@yaho o.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-343618ffa088779 0ed12c3f9cf278c d7ca7eef51-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, miller.pau...@g mail.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

[...]

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*******@yaho o.com.ar
<mailto:ga***** **@yahoo.com.ar >wrote:

En Sun, 03 Feb 2008 01:03:43 -0200, James Matthews
<ny*******@gmai l.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***********@g mail.com <mailto:mi***** ******@gmail.co mwrote:
>>
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.co m

<mailto:ro*@pan ix.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.comw rote:

>>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 / internationaliz ation
e.g.
print _( "hello" )

cheers,
Stef

mi***********@g mail.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!