Better writing in python

[Alexandre Badez]

I'm just wondering, if I could write a in a "better" way this code

lMandatory = []
lOptional = []
for arg in cls.dArguments:
if arg is True:
lMandatory.appe nd(arg)
else:
lOptional.appen d(arg)
return (lMandatory, lOptional)

I think there is a better way, but I can't see how...

[Marc 'BlackJack' Rintsch]

On Wed, 24 Oct 2007 12:09:40 +0000, Alexandre Badez wrote:

I'm just wondering, if I could write a in a "better" way this code

lMandatory = []
lOptional = []
for arg in cls.dArguments:
if arg is True:
lMandatory.appe nd(arg)
else:
lOptional.appen d(arg)
return (lMandatory, lOptional)

I think there is a better way, but I can't see how...

Drop the prefixes. `l` is for list? `d` is for what!? Can't be
dictionary because the code doesn't make much sense.

Where is `cls` coming from?

Ciao,
Marc 'BlackJack' Rintsch

[Paul Hankin]

On Oct 24, 1:09 pm, Alexandre Badez <alexandre.ba.. [e-mail] e:

I'm just wondering, if I could write a in a "better" way this code

lMandatory = []
lOptional = []
for arg in cls.dArguments:
if arg is True:
lMandatory.appe nd(arg)
else:
lOptional.appen d(arg)
return (lMandatory, lOptional)

I think there is a better way, but I can't see how...

import operator
return filter(cls.dArg uments), filter(operator .not_, cls.dArguments)

Or just:

mandatory = [arg for arg in cls.dArguments in arg]
optional = [arg for arg in cls.dArguments in not arg]
return mandatory, optional

--
Paul Hankin

[Paul Hankin]

On Oct 24, 1:09 pm, Alexandre Badez <alexandre.ba.. [e-mail] e:

I'm just wondering, if I could write a in a "better" way this code

lMandatory = []
lOptional = []
for arg in cls.dArguments:
if arg is True:
lMandatory.appe nd(arg)
else:
lOptional.appen d(arg)
return (lMandatory, lOptional)

I think there is a better way, but I can't see how...

import operator
return filter(cls.dArg uments), filter(operator .not_, cls.dArguments)

Or just:

mandatory = [arg for arg in cls.dArguments in arg]
optional = [arg for arg in cls.dArguments in not arg]
return mandatory, optional

--
Paul Hankin

[Paul Hankin]

On Oct 24, 1:09 pm, Alexandre Badez <alexandre.ba.. [e-mail] e:

I'm just wondering, if I could write a in a "better" way this code

lMandatory = []
lOptional = []
for arg in cls.dArguments:
if arg is True:
lMandatory.appe nd(arg)
else:
lOptional.appen d(arg)
return (lMandatory, lOptional)

I think there is a better way, but I can't see how...

import operator
return filter(cls.dArg uments), filter(operator .not_, cls.dArguments)

Or just:

mandatory = [arg for arg in cls.dArguments in arg]
optional = [arg for arg in cls.dArguments in not arg]
return mandatory, optional

--
Paul Hankin

[kyosohma]

On Oct 24, 7:09 am, Alexandre Badez <alexandre.ba.. [e-mail] e:

I'm just wondering, if I could write a in a "better" way this code

lMandatory = []
lOptional = []
for arg in cls.dArguments:
if arg is True:
lMandatory.appe nd(arg)
else:
lOptional.appen d(arg)
return (lMandatory, lOptional)

I think there is a better way, but I can't see how...

You might look into list comprehensions. You could probably do this
with two of them:

<code>
# completely untested
lMandatory = [arg for arg in cls.dArguments if arg is True]
lOptional = [arg for arg in cls.dArguments if arg is False]
</code>

Something like that. I'm not the best with list comprehensions, so I
may have the syntax just slightly off. See the following links for
more information:

http://www.secnetix.de/olli/Python/l...ehensions.hawk
http://docs.python.org/tut/node7.html

Mike

[Neil Cerutti]

On 2007-10-24, Alexandre Badez <al************ *@gmail.comwrot e:

I'm just wondering, if I could write a in a "better" way this
code

