Python - how to take the max length from a value of dictionary? Without lambda-CodePudding

Let us say I have this function:

    def frequent_base(self):
        dict = {}    
        for i in range(len(self.items)):
            if self.items[i].base not in dict:
                dict[self.items[i].base] = [(self.items[i].value)]
            else:
                dict[self.items[i].base]  = [(self.items[i].base)]
        return max(len(dict[self.items]), key=len(d))

Now, I can make it complicated and build a function which returns me index and such..
but it is bad coding and bad habit and takes long time ( especially in a test ).
How do I take the length?
let us say I have:
key1 with length 3 of value ( key1 has 3 values )
key2 with length 4 of value ( key 2 has 4 values )
key3 with length 2 of value ( key 3 has 2 values )

How do I take, not the key itself, not the value itself, but the len of values of key? which is 4 in this case.
or how do I take the key itself and then say length of value of that key? But I want to use Max function, I need to understand how to use that function good, with the key.

I will write and make myself super clear:

dict[1] = [1,2,3]  
dict[2] = [1,2,3,4,5]  
dict[3] = [1,2,3,7,8,9,10]   
dict = {1: [1,2,3], 2:[1,2,3,4,5], 3:[1,2,3,7,8,9,10]}

I wish to return not dict[3], not 3, not the list of dict[3] it self.
I wish to return the length of the dict[3], which is 7

def frequent_base(self): dict = {} for i in range(len(self.items)): if self.items[i].base not in dict: dict[self.items[i].base] = [(self.items[i].value)] else:
dict[self.items[i].base] = [(self.items[i].base)] def key_for_len(dictionary): return dictionary[1] return max(dict.items(), key= key_for_len)

I am received error

CodePudding user response：

Only thing you seem to need is maximal length amongst the values of your dictionary. You can easily get all the values using d.values() (d.items() would give you (key, value) tuples, which are harder to compare). Now we can easily calculate lengths of each value with generator comprehension (very much like list comprehension, which would also work) - len(v) for v in d.values(). Now we have an iterable with all the lengths, so it's just a matter of finding the maximum -

max(len(v) for v in d.values())

Should you need to get key or value with maximum length, we'd have to take a slightly different approach - we can use max key = argument to specify how we decide which element in the iterable is maximal - it is obvious when we are trying to get a maximum from few numbers, but not when we try to decide if (1, 3) is bigger than (2, 2) - in such case, we need to create a function that maps our items to easily comparable things like a number. In this case, we'd have tuples of (key, value) and we are comparing length of value - thus our function would be

def lenOfValue(kv):
    return len(kv[1]) # kv[1] - 2nd element of a (key, value) tuple

code(1)

Then we pass that to max:

print(max(d.items(), key = lenOfValue))

And we get (2, [3, 4, 5, 6])

Bonus: lambda

Lambdas can be used here, which are really just a shorthand that lets us skip defining whole another function that we will probably never use again. This code would be functionally exactly the same.

print(max(d.items(), key = lambda kv: len(kv[1])))

code(2)

Lambdas are nothing very complicated, being just a notation for creating simple, one-liner functions without all the bother of a def block, return etc. Because Python's functions are objects like nearly anything else, this piece of code:

lenOfValue = lambda kv: len(kv[1])

really is in no way different that our previously used more lengthy definition of:

def lenOfValue(kv):
    return len(kv[1])

It saves us few words and shows us the middle step between code(1) and code(2).

CodePudding user response：

a_dict = {'some_key':[67,30,10], 'another_key':[87]}


max({ (k,len(v)) for k,v in a_dict.items() })

('some_key', 3)