# Possibly heterogeneous (values can be of different types)
typeof((2, 'a', 1.0, "test"))
Tuple{Int64, Char, Float64, String}
Marie-Hélène Burle
Values can be stored in collections. This workshop introduces tuples, dictionaries, sets, and arrays in Julia.
Tuples are immutable, indexable, and possibly heterogeneous collections of elements. The order of elements matters.
Tuple{Int64, Char, Float64, String}
LoadError: MethodError: no method matching setindex!(::Tuple{Int64, Char, Float64, String}, ::Int64, ::Int64)
Tuples can have named components:
NamedTuple{(:a, :b, :c, :d), Tuple{Int64, Char, Float64, String}}
Julia also has dictionaries: associative collections of key/value pairs:
Dict{String, Any} with 3 entries:
"Index" => 0.3
"Age" => 52
"Name" => "Roger"
"Name"
, "Age"
, and "Index"
are the keys; "Roger"
, 52
, and 0.3
are the values.
The =>
operator is the same as the Pair
function:
Dictionaries can be heterogeneous (as in this example) and the order doesn’t matter. They are also indexable:
And mutable (they can be modified):
Sets are collections without duplicates. The order of elements doesn’t matter.
Notice how this is a set of 5 (and not 6) elements: the duplicated 8 didn’t matter.
You can compare sets:
Set{Int64} with 7 elements:
4
7
2
10
9
8
3
Set{Int64} with 1 element:
2
# The setdiff is the set of elements that are in the first set but not in the second
# Note that the order matters here
setdiff(set1, set2)
Set{Int64} with 4 elements:
4
7
9
8
Sets can be heterogeneous:
Unidimensional arrays in Julia are called vectors.
These 3 syntaxes are equivalent:
These 4 syntaxes are equivalent:
Elements separated by semi-colons or end of lines get expanded vertically.
Those separated by commas do not get expanded.
Elements separated by spaces or tabs get expanded horizontally.
Your turn:
Compare the outputs of the following:
In Julia, arrays can be heterogeneous:
This is possible because all elements of an array, no matter of what types, will always sit below the Any
type in the type hierarchy.
Below are examples of some of the functions initializing arrays:
2×3×4 Array{Float64, 3}:
[:, :, 1] =
0.181869 0.0915411 0.651725
0.327594 0.503996 0.27463
[:, :, 2] =
0.304913 0.376308 0.227217
0.901566 0.0548263 0.346646
[:, :, 3] =
0.324947 0.310066 0.821691
0.831401 0.422848 0.555132
[:, :, 4] =
0.00253272 0.280317 0.27852
0.176464 0.114991 0.206782
2×3×4 Array{Int64, 3}:
[:, :, 1] =
-8987527465178754461 3428059773622617463 4155247183085351984
5107481386831561392 -1632077291384995587 -1972479445349631935
[:, :, 2] =
-2189845061699179087 -1582333260449727536 -494174093546093300
-7552585497212562283 -9001205848815962154 -3489427829148735653
[:, :, 3] =
-3510160236216512912 3760518427195529092 -5729286918391534193
-5831521150042076744 7623549659816828566 -8248804342961297846
[:, :, 4] =
-1139332079754777915 6506942486810367180 826351831923977874
-4656394141551938766 -8814845756355561796 -3497203115541871575
To apply a function to each element of a collection rather than to the collection as a whole, Julia uses broadcasting.
LoadError: MethodError: no method matching abs(::Vector{Int64})
This doesn’t work because the function abs
only applies to single elements.
By broadcasting abs
, you apply it to each element of a
:
The dot notation is equivalent:
It can also be applied to the pipe, to unary and binary operators, etc.
Your turn:
Try to understand the difference between the following 2 expressions:
Hint: 0/1 are a short-form notations for false/true in arrays of Booleans.
Julia has an array comprehension syntax similar to Python’s:
As in other mathematically oriented languages such as R, Julia starts indexing at 1
.
Indexing is done with square brackets:
Your turn:
Index the element on the 3rd row and 2nd column of b
:
Your turn:
How can I get the second column?
How can I get the tuple (2, 4)
? (a tuple is a list of elements)
As in Python, by default, arrays are passed by sharing:
This prevents the unwanted copying of arrays.