Does anyone else use this little idiom?

M

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
 
R

Roy Smith

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"
 
G

Gabriel Genellina

En Sun, 03 Feb 2008 01:03:43 -0200, James Matthews <[email protected]>
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.

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

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

Jeff Schwab

How said:
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 aw

Would something like this be acceptable? It still requires a loop
variable, plus an extra line of code per loop, plus a one-time class
definition (and import into each client module), and it's probably
slower than "for dummy in range." The syntax might be more inuitive
than "dummy" or "_" in a for loop, though.

class Go:
def __init__(self, count):
self.count = count

def again(self):
if self.count <= 0:
return False
self.count -= 1
return True

go = Go(3)
while go.again():
print "hello"
 
B

Ben Finney

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. As you noted, '_' is easily ambiguous. Explicit is better
than implicit; the name 'dummy' makes it much clearer.
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.

The name '_' also has an established meaning for the "gettext"
internationalisation/localisation library, pre-dating Python and
documented in <URL:http://www.python.org/doc/lib/module-gettext>.
 
S

Steven D'Aprano

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.
 
S

Steven D'Aprano

Not to me. As you noted, '_' is easily ambiguous. Explicit is better
than implicit; the name 'dummy' makes it much clearer.

Assuming you're not writing code like the following:

dummies = [Pacifier() for x in xrange(100)]
for dummy in dummies:
check_for_quality(dummy)


"dummy" as the name of a variable you don't care about is just a
convention, no different from "_" or "paris_hilton" or "shrubbery". In
fact, to me "dummy" implies that it holds a dummy value that will be
replaced later with the actual value needed.

If you want an explicit name, try a variation of "dontcare". Assuming
that you're an English speaker.

People seem to forget that "explicit" just means that there's a
convention that nearly everybody knows, and if you follow it, nearly
everybody will know what you mean. Often that convention is nothing more
than the meanings of words in whatever human language you're speaking,
but it's still a convention.
 
A

Arnaud Delobelle

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...
 
R

Robert Kern

James said:
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 <[email protected]

En Sun, 03 Feb 2008 01:03:43 -0200, James Matthews
<[email protected] <mailto:[email protected]>>
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.

Should be `for _ in xrange(n)` to match the Ruby example. Both iterate n
times.
Me too. Government don't collect taxes by the number of variable names
used (yet).

--
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
 
S

Steve Holden

Gabriel Genellina wrote:
[...]
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
 
S

Steve Holden

Jeff said:
Would something like this be acceptable? It still requires a loop
variable, plus an extra line of code per loop, plus a one-time class
definition (and import into each client module), and it's probably
slower than "for dummy in range." The syntax might be more inuitive
than "dummy" or "_" in a for loop, though.

class Go:
def __init__(self, count):
self.count = count

def again(self):
if self.count <= 0:
return False
self.count -= 1
return True

go = Go(3)
while go.again():
print "hello"

One could rename the again() method __call__(), allowing the even more
horrible but less verbose

while Go(3)():
print "hello"

That'd confuse the newbies!

regards
Steve
 
S

Steve Holden

Jeff said:
Would something like this be acceptable? It still requires a loop
variable, plus an extra line of code per loop, plus a one-time class
definition (and import into each client module), and it's probably
slower than "for dummy in range." The syntax might be more inuitive
than "dummy" or "_" in a for loop, though.

class Go:
def __init__(self, count):
self.count = count

def again(self):
if self.count <= 0:
return False
self.count -= 1
return True

go = Go(3)
while go.again():
print "hello"

One could rename the again() method __call__(), allowing the even more
horrible but less verbose

while Go(3)():
print "hello"

That'd confuse the newbies!

regards
Steve
 
S

Stef Mientki

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

cheers,
Stef
 
I

Ivan Illarionov

Plain Python function are very often more powerful than classes:
.... if not hasattr(go, 'count'):
.... go.count = count
.... if go.count <= 0:
.... del go.count
.... return False
.... go.count -= 1
.... return True
........ print 'hello'
....
hello
hello
hello
 
Z

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!
 
P

Paul McGuire

Would something like this be acceptable?  It still requires a loop
variable, plus an extra line of code per loop, plus a one-time class
definition (and import into each client module), and it's probably
slower than "for dummy in range."  The syntax might be more inuitive
than "dummy" or "_" in a for loop, though.

class Go:
     def __init__(self, count):
         self.count = count

     def again(self):
         if self.count <= 0:
             return False
         self.count -= 1
         return True

go = Go(3)
while go.again():
     print "hello"- Hide quoted text -

- Show quoted text -

Here's something similar, in a decorator:

def iterative(fn):
def times_(n):
i = 0
while i < n:
fn()
i += 1
fn.times = times_
return fn

@iterative
def aFunction():
print "this is a function"

aFunction.times(3)

Prints:
this is a function
this is a function
this is a function

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

miller.paul.w

+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!

Lol. It isn't that I'm too lazy; it's just that the character "_"
looks like "-" to me, and, in the math class I'm taking right now
(category theory), "-" is one of the notations to indicate "whatever"
-- a metasyntactic placeholder, if you will. (For example, Hom (C, -)
is the covariant hom functor from C -> Sets. If this makes no sense
to you, don't worry about it.)

After this discussion, it seems that if I'm to write Python for public
consumption, I should prefer

for dummy in xrange (n):
do_stuff()

or one of the other suggestions instead. :)
 
M

miller.paul.w

[... 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. :-
 
M

miller.paul.w

My apologies if any attributions are messed up.


Actually, "_" isn't ambiguous at all. It's a perfectly well-defined
variable name. It just seems most people don't know that, probably
because most people never get the urge to name a variable "_".

The whole reason I find myself wanting to use "_" is that "for _ in
xrange (n):" goes beyond explicit to redundant if you're not using the
index variable inside the loop. Ruby's version is much better in this
respect, because every token matters.
In
fact, to me "dummy" implies that it holds a dummy value that will be
replaced later with the actual value needed.

If you want an explicit name, try a variation of "dontcare". Assuming
that you're an English speaker.

That reminds me... I saw some code once that used a dummy variable
named "dont_give_a_shit". I got a few seconds of giggles out of it,
at least. :)
People seem to forget that "explicit" just means that there's a
convention that nearly everybody knows, and if you follow it, nearly
everybody will know what you mean. Often that convention is nothing more
than the meanings of words in whatever human language you're speaking,
but it's still a convention.

Well, I'd argue that's only part of what "explicitness" means. In
this specific use case, having to write the index variable isn't being
explicit; it's a simple redundancy. Writing "_", or "dontcare" or
"dont_give_a_shit" doesn't seem more explicit at all. It seems silly
to have to write it at all if I don't intend to use it. I'd really
prefer something like the Ruby syntax because all you have to write is
the number of times you want to do something, and then the thing you
want to do. (I guess, in that respect, I'd even consider the xrange
call a redundancy.)

Thanks, everyone for the replies. :)
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

Forum statistics

Threads
473,734
Messages
2,569,441
Members
44,832
Latest member
GlennSmall

Latest Threads

Top