列出由第一个项目分组的元组（用作Python字典键）中的第二个项目

Question

I have a dict of tuples: (port , freq).

d = {(0, 410): None, (1, 640): None, (2, 88): None, (2, 410): None, (0, 33): None}

I want to collect all tuples with the same port number, the frequencies for these are unique. I then want to list these frequencies.

If I can do this without having a value that would be great as it isn't needed, however port, freq must be unique and making them keys allowed me to achieve this.

I managed to list all the frequencies but this is not what I want.

_, freq = zip (*list( d.keys() ))

Can someone show me an efficient pythonic way to do this please?

Answer 1

zip ing is not an inefficient way of doing what you need.
A simple list comprehension would be sufficient:

freq = [x[1] for x in d]

Or:

import operator as op
freq = list(map(op.itemgetter(1), d))

Answer 2

the None valued dictionary seems awkward, a set works too

d = {(0, 410), (1, 640), (2, 88), (2, 410), (0, 33)}
type(d)
Out[410]: set

itertools groupby is the tool if standard libs are allowed

from itertools import groupby


grouped = [(k, *g) for k, g in groupby(sorted(list(d),
                                              key=lambda x: x[0]),
                                       key=lambda x: x[0])]
print(*grouped, sep='\n')
(0, (0, 410), (0, 33))
(1, (1, 640))
(2, (2, 88), (2, 410))

what I came up with for pulling apart the groupby structure seems ugly

[(b[0], list(b[-1])) 
 for b in [(a[0], *zip(*a[1:])) 
           for a in grouped ]]
Out[399]: [(0, [410, 33]), (1, [640]), (2, [88, 410])] 

Answer 3

This is exactly the kind of problem collections.defaultdict was created for.

This is how you would create a defaultdict that creates a new list when a missing key is accessed:

from collections import defaultdict as ddict

dd = ddict(list)

Now you can just populate your default dictionary with the second item from all your tuples:

for port, freq in d:
    dd[port].append(freq)

Done. This works because each time a missing key with the value of port is accessed, a new list is created, and then you just append to that list. If the key is already there, you just append to the existing list.

Now you can access all the frequencies for any given port:

print(dd[0])

Note: if your goal for your first data structure is to have a collection of unique tuples, instead of using a dictionary to hold your tuples I suggest using a set instead. A set is just that- a set of unique items, with no associated values to consider:

>>> s = {(0, 410), (1, 640), (2, 88), (2, 410), (0, 33)}
>>> type(s).__name__
'set'

Answer 4

A simple solution.

Let's make a dictionary where each key is the port and each value is a list of the frequencies, this allows you to sum them or operate on them as you like and gives you O(1) access to them!

#first let's make a dict of all the keys with empty lists
my_dict = dict.fromkeys( [str(x[0]) for x in d.keys()], [])

#now let's append those frequencies!
[my_dict[str(soc)].append(freq) for soc, freq in d.keys()]

note that this doesnt give you a sorted structure, but you can save a sockets list and use it for the from_keys method and have a sorted way of accessing sockets. eg

sockets = [str(x[0]) for x in d.keys()] #str() allows us to use an integer as a key, keep this in mind!

This however, makes it really easy to access all the different frequencies for a given socket, just like this:

my_dict['socket']

Interpreter copy paste demo:

>>> d = {(0, 410): None, (1, 640): None, (2, 88): None, (2, 410): None, (0, 33): None}
>>> my_dict = dict.fromkeys( [str(x[0]) for x in d.keys()], [])
>>> [my_dict[str(soc)].append(freq) for soc, freq in d.keys()]
[None, None, None, None, None]
>>> my_dict
{'0': [410, 640, 88, 410, 33], '1': [410, 640, 88, 410, 33], '2': [410, 640, 88, 410, 33]}
>>>

Note that this converts form the current format that you have (or edit your post and ping me :D). You can adapt whatever code you may have to get similar results and have equivalent level of happiness to access things. Keeping a sorted list of the keys makes life really easy. Python3 is supposed to keep dictionaries sorted by default now so don't take my word on it but if you use my_dict.keys() it should return them in a sorted way but I could be wrong about how that operates.

TakeAway

A dict of socket-> frequencies will be the easiest to deal with. An optional sorted list of sockets might help also