Python: avoiding if condition for this code?

Question

for the following code

a =func()
if a != None:
 b.append(a)

a can be assigned to None, is there a way to avoid the if statement and only use one line of code?

original problem is the following

import xml.etree.ElementTree as etree
r = etree.parse(f).getroot()
b = etree.Element('register',{})
a = r.find('tag_name') # a may get None if did not find it
if a != None:
 b.append(a)

ok, I used all the answers and got this, personally I think it's the most complex python I have ever wrote so far, lol

NS_MAP = {
 'spirit' : 'http://www.spiritconsortium.org/XMLSchema/SPIRIT/1.4',
 'app' : 'http://www.app.com/SPIRIT-app'
 }
mp=etree.Element('MemoryProperty', {'version':'alpha'})
mpt=etree.ElementTree(mp)
def copy_tags(tp, op, p, tn, ns='spirit'):
 c = p.find('{%s}%s'%(NS_MAP[ns],tn))
 if c is not None:
 (op == '<-') and tp.append(c)
 return c 
for reg in regs:
 te = etree.Element('register',{})
 copy_tags(te,'<-',reg,'name')
 copy_tags(te,'<-',reg,'addressOffset')
 copy_tags(te,'<-',reg,'access')
 (lambda e, t: copy_tags(te,'<-',t,'usageConstraints',ns='app') if t is not None else None)(te, copy_tags(te,'|',reg,'vendorExtensions'))
 mp.append(te)
mpt.write('map_gen.xml')

Answer 1

If you can call func() beforehand, and you want to combine the test and assignment statements into a single statement, then you can do this, with an if-else expression:

b += [a] if a is not None else []

If a is not None, then this will add [a] to b -- essentially the same operation as b.append(a)

If a is None, then this will add [] to b, which will leave b unchanged.

This won't work unless b is a list, or at least supports "+=" in-place addition. If it doesn't -- perhaps it's some custom object, then you should be able to do this:

(b.append(a) if a is not None else None)

This is an expression, evaluated for its side effects, and then thrown away. If a is None, then the b.append(a) call will never be executed. In either case, the value of the expression is None, but we don't care about it, so it gets ignored.

Now, if you want to combine the func() call with this, then you'll have to do something different in order to avoid calling func twice. If you can use the "+=" syntax, then you can do it like this:

b += filter(None, [func()])

filter(None, <list>) returns the list with all false elements (None included, but also 0 and []) removed. This statement, then, will add either [func()] or [] to b.

[Edited]

Finally, for the worst case scenario: If you can't call func() more than once, and you can't use b += <list>, and you need to accept 0, "", [], etc, and only exclude None, and you need it all on one line, here's the ugliest line of code yet:

(lambda l, a: l.append(a) if a is not None else None)(b, func())

This is essentially @ekhumoro's solution, compressed into one line. It defines an anonymous function, calls it, discards the value, and then discards the function, all for the sake of the side effect.

Now, this is a single line, but it's certainly not easier to read or understand than the original code. If I were you, I'd stick with the original, or go with @ekhumoro's idea of just defining a helper function and using that.

Answer 2

python 3.8 walrus operator

if a := func(): b.append(a)

Answer 3

You asked the wrong question here. The clue is in your reply to one of the comments where you say "I have 10+ tags, if I can get 3 line to 1 line, I will save 20+ lines".

So your problem actually is not that you have 3 lines of code but that you are needlessly repeating 3 lines of code over and over. You could use a function to extract the repeated lines, but it sounds like in this case you may actually want a loop:

THE_TAGS = ('tag1', 'tag2', 'and so on')
for tag in THE_TAGS:
 a = r.find(tag) # a may get None if did not find it
 if a != None:
 b.append(a)

Or if you need to append to different lists:

def extract_tag(r, tag_name, to):
 a = r.find(tag_name) # a may get None if did not find it
 if a != None:
 to.append(a)
extract_tag(r, 'tag1', b)
extract_tag(r, 'tag2', c)

Answer 4

Short answer: Not really.

Longer answer: If you really wanted to avoid this (perhaps because you want to implement this behavior --- appending only non-None values) from several different blocks of code) then you could create a class as a proxy around the underlying b object and hide the details in its append method.

class NonNoneAppender:
 def __init__(self, obj):
 if not hasattr(obj, 'append') or not callable(obj.append):
 raise ValueError, "Object must have append method"
 self.__obj = obj
 def append(self, item):
 if item is not None:
 return self.__obj.append(item)
 def __getattr__(self, attr):
 return getattr( self.__obj, attr) 

... and then you could do something like:

b = NonNoneAppender(b)

However, I'm not sure this would make any sense at all for your code.

Answer 5

Attacking your real problem, and doing it in two lines for clarity:

temp = [r.find(tag) for tag in list_of_tags]
b.extend(x for x in temp if x is not None)

Note: Element.extend is new in Python 2.7/3.2

Answer 6

Presumably you're not trying to remove just a single if statement from your code...

So the obvious answer is to use a function:

import xml.etree.ElementTree as etree
def append(parent, child):
 if child is not None:
 parent.append(child)
r = etree.parse(f).getroot()
b = etree.Element('register',{})
append(b, r.find('tag_name'))

Answer 7

You can just add everything and remove Nones at the end with b = [a for a in b if b is not None]. Or, in your particular use case, you can do b.extend(r.findall('tag_name')[:1]). This may be a bit slower, however, as it will go through the whole tree, rather than stopping at the first instance.

Answer 8

(Should be comment to this answer but I don't have enough reputation)

Keep in mind that walrus operator can be quite surprising.

1. Variable that walrus is assigning to will be not local to eg. if block:

   if a := func():
    b.append(a)
   print(a) # a just leaked to upper scope
   

2. Walrus operator has low precedence, so when used in comparison must be surrounded in parentheses, or comparison will be evaluated first.

   def func(x):
    return x
   b = []
   if a := func(7) == 7:
    b.append(a)
    print(a, "appended !") # prints: True appended !
   

Answer 9

b+=list(set([r.find('tag_name')])-set([None]))

But it's very ugly. A little cleaner, but also a line longer:

b.append(r.find('tag_name'))
b.remove(None)

Still not very neat though. If I were you I'd just keep that if statement.