# 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:
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.676981 0.00192985 0.460161
0.579801 0.0571031 0.19217
[:, :, 2] =
0.709137 0.355586 0.717515
0.334442 0.768498 0.93754
[:, :, 3] =
0.110039 0.468733 0.764542
0.708841 0.418923 0.102156
[:, :, 4] =
0.1735 0.92587 0.822419
0.122246 0.749059 0.52207
2×3×4 Array{Int64, 3}:
[:, :, 1] =
7539227344717627596 -3475288731017273925 3435963957489459227
7076298999511187079 -4056353322580659761 -837262113887699001
[:, :, 2] =
-7562670463192357073 -8927025020788172752 6417337822872556077
3692648043801976038 3471765935100455283 -6192652305627405865
[:, :, 3] =
7031151667336399214 5088860813990033390 5115764253454872856
-6119814429800991191 -8609024759557032284 -1204795858698859213
[:, :, 4] =
-2961801139235269924 5392657125003334687 1122551460163567839
1768937120468164288 -3560940733318201168 -6602997138296377453
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.