具有与键对应的多个唯一值的 Python 字典

Question

I have 2 lists which correspond to what I would like to be my key:value pairs, for example:

list_1 = [1,1,1,1,1,1,1,1,1,2,2,2,2,2,2] #(key)

list_2 = [x,x,x,y,g,r,t,w,r,r,r,t,f,c,d] #(value)

I've (kind of) been able to create a dictionary via: dict = dict(zip(list_1, [list_2]))

However the problem with this is that it is only picking up '1' as a key and also results in duplicate entries within the list of values for the key.

Can anyone suggest a way to create a dictionary so that only the unique values from list_2 are mapped to their corresponding key?

Thanks

EDIT:

output I'm looking for would be one dictionary keyed by 1 and 2 with lists as values containing only the unique values for each ie:

dict = {1: [x,y,g,r,t,w], 2: [r,t,f,c,d]}

Answer 1

Since a dictionary is a set it cant contain twice the same key but it can have the key once then a list of value for that you can use the one-line method

my_dict = {key:[list_2[i] for i in range(len(list_2)) if list_1[i]==key] for key in set(list_1)}

Or a more classic method

my_dict = {}
for key_id in range(len(list_1)):
    if list_1[key_id] not in my_dict:
        my_dict[list_1[key_id]] = []
    my_dict[list_1[key_id]].append(list_2[key_id])

In both case the result is

my_dict = {1: ['x', 'x', 'x', 'y', 'g', 'r', 't', 'w', 'r'], 2: ['r', 'r', 't', 'f', 'c', 'd']}

Answer 2

This sort of problem is properly solved with a collections.defaultdict(set) ; the defaultdict gives you easy auto-vivificaction of set s for each key on demand, and the set uniquifies the values associated with each key:

from collections import defaultdict

mydict = defaultdict(set)
for k, v in zip(list_1, list_2):
    mydict[k].add(v)

You can then convert the result to a plain dict with list values with:

mydict = {k: list(v) for k, v in mydict.items()}

If order of the values must be preserved, on modern Python you can use dict s instead of set (on older Python, you'd use collections.OrderedDict ):

mydict = defaultdict(dict)
for k, v in zip(list_1, list_2):
    mydict[k][v] = True  # Dummy value; we're using a dict to get an ordered set of the keys 

with the conversion to plain dict with list values being unchanged

If the input is already sorted, itertools.groupby is theoretically slightly more efficient (it's actual O(n) , vs. average case O(n) using dict s), but in practice the defaultdict is typically as faster or faster (the implementation of groupby has some unavoidable inefficiencies). Just for illustration, the groupby solution would be:

from itertools import groupby
from operator import itemgetter

mydict = {k: {v for _, v in grp} for k, grp in groupby(zip(list_1, list_2), key=itemgetter(0))]

# Or preserving order of insertion:
getval = itemgetter(1)  # Construct once to avoid repeated construction
mydict = {k: list(dict.fromkeys(map(getval, grp)))
          for k, grp in groupby(zip(list_1, list_2), key=itemgetter(0))]

Answer 3

The problem is your key is too unique. there're only two unique keys 1 and 2. So if you're creating dictionaries you can't have {1:x, 1:y} at same time for example, unless you change the key to something new and unique.

I would use a tuple in your purpose:

list(set(tuple(zip(list_1, list_2))))

The set gives you unique mappings which is what dropping the duplicates.

Answer 4

keys = [1,1,1,1,1,1,1,1,1,2,2,2,2,2,2] 

values = ['x','x','x','y','g','r','t','w','r','r','r','t','f','c','d'] 

result = {}

for key,value in  zip(keys,values):

  if key not in result:

    result[key] = []
    if value not in result[key]:
      result[key].append(value)
  else:

    if value not in result[key]:
      result[key].append(value)


print(result)

{1: ['x', 'y', 'g', 'r', 't', 'w'], 2: ['r', 't', 'f', 'c', 'd']}

Note:

zip(keys,values) this will create a iterable of tuples, each tuple consist of one element from the keys and values.

(1,'x')
(1,'x')