¿Existen bibliotecas go que proporcionen capacidad de matriz asociativa?

Question

Estoy buscando una capacidad de lenguaje similar al "diccionario" en python para facilitar la conversión de algún código python.

EDITAR: Los mapas funcionaron bastante bien para esta aplicación de deduplicación. Pude condensar 1.3e6 elementos duplicados hasta 2.5e5 elementos únicos usando un mapa con un índice de cadena de 16 bytes en solo unos segundos. El código relacionado con el mapa era simple, así que lo he incluido a continuación. A tener en cuenta que la asignación previa de mapa con 1.3e6 elementos aceleraron hacia arriba por sólo un pequeño porcentaje:

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

El tipo de mapa. http://golang.org/doc/effective_go.html#maps

Hay una cierta diferencia con el pitón en el que las claves tienen que ser escrito, por lo que no puede mezclarse numérico y teclas de cuerda (por alguna razón se me olvidó que puede), pero son bastante fáciles de usar .

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

Answer 2

Probablemente usted está buscando un map.

Answer 3

Para ampliar un poco en las respuestas ya dadas:

mapa A Go es una estructura de mapa de datos con tipo hash. La firma de tipo de mapa tiene el formato map[keyType]valueType donde keyType y valueType son los tipos de las claves y los valores, respectivamente.

Para inicializar un mapa, debe utilizar la función make:

m := make(map[string]int) 

Un mapa sin inicializar es igual a nil, y si están leyendo o escribiendo un pánico se producirá en tiempo de ejecución.

La sintaxis para almacenar valores es lo mismo que hacerlo con matrices o rodajas:

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

Del mismo modo, la recuperación de los valores de un mapa se realiza de este modo:

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

Usted puede utilizar la palabra clave range para iterar sobre un mapa con un bucle for:

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

Este código imprimirá:

Alice 21 
Bob 17 

Recuperación de un valor de una clave que no está en el mapa devolverá el valor del tipo de valor cero:

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

Mediante la lectura de varios valores de un mapa, se puede prueba la presencia de una llave.El segundo valor será un valor lógico que indica la presencia de la llave:

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

Para eliminar una entrada de clave/valor a partir de un mapa, le da la vuelta alrededor y asignar false como el segundo valor:

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

Usted puede almacenar tipos arbitrarios en un mapa utilizando el vacío tipo de interfaz interface{}:

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

la única condición es que al recuperar esos valores debe realizar una afirmación de tipo de utilizarlos en su forma original:

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

Se puede utilizar un interruptor de tipo para determinar los tipos de los valores que estés tirando hacia fuera, y tratar con ellos adecuadamente:

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) 
    } 
} 

Dentro de cada uno de esos bloques case, u serán del tipo especificado en la declaración case; no es necesaria una aserción de tipo explícita.

Este código imprimirá:

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

La clave puede ser de cualquier tipo para el que se define el operador de igualdad, tales como enteros, flotadores, cuerdas, y los punteros. Los tipos de interfaz también se pueden usar, siempre que el tipo subyacente sea compatible con la igualdad. (Estructuras, matrices y las rebanadas no se pueden utilizar como teclas de mapa, porque la igualdad no está definido en esos tipos.)

Por ejemplo, el mapa o puede tomar teclas de cualquiera de los tipos anteriores:

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

Y eso es mapas en pocas palabras.