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 are correct that the lambda function you defined will be applied to all the keys, however that does not mean that min will return whatever your lambda function may return.

Perhaps it's helpful to spell out the line

min(prices, key=lambda k: prices[k])

in words:

"Find the minimum of the iterable prices (the dictionary keys¹), as if each key k had the value prices[k]."

If you want the associated value, you can use the returned key to access prices

>>> prices[min(prices, key=lambda k: prices[k])]
>>> 10.75

or much shorter:

>>> min(prices.values())
>>> 10.75

¹ Because a dictionary is an iterable of keys (list(prices) gives a list of keys).

Your key function key=lambda x: x > 0 just evaluates to a Boolean. You can see this you you write it out in a loop:

lst = [10, -5, 20, 1]
for item in lst:
    print(item > 0)

Booleans are subclasses of integers, so the conversion is easy:

lst = [10, -5, 20, 1]
for item in lst:
    print(int(item > 0))

Guess what; -5 is the only value that returns False (0) so that's the result you get as the minimum (that was your key).

You could filter this list but, really, you'd just be better re-building it with positive elements and then using min() without a key, to be clear on what you're doing:

lst = [10, -5, 20, 1]
lst = [item for item in lst if item > 0]
print(min(lst))

The code is using the min builtin function, but with a key parameter. Thus, it does not return the actual minimum element of the list, but the element for which that key function is minimal, i.e. it behaves more like "arg-min" than actually "min".

In the key function (defined as a lambda expression), abs is just the absolute difference, in this case between the parameter x (a number from the list) and 5.

That line is somewhat equivalent to, but much shorter and more readable than, this loop:

a = [1,3,4,7,8,9,12,13,14]
b = min_k = None
for x in a:
    k = abs(x-5)
    if min_k is None or k < min_k:
        b, min_k = x, k