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

[kyosohma]

On Oct 24, 8:02 am, kyoso...@gmail. com wrote:

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...tut/node7.html

Mike

After reading the others replies, it makes me think that I'm barking
up the wrong tree. Ah well.

Mike

[A.T.Hofkamp]

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

You can do it shorter, not sure that it also qualifies as better....

d = { True : [] , False : [] }
for arg in cls.arguments:
d[arg == True].append(arg)

return d[True], d[False]

One potential problem here is that 'arg == True' may not be the same as 'if
arg:'. I couldn't come up with a better equivalent expression, maybe one of the
other readers knows more about this?
Albert

[Bjoern Schliessmann]

Alexandre Badez wrote:

I'm just wondering, if I could write a in a "better" way this code
[...]
I think there is a better way, but I can't see how...

What's "better" for you? Shorter? More performant? More readable?
Complying with best practice? Closely following a specific
programming paradigm?

Regards,
Björn

--
BOFH excuse #403:

Sysadmin didn't hear pager go off due to loud music from bar-room
speakers.

[Paul Hankin]

On Oct 24, 2:02 pm, kyoso...@gmail. com wrote:

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.

Your list comprehensions are right, but 'arg is True' and 'arg is
False' are better written as 'arg' and 'not arg' respectively.

--
Paul Hankin

[cokofreedom]

On Oct 24, 4:15 pm, Paul Hankin <paul.han...@gm ail.comwrote:

On Oct 24, 2:02 pm, kyoso...@gmail. com wrote:

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.

Your list comprehensions are right, but 'arg is True' and 'arg is
False' are better written as 'arg' and 'not arg' respectively.

--
Paul Hankin

Anyone know why towards arg is True and arg is False, arg is None is
faster than arg == None ...

[George Sakkis]

On Oct 24, 10:42 am, cokofree...@gma il.com wrote:

On Oct 24, 4:15 pm, Paul Hankin <paul.han...@gm ail.comwrote:

On Oct 24, 2:02 pm, kyoso...@gmail. com wrote:

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.

Your list comprehensions are right, but 'arg is True' and 'arg is
False' are better written as 'arg' and 'not arg' respectively.

--
Paul Hankin

Anyone know why towards arg is True and arg is False, arg is None is
faster than arg == None ...

And quite often incorrect, especially the "arg is True" and "arg is
False".

[Marc 'BlackJack' Rintsch]

On Wed, 24 Oct 2007 16:04:28 +0200, A.T.Hofkamp wrote:

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

You can do it shorter, not sure that it also qualifies as better....

d = { True : [] , False : [] }
for arg in cls.arguments:
d[arg == True].append(arg)

return d[True], d[False]

One potential problem here is that 'arg == True' may not be the same as 'if
arg:'. I couldn't come up with a better equivalent expression, maybe one of the
other readers knows more about this?

With ``if arg:`` the interpreter asks `arg` for its "boolean value". So a
better way would be:

d[bool(arg)].append(arg)

As `True` and `False` are instances of `int` with the values 1 and 0 it's
possible to replace the dictionary by a list:

tmp = [[], []]
for arg in cls.arguments:
tmp[bool(arg)].append(arg)
return tmp[1], tmp[0]

Maybe that's nicer. Maybe not.

Ciao,
Marc 'BlackJack' Rintsch

[Bruno Desthuilliers]

Bjoern Schliessmann a écrit :

Alexandre Badez wrote:

>I'm just wondering, if I could write a in a "better" way this code
[...]
I think there is a better way, but I can't see how...

What's "better" for you? Shorter? More performant? More readable?
Complying with best practice? Closely following a specific
programming paradigm?

I think the OP meant "more pythonic".

[beginner]

On Oct 24, 9:04 am, "A.T.Hofkam p" <[e-mail]. nlwrote:

On 2007-10-24, 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 can do it shorter, not sure that it also qualifies as better....

d = { True : [] , False : [] }
for arg in cls.arguments:
d[arg == True].append(arg)

return d[True], d[False]

One potential problem here is that 'arg == True' may not be the same as 'if
arg:'. I couldn't come up with a better equivalent expression, maybe one of the
other readers knows more about this?

Albert

d[bool(arg)].append(arg) resolves your concern?

[Alexandre Badez]

On Oct 24, 3:46 pm, Duncan Booth <duncan.bo...@i nvalid.invalidw rote:

For a 'python like' look lose the Hungarian notation (even Microsoft
have largely stopped using it)

I wish I could.
But my corporation do not want to apply python.org coding rules

increase the indentation to 4 spaces,

Well, it is in my python file.
I do not do it here, because I'm a bit lazy.

and also get rid of the spurious parentheses around the result.

Thanks

Otherwise it is fine: clear and to the point.

Thanks

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

And finally thanks again ;)