My goal is to do the following:
Evaluate the existing dictionary using [key(string), item(int), format] and find the item in the dictionary with highest value in key-value pair.
Output the corresponding item (i.e. key value) with the highest value
For example consider the following code:
emails={}
emails={'abc#abc.org':1, 'bcd#bcd.org':2, 'efg#efg.org':3'}
The output should be, in the above example, ('efg#efg.org', 3)
Thank you for your time.
If you want the max evaluated by value then you can do
>>> max(emails.items(), key=lambda x:x[1])
('efg#efg.org', 3)
This solution finds the key with the maximum value; you can then access the dictionary with that key if you want the (key, value) pair.
>>> k = max(emails, key=emails.get)
>>> (k, emails[k])
('efg#efg.org', 3)
Related
I am looking to solve a problem to compare the string of the key and value of the same dictionary.
To return a dictionary of all key and values where the value contains the key name as a substring.
a = {"ant":"antler", "bi":"bicycle", "cat":"animal"}
the code needs to return the result:
b = {"ant":"antler", "bi":"bi cycle"}
You can iterate through the dictionary and unpack the key and the value at the same time this way:
b = {}
for key, value in a.items():
if value in key:
b[value] = key
This will generate your wanted solution. It does that by unpacking both the key and the value and checking if they match afterward.
You can also shorten that code by using a dictionary comprehension:
b = {key:value for key, value in a.items() if key in value}
This short line does the exact same thing as the code before. It even uses the same functionalities with only one addition - a dictionary comprehension. That allows you to put all that code in one simple line and declare the dictionary on the go.
answer = {k:v for k,v in a.items() if k in v}
Notes:
to iterate over key: value pair we use dict.items();
to check if a string is inside some other string we use in operator;
to filter items we use if-clause in the dictionary comprehension.
See also:
about dictionary comprehensions
about operators in and not in
There exists a dictionary.
my_dict = {'alpha':{'a':1, 'b':2, 'c':3}}
How to return a single list with one key inside which refers to the greatest value. If there are multiple occurrences of the greatest value then return a list with keys of similar value.
You can use max to get the maximum value, and extract the keys that has that value:
max_value = max(my_dict['alpha'].values())
print([key for key, value in my_dict['alpha'].items() if value == max_value])
When we iterate over the dictionary below, each iteration returns(correctly) a key,value pair
for key, value in dict.items():
print "%s key has the value %s" % (key, value)
'some key' key has the value 'some value' (repeated however many times there are a k,v pair)
The above makes sense to me, however if we do this:
for key in dict.items():
print "%s key has the value %s" % (key, value)
("some key", "some value") has the value "some value" (the left tuple will iterate through each key value pair and the right value will just stay at the first value in the dict and repeat)
We end up getting each k,v pair returned in the first %s (key) and the 2nd %s (value) does not iterate, it just returns the first value in the dict for each iteration of the for loop.
I understand that if you iterate with only for key in dict then you are iterating over the keys only. Here since we are iterating a set of tuples (by using dict.items()) with only the key in the for loop, the loop should run for the same number of times as the first example, since there are as many keys as key,value pairs.
What I'm having trouble grasping is why python gives you the entire tuple in the second example for key.
Thanks for the help all -- I'd like to add one more question to the mix.
for a,a in dict.items():
print a
Why does the above print the value, and if i print a,a - obviously both values are printed twice. If I had typed for a,b I would be iterating (key,value) pairs so I would logically think I am now iterating over (key,key) pairs and would therefore print key rather than value. Sorry for the basic questions just playing around in interpreter and trying to figure stuff out.
The first example is utilizing something known as "tuple unpacking" to break what is REALLY the same tuple as in your separate example down into two different variables.
In other words this:
for key, value in dict.items():
Is just this:
for keyvalue in dict.items():
key, value = keyvalue[0], keyvalue[1]
Remember that a for loop always iterates over the individual elements of the iterator you give it. dict.items() returns a list-like object of tuples, so every run through the for loop is a new tuple, automatically unpacked into key, value if you define it as such in the for loop.
It may help to think of it this way:
d = {'a':1, 'b':2, 'c':3}
list(d) # ['a', 'b', 'c'] the keys
list(d.keys()) # ['a', 'b', 'c'] the keys
list(d.values()) # [1, 2, 3] the values
list(d.items()) # [('a',1), ('b',2), ('c',3)] a tuple of (key, value)
N.B. that the only reason your code
for key in dict.items():
print "%s key has value: %s" % (key, value)
Does not throw a NameError is because value is already defined from elsewhere in your code. Since you do not define value anywhere in that for loop, it would otherwise throw an exception.
In the second example you gave you are not assigning "value" to anything:
Notice the small edit here:
for key in dict: ##Removed call to items() because we just want the key,
##Not the key, value pair
value = dict[key] # Added this line
print "%s key has the value %s (key, value)
Note:
In the second example, you could now call dict.keys() or just dict (referencing a dictionary in a for loop will return it's keys). Calling dict.items() will confusingly assign
key=(, )
which is probably not what you want.
I worked to access the item in ordered dictionary. d is the ordered dictionary:
print d.items()
Here the output is a pair. I want to access the key and value in this pair.
You can unpack the key, value (a tuple) as below:
for key, value in d.items():
print (key)
print (value)
This works both on python 2 and 3.
From docs:
Return a new view of the dictionary’s items ((key, value)
pairs).
Each "pair" in d.items() is a tuple (ordered, immutable sequence) (key, value). You can "unpack" the values in each tuple into separate names, for example in a for loop:
for key, value in d.items():
I have a simple question (or so I thought).
I have a dictionary, lets say it looks like this:
dict = {'A':100, 'a':10, 'T':50, 't':5}
I simply want to delete the key with the highest value. I tried this:
del max(dict.values())
and this is the error message: 'Syntax Error: can´t delete function call'.
I want the end result to be:
dict = {'a':10, 'T':50, 't':5}
You need to get a hold of the key to the max value.
Try this instead:
del d[max(d, key=d.get)]
Also, you should avoid calling your variable dict because it shadows the built-in name.
max(d.values()) will give you the maximum value (100), but to delete an entry from a dictionary you need the corresponding key ('A').
You can do this:
d = {'A':100, 'a':10, 'T':50, 't':5}
key_to_delete = max(d, key=lambda k: d[k])
del d[key_to_delete]
By the way, you shouldn't name your dictionary dict because that's the name of a built-in type.
If there may be multiple entries with the same maximum value and you want to delete all of them:
val_to_delete = max(d.values())
keys_to_delete = [k for k,v in d.iteritems() if v==val_to_delete]
for k in keys_to_delete:
del d[k]