lMandatory = []
lOptional = []
for arg in cls.dArguments:
if arg is True:
lMandatory.appe nd(arg)
else:
lOptional.appen d(arg)
return (lMandatory, lOptional)

I think there is a better way, but I can't see how...

I don't think there's much improvement to be made. What are your
particular concerns? Is it too slow? Too verbose? Does it not
work correctly?

It appears to be an application of itertools.group by, but that'll
almost certainly be less efficient. To use groupby, you have to
sort by your predicate, and build lists to save results. Your for
loop avoids the sorting.

Here's some instrumentality for ya:

from itertools import groupby
from operator import truth
from collections import defaultdict

result = defaultdict(lis t)
for k, g in groupby(sorted( cls.dArguments, key=truth), truth):
result[k].extend(g)

I like your initial attempt better.

P.S. I didn't realize until working out this example that extend
could consume an iterator.

--
Neil Cerutti
The word "genius" isn't applicable in football. A genius is a guy like Norman
Einstein. --Joe Theisman

[Harold Fellermann]

Hi Alexandre,

On Oct 24, 2:09 pm, Alexandre Badez <alexandre.ba.. [e-mail] e:

I'm just wondering, if I could write a in a "better" way this code

Please tell us, what it is you want to achieve. And give us some
context
for this function.

lMandatory = []
lOptional = []
for arg in cls.dArguments:
if arg is True:
lMandatory.appe nd(arg)
else:
lOptional.appen d(arg)
return (lMandatory, lOptional)

This snippet will seperate d.Arguments into two lists: one that
holds all elements that are references to True(!) and another list
that holds the rest. The condition 'if args is True' will only
be hold if arg actually _is_ the object _True_. This is probably
not what you want. Apart from that, you might go with

lMandatory = [ arg for arg in cls.dArguments if condition() ]
lOptional = [ arg for arg in cls.dArguments if not condition() ]

the second line could be rewritten

lOptional = list(set(cls.dA rguments)-set(lMandatory) )

If lMandatory and lOptional do not need to be lists, you can also
write

lMandatory = set(arg for arg in cls.dArguments if condition())
lOptional = set(cls.dArgume nts) - lMandatory

But please, give us some more context of what you want to do.

- harold -

[Alexandre Badez]

Thanks for your try Cliff, I was very confused :P
More over I made some mistake when I post (to make it easiest).

Here is my real code:

with
dArguments = {
'argName' : {
'mandatory' : bool, # True or False
[...], # other field we do not care here
}
}

lMandatory = []
lOptional = []
for arg in cls.dArguments:
if cls.dArguments[arg]['mandatory']:
lMandatory.appe nd(arg)
else:
lOptional.appen d(arg)
return (lMandatory, lOptional)

So, as you see, we agree each other about "if bool" or "if bool is
True" ;)

So, my question was how to give it a better 'python like' look ?
Any idea ?

[Duncan Booth]

Alexandre Badez <al************ *@gmail.comwrot e:

Thanks for your try Cliff, I was very confused :P
More over I made some mistake when I post (to make it easiest).

Here is my real code:

with
dArguments = {
'argName' : {
'mandatory' : bool, # True or False
[...], # other field we do not care here
}
}

lMandatory = []
lOptional = []
for arg in cls.dArguments:
if cls.dArguments[arg]['mandatory']:
lMandatory.appe nd(arg)
else:
lOptional.appen d(arg)
return (lMandatory, lOptional)

So, as you see, we agree each other about "if bool" or "if bool is
True" ;)

So, my question was how to give it a better 'python like' look ?
Any idea ?

For a 'python like' look lose the Hungarian notation (even Microsoft
have largely stopped using it), increase the indentation to 4 spaces,
and also get rid of the spurious parentheses around the result.
Otherwise it is fine: clear and to the point.

If you really wanted you could write something like:

m, o = [], []
for arg in cls.dArguments:
(m if cls.dArguments[arg]['mandatory'] else o).append(arg)
return m, o

Or even:
m, o = [], []
action = [o.append, m.append]
for arg in cls.dArguments:
action[bool(cls.dArgum ents[arg]['mandatory'])](arg)
return m, o

but it just makes the code less clear, so why bother?