web-dev-qa-db-fra.com

Dans quel cas utiliserais-je un Tuple comme clé de dictionnaire?

J'étudiais la différence entre les listes et les tuples (en Python). Une évidence est que les tuples sont immuables (les valeurs ne peuvent pas être modifiées après l'affectation initiale), tandis que les listes sont mutables.

Une phrase dans l'article m'a fait:

Seuls les éléments immuables peuvent être utilisés comme clés de dictionnaire, et donc seuls les tuples et non les listes peuvent être utilisés comme clés.

J'ai du mal à penser à une situation où je voudrais utiliser un Tuple comme clé de dictionnaire. Pouvez-vous fournir un exemple de problème où ce serait la solution naturelle, efficace, élégante ou évidente?

Modifier:

Merci pour vos exemples. Jusqu'à présent, je considère qu'une application très importante est la mise en cache des valeurs de fonction.

pythonlistdictionarytuples
60
Escualo

Exemple classique: vous souhaitez stocker la valeur du point en tant que Tuple de (x, y)

94
Imran
salaries = {}
salaries[('John', 'Smith')] = 10000.0
salaries[('John', 'Parker')] = 99999.0

EDIT 1 Bien sûr, vous pouvez faire salaries['John Smith'] = whatever, Mais ensuite vous devrez faire un travail supplémentaire pour séparer la clé en prénom et nom. Qu'en est-il de pointColor[(x, y, z)] = "red", ici l'avantage de la touche Tuple est plus important.

Je dois souligner que ce n'est pas la meilleure pratique. Dans de nombreux cas, vous feriez mieux de créer des classes spéciales pour gérer de telles situations, mais Arrieta a demandé des exemples, que je lui ai donnés.

MODIFIER

Soit dit en passant, chaque élément Tuple doit également être lavable:

>>> 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
>>>
25
Boris Gorelik

J'utilise Tuple beaucoup de temps comme clé dict par exemple.

  • Je les utilise quand je dois créer une clé unique à partir de plusieurs valeurs, par exemple.

    basé sur first_name, la clé last_name pourrait être clé = '%s_%s'%(first_name, last_name) mais la meilleure façon est key = (first_name, last_name) car

    1. C'est un calcul plus lisible, plus court et moins
    2. Il est plus facile de récupérer les valeurs individuelles
    3. Plus important encore, key = '%s_%s'%(first_name, last_name) est incorrect et peut ne pas donner de clés uniques pour toutes les valeurs de first_name Et last_name Par exemple lorsque les valeurs contiennent _

  • Mise en cache des résultats d'une fonction

    def func(a1, b1):
    if (a1,b1) in cache: return cache[(a1,b1)]
    ...
8
Anurag Uniyal

Vous utilisez des tuples comme clés lorsque vous souhaitez afficher plusieurs éléments qui forment une clé ensemble.

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

Ici, si nous utilisons x-coordinate ou y-coordinate séparément, nous ne représenterions pas ce point.

5
Ani Menon

J'ai utilisé des tuples comme clés de dictionnaire dans une application qui compare les périphériques réseau par emplacement géographique. Étant donné que les périphériques sont nommés de manière similaire pour chaque emplacement, cela fournit un moyen naturel de savoir si un périphérique correspondant à cet appariement a encore été vu lors du traitement de multiples.

c'est à dire.

seen = {}
seen[('abc', 'lax')] = 1
seen[('xyz', 'nyc')] = 1
4
jathanism

Dans le contexte du Machine Learning et du Deep Learning, si vous effectuez une recherche hyperparamétrique pour le meilleur hyperparamètres, alors l'utilisation de tuples comme clés est certainement super utile.

Supposons que vous recherchez la meilleure combinaison d'hyperparamètres pour learning_rate, regularization_factor, et model_complexity.

Ensuite, vous pouvez avoir un dictionnaire en Python où vous faites la combinaison différente que ces hparams peuvent prendre comme clés et leurs matrices de poids correspondantes de l'algorithme de formation comme valeurs

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

Ces matrices de poids sont en outre nécessaires pour effectuer des prévisions en temps réel.

2
kmario23

Vous pouvez l'utiliser pour une recherche à temps constant approximatif d'un point dans l'espace de recherche. Par exemple, vous pouvez l'utiliser pour un problème de satisfaction de contrainte, où chaque tuple peut contenir des contraintes. La contrainte peut être de la forme (v1.v2) où color (v1)! = Color (v2) pour colorier prob, etc. En utilisant des tuples comme clés de dictionnaire, vous pourrez dire en temps constant si une permutation satisfait ou non à une contrainte .

2
Bhavya Ghai

Je suppose que dans le cas du tri, il pourrait être utile d'utiliser un tuple. Par exemple, supposons que la clé du dictionnaire représente un champ de tri (il y aurait évidemment un champ de tri par défaut pour empêcher que la clé soit None). Si vous aviez besoin de plusieurs champs de tri, comme le tri par nom de famille, puis par prénom, l'utilisation d'un Tuple comme clé de dictionnaire ne serait-elle pas une bonne idée?

Bien sûr, une telle idée peut avoir une utilité limitée, mais cela ne signifie pas qu'elle est complètement inutile.

2
Dustin

Vous pouvez l'utiliser pour l'analyse en entonnoir si vous créez un outil d'analyse de base.

Par exemple, en comptant combien de personnes ont cliqué sur l'image3 après avoir survolé le texte2.

    funnels = defaultdict(int)
    funnels[('hovered_text2', 'clicked_image3')] += 1
1
bit2pixel
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()
1
John
a[("John", "Doe")] = "123 Fake Street"
1
tkerwin