Home / Questions / 216587
Accepted
Jesus_jbs
Asked: 2020-11-25 01:08:48 +0800 CST 2020-11-25 01:08:48 +0800 CST

How do "key" and "lambda" work in "max()" or "min()" functions?

  • 772

I would like to understand the operation and creation of "keys" or "lambdas" that can condition the functions max()or min(), applied to lists, dictionaries or tuples.

An example of what I mean would be:

def pais_mas_bienes(registros, tipo_bien='Cultural'):
    ''' Calcula el país con mayor número de bienes de un tipo dado
        Devuelve una tupla con el número de bienes y el nombre del país
        
        ENTRADA:
        - registros: lista de tuplas con información de bienes -> [(id, name, year, category, country)]
        - tipo_bien: el tipo de bienes para el que se realizará la operación -> str
        
        SALIDA:
        - Tupla con el número de bienes y el nombre del país -> (int, str)
    '''
    tuplas = list(indexa_por_paises(registros, tipo_bien).items())
    filtro = max(tuplas, key = lambda x: len(x[1]))
    contador = filtra_por_pais_bienes(registros, filtro[0], tipo_bien)
    result = (contador, filtro[0])
    return result

And the helper functions used:

def indexa_por_paises(registros, tipo_bien):
    result = {}
    for i in registros:
        if i[3] == tipo_bien and i[4] in result:
            result[i[4]] += [i]
        if i[3] == tipo_bien and i[4] not in result:
            result[i[4]] = [i]
    return result

def filtra_por_pais_bienes(registros, pais, tipo_bien):
    result = [i for i in registros if i[3]==tipo_bien and i[4]==pais]
    return len(result)
python

1 Answers

  1. Best Answer

    The functions max()and min(), as well as the function sorted()need to know how to compare two values, to determine in what order to put them and therefore which is the maximum or the minimum.

    By default Python already has ways to compare the basic types (integer, string, tuple, etc.). For your own types (classes) the class can incorporate a method .__lt__()that is evaluated to do the comparison <, and if it is the case that the class embeds those methods, sorted(), max()and min()will use them for sorting.

    In case you want to override python's default rules (or those built into the class's method) .__lt__(), you can provide a parameter called keyto these functions.

    That parameter is the name of another function that you must program separately, or one lambdaif the function is so simple that it merely consists of returning an expression. Whether it is a function or one lambda, its operation is the same:

    • Receive a parameter that is an element of the list you are sorting
    • Returns a value that can be an integer, string, tuple, or one of the types that python already knows how to sort by. That value represents the "order value" of that element.

    Python calls your function keyfor each element of the list that it wants to sort, and sorts it according to the value returned by the key. It is as if it had transformed all the elements of your list into others (the ones that return key), sorted those others, and then replaced each one with its original value.

    An example (list of tuples)

    Imagine that your elements are tuples. By default python already knows how to order them and its method is to order according to the value of the first element of the tuple, and if they are equal by the second, etc. So:

    mis_datos = [(1,20), (5,3), (3,1), (2, 10)]
print("Ordenada: ", sorted(mis_datos))
print("Maximo: ", max(mis_datos))

    Ordenada:  [(1, 20), (2, 10), (3, 1), (5, 3)]
Maximo:  (5, 3)

    But it turns out that we want it to sort by the second element . We then need to make a function that will receive each tuple and return the second element, for example like this:

    def get_segundo_elemento(tupla):
    return tupla[1]

    Using this function like key:

    print("Ordenada: ", sorted(mis_datos, key=get_segundo_elemento))
print("Maximo: ", max(mis_datos, key=get_segundo_elemento))

    Ordenada:  [(3, 1), (5, 3), (2, 10), (1, 20)]
Maximo:  (1, 20)

    In this case the function is very simple, in other cases it could contain inside conditionals, loops or whatever you need to compute a "sort value". In cases as simple as these it may not be worth defining a function and inventing a name for it, especially if you're not going to use it anywhere else. You can use a lambda expression instead:

    print("Ordenada: ", sorted(mis_datos, key=lambda x: x[1]))

    Moreover, for this particular case you don't even need to write the function, since it is such a common case that python already provides functions for it in its module operator.

    from operator import itemgetter
print("Ordenada: ", sorted(mis_datos, key=itemgetter(1)))

    Here the syntax can be more confusing, because it itemgetter(1)is a function that, when executed, returns another function , which expects a list or tuple as a parameter, and will return its element with index 1. Personally, I find the lambda expression clearer , but it is convenient know the existence of the possibilities that it offers you operatorfor functional programming.

    Another example (list of dictionaries)

    To compare dictionaries, python does not have a default method, so in this case it is essential to give it a key. The most typical case is that you want to sort the list by a particular field in the dictionary. The mechanism is similar to that seen for the tuple. For example:

    mis_datos = [
    { "nombre": "Juan", "edad": 40},
    { "nombre": "Arturo", "edad": 49 },
    { "nombre": "Javier", "edad": 61 },
    { "nombre": "Rodrigo", "edad": 45 }]

sorted(mis_datos, key=lambda x: x["nombre"])
sorted(mis_datos, key=lambda x: x["edad"])

    Or if you prefer:

    sorted(mis_datos, key=itemgetter("nombre"))
sorted(mis_datos, key=itemgetter("edad"))

    Note however that all elements of the list are assumed to be dictionaries that have the key in question.

    If you have particular doubts about how to define a function keyfor your particular list, ask again giving information about what the elements of the list are like and what sorting you would like for them.

    • 5