检查字典中是否已经存在两个数字作为一个键（Python）

Question

I'm trying to store the LCM of two numbers in a dictionary to perform the calculation only if it has not been completed yet aka is already stored in the dictionary. I take the numbers a and b as key and try to check in my code if they already exist as key. Exactly there it fails with me, because I don't know, how I should define the two numbers as a key. It should not matter if a=7 , b=8 or a=8 and b=7. Thanks for the help! The exact position is marked in the code

a = int(input("Give A: "))
b = int(input("Give B: "))

dic = {}





while a != 0 and b != 0:

#my problem is here!
    
    if (a,b)in dic.keys():
        print("Found in dictionary!")
        print("LCM for ", a, " and ", b, " is ", dic[a,b])
        
        a = int(input("Give A: "))
        b = int(input("Give B: "))
        
   # choose the greater number
   
   
   
    else:
        if a > b:
            greater = a
        else:
            greater = b

        while(True):
            if((greater % a == 0) and (greater % b == 0)):
                lcm = greater
                #adding lcm to dic with the keys a and b
                dic[a,b] = (lcm)
                print ("Not found in dictionary!")
                print("LCM for ", a, " and ", b, " is ", dic[a,b])
                break
                
            else:           
                greater += 1
                
        a = int(input("Give A: "))
        b = int(input("Give B: "))
        
    
        
print ("Terminated + the values added so far were: " , dic)

Answer 1

If you want to compare collections where order doesn't matter, a set is usually what you want. set(a, b) is equal to set(b, a)

However, sets are unhashable types, so you won't be able to use them as dictionary keys. Instead, you can use a frozenset, which will work the same, but its immutable. Because it is immutable, it will be a hashable type, and can be used as a dictionary key.

https://docs.python.org/3/library/stdtypes.html#frozenset

Note that this will be slightly weird if a == b. Sets only store unique values, so set(5, 5) will be equal to set(5). This will still be mathematically correct in your use case, since lcm(5, 5) is the same as lcm(5), but its something to keep in mind if eg. The number of elements in the collection is relevant

Answer 2

I think the best way of storing data will be in list. If you are not forced to use dictionary in some way, just don't. Put dict away in this case. You don't need to have variable a and b as key. Just simple create a nested list (eg data = [[7, 8, 56], [6, 5, 30]] ).

First create variable where you will be storing input data. Then, if variable does not contain new input simply add it in a format [a, b, lcm] .

a = int(input("Give A: "))
b = int(input("Give B: "))

data = []

while a != 0 and b != 0:

    match = False   
    for item in data:   # iterate list

        if item[0] == a and item[1] == b:   # if match, store lcm
            match = item[2]
            break
    
    if match:
        print("Found in dictionary!")
        print("LCM for ", a, " and ", b, " is ", match)
        
        a = int(input("Give A: "))
        b = int(input("Give B: "))
        

    else:
        if a > b:
            greater = a
        else:
            greater = b

        while(True):
            if((greater % a == 0) and (greater % b == 0)):
                lcm = greater
                data.append([a, b, lcm])    # Append to the list

                print("Not found in dictionary!")
                print("LCM for ", a, " and ", b, " is ", lcm)
                break
                
            else:           
                greater += 1
                
        a = int(input("Give A: "))
        b = int(input("Give B: "))
        
    
        
print ("Terminated + the values added so far were: " , data)

Hope it helped!

Answer 3

Dunno the best answer, but I'd suggest using a dict subclass for this. Something like this:

class SortedTupleDict(dict):

    def __setitem__(self, key, value):
        super().__setitem__(tuple(sorted(key)), value)

    def __getitem__(self, item):
        return super().__getitem__(tuple(sorted(item)))

    def __contains__(self, item):
        return super().__contains__(tuple(sorted(item)))


d = SortedTupleDict()
d[(3, 1)] = 'test'
print(d)  # {(1, 3): 'test'}

# True
assert d[(3, 1)] == d[(1, 3)] == 'test'
assert (3, 1) in d

What it's doing here is sorting the elements in the tuple from lowest to highest, so (4, 1, 2) is stored as (1, 2, 4) . Then when retrieving an item by a key, it sorts the tuple and then looks it up in the dict object.