在什么情况下，我会使用元组作为字典键？

我当时正在学习 列表和元组之间的区别(Python 语言)。一个明显的问题是元组是不可变的(初始赋值后不能更改值) ，而列表是可变的。

文章中的一句话让我想到:

只有不可变元素可以用作 字典键，因此只有元组 而不是列表可以用作键。

我很难想象使用元组作为字典键的情况。您能否提供一个示例问题，其中这将是自然的、高效的、优雅的或明显的解决方案？

编辑:

谢谢你的例子。到目前为止，我认为一个非常重要的应用是函数值的缓存。

101729 次浏览
小开 
a[("John", "Doe")] = "123 Fake Street"
小开 
salaries = {}
salaries[('John', 'Smith')] = 10000.0
salaries[('John', 'Parker')] = 99999.0

EDIT 1 Of course you can do salaries['John Smith'] = whatever, but then you'll have to do extra work to separate the key into first and last names. What about pointColor[(x, y, z)] = "red", here the benefit of tuple key is more prominent.

I must stress out that this is not the best practice. In many cases you better create special classes to handle situations like that, but Arrieta asked for examples, which I gave her (him).

EDIT 0

By the way, each tuple element has to be hashable too:

>>> d = {}
>>> t = (range(3), range(10, 13))
>>> d[t] = 11
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: list objects are unhashable
>>>
小开
最佳答案

Classic Example: You want to store point value as tuple of (x, y)

小开

I suppose in the case of sorting, there could be merit in using a tuple. For example, suppose the dictionary key represents a sort field (obviously there would be a default sort field to prevent the key from being None). If you needed multiple sort fields, such as the case of sorting by last name, then first name, wouldn't using a tuple as the dictionary key be a good idea?

Sure, such an idea might have limited use, but that doesn't mean it is completely useless.

小开

I use tuple lots of time as dict key e.g.

  • I do use them when I have to create a unique key from multiple values e.g.

    based on first_name, last_name key could be key = '%s_%s'%(first_name, last_name) but better way is key = (first_name, last_name) because

    1. It is more readable, shorter and less computation
    2. It is easier to retrieve the individual values
    3. Most importantly key = '%s_%s'%(first_name, last_name) is wrong and may not give unique keys for all values of first_name and last_name e.g. when values contain _

  • Caching the results of a function 

    def func(a1, b1):
if (a1,b1) in cache: return cache[(a1,b1)]
...
小开

I used tuples as dictionary keys in application that compares network devices by geographical location. Since the devices are named similarly for each location, it provides a natural way to know if a device matching that pairing has been seen yet while processing multiples.

i.e.

seen = {}
seen[('abc', 'lax')] = 1
seen[('xyz', 'nyc')] = 1
小开

You can use it for funnel analysis if you are building a basic analytics tool.

For example, counting how many people clicked the image3 after hovering on text2.

    funnels = defaultdict(int)
funnels[('hovered_text2', 'clicked_image3')] += 1
小开 
def getHash(word):
result={}
for i in range(len(word)):
if word[i] in result:
result[word[i]]+=1
else :
result[word[i]]=1


return tuple (sorted((result.items())))




def groupAnagrams(words):
resultHash={}
for i in range(len(words)):
s=getHash(words[i].lower())
#print s
if s in resultHash :
l=list(resultHash[s])
l.append(words[i])
resultHash[s] = l # list(resultHash[s]).append(words[i])
else :
resultHash[s]=[words[i]] # Creating list


return resultHash.values()
小开

You use tuples as keys when you want to show multiple elements which form a key together.

Eg: {(<x-coordinate>,<y-coordinate>): <indicating letter>}

Here if we use x-coordinate or y-coordinate separately, we wouldn't be representing that point.

小开

You can use it for approx constant time search of a point in search space. For example you can use it for constraint satisfaction problem, where each tuple might contain some constraints. Constraint might be of the form (v1.v2) where color(v1)!=color(v2) for coloring prob, etc. Using tuples as dictionary keys, you will able to tell in constant time whether a permutation satisfies a constraint or not.

小开

In the context of Machine Learning and Deep Learning, if you're doing hyperparameter search for the best hyperparameters, then using tuples as keys is definitely super useful.

Let's say you're searching for the best hyperparameter combination for learning_rate, regularization_factor, and model_complexity.

Then you can have a dictionary in Python where you make the different combination that these hparams can take as keys and their corresponding weight matrices from the training algorithm as values

hparams_hist = {}
hparams_hist[(0.001, 0.7, 5)] = weight_matrix1
hparams_hist[(0.0001, 0.8, 2)] = weight_matrix2

These weight matrices are further needed to make realtime prediction.

小开

I think tuples as dictionary keys will be good, if we are storing :-

  1. Some points in the coordinate system.

  2. helps in flag the position of the matrix that you want in the next iteration. for eg:-

    flag = {(0,1): True, (1,0) = False}

小开

Suppose dictionary contain your subjects and marks.if you have same marks in two subjects so we can use tupple.

D = {}

D[('math','history')] = 74


提交答案