lambda is an anonymous function, it is equivalent to:

def func(p):
   return p.totalScore     

Now max becomes:

max(players, key=func)

But as def statements are compound statements they can't be used where an expression is required, that's why sometimes lambda's are used.

Note that lambda is equivalent to what you'd put in a return statement of a def. Thus, you can't use statements inside a lambda, only expressions are allowed.

What does max do?

max(a, b, c, ...[, key=func]) -> value

With a single iterable argument, return its largest item. With two or more arguments, return the largest argument.

So, it simply returns the object that is the largest.

How does key work?

By default in Python 2 key compares items based on a set of rules based on the type of the objects (for example a string is always greater than an integer).

To modify the object before comparison, or to compare based on a particular attribute/index, you've to use the key argument.

Example 1:

A simple example, suppose you have a list of numbers in string form, but you want to compare those items by their integer value.

>>> lis = ['1', '100', '111', '2']

Here max compares the items using their original values (strings are compared lexicographically so you'd get '2' as output) :

>>> max(lis)
'2'

To compare the items by their integer value use key with a simple lambda:

>>> max(lis, key=lambda x:int(x))  # compare `int` version of each item
'111'

Example 2: Applying max to a list of tuples.

>>> lis = [(1,'a'), (3,'c'), (4,'e'), (-1,'z')]

By default max will compare the items by the first index. If the first index is the same then it'll compare the second index. As in my example, all items have a unique first index, so you'd get this as the answer:

>>> max(lis)
(4, 'e')

But, what if you wanted to compare each item by the value at index 1? Simple: use lambda:

>>> max(lis, key = lambda x: x[1])
(-1, 'z')

Comparing items in an iterable that contains objects of different type:

List with mixed items:

lis = ['1','100','111','2', 2, 2.57]

In Python 2 it is possible to compare items of two different types:

>>> max(lis)  # works in Python 2
'2'
>>> max(lis, key=lambda x: int(x))  # compare integer version of each item
'111'

But in Python 3 you can't do that any more:

>>> lis = ['1', '100', '111', '2', 2, 2.57]
>>> max(lis)
Traceback (most recent call last):
  File "<ipython-input-2-0ce0a02693e4>", line 1, in <module>
    max(lis)
TypeError: unorderable types: int() > str()

But this works, as we are comparing integer version of each object:

>>> max(lis, key=lambda x: int(x))  # or simply `max(lis, key=int)`
'111'

You have to both filter and use a key argument to max:

from operator import itemgetter

max(filter(lambda a: a[2] >= 100, yourlist), key=itemgetter(1))

The filter can also be expressed as a generator expression:

max((t for t in yourlist if t[2] >= 100), key=itemgetter(1))

Demo:

>>> yourlist = [(1, 2, 300), (2, 3, 400), (3, 6, 50)]
>>> max((t for t in yourlist if t[2] >= 100), key=itemgetter(1))
(2, 3, 400)
>>> max(filter(lambda a: a[2] >= 100, yourlist), key=itemgetter(1))
(2, 3, 400)

Note that because you filter, it's easy to end up with an empty list to pick the max from, so you may need to catch ValueErrors unless you need that exception to propagate up the call stack:

try:
    return max(filter(lambda a: a[2] >= 100, yourlist), key=itemgetter(1))
except ValueError:
    # Return a default
    return (0, 0, 0)

There is really nothing wrong with the way you were going about this. You just needed to incorporate your lambda into the rest of your code in the right way:

myList = [1,2,3,10,4,5,6,7,8,9]

def maxVal(list_a, compare_function):
    max = -sys.maxsize - 1  # strange but true...this seems to be the canonical way to get the smallest 32 bit `int`
    for i in list_a:
        if compare_function(i, max):
            max = i
    return max

my_compare_function = lambda x,y: max(x, y)

print(maxVal(myList, my_compare_function))

Result:

10

I did have to change at what level return max was being called. I don't know if this was a logic error, or just a transcription error when you put your code into a S.O. question. Also note that I moved the 10 to a different place in your input data to make sure it didn't have to be at the end to be found to be the largest value.

If you want a "cooler" and more modern answer, reduce is really designed to do just what you want. Here's a simple solution.

import functools

myList = [1,2,3,10,4,5,6,7,8,9]
r =  functools.reduce(lambda v1, v2: max(v1, v2), myList)
print(r)

Result:

10

Also note that 'max' itself is a function that takes two parameters, so you could use it directly to get to something very simple...not that this works in your case where your assignment is to use a lambda:

myList = [1,2,3,10,4,5,6,7,8,9]
r =  functools.reduce(max, myList)
print(r)

These functional equivalents to writing loops are all the rage, and for good reason. When combined with processing data as streams, it's a super powerful idea. And as it becomes more popular, I think it will be thought to be more readable. As an old timer, I'm just getting on board with all of this functional/streams programming...more in Java than Python, but still. It's a powerful set of tools that would be to your benefit to really understand well.