Golang implémente le dictionnaire Python

En programmation, l'utilisation du dictionnaire Python est l'une des structures de données les plus courantes dont la fonction principale est de mapper les clés aux valeurs. Lorsque vous utilisez Golang, comme il s'agit d'un langage typé statiquement, il ne prend pas en charge les types de dictionnaire comme Python. Par conséquent, dans certains scénarios, il est nécessaire d’implémenter une structure de données similaire à un dictionnaire Python. Cet article explique comment implémenter le dictionnaire Python dans Golang.

1. Implémentation du dictionnaire Python

En Python, les dictionnaires sont principalement implémentés à l'aide de tables de hachage. La table de hachage a une efficacité de recherche de O(1). Lorsque des opérations telles que l'insertion, la suppression et la recherche sont requises, la table de hachage peut être complétée rapidement. Dans Golang, une structure de données similaire au dictionnaire en Python peut être implémentée via des structures et des cartes.

1. Basé sur l'implémentation de la structure

En définissant une structure qui contient une structure de données de paires clé-valeur, vous pouvez obtenir des fonctions similaires au dictionnaire en Python. Ensuite, implémentez les méthodes correspondantes, telles que les fonctions d'insertion, de suppression et de recherche, pour effectuer les opérations du dictionnaire.

type Dict struct {
    items map[interface{}]interface{}
}
 
func NewDict() *Dict {
    return &Dict{items: map[interface{}]interface{}{}}
}
 
func (d *Dict) Set(key, value interface{}) {
    d.items[key] = value
}
 
func (d *Dict) Get(key interface{}) (interface{}, bool) {
    value, ok := d.items[key]
    return value, ok
}
 
func (d *Dict) Remove(key interface{}) {
    delete(d.items, key)
}
 
func (d *Dict) Contains(key interface{}) bool {
    _, ok := d.items[key]
    return ok
}
 
func (d *Dict) Len() int {
    return len(d.items)
}

Dans le code ci-dessus, la structure Dict définit une carte de paires clé-valeur et implémente les méthodes Set, Get, Remove, Contains et Len. Parmi eux, la méthode Set est utilisée pour insérer des paires clé-valeur, la méthode Get est utilisée pour obtenir la valeur en fonction de la clé, la méthode Remove est utilisée pour supprimer la paire clé-valeur, la méthode Contains est utilisée pour déterminer si une certaine clé est contenue et la méthode Len est utilisée pour obtenir la longueur du dictionnaire.

2. Implémenté basé sur map

map est un type intégré dans Golang, et sa couche inférieure est également implémentée à l'aide d'une table de hachage. En utilisant le type map, vous pouvez également réaliser des fonctions similaires aux dictionnaires en Python.

type Dict map[interface{}]interface{}
 
func NewDict() Dict {
    return make(map[interface{}]interface{})
}
 
func (d Dict) Set(key, value interface{}) {
    d[key] = value
}
 
func (d Dict) Get(key interface{}) (interface{}, bool) {
    value, ok := d[key]
    return value, ok
}
 
func (d Dict) Remove(key interface{}) {
    delete(d, key)
}
 
func (d Dict) Contains(key interface{}) bool {
    _, ok := d[key]
    return ok
}
 
func (d Dict) Len() int {
    return len(d)
}

Dans le code ci-dessus, un alias Dict de type map[interface{}]interface{} est défini et les méthodes Set, Get, Remove, Contains et Len sont implémentées dans la structure. Parmi eux, la méthode Set est utilisée pour insérer des paires clé-valeur, la méthode Get est utilisée pour obtenir la valeur en fonction de la clé, la méthode Remove est utilisée pour supprimer la paire clé-valeur, la méthode Contains est utilisée pour déterminer si une certaine clé est contenue et la méthode Len est utilisée pour obtenir la longueur du dictionnaire.

2. Code de test

Ensuite, écrivons le code de test pour vérifier si le dictionnaire implémenté a la fonction correspondante.

func TestDict(t *testing.T) {
    // 基于结构体实现字典
    d := NewDict()
    d.Set(1, "hello")
    d.Set("world", "golang")
 
    if v, ok := d.Get(1); !ok || v != "hello" {
        t.Errorf("expect: hello but get: %v", v)
    }
 
    if v, ok := d.Get("world"); !ok || v != "golang" {
        t.Errorf("expect: golang but get: %v", v)
    }
 
    d.Remove("world")
    if d.Contains("world") {
        t.Errorf("should not contain key: world")
    }
 
    if d.Len() != 1 {
        t.Errorf("expect length: 1 but get: %v", d.Len())
    }
 
    // 基于map实现字典
    dict := NewDict()
    dict.Set(1, "hello")
    dict.Set("world", "golang")
 
    if v, ok := dict.Get(1); !ok || v != "hello" {
        t.Errorf("expect: hello but get: %v", v)
    }
 
    if v, ok := dict.Get("world"); !ok || v != "golang" {
        t.Errorf("expect: golang but get: %v", v)
    }
 
    dict.Remove("world")
    if dict.Contains("world") {
        t.Errorf("should not contain key: world")
    }
 
    if dict.Len() != 1 {
        t.Errorf("expect length: 1 but get: %v", dict.Len())
    }
}

Le code de test contient deux parties, correspondant au dictionnaire basé sur la structure et l'implémentation de la carte. Tout d’abord, insérez la paire clé-valeur dans le dictionnaire, puis récupérez la valeur et vérifiez si la valeur est correcte. Ensuite, supprimez une paire clé-valeur et vérifiez si la longueur du dictionnaire a changé.

3. Résumé

À travers les exemples ci-dessus, nous pouvons voir que l'utilisation de structures et de cartes dans Golang peut réaliser des fonctions similaires aux dictionnaires en Python. Les méthodes de mise en œuvre sont principalement basées sur la structure et basées sur la carte. Quelle que soit la méthode de mise en œuvre utilisée, il faut prêter attention aux problèmes tels que les conflits de hachage pour garantir sa stabilité et son efficacité. Dans le même temps, nous pouvons également mieux comprendre leurs principes de mise en œuvre et leurs méthodes d'utilisation en implémentant ces structures de données de base.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!