Y a-t-il des bibliothèques Go qui offrent une fonctionnalité de tableau associatif?

Question

Je suis à la recherche d'une fonctionnalité de langue go similaire au "dictionnaire" en python pour faciliter la conversion de certains codes python.

EDIT: Les cartes ont très bien fonctionné pour cette application de-dupe. J'ai été capable de condenser 1.3e6 éléments dupliqués en 2.5e5 éléments uniques en utilisant une carte avec un index de chaîne de 16 octets en quelques secondes. Le code lié à la carte était simple, donc je l'ai inclus ci-dessous. A noter que la pré-attribution de la carte avec 1.3e6 éléments filaient vers le haut par seulement quelques pour cent:

var m = make(map[string]int, 1300000) // map with initial space for 1.3e6 elements 

ct, ok := m[ax_hash] 
if ok { 
    m[ax_hash] = ct + 1 
} else { 
    m[ax_hash] = 1 
} 

Answer 1

Le type de carte. http://golang.org/doc/effective_go.html#maps

Il y a une certaine différence de python en ce que les clés doivent être saisis, de sorte que vous ne pouvez pas mélanger les touches numériques et chaîne (pour une raison quelconque, j'oublié que vous pouvez), mais ils sont assez faciles à utiliser .

dict := make(map[string]string) 
dict["user"] = "so_user" 
dict["pass"] = "l33t_pass1" 

Answer 2

Vous êtes probablement un map.

Answer 3

Pour parler un peu plus des réponses déjà données:

Une carte Go est une structure de données de carte de hachage typé. La signature de type d'une carte est de la forme map[keyType]valueType où keyType et valueType sont respectivement les types des clés et des valeurs.

Pour initialiser une carte, vous devez utiliser la fonction make:

m := make(map[string]int) 

Une carte non initialisée est égale à nil, et si elles sont lues ou écrites une panique se produira lors de l'exécution.

La syntaxe pour stocker des valeurs est la même que faire avec des tableaux ou des tranches:

m["Alice"] = 21 
m["Bob"] = 17 

De même, la récupération des valeurs à partir d'une carte se fait comme ceci:

a := m["Alice"] 
b := m["Bob"] 

Vous pouvez utiliser le mot-clé range à itérer sur une carte avec une boucle for:

for k, v := range m { 
    fmt.Println(k, v) 
} 

Ce code imprimera:

Alice 21 
Bob 17 

Récupération d'une valeur pour une clé qui ne sont pas sur la carte renverra la valeur de type de valeur zéro:

c := m["Charlie"] 
// c == 0 

En lisant plusieurs valeurs à partir d'une carte, vous pouvez tester la présence d'une clé.La deuxième valeur est une valeur booléenne indiquant la présence de la clé:

a, ok := m["Alice"] 
// a == 21, ok == true 
c, ok := m["Charlie"] 
// c == 0, ok == false 

Pour supprimer une entrée clé/valeur à partir d'une carte, vous retournez et assignez false comme la deuxième valeur:

m["Bob"] = 0, false 
b, ok := m["Bob"] 
// b == 0, ok == false 

Vous peut stocker les types arbitraires dans une carte en utilisant le type d'interface vide interface{}:

n := make(map[string]interface{}) 
n["One"] = 1 
n["Two"] = "Two" 

la seule condition est que lors de la récupération de ces valeurs vous devez effectuer une affirmation de type pour les utiliser dans leur forme originale:

a := n["One"].(int) 
b := n["Two"].(string) 

Vous pouvez utiliser un commutateur de type pour déterminer les types de valeurs que vous tiriez sur, et de les traiter de façon appropriée:

for k, v := range n { 
    switch u := v.(type) { 
     case int: 
      fmt.Printf("Key %q is an int with the value %v.\n", k, u) 
     case string: 
      fmt.Printf("Key %q is a string with the value %q.\n", k, u) 
    } 
} 

À l'intérieur de chacun des blocs case, u sera du type spécifié dans l'instruction case; aucune assertion de type explicite n'est nécessaire.

Ce code imprimera:

Key "One" is an int with the value 1. 
Key "Two" is a string with the value "Two". 

La clé peut être de tout type pour lequel l'opérateur d'égalité est définie, comme les entiers, flottants, des chaînes et des pointeurs. Les types d'interface peuvent également être utilisés, à condition que le type sous-jacent prenne en charge l'égalité. (Struct, les tableaux et les tranches ne peuvent pas être utilisées comme clés de carte, parce que l'égalité n'est pas défini sur ces types.)

Par exemple, la carte o peut prendre les clés de l'un des types ci-dessus:

o := make(map[interface{}]int) 
o[1] = 1 
o["Two"] = 2 

Et ce sont des cartes en un mot.