--- engine: julia --- # Containers Julia offers a wide selection of container types with largely similar interfaces. This chapter introduces `Tuple`, `Range`, and `Dict`; the next chapter covers `Array`, `Vector`, and `Matrix`. These containers are: - **iterable:** You can iterate over the elements of the container: ```julia for x ∈ container ... end ``` - **indexable:** You can access elements via their index: ```julia x = container[i] ``` and some are also - **mutable:** You can add, remove, and modify elements. Furthermore, there are several common functions, e.g., - `length(container)` --- number of elements - `eltype(container)` --- element type - `isempty(container)` --- test if container is empty - `empty!(container)` --- empties the container (if mutable) ## Tuples A tuple is an immutable container of elements. You cannot add new elements or change existing values. ```{julia} t = (33, 4.5, "Hello") @show t[2] # indexable for i ∈ t println(i) end # iterable ``` A tuple is an **inhomogeneous** type. Each element has its own type, which is reflected in the tuple's type: ```{julia} typeof(t) ``` Tuples are frequently used as function return values to return more than one object. ```{julia} # Integer division and remainder: # Assign quotient and remainder to variables `q` and `r`: q, r = divrem(71, 6) @show q r; ``` Parentheses can be omitted in certain constructs. This *implicit tuple packing/unpacking* is commonly used in multiple assignments: ```{julia} x, y, z = 12, 17, 203 ``` ```{julia} y ``` Some functions require tuples as arguments or always return tuples. A single-element tuple is written as: ```{julia} x = (13,) # a 1-element tuple ``` The comma - not the parentheses - makes the tuple. ```{julia} x= (13) # not a tuple ``` ## Ranges We have already used *range* objects in numerical `for` loops. ```{julia} r = 1:1000 typeof(r) ``` There are various *range* types. `UnitRange`, for example, is a *range* with step size 1. Their constructors are typically all named `range()`. The colon is a special syntax. - `a:b` is parsed as `range(a, b)` - `a:b:c` is parsed as `range(a, c, step=b)` *Ranges* are iterable, immutable, and indexable. ```{julia} (3:100)[20] # the 20th element ``` Recall the semantics of the `for` loop: `for i in 1:1000` does **not** mean 'increment the loop variable `i` by one each iteration'; **rather**, it means 'successively assign the values 1, 2, 3, ..., 1000 to the loop variable from the container'. Creating this container explicitly would be very inefficient. - _Ranges_ are "lazy" vectors never stored as concrete lists. This makes them ideal as `for` loop iterators: memory-efficient and fast. - They are "recipes" or generators that respond to the query "Give me your next element!". - In fact, the supertype `AbstractRange` is a subtype of `AbstractVector`. The macro `@allocated` outputs how many bytes of memory were allocated during the evaluation of an expression. ```{julia} @allocated r = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] ``` ```{julia} @allocated r = 1:20 ``` The `collect()` function converts a range to a concrete vector. ```{julia} collect(20:-3:1) ``` Quite useful, e.g., when preparing data for plotting, is the *range* type `LinRange`. ```{julia} LinRange(2, 50, 300) ``` `LinRange(start, stop, n)` generates `n` equidistant values from start to stop. Use `collect()` to obtain the corresponding vector if needed. ## Dictionaries - _Dictionaries_ (also known as associative arrays or lookup tables) are special containers. - Whereas vector entries are addressed by integer indices: `v[i]`; dictionary entries are addressed by more general _keys_. - A dictionary is a collection of _key-value_ pairs with parameterized type `Dict{S,T}`, where `S` is the key type and `T` is the value type. Create a dictionary explicitly: ```{julia} # Population in 2020 in millions, source: wikipedia Ppl = Dict("Berlin" => 3.66, "Hamburg" => 1.85, "München" => 1.49, "Köln" => 1.08) ``` ```{julia} typeof(Ppl) ``` and indexed with the _keys_: ```{julia} Ppl["Berlin"] ``` Querying a non-existent _key_ throws an error. ```{julia} Ppl["Leipzig"] ``` Check beforehand with `haskey()`... ```{julia} haskey(Ppl, "Leipzig") ``` Or use `get(dict, key, default)`, which returns the default value instead of throwing an error. ```{julia} @show get(Ppl, "Leipzig", -1) get(Ppl, "Berlin", -1); ``` You can also request all `keys` and `values` as special containers. ```{julia} keys(Ppl) ``` ```{julia} values(Ppl) ``` Iterate over the `keys`... ```{julia} for i in keys(Ppl) n = Ppl[i] println("The city $i has $n million inhabitants.") end ``` Or iterate directly over `key-value` pairs. ```{julia} for (city, pop) ∈ Ppl println("$city : $pop Million.") end ``` ### Extending and Modifying Add `key-value` pairs to a `Dict`... ```{julia} Ppl["Leipzig"] = 0.52 Ppl["Dresden"] = 0.52 Ppl ``` Change a `value`: ```{julia} # Update: Leipzig data was from 2010, not 2020 Ppl["Leipzig"] = 0.597 Ppl ``` Delete a pair by its `key`: ```{julia} delete!(Ppl, "Dresden") ``` Many functions work with `Dicts` like other containers. ```{julia} maximum(values(Ppl)) ``` ### Creating an Empty Dictionary Without explicit types: ```{julia} d1 = Dict() ``` With explicit types: ```{julia} d2 = Dict{String, Int}() ``` ### Conversion to Vectors: `collect()` - `keys(dict)` and `values(dict)` return special container types. - `collect()` converts them to `Vector`s. - `collect(dict)` returns a `Vector{Pair{S,T}}`. ```{julia} collect(Ppl) ``` ```{julia} collect(keys(Ppl)), collect(values(Ppl)) ``` ### Ordered Iteration over a Dictionary We sort the keys. As strings, they are sorted alphabetically. With the `rev` parameter, sorting is done in reverse order. ```{julia} for k in sort(collect(keys(Ppl)), rev = true) n = Ppl[k] println("$k has $n million inhabitants ") end ``` Let's sort `collect(dict)`, a vector of pairs. Use `by` to specify the sort key: the second element of each pair. ```{julia} for (k,v) in sort(collect(Ppl), by = pair -> last(pair), rev=false) println("$k has $v million inhabitants") end ``` ### An Application of Dictionaries: Counting Frequencies Let's do "experimental stochastics" with 2 dice: Let `l` be a vector containing 100,000 sums of two dice rolls (numbers from 2 to 12). How frequently does each number from 2 to 12 occur? Roll the dice: ```{julia} l = rand(1:6, 100_000) .+ rand(1:6, 100_000) ``` Count event frequencies using a dictionary. Use the event as the `key` and its frequency as the `value`. ```{julia} # In this case, a simple vector would also work. # A better use case for dictionaries is word frequency in texts, # where keys are strings instead of integers. d = Dict{Int,Int}() # dictionary for counting for i in l # for each i, increment d[i] d[i] = get(d, i, 0) + 1 end d ``` Result: ```{julia} using Plots plot(collect(keys(d)), collect(values(d)), seriestype=:scatter) ``` Explanatory image: [https://math.stackexchange.com/questions/1204396/why-is-the-sum-of-the-rolls-of-two-dices-a-binomial-distribution-what-is-define](https://math.stackexchange.com/questions/1204396/why-is-the-sum-of-the-rolls-of-two-dices-a-binomial-distribution-what-is-define)