Proper use of lambda in function definition

Question

I want to write a simple function that recognizes palindromes:

>>> def palindrome(s):
    return s == s[::-1]

It works fine but it is case sensitive and to fix that I could do:

>>> def palindrome(s):
    return s.lower() == s[::-1].lower()

>>> palindrome('Aba')
True

but I figure it's not very elegant. I tried to lowercase the input by using lambda expressions but I am doing something wrong and don't know how to fix it:

>>> def palindrome(lambda s : s.lower()):
    return s == s[::-1]
SyntaxError: invalid syntax

Answer 1

You cannot use a lambda expression to describe actions that should be performed on input parameters (you can however use lambda to define a default value). You can do two things:

• Define a function in the head of the function:

  def palindrome(s):
      s = s.lower()
      return s == s[::-1]
  

• Use a decorator:

  def caseinsensitive(f):
      def helper(s):
          s = s.lower()
          return f(s)
      return helper
  

  and then define your palindrome as:

  @caseinsensitive
  def palindrome(s):
      return s == s[::-1]
  

  Here you can reuse the @caseinsensitive to define all functions that do this as a first step.

Answer 2

Just call lower once, reassign s to the value and forget the lambda:

def palindrome(s):
    s = s.lower()
    return s == s[::-1]

Answer 3

This isn't really idiomatic python, but what you're looking for is something like this:

def palindrome(s):
    return (lambda x: x == x[::-1])(s.lower())

That is, you define a lambda function and immediately invoke it, binding s.lower() to x.

Answer 4

def palindrome(s):
    s = s.lower()
    return s == s[::-1]

This is pretty straightforward and easy to use and understand answer, which is 100% correct and good. BUT if you want to use lambda expression you must think how and what and why and stuff so let's go into the magical world of FUNCTIONAL PROGRAMMING.

If you don't know what a lambda expression is, basically when you type in the word lambda it specifies that you will later on give it some value for instance typing lambda a means you will supply it with 1 value (argument), typing lambda a, b explicitly means you will suppliy it with 2 values (arguments). So now that this whole thing of "what does even this lambda word mean" is done let's go deeper into the magical world of FUNCTIONAL PROGRAMMING.

So now when you tell python that it will have to wait some time (or maybe no time at all) for that value so it can do some magic on it, you can tell it what to do with it for instance

some_var = lambda some_string: some_string.lower()

So now this means that it's going to get some value, we expect it to be some sort of string and we can and will hold it in some_var for reasons only PHP programmers and us (me) know.

Next up is really straight forward we just return the check whether it is or not a palindrome

return some_var == some_var[::-1]

Let's get some glue and build this lambda beast from the things we have earlier

def palindrome():
    some_var = lambda some_string : some_string.lower()
    return some_var == some_var[::-1]

As you can see we no longer need to declare that we use some puny s in the method, hence we just press DEL and we can go along into the beatiful world of FUNCTIONAL PROGRAMMING.

So let's try to call this function, but the question raises how to do it?

palindrome("superpalindrome") == False

It does not compile though, because it thinks we are trying to give the palindrome method some kind of an argument while the definition has none at all. So the correct call of the function should be

palindrome()("superpalindrome") == False

In short, this is just magic, lambda expressions are actually in most cases worse in case of time usage, so you should stick to doing stuff in a OOP way or even else pythonic way. If you want to use lambda expressions you should try switching to Haskell(which I strongly advise) or Scala. If you have any further questions, feel free to ask me, I love talking about Haskell. Or FUNCTIONAL PROGRAMMING.

Full answer that is even more simplified

def palindrome():
    return lambda some_str : some_str.lower() == some_str.lower()[::-1]

method = palindrome()

print(method("cococ"))

Answer 5

Maybe you wanted this:

(lambda lstr : lstr == lstr[::-1])((lambda x : x.lower())('abA'))