Wolfram Computation Meets Knowledge

34 Associations

Counts gives an association that reports how many times each different element occurs:
Counts[{a, a, b, c, a, a, b, c, c, a, a}]
You can get the value associated with a particular key using [...].
Find the value associated with c in the association:
<|a -> 6, b -> 2, c -> 3|>[c]
Operations that work on lists typically also work on associationsbut apply themselves only to the values, not the keys.
This adds 500 to each value in the association:
<|a -> 6, b -> 2, c -> 3|> + 500
/@ applies a function to each value in the association:
f /@ <|a -> 6, b -> 2, c -> 3|>
Total gives the total of the values:
Total[<|a -> 6, b -> 2, c -> 3|>]
Sort operates on the values:
Sort[<|a -> 6, b -> 2, c -> 3|>]
KeySort operates on the keys:
KeySort[<|c -> 1, b -> 2, a -> 4|>]
The functions Keys and Values extract the keys and values of an association.
Get the list of keys in the association:
Keys[<|a -> 6, b -> 2, c -> 3|>]
Get the list of values in the association:
Values[<|a -> 6, b -> 2, c -> 3|>]
Normal turns an association into a normal list of rules. Association makes an association from a list of rules.
Normal[<|a -> 6, b -> 2, c -> 3|>]
Association[{a -> 6, b -> 2, c -> 3}]
LetterCounts counts how many times letters occur in a string.
Count how many times each letter occurs in the Wikipedia article on computers:
KeyTake picks out elements of an association that appear in a list of keys you specify. Here we’re taking the elements whose keys are letters in the (lowercase) alphabet.
Take only those elements in the association whose keys appear as letters in the alphabet:
KeyTake[LetterCounts[WikipediaData["computers"]], Alphabet[]]
BarChart plots the values in an association. With the option ChartLabelsAutomatic, it uses the keys as labels.
BarChart[ KeyTake[LetterCounts[WikipediaData["computers"]], Alphabet[]], ChartLabels -> Automatic]
Here’s a direct way to apply a pure function to an association.
Apply a pure function to an association:
f[#["apples"], #["oranges"]] &[<|"apples" -> 10, "oranges" -> 12, "pears" -> 4|>]
It’s very common to have keys that are strings, and the Wolfram Language has a special way to handle these when it comes to pure functions: you can just use #key to refer to an element whose key is "key".
Use the simpler notation for association elements whose keys are strings:
f[#apples, #oranges] &[<|"apples" -> 10, "oranges" -> 12, "pears" -> 4|>]
Compute the fraction of letters in the “computers” article that are “e”:
#e/Total[#] & @LetterCounts[WikipediaData["computers"]] // N
key1value1,key2value2, ... an association
Association[rules] turn a list of rules into an association
assoc[key] extract an element of an association
Keys[assoc] list of keys in an association
Values[assoc] list of values in an association
Normal[assoc] turn an association into a list of rules
KeySort[assoc] sort an association by its keys
KeyTake[assoc,keys] take elements with particular keys
#key function slot for an element with key “key
Counts[list] an association with counts of distinct elements
LetterCounts[string] an association with counts of distinct letters
34.1Make a list, in order, of the number of times each of the digits 0 through 9 occurs in 3^100. »
Expected output:
34.2Make a labeled bar chart of the number of times each of the digits 0 through 9 occurs in 2^1000. »
Expected output:
34.3Make a labeled bar chart of the number of times each possible first letter occurs in words from WordList[ ], with all letters made uppercase. »
Expected output:
34.4Make an association giving the 5 most common first letters of words in WordList[ ] and their counts. »
Sample expected output:
34.5Find the numerical ratio of the number of occurrences of “q” and “u” in the Wikipedia entry for computers. »
Sample expected output:
34.6Find the 10 most common words in ExampleData[{"Text", "AliceInWonderland"}]»
Expected output:
Why are associations called “associations”?
Because they associate values with keys. Other names used for the same concept are associative arrays, dictionaries, hashmaps, structs, key-value maps and symbolically indexed lists.
How does one type in an association?
Start with <| (< followed by |), then use -> for each . Alternatively use Association[a->1, b->2].
Can an association have several elements with the same key?
Normally you get Missing[...]. But if you use Lookup to look up the key, you can specify what to return if the key is absent.
How can I do operations on the keys of an association?
Use KeyMap, or use functions like KeySelect and KeyDrop. AssociationMap creates an association by mapping a function over keys.
How can I combine several associations into one?
Use Merge. You have to give a function to say what to do if the same key occurs in multiple associations.
Can one use [[...]] to extract part of an association, like one extracts part of a list?
Yes, if you explicitly say assoc[[Key[key]]]. For example, assoc[[2]] will extract the second element of assoc, whatever key it has. assoc[[key]] is a special case that works the same as assoc[key].
What happens in pure functions if the keys in an association aren’t strings?
You can’t use #key anymore; you have to explicitly use #[key].
Next Section