6b. Named Tuples and Dictionaries

Keys and Values

Most collections in Julia are characterized by keys, which serve as unique identifiers of their elements and have a corresponding value associated to each. [note] Not all collections represent maps of keys to values. For example, the type Set, which represents a group of unique unordered elements, doesn't have keys. For instance, the vector x = [2, 4, 6] has the indices 1, 2, 3 as its keys, and 2, 4, 6 are their respective values.

Keys are more general than indices—they encompass all the possible identifiers of a collection's elements (e.g., strings, numbers, or other objects), while indices exclusively employ integers as identifiers. To know the keys and values of a collection, Julia provides the functions keys and values.

The following code snippets illustrate the use of keys and values. The examples are based on vectors and tuples, whose keys are exclusively represented by indices. Importantly, neither keys nor values necessarily return a vector by default, requiring the function collect to get a vector form.

x = [4, 5, 6]

3-element Vector{Int64}:
 1
 2
 3

3-element Vector{Int64}:
 4
 5
 6

x = (4, 5, 6)

3-element Vector{Int64}:
 1
 2
 3

3-element Vector{Int64}:
 4
 5
 6

The Type 'Pair'

Collections of key-value pairs in Julia are represented by the type Pair{<key type>, <value type>}. While we won't directly work with objects of having this type, they form the basis for constructing dictionaries and named tuples.

A key-value pair can be created by using the operator => as in <key> => <value>. For instance, "a" => 1 represents a pair, where a is its key and 1 its corresponding value. In addition, we can create pairs through the function Pair(<key>, <value>), such that Pair("a",1) is equivalent. Moreover, given a pair x, we can access its key by x[1] or x.first, and its value by x[2] or x.second. All this is demonstrated below.

some_pair = ("a" => 1)      # or simply 'some_pair = "a" => 1'

some_pair = Pair("a", 1)    # equivalent

"a" => 1

"a"

"a"

some_pair = ("a" => 1)      # or simply 'some_pair = "a" => 1'

some_pair = Pair("a", 1)    # equivalent

"a" => 1

1

1

The Type 'Symbol'

The type used to represent keys can vary depending on the collection. One important type used as key is Symbol, which provides an efficient way to represent string-based keys. A symbol with name x is denoted :x, and can be created from strings using the function Symbol(<some string>). [note] This type also enables programmatic creation of variables. For example, it can be employed for creating new columns in the package DataFrames, which provides a table representation of data.

some_symbol = :x

some_symbol = Symbol("x")                       # equivalent

:x

vector_symbols = [:x, :y]

vector_symbols = [Symbol("x"), Symbol("y")]     # equivalent

2-element Vector{Symbol}:
 :x
 :y

Dictionaries

Dictionaries are collections of key-value pairs, exhibiting three distinctive features:

Dictionaries are created through the function Dict, with each argument denoting key-value pairs through the notation <key> => <value>.

some_dict = Dict(3 => 10, 4 => 20)

Dict{Int64, Int64} with 2 entries:
  4 => 20
  3 => 10

10

dict = Dict("a" => 10, "b" => 20)

Dict{String, Int64} with 2 entries:
  "b" => 20
  "a" => 10

10

some_dict = Dict(:a => 10, :b => 20)

Dict{Symbol, Int64} with 2 entries:
  :a => 10
  :b => 20

10

some_dict = Dict((1,1) => 10, (1,2) => 20)

Dict{Tuple{Int64, Int64}, Int64} with 2 entries:
  (1, 2) => 20
  (1, 1) => 10

10

As regular dictionaries are unordered, accessing their elements doesn't follow any pattern. The following example illustrates this, where a vector collects the keys of a dictionary. [note] The package OrderedCollections addresses this, by offering a special dictionary called OrderedDict. It behaves pretty similarly to regular dictionaries, including its syntax.

some_dict = Dict(3 => 10, 4 => 20)

keys_from_dict = collect(keys(some_dict))

2-element Vector{Int64}:
 4
 3

some_dict = Dict("a" => 10, "b" => 20)

keys_from_dict = collect(keys(some_dict))

2-element Vector{String}:
 "b"
 "a"

some_dict = Dict(:a => 10, :b => 20)

keys_from_dict = collect(keys(some_dict))

2-element Vector{Symbol}:
 :a
 :b

some_dict = Dict((1,1) => 10, (1,2) => 20)

keys_from_dict = collect(keys(some_dict))

2-element Vector{Tuple{Int64, Int64}}:
 (1, 2)
 (1, 1)

Destructuring (OPTIONAL)

Previously, we've demonstrated how to create a named tuple nt using variables as its source. This approach automatically defines the key-value pairs of the named tuple by each variable's name and value.

Next, we show that we are also able to perform the opposite operation: extracting values from a named tuple and assigning them to individual variables. This process is known as destructuring, and allows users to "unpack" a collection's values into separate variables.

To make the section self-contained, we start by reviewing destructuring for regular tuples. This will provide a foundational understanding before exploring destructuring named tuples. Both approaches enable the creation of variables with specific values, although they cater to distinct situations.

Destructuring Collections Through Tuples

Given a collection list with two elements, destructuring allows the user to create variables x and y with the values of list. This requires running x,y = list, with the tuple on the left-hand side of =. The following examples illustrate this operation, according to several objects taken as list.

list = [3,4]

x,y  = list

list = 3:4

x,y  = list

list = (3,4)

x,y  = list

list = (a = 3, b = 4)

x,y  = list

In addition to destructuring all elements in list as above, we can also selectively destructure a subset of elements. When working with tuples, destructuring assigns values in a sequential order, without allowing any values to be skipped. As a result, if you're not interested in a particular element, you must explicitly indicate it. This requires assigning _ as a variable name, which signals that no assignment should be performed for that value.

list = [3,4,5]

(x,)    = list

list = [3,4,5]

x,y     = list

list = [3,4,5]

_,_,z   = list                  # _ skips the assignment of that value

list = [3,4,5]

x,_,z   = list                  # _ skips the assignment of that value

Named Tuples Destructuring

Consider now the case where list is a named tuple. Destructuring named tuples offers greater flexibility compared to regular tuples: you can extract key-value pairs without adhering to the order of elements and without explicitly identifying the values to be skipped.

To illustrate this, let's first consider destructuring a named tuple nt through a tuple on the left-hand side of the assignment. This will serve as a baseline for further discussions.

nt      = (; name1 = 10, name2 = 20, name3 = 30)

x, y, z = nt

nt      = (; name1 = 10, name2 = 20, name3 = 30)

x, y    = nt

nt      = (; name1 = 10, name2 = 20, name3 = 30)

_, _, z = nt        # _ is notation to indicate we don't want the first two values of 'nt'

Instead of using a tuple on the left-hand side, let's now utilize a named tuple. This makes it possible to specify the variables to be created by referencing their corresponding keys. The variable created will then be assigned the value associated with that key, regardless of the order in which you specify each variable.

nt = (; name1 = 10, name2 = 20, name3 = 30)

(; name2, name1) = nt                   # names in any order

nt = (; name1 = 10, name2 = 20, name3 = 30)

(; name3)               = nt

Remark

Be careful with mixing tuples and named tuples in destructuring. The following example shows the potential issue that could arise otherwise.

Named Tuple Tuple

nt = (; name1 = 10, name2 = 20, name3 = 30)

 name2, name1    = nt            # variables defined according to POSITION
(name2, name1)   = nt            # alternative notation

Output in REPL

julia>

name2

10

julia>

name1

20

nt = (; name1 = 10, name2 = 20, name3 = 30)

(; name2, name1) = nt            # variables defined according to NAME
 ; name2, name1  = nt            # alternative notation

Output in REPL

julia>

name1

10

julia>

name2

20

The same caveat applies to a single-variable assignment.

Named Tuple Tuple

nt = (; name1 = 10, name2 = 20)

(name2,)  = nt            # variable defined according to POSITION -> only first element

Output in REPL

julia>

name2

10

nt = (; name1 = 10, name2 = 20)

(; name2) = nt            # variable defined according to NAME

Output in REPL

julia>

name2

20

An Application of Destructuring

Destructuring named tuples is particularly useful for passing multiple parameters to a function. If you need to repeatedly call a function like this, defining a named tuple to store all relevant parameters proves highly efficient. In this way, the named tuple serve as a single argument passed directly to the function. Then, inside the function, you can extract the specific parameters needed for each operation.

The approach eliminates the need for repetitively specifying a named tuple when a parameter is used, resulting in cleaner and more concise code.

parameters_list = (; β = 3, δ = 4, ϵ = 5)

# function 'foo' only uses 'β' and 'δ' 
function foo(x, parameters_list) 
    x * parameters_list.δ + exp(parameters_list.β) / parameters_list.β
end

parameters_list = (; β = 3, δ = 4, ϵ = 5)

# function 'foo' only uses 'β' and 'δ' 
function foo(x, δ, β) 
    x * δ + exp(β) / β
end

parameters_list = (; β = 3, δ = 4, ϵ = 5)

# function 'foo' only uses 'β' and 'δ' 
function foo(x, parameters_list)
    (; β, δ) = parameters_list

    x * δ + exp(β) / β
end