"An array is a sequence of values. The values in an array are called elements or sometimes items and they can be of any type. We will see more about arrays in the next lesson, for now we simply consider the basics.\n",
"There are several ways to create a new array; the simplest is to enclose the elements in square brackets (`[ ]`):"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ddfba3ab-f520-4617-a937-3809cc1f06b6",
"metadata": {},
"outputs": [],
"source": [
"a1 = [10, 20, 30, 40]\n",
"@show a1\n",
"a2 = [\"a\", \"b\", \"c\"]\n",
"@show a2;"
]
},
{
"cell_type": "markdown",
"id": "cb15aba4-a6d4-45db-9783-501ac4b8fb63",
"metadata": {},
"source": [
"The first example is an array of four integers. The second is an array of three strings. The elements of an array don’t have to be the same type. The following array contains a string, a float, an integer, and another array:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "56814d39-2d81-4f2d-bf63-a1a3030d2ccf",
"metadata": {},
"outputs": [],
"source": [
"a3 = [\"spam\", 2.0, 5, [10, 20]]\n",
"@show a3;"
]
},
{
"cell_type": "markdown",
"id": "7a18ac29-c477-4d58-bb22-2566b2248d7e",
"metadata": {},
"source": [
"An array within another array is nested.\n",
"An array that contains no elements is called an empty array; you can create one with empty brackets, `[]`.\n",
"\n",
"The function typeof can be used to find out the kind of the array:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f53616f1-910d-47ab-be2f-68127dd6f2e6",
"metadata": {},
"outputs": [],
"source": [
"@show typeof(a1)\n",
"@show typeof(a2)\n",
"@show typeof(a3);"
]
},
{
"cell_type": "markdown",
"id": "fd99f8ca-a174-4b25-a12b-764d7807f3a6",
"metadata": {},
"source": [
"The syntax for accessing the elements of an array is the same as for accessing the characters of a string—the bracket operator. The expression inside the brackets specifies the index. Remember that the indices start at 1:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4b1262f3-672d-421f-bf1a-4dd860407a7a",
"metadata": {},
"outputs": [],
"source": [
"a1[1]"
]
},
{
"cell_type": "markdown",
"id": "8dcd70d7-467f-497a-b94e-e9aae0ec738a",
"metadata": {},
"source": [
"Arrays are mutable. When the bracket operator appears on the left side of an assignment, it identifies the element of the array that will be assigned:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8442b5f4-bc86-4620-a4bc-a10322b254da",
"metadata": {},
"outputs": [],
"source": [
"a1[1] = 5\n",
"@show a1;"
]
},
{
"cell_type": "markdown",
"id": "26d27784-832e-45eb-b421-03acb522a619",
"metadata": {},
"source": [
"Array indices work according to these rules:\n",
" - Any integer expression can be used as an index.\n",
" - If you try to read or write an element that does not exist, you get a BoundsError.\n",
" - The keyword `end` points to the last index of the array.\n",
"\n",
"The `∈` operator also works on arrays:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "58f736f7-adfb-43ed-b825-3e031638d760",
"metadata": {},
"outputs": [],
"source": [
"@show 10 in a1;"
]
},
{
"cell_type": "markdown",
"id": "db829f89-95f0-478e-9193-938ca27691c1",
"metadata": {},
"source": [
"The most common way to traverse the elements of an array is with a `for` loop."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7bd5fdef-3212-46de-af51-44f1407e53f0",
"metadata": {},
"outputs": [],
"source": [
"for element in a1\n",
" println(element)\n",
"end"
]
},
{
"cell_type": "markdown",
"id": "720bf843-5d4d-4c50-8917-193046dcaa3b",
"metadata": {},
"source": [
"This works well if you only need to read the elements of the array. As changing the variable `element` has no effect on the array elements.\n",
"If you want to write or update the elements, you need the indices. A common way to do that is to use the built-in function eachindex:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a6415603-4d90-4cc2-bd07-0a93f135db33",
"metadata": {},
"outputs": [],
"source": [
"@show a1\n",
"for i in eachindex(a1)\n",
" a1[i] = a1[i] * 2\n",
"end\n",
"@show a1;"
]
},
{
"cell_type": "markdown",
"id": "7969b8f9-335a-4bd2-82f7-1d9795234ed5",
"metadata": {},
"source": [
"## Dictionaries"
]
},
{
"cell_type": "markdown",
"id": "ea8518c1-8e1d-4532-8055-e04c3aa3e7c4",
"metadata": {},
"source": [
"A dictionary contains a collection of indices, which are called keys, and a collection of values. Each key is associated with a single value. The association of a key and a value is called a key-value pair or sometimes an item.\n",
"\n",
"The function `Dict` creates a new dictionary with no items. Because Dict is the name of a built-in function, you should avoid using it as a variable name. "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "59ae8d17-a6f6-4210-95bc-0e7492bc8a7a",
"metadata": {},
"outputs": [],
"source": [
"eng2de = Dict()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "28490ea3-c4d3-4e4d-915f-612ad36c9472",
"metadata": {},
"outputs": [],
"source": [
"eng2de[\"one\"] = \"ein\";"
]
},
{
"cell_type": "markdown",
"id": "f2aff40c-6dcb-421a-b67f-1662c5bf4702",
"metadata": {},
"source": [
"You can also initialize a dictionary with items as:"
"Dictionaries are mutable, meaning that it is always possible to modify their elements, add new key-value pairs or removing existing ones."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "22b295dc-994e-4bbc-ac8d-da5ab9e73493",
"metadata": {},
"outputs": [],
"source": [
"eng2de[\"four\"] = \"VIER\"\n",
"@show eng2de\n",
"eng2de[\"four\"] = \"vier\"\n",
"@show eng2de\n",
"delete!(eng2de, \"four\")\n",
"@show eng2de;"
]
},
{
"cell_type": "markdown",
"id": "01513ad2-3083-4c89-adca-ccc8a88d93d4",
"metadata": {},
"source": [
"In general, the order of the key-value pairs is unpredictable. However this is not important, as the values are always accessed using the keys."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e9e4c5b9-9539-4294-a6ec-0a29fb76bf7b",
"metadata": {},
"outputs": [],
"source": [
"eng2de[\"two\"]"
]
},
{
"cell_type": "markdown",
"id": "9944dbbd-478b-4ae1-ac89-e16be08a0868",
"metadata": {},
"source": [
"If the key isn’t in the dictionary, you get an exception:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8221269b-7a8f-4cfd-ab8e-0aa4fd6c962d",
"metadata": {},
"outputs": [],
"source": [
"eng2de[\"four\"]"
]
},
{
"cell_type": "markdown",
"id": "a545abaa-78dc-4625-84e9-03b1c8beaaf8",
"metadata": {},
"source": [
"The `length` function works on dictionaries; it returns the number of key-value pairs:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0e242667-b921-4242-bdcc-cbcac14909b2",
"metadata": {},
"outputs": [],
"source": [
"length(eng2de)"
]
},
{
"cell_type": "markdown",
"id": "8e42655b-f2a0-41f0-be90-015ebfeafdb9",
"metadata": {},
"source": [
"The function `keys` returns a collection with the keys of the dictionary:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3236f973-d3fa-42ba-a1c0-41e0002446cb",
"metadata": {},
"outputs": [],
"source": [
"keys(eng2de)"
]
},
{
"cell_type": "markdown",
"id": "acfa7044-5695-4af8-b4bc-320c8a48a220",
"metadata": {},
"source": [
"Now you can use the `∈` operator to see whether something appears as a key in the dictionary:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1fdeb10c-0d84-4c22-b734-d68e2eafe375",
"metadata": {},
"outputs": [],
"source": [
"@show \"one\" ∈ keys(eng2de)\n",
"@show \"four\" ∈ keys(eng2de);"
]
},
{
"cell_type": "markdown",
"id": "986919d6-4f27-4fad-b222-20697bf6af40",
"metadata": {},
"source": [
"To see whether something appears as a value in a dictionary, you can use the function `values`, which returns a collection of values, and then use the `∈` operator:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ab90dad1-61d0-4dbd-b829-a354c13fcb71",
"metadata": {},
"outputs": [],
"source": [
"@show \"ein\" ∈ values(eng2de)\n",
"@show \"vier\" ∈ values(eng2de);"
]
},
{
"cell_type": "markdown",
"id": "049c9dfd-1e51-4898-98e5-a4b812d0bba2",
"metadata": {},
"source": [
"### Loops over dictionaries\n",
"\n",
"You can traverse the keys of the dictionary in a `for` statement."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e7062d3f-2125-4ecd-ab13-d04944a71fe1",
"metadata": {},
"outputs": [],
"source": [
"function print_dictionary(dic)\n",
" for key in keys(dic)\n",
" println(key, \" \", dic[key])\n",
" end\n",
"end\n",
"\n",
"print_dictionary(eng2de)"
]
},
{
"cell_type": "markdown",
"id": "cf27195c-e601-49ca-b03d-63162bf59bce",
"metadata": {},
"source": [
"Again, the keys are in no particular order. To traverse the keys in alphabetically sorted order, you can combine `sort` and `collect`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6d52aeba-3c7e-405c-bcfe-d76e37e94f51",
"metadata": {},
"outputs": [],
"source": [
"function print_dictionary_sorted(dic)\n",
" for key in sort(collect(keys(dic)))\n",
" println(key, \" \", dic[key])\n",
" end\n",
"end\n",
"\n",
"print_dictionary_sorted(eng2de)"
]
},
{
"cell_type": "markdown",
"id": "8daa9d3e-19de-4415-ba6c-6aeb174b38fa",
"metadata": {},
"source": [
"### Exercises\n",
" - Write a function that given a string as input counts how many times each letter appears. Use a dictionary."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "aba1978b-e675-48a7-89aa-75553db70537",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "3a9b281f-6cc0-4d39-b9e2-d816823f9873",
"metadata": {},
"source": [
"## Tuples and named tuples"
]
},
{
"cell_type": "markdown",
"id": "a722109e-86cc-44e3-9256-a3e93a1668f5",
"metadata": {},
"source": [
"A tuple is a sequence of values. The values can be of any type, and they are indexed by integers. The tuples are immutable and each element can have its own type."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8502cf2e-8bea-4707-811c-f4e6e1de3c8f",
"metadata": {},
"outputs": [],
"source": [
"t = 'a', 'b', 'c', 'd', 'e'"
]
},
{
"cell_type": "markdown",
"id": "d01f5647-a240-4620-9a3a-782835aca39c",
"metadata": {},
"source": [
"Although it is not necessary, it is common to enclose tuples in parentheses:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bfa31b99-bf9d-49bb-babc-fe8a65248429",
"metadata": {},
"outputs": [],
"source": [
"t = ('a', 'b', 'c', 'd', 'e')"
]
},
{
"cell_type": "markdown",
"id": "3fa935e0-0611-4b8a-982c-329c33a74f99",
"metadata": {},
"source": [
"To create a tuple with a single element, you have to include a final comma:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cb1bea15-2b80-43b2-be8e-27507d550fca",
"metadata": {},
"outputs": [],
"source": [
"t1 = ('a',)\n",
"@show typeof(t1)\n",
"\n",
"t2 = ('a')\n",
"@show typeof(t2);"
]
},
{
"cell_type": "markdown",
"id": "193457ac-4e4b-4e58-8c28-6d8b4331d532",
"metadata": {},
"source": [
"Another way to create a tuple is the built-in function tuple. With no argument, it creates an empty tuple:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "952acafe-ca5d-4b58-8969-224b0fe3a28f",
"metadata": {},
"outputs": [],
"source": [
"t3 = tuple()\n",
"@show typeof(t3)\n",
"\n",
"t4 = tuple(1, 'a', π)\n",
"@show typeof(t4);"
]
},
{
"cell_type": "markdown",
"id": "729c3597-1a35-4a26-ae7a-6dadee31daeb",
"metadata": {},
"source": [
"Using the bracket operator it is possible to access an element. Note, differently from other programming languages (for example C, C++, Python) in Julia the first element is 1."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9817c28f-428d-4d5b-8384-608f9b4d763d",
"metadata": {},
"outputs": [],
"source": [
"t4[2]"
]
},
{
"cell_type": "markdown",
"id": "aeda8602-f9da-4173-a692-54e2e9a0e178",
"metadata": {},
"source": [
"But if you try to modify one of the elements of the tuple, you get an error:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cfc94cc9-832c-45d2-85b8-aaf789f33f6a",
"metadata": {},
"outputs": [],
"source": [
"t4[2] = 'b'"
]
},
{
"cell_type": "markdown",
"id": "b9f13b5c-9e61-46b9-a47d-f90199bd7bd2",
"metadata": {},
"source": [
"Because tuples are immutable, you can’t modify the elements."
]
},
{
"cell_type": "markdown",
"id": "a10cb9a7-8f44-44f8-831f-178b780e4ac9",
"metadata": {},
"source": [
"Strictly speaking, a function can only return one value, but if the value is a tuple, the effect is the same as returning multiple values. For example, if you want to divide two integers and compute the quotient and remainder, it is inefficient to compute x ÷ y and then x % y. It is better to compute them both at the same time.\n",
"\n",
"The built-in function `divrem` takes two arguments and returns a tuple of two values, the quotient and remainder. You can store the result as a tuple: "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d1dde137-036f-4b93-8010-13b3e835ebd8",
"metadata": {},
"outputs": [],
"source": [
"t = divrem(7, 3)"
]
},
{
"cell_type": "markdown",
"id": "ea615dbd-effb-4442-b160-20e7c9b6c22e",
"metadata": {},
"source": [
"Alternatively, we can use tuple assignment to store the elements separately:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c4969556-7945-43c9-8b96-1ea1032cbb3c",
"metadata": {},
"outputs": [],
"source": [
"q, r = divrem(7, 3)\n",
"\n",
"@show q r;"
]
},
{
"cell_type": "markdown",
"id": "4574e191-aaa8-4834-8837-54947d6ddf30",
"metadata": {},
"source": [
"### Gather and scatter\n",
"\n",
"Functions can take a variable number of arguments. A parameter name that ends with `...` gathers arguments into a tuple. For example, `printall` takes any number of arguments and prints them one by line:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "43f8c7ad-5ac2-425e-a50f-c45624bb3d8a",
"metadata": {},
"outputs": [],
"source": [
"function printall(args...)\n",
" for arg in args\n",
" println(arg)\n",
" end\n",
"end\n",
"\n",
"printall(1)\n",
"printall(1, 2.0, '3')"
]
},
{
"cell_type": "markdown",
"id": "eb662374-fe83-49d7-a5be-d9582d037ad1",
"metadata": {},
"source": [
"The complement of gather is scatter. If you have a sequence of values and you want to pass it to a function as multiple arguments, you can use the `...` operator. For example, `divrem` takes exactly two arguments; it doesn’t work with a tuple:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bf55fc10-8432-41e3-bd6c-2244c8c96513",
"metadata": {},
"outputs": [],
"source": [
"t = (7, 3)\n",
"divrem(t)"
]
},
{
"cell_type": "markdown",
"id": "d05def39-3244-4acd-a082-a7ee532f8f1d",
"metadata": {},
"source": [
"But if you scatter the tuple, it works:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e7df53bc-6b2d-4501-9ca8-61e3cb79eb1a",
"metadata": {},
"outputs": [],
"source": [
"t = (7, 3)\n",
"divrem(t...)"
]
},
{
"cell_type": "markdown",
"id": "2cf01c32-9d1b-4e83-9375-f737e51c58ed",
"metadata": {},
"source": [
"### Dictionaries and Tuples"
]
},
{
"cell_type": "markdown",
"id": "00e97ccc-8e64-4eef-84be-85a266eb3490",
"metadata": {},
"source": [
"Dictionaries can be used as iterators that iterate the key-value pairs. You can use it in a `for` loop like this:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ed483334-36d0-4700-b178-cd9dc5f12189",
"metadata": {},
"outputs": [],
"source": [
"d = Dict('a'=>1, 'b'=>2, 'c'=>3);\n",
"for (key, value) in d\n",
" println(key, \" \", value)\n",
"end"
]
},
{
"cell_type": "markdown",
"id": "dcb05236-810a-410b-aaa0-0cb431e3e64f",
"metadata": {},
"source": [
"It is common to use tuples as keys in dictionaries. For example, a telephone directory might map from last-name, first-name pairs to telephone numbers. Assuming that we have defined last, first and number, we could write:"
]
},
{
"cell_type": "markdown",
"id": "e5462d35-fa68-42d8-ba00-c5dd1747c557",
"metadata": {},
"source": [
"`directory[last, first] = number`"
]
},
{
"cell_type": "markdown",
"id": "9980d710-392b-4716-b44d-98e6c5c8b838",
"metadata": {},
"source": [
"### Named tuples"
]
},
{
"cell_type": "markdown",
"id": "e514c4bd-c17c-44f4-a89f-88154cc1bf6c",
"metadata": {},
"source": [
"Named tuples are a special type of tuple in Julia where each element has a specific name associated with it. This allows you to access elements by their names, making the code more readable and self-explanatory."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "78fb5959-407a-4128-9287-bb9d455f22dc",
"metadata": {},
"outputs": [],
"source": [
"person = (name = \"Michele\", age = 28, city = \"Stuttgart\")"
]
},
{
"cell_type": "markdown",
"id": "63075b2d-ef86-48e4-8f84-981f81fdece0",
"metadata": {},
"source": [
"Named tuples are immutable, however it is possible to update the content, or to add new elements, by creating a new version. For example:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ecd22e07-5ba3-4f11-bc77-d967a6fc3fe8",
"metadata": {},
"outputs": [],
"source": [
"updated_person = (person..., age = 29)\n",
"updated_person = (person..., number = \"0711 ...\")"
An array is a sequence of values. The values in an array are called elements or sometimes items and they can be of any type. We will see more about arrays in the next lesson, for now we simply consider the basics.
There are several ways to create a new array; the simplest is to enclose the elements in square brackets (`[ ]`):
The first example is an array of four integers. The second is an array of three strings. The elements of an array don’t have to be the same type. The following array contains a string, a float, an integer, and another array:
The syntax for accessing the elements of an array is the same as for accessing the characters of a string—the bracket operator. The expression inside the brackets specifies the index. Remember that the indices start at 1:
A dictionary contains a collection of indices, which are called keys, and a collection of values. Each key is associated with a single value. The association of a key and a value is called a key-value pair or sometimes an item.
The function `Dict` creates a new dictionary with no items. Because Dict is the name of a built-in function, you should avoid using it as a variable name.
To see whether something appears as a value in a dictionary, you can use the function `values`, which returns a collection of values, and then use the `∈` operator:
Using the bracket operator it is possible to access an element. Note, differently from other programming languages (for example C, C++, Python) in Julia the first element is 1.
Strictly speaking, a function can only return one value, but if the value is a tuple, the effect is the same as returning multiple values. For example, if you want to divide two integers and compute the quotient and remainder, it is inefficient to compute x ÷ y and then x % y. It is better to compute them both at the same time.
The built-in function `divrem` takes two arguments and returns a tuple of two values, the quotient and remainder. You can store the result as a tuple:
Functions can take a variable number of arguments. A parameter name that ends with `...` gathers arguments into a tuple. For example, `printall` takes any number of arguments and prints them one by line:
The complement of gather is scatter. If you have a sequence of values and you want to pass it to a function as multiple arguments, you can use the `...` operator. For example, `divrem` takes exactly two arguments; it doesn’t work with a tuple:
It is common to use tuples as keys in dictionaries. For example, a telephone directory might map from last-name, first-name pairs to telephone numbers. Assuming that we have defined last, first and number, we could write:
Named tuples are a special type of tuple in Julia where each element has a specific name associated with it. This allows you to access elements by their names, making the code more readable and self-explanatory.
