Given a dictionary myDictionary, write a function that prints all of the key/value pairs of the dictionary, one per line, in the following format:
key: value
key: value
key: value
Use the following function header:
def printKeyValuePairs(myDictionary):
For example, if
myDictionary = {'The Beatles':10, 'Bob Dylan':10, 'Radiohead':5}
your function would print
The Beatles: 10
Bob Dylan: 10
Radiohead: 5
for key in myDictionary:
print("{}: {}".format(key, myDictionary[key]))
I read on SO somewhere there is a good reason not to either access dictionary values using myDictionary[key] over the following, or visa-versa, but I can't recall where (or if I'm remembering correctly).
for key, value in myDictionary.items():
print(f"{key}: {value}")
There are essentially two (modern) ways to do string formatting in Python, both covered in great detail [here][1]:
"var1: {}, var2: {}".format("VAR1", "VAR2")
f"var1: {"VAR1"}, var2: {"VAR2"}"
Both yield var1: var1, var2:VAR2, but the latter is only supported in Python 3.6+.
here is a simple function that prints all the key value pairs in a dictionary:
def printKeyValuePairs(myDictionary):
"""prints each key, value pair in a line"""
for key, val in myDictionary.items():
print("{}: {}".format(key, val))
if the a dictionary has the following key, value pairs:
my_dict = {'The Beatles':10, 'Bob Dylan':10, 'Radiohead':5}
if we call the function defined above, we get the following output:
printKeyValuePairs(my_dict)
The Beatles: 10
Bob Dylan: 10
Radiohead: 5
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
Let's say we have a dict and specified function which takes two parameters as input
foo = {'key1':'value1', 'key2':'value2'}
def bar(key, value):
print key, value
Is is possible to call this function for every key value pair in one liner?
I know that I can do it in list/dict comprehension but I think this solution is not pythonic cause I dont return anyting in bar function. Is there any recommended and pythonic way to do that?
Use a for-loop over the .items method of the dictionary:
for item in foo.items():
bar(*item)
The * syntax unpacks the tuples (e.g. ('key1', 'value1')) into the arguments to a function. Note that you could do the unpacking in the for-loop too:
for k, v in foo.items():
bar(k, v)
Both of which give:
key2 value2
key1 value1
You may notice that they are in a different order to the order you defined them in. This is just an implicit feature of dictionaries - they have no (reliable) order. The reason I say "reliable" is because it is deterministic (based on each object's hash, but it is unwise to rely on this.
yes, you can with a tiny modification to your function
foo = {'key1':'value1', 'key2':'value2'}
def bar(pair):
key, value = pair
print key, value
With this function at hand, you can use map.
map(bar, foo.items())
that produces:
key2 value2
key1 value1
Quoting PEP-20
Simple is better than complex.
Read the Zen of Python
Keeping things simple, you could do something like -
def bar(key, value):
print key, value
for k, v in foo.items():
bar(k, v)
foo = {'key1':'value1', 'key2':'value2'}
def bar(key, value):
print key, value
[bar(key, value) for key,value in foo.items()]
I have the following data structure whereby I would like to extract a given key: value pair by searching for the specific value. Use Case: I need to extract u'LOB_B': u'mcsmsg.example.net' from the dict.
{u'status': u'successful',
u'availableFqdnList': [
{u'LOB_A': u'pcload.us.example.net'},
{u'LOB_B': u'mcsmsg.example.net'},
{u'LOB_B': u'gtxd.example.net'},
{u'LOB_B': u'diamond.example.net'}]}
for key, value in my_dict.values():
if value == 'mcsmsg.example.net':
print("Print key value pairs for available FQDN list")
print key, "=", value
Error = for key, value in my_dict.values():
ValueError: too many values to unpack
I don't think values() is the function you want.
Probably you want items() instead.
If you are using python2, you can using iteritems()
Or for python3, it's items()
They will iter the key, value in the dictionary for you.
dic = {'a':1,'b':2}
for key,value in dic.items():
print(key)
print(value)
it will return
a
1
b
2
As a simple to understand way of getting this done
d = {u'status': u'successful',
u'availableFqdnList': [{u'LOB_A': u'pcload.us.example.net'},
{u'LOB_B': u'mcsmsg.example.net'},
{u'LOB_B': u'gtxd.example.net'},
{u'LOB_B': u'diamond.example.net'}]}
for val in d['availableFqdnList']:
if val.values()[0] == "mcsmsg.example.net":
print("%s=%s" %(val.keys()[0], val.values()[0]))
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():