470,613 Members | 1,721 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 470,613 developers. It's quick & easy.

Does anyone else use this little idiom?

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
Feb 3 '08 #1
18 1189
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"
Feb 3 '08 #2
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

Feb 3 '08 #3
"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
Feb 3 '08 #4
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
Feb 3 '08 #5
On Feb 3, 2:03*am, miller.pau...@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
[...]

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

Feb 3 '08 #6
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

Feb 3 '08 #7
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 +1 571 484 6266 +1 800 494 3119
Holden Web LLC http://www.holdenweb.com/

Feb 3 '08 #8
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
Feb 3 '08 #9
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!
Feb 3 '08 #10
On Feb 3, 11:20 am, Paul McGuire <pt...@austin.rr.comwrote:

[... 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. :-
>
Feb 3 '08 #11
>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
Feb 3 '08 #12
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
Feb 3 '08 #13
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.
Feb 4 '08 #14
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
Feb 4 '08 #15
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"
Feb 4 '08 #16
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
Feb 4 '08 #17
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
Feb 5 '08 #18
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
Feb 5 '08 #19

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

20 posts views Thread by Corno | last post: by
5 posts views Thread by Grant Olson | last post: by
17 posts views Thread by christophe.chazeau | last post: by
8 posts views Thread by Andrew Savige | last post: by
5 posts views Thread by jbperez808 | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.