6b. Named Tuples and Dictionaries

Keys and Values

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

Keys are more general than indices: while indices are limited to integer identifiers, keys can be any valid Julia object (e.g., strings, numbers, or other objects).

To extract the keys and values of a collection, Julia provides the functions keys and values. The following examples demonstrate their behavior with vectors and tuples, whose keys are represented by indices. Note that neither keys nor values return a vector, requiring the collect function to obtain a vector representation.

x        = [4, 5, 6]

x_keys   = collect(keys(x))
x_values = collect(values(x))

3-element Vector{Int64}:
 1
 2
 3

3-element Vector{Int64}:
 4
 5
 6

x        = (4, 5, 6)

x_keys   = collect(keys(x))
x_values = collect(values(x))

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>}. Although we'll rarely work with objects of this type in this book, they form the basis for constructing other collections, such as dictionaries and named tuples.

A key-value pair can be created by using the operator =>, as in <key> => <value>. For instance, "a" => 1 constructs a pair, where a is the key and 1 the corresponding value. Alternatively, pairs can be created using the function Pair(<key>, <value>), where Pair("a",1) is equivalent to "a" => 1.

Given a pair x, we can access its key via either x[1] or x.first. Likewise, its value can be obtained using either 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 vary across collections. One particularly common choice is Symbol, which offers an efficient way to encode string-based identifiers. A symbol named x is written as :x, and can be constructed from a string using the function Symbol(<string>). [note] Symbol also enables the programmatic creation of variables. A typical use case arises in data analysis, where symbols are employed to generate new columns in tabular data structures.

vector_symbols = [:x, :y]

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

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

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

Dictionaries

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

The function Dict can be used to create dictionaries, where each argument is a key-value pair written in the form <key> => <value>.

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

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

10

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

10

10

Regular dictionaries are inherently unordered, meaning that the access to their elements doesn't follow any pattern. The following example illustrates this, by collecting the dictionary keys into a vector. [note] The package OrderedCollections addresses this, by offering a special dictionary called OrderedDict. It behaves similarly to regular dictionaries, including their syntax, but endows the dictionary with an order.

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 Tuples and Named Tuples

Previously, we demonstrated how to create tuples and named tuples from variables. Next, we show that the reverse operation is also possible, where values are extracted from a tuple or named tuple and then assigned to separate variables. This process is known as destructuring, enabling users to "unpack" the values of a collection into distinct variables.

Destructuring involves the assignment operator = with either a tuple or named tuple on the left-hand side. The choice between one or the other determines what objects can be used on the right-hand side. Specifically, tuples on the left-hand side are quite flexible, allowing values to be unpacked from a variety of collections. Named tuples on the left-hand side, instead, necessarily require a named tuple on the right-hand side. Next, we develop each case separately.

Destructuring Collections Through Tuples

Given a collection list with two elements, destructuring via tuples allows us to unpack its values into the variables x and y. The syntax for this is <tuple> = <collection>, as in x,y = list. In the following, we illustrate the process by considering different objects as list.

list = [3,4]

x,y  = list

3

4

list = 3:4

x,y  = list

3

4

list = (3,4)

x,y  = list

3

4

list = (a = 3, b = 4)

x,y  = list

3

4

In addition to unpacking all elements, destructuring can also be applied to only a subset of elements. The assignment is then carried out sequentially, following the collection's inherent order.

Importantly, this method doesn't allow skipping specific values. When a value must be disregarded, the conventional approach is to bind it to the special variable name _. This symbol serves purely as a placeholder, indicating that the value is unimportant and has no effect on execution.

For illustration, we'll use a vector as an example of list. Nonetheless, the same principle applies to any collection.

list  = [3,4,5]

(x,)  = list

3

list  = [3,4,5]

x,y   = list

3

4

list  = [3,4,5]

_,_,z = list        # _ or any symbol (_ just signals we don't care about that value)

5

list  = [3,4,5]

x,_,z = list        # _ or any symbol (it just signals we don't care about that value)

3

5

Destructuring with Named Tuples on Both Sides

Destructuring can also be applied with named tuples on the left-hand side of an assignment. In this form, values are extracted by referencing directly to their field names, rather than relying on their positional order. The main advantage of this approach is flexibility: variables can be assigned in any order, provided each name matches a field in the named tuple.

nt             = (; key1 = 10, key2 = 20, key3 = 30)

(; key3, key1) = nt            # keys in any order

10

30

nt             = (; key1 = 10, key2 = 20, key3 = 30)

(; key2)       = nt            # only one key

20

Remark

When destructuring with a tuple on the left-hand side and a named tuple on the right-hand side, keep in mind that the assignment is carried out strictly by position. This means that variable names on the left don't influence the result. In other words, the keys of the named tuple are completely ignored during the process.

Named Tuple Tuple

nt = (; key1 = 10, key2 = 20, key3 = 30)

(key2, key1)   = nt     # variables defined according to POSITION
key2, key1     = nt     # alternative notation

Output in REPL

julia>

key2

10

julia>

key1

20

nt = (; key1 = 10, key2 = 20, key3 = 30)

(; key2, key1) = nt     # variables defined according to KEY
 ; key2, key1  = nt     # alternative notation

Output in REPL

julia>

key2

20

julia>

key1

10

The same caveat applies to assignments of single variables.

Named Tuple Tuple

nt       = (; key1 = 10, key2 = 20)

(key2,)  = nt            # variable defined according to POSITION

Output in REPL

julia>

key2

10

nt       = (; key1 = 10, key2 = 20)

(; key2) = nt            # variable defined according to KEY

Output in REPL

julia>

key2

20

Applications of Destructuring

Destructuring named tuples is particularly valuable in scientific modelling, where numerous parameters are referenced repeatedly throughout the code. By grouping all parameters into a single named tuple, we can pass them to a function as one consolidated argument. Functions written in this style typically begin by destructuring the named tuple, extracting exactly the parameters needed for the computations.

β = 3 
δ = 4 
ϵ = 5

# function 'foo' uses β and δ, but not ϵ
function foo(x, δ, β) 
    x * δ + exp(β) / β


end

output = foo(1, δ, β)

10.6952

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



# function 'foo' uses β and δ, but not ϵ
function foo(x, parameters_list) 
    x * parameters_list.δ + exp(parameters_list.β) / parameters_list.β


end

output = foo(1, parameters_list)

10.6952

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



# function 'foo' uses β and δ, but not ϵ
function foo(x, parameters_list)
    (; β, δ) = parameters_list
    
    x * δ + exp(β) / β
end

output = foo(1, parameters_list)

10.6952

Destructuring also provides a convenient solution for retrieving multiple outputs from a function. When a function wraps its results in a tuple, we can then immediately unpack the tuple into separate variables. This often makes the subsequent code easier to read and reason about. In the example below, the function foo returns a tuple, which is then unpacked into variables x, y, and z.

function foo()
    out1 = 2
    out2 = 3
    out3 = 4

    out1, out2, out3
end

x, y, z = foo()

Another common use of destructuring arises when we only need a subset of a function's outputs. While both tuples and named tuples can be applied for this purpose, tuples offer greater flexibility, as they can be combined with various types of collections. In contrast, named tuples are restricted to returning another named tuple as the function's output, thus requiring knowing the field names in advance.

The following example illustrates this functionality by extracting the first and third output of foo, while ignoring the second.

function foo()
    out1 = 2
    out2 = 3
    out3 = 4

    out1, out2, out3
end

x, _, z = foo()

function foo()
    out1 = 2
    out2 = 3
    out3 = 4

    (; out1, out2, out3)
end

(; out1, out3) = foo()