Python Programming for Biology: Bioinformatics and Beyond

Lambda: anonymous functions

So  far  we  have  been  discussing  the  normal  named  Python  functions.  However,  Python

also has some seemingly strange functionality to define anonymous functions. Here’s how

you  can  define  an  anonymous  function  using  the  lambda  keyword;  note  how  it  is

immediately assigned to a variable and that a colon ‘:’ is used to separate the inputs from

what is returned.

cube = lambda x: x*x*x

print(cube(3)) # Result: 27

This is equivalent to:

def cube(x):

return x*x*x

print(cube(3)) # Result: 27

A  lambda  function  can  only  be  simple;  it  cannot  contain  control  statements  like  if  or

for. So its use is restricted. There might seem little point in defining such limited functions

that you cannot name, but there are a few situations where they are very handy. Consider

that  you  have  a  function  that  accepts  another  function  as  an  argument;  in  this  case  the

argument function is called if there is an error:

def jobFunc(arg1, errorFunc):

Now imagine that you want to pass some arguments to errorFunc to say how the error

should be displayed:

def jobFunc(arg1, errorFunc('Warning', color='Red')): # Wrong

The  above  is  not  what  we  want  because  errorFunc  is  always  called  when  jobFunc  is

defined.  What  we  really  want  to  do  is  only  call  errorFunc  with  the  warning  message

somewhere inside jobFunc, when and where it is needed. Accordingly we can use lambda

to wrap errorFunc without it being called.

def jobFunc(arg1, lambda: errorFunc('Warning', color='Red')):

As  another  demonstration,  consider  the  sorting  example  for  nested  functions  in  the

previous section. We could use lambda instead:

def drawAtoms(atoms):

atoms.sort(key=lambda atom: atom.z)

---