Julia-programmeertutorial voor beginners

Hoe installeer en start je Julia? 

Julia installeren is eenvoudig. Download de installer voor jouw besturingssysteem op deze pagina van de Julia-website en vink het vakje aan dat Julia toevoegt aan het systeem-PATH. Als je julia in de command line typt en de volgende output krijgt, draait alles goed.

Julia installeren en uitvoeren

Zowel PyCharm als VSCode bieden Julia-plugins met ondersteuning voor code-highlighting en debuggen. Omdat data scientists echter vaak in JupyterLab werken, is het ook makkelijk om een Julia-kernel aan JupyterLab toe te voegen. Nadat je de julia-prompt in de terminal hebt geopend, voer je simpelweg deze twee regels in:

using Pkg
add("IJulia")

De code voegt het pakket IJulia toe aan de Julia-installatie op het systeem. Herstart eventuele actieve JupyterLab-sessies en je zou de Julia-optie in de Launcher moeten zien.

Julia draait in JupyterLab

Basis­synthax van Julia

In deze sectie behandelen we de basis van de Julia-syntax, waaronder variabelen, datatypen, operatoren, vectoren, enzovoort.

Operatoren  

In programmeren zijn er speciale tekens, operatoren genoemd, die specifieke wiskundige of logische processen voorstellen. Hieronder zie je de meest voorkomende operatoren, waaronder optellen, aftrekken, vermenigvuldigen, delen en meer. 

Opmerking: In Julia schrijf je commentaar met een enkel  #-teken. Alles wat na de # staat, wordt genegeerd door het programma (tot het einde van de regel).

# Addition in Julia
37 + 73

110

# Subtraction in Julia
17 - 19

-2

# Multiplication in Julia
29 * 33

957

# Division in Julia
22 / 7

3.142857142857143

# Backwards division in Julia, the above is equal to 0 / 5.
5 \ 0

0

# The remainder operator in Julia 
98456 % 23

16

# Raising to the power 2 (squaring)
(22 / 7) ^ 2

9.877551020408163

# Raising to the power 3 (cubing)
-7 ^ 3

-343

# Raising to the power 0.5 (square-rooting)
(355 / 133) ^ 0.5

1.633760365638372

Variabelen

In programmeren gebruiken we variabelen om informatie op te slaan. Variabelen maken het makkelijk om naar een stukje informatie te verwijzen via een naam. Hier slaan we bijvoorbeeld het getal 73 op in een variabele a, en de string “Hello world!” in de variabele “word” (we bekijken Julia’s verschillende datatypen in de volgende sectie). De naam van de variabele in de command line typen, print de waarde.

# Storing the number 73 in a variable a
a = 73
a

73

# Storing "Hello world!" in word
word = "Hello world!"
word

Hello world!

Alle Julia-operatoren en -functies werken hetzelfde op variabelen.

# Multiplying two numeric variables
a = 73
b = 37
a * b

2701

Je kunt elk alfanumeriek teken gebruiken in variabelenamen, inclusief underscores. Er zijn echter bepaalde conventies in het benoemen ervan in Julia. Variabelenamen:

• zijn lower_snake_case (kleine letters en woorden gescheiden door een underscore)
• mogen niet met een cijfer beginnen.

Introductie tot datatypen in Julia 

Datatypen vertellen het programma welke waarden een variabele kan aannemen en welke wiskundige of logische operatoren erop gebruikt kunnen worden zonder een fout te veroorzaken. Er zijn verschillende datatypen in Julia, hieronder vind je de meest basale.

Het datatype van een variabele kun je printen met de functie typeof():

# Getting the type of 3.14
typeof(3.14)

Float64

Bij het uitvoeren van bewerkingen in Julia moet je letten op de gevolgen van verschillende datatypen. Zo levert het vermenigvuldigen van een float met een integer een float op.

# Bank balance as an integer
balance = 100

# Interest rate as a float
interest_rate = 1.05

# Interest rate as a float
new_balance = balance * interest_rate

typeof(new_balance)

Float64

Omgekeerd leidt het uitvoeren van bewerkingen op strings en numerieke datatypen vaak tot een fout. Zoals het volgende.

# Bank balance as an integer
balance = 100

# Interest rate as a string
interest_rate = “5%”

# Interest rate as a float
new_balance = balance * interest_rate

ERROR: MethodError:
no method matching *(::Int64, ::String)

Datatypen converteren in Julia 

Het is mogelijk om verschillende datatypen in Julia om te zetten naar andere datatypen met ingebouwde functies. Hieronder staat een tabel met hoe je verschillende datatypen in Julia converteert. 

Werken met tekens en strings in Julia 

We zagen de datatypen character en string in de vorige sectie; in deze sectie duiken we dieper in veelvoorkomende bewerkingen met tekens en strings. Ter herinnering: een string is een geordende reeks tekens of gewone tekst tussen dubbele aanhalingstekens. 

# A string is a series of characters
word = "Hello world!"
word

"Hello world!"

Voor een multi-line string kun je drievoudige aanhalingstekens gebruiken:

multi_line = """
   This is a
   multi-line string.
"""
print(multi_line)

This is a
multi-line string.

Je kunt op verschillende manieren informatie en eigenschappen uit strings halen. Zo kun je met bracket-indexering individuele tekens of een bereik van tekens extraheren op basis van hun positie. In dit voorbeeld staat 1:3 voor de reeks getallen van 1 tot en met 3.

text = "Julia is a high-level, dynamic programming language"
# Extracting the first character in text based on its index
text[1]

'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

# Extracting the first three characters in text based on its index
text[1:3]

"Jul"

Boven zetten we 1 tussen de haken en dat levert het eerste teken op. Je kunt ook de speciale begin-operator gebruiken:

# Extracting the first character in text with the begin operator
text[begin]

'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

Als je één enkel teken uit een string haalt, heeft het het datatype Char.

# Extract the type of the fourth character
typeof(text[4])

Char

# Extract the type of the fourth character
typeof(text[4])

Als je daarentegen een string slice’t en meer dan één teken extraheert, is de output ook een string. 

# Extract the type of the first 5 characters
typeof(text[begin:5])

String

Hierboven nemen we de eerste vijf tekens van text. Let erop dat beide indices aan weerszijden van de dubbele punt inclusief zijn. In tegenstelling tot Python worden negatieve indices niet ondersteund. In plaats daarvan gebruik je de end-operator met een negatief getal. Om bijvoorbeeld het derde teken vanaf het einde van de string te krijgen, kun je het volgende schrijven. 

# Third from the end of the string
text[end-2]

'a': ASCII/Unicode U+0067 (category Ll: Letter, lowercase)

Veelvoorkomende stringbewerkingen in Julia 

Je kunt de functie length() gebruiken om het aantal tekens in een string te tellen.

# Count the number of characters in a string
length(text)

51

Een veelvoorkomende taak is om twee of meer strings samen te voegen. Dat kan met de functie string(), waarbij je strings door komma’s gescheiden doorgeeft.

# Creating one string from "Julia", "is", "awesome"
string("Julia ", "is ", "awesome!")

"Julia is awesome!"

Je kunt ook de * (vermenigvuldigings)operator gebruiken om strings samen te voegen

# Creating one string by multiplying strings
"73 " * "is " * "the " * "best " * "prime."

"73 is the best prime."

Vergeet in beide gevallen niet een spatie tussen de woorden te laten. Een andere manier om strings te koppelen is door een string meerdere keren te herhalen. Zo doe je dat met de ^ (machts)operator:

# Creating one string with the exponentiation operator
"Three times the fun!" ^ 3

"Three times the fun! Three times the fun! Three times the fun!"

Arrays in Julia 

Een ander veelgebruikt datatype in Julia en andere talen zijn arrays, zoals ze in Julia heten. Arrays zijn een lijst met waarden tussen vierkante haken []. Arrays worden anders genoemd op basis van hun dimensies. 

• Eendimensionale arrays heten vectoren.
• Tweede­mensionale arrays heten matrices.
• Driedimensionale arrays en hoger heten gewoon arrays.

In deze tutorial focussen we uitsluitend op vectoren. Vectoren kun je maken door items tussen een paar haken te zetten, zoals hieronder.

# Define a three-integer vector
x = [1, 2, 3]

3-element Vector{Int64}:
1
2
3

# Get the type of x
typeof(x)

Vector{Int64} (alias for Array{Int64, 1})

De vector x heeft het type Vector, wat een alias is voor een eendimensionale array (zoals te zien is in de output alias for Array{In664, 1}). Alle elementen hebben het datatype Int64. Maar dat betekent niet dat alle elementen altijd hetzelfde type moeten hebben. Hier is bijvoorbeeld een vector met elementen van verschillende types. 

# Define a vector with various data types
array = [1, "Hello", 22/7]

3-element Vector{Any}:
1
"Hello"
3.142857142857143

Zoals je ziet hebben de vector­elementen het datatype Any tussen de accolades, wat meerdere datatypen voorstelt. Je kunt zelfs vectoren in vectoren stoppen.

# Define a vector with various data types, including another vector
array = [1, 2, 3, ["Hello", 73]]

4-element Array{Any,1}:
1
2
3
Any["Hello", 73]

De functie length() werkt hetzelfde op vectoren als op strings: het telt het aantal elementen in de array.

# Get the length of a vector
length(array)

3

Indexeerregels werken ook vergelijkbaar — hier indexeren we het eerste en tweede element in de array.

# Get the first element of a vector
array = [1, "Hello", 22/7]
array[begin]

1

# Get the last element of a vector
array[end-1]

"Hello"

Booleaanse operatoren en numerieke vergelijkingen 

Programmeertalen gebruiken Booleaanse waarden om logica te implementeren. Een Boolean kan slechts twee waarden hebben: true of false. Booleans zijn vooral handig bij numerieke vergelijkingen en Booleaanse operatoren. Laten we eerst kijken naar numerieke vergelijkingen.

Numerieke vergelijkingsoperatoren in Julia

In de tabel hieronder vind je de meest gebruikte numerieke vergelijkingsoperatoren in Julia. Zoals je in de voorbeelden ziet, kun je Booleans, numerieke objecten en meer vergelijken met numerieke vergelijkingsoperatoren. Merk op dat je één of twee symbolen kunt gebruiken om kleiner/groter dan of gelijk aan te schrijven. Voor de versie met één symbool typ je \le gevolgd door TAB of \ge gevolgd door TAB.

Booleaanse operatoren in Julia

Naast numerieke vergelijkingen zijn er Booleaanse operatoren — zoals and/or. Daarmee kun je twee of meer Booleaanse expressies combineren tot één. Hieronder vind je de meest voorkomende Booleaanse operatoren en hoe je ze gebruikt. 

Intermediaire Julia-syntax

Voorwaardelijke statements in Julia

Met Booleaanse waarden en operatoren kun je voorwaardelijke statements schrijven. Bijvoorbeeld: als iets evalueert naar true — voer een bewerking uit. Als het false is, voer je een andere uit. Voorwaardelijke statements worden ook wel if/else-statements genoemd. Zo schrijf je ze:

if true
   print("Do something")
else
   print("Do something else")
end

Wanneer een voorwaarde na het sleutelwoord if evalueert naar true, wordt het if-blok uitgevoerd; anders wordt het else-blok uitgevoerd. Dit voorbeeld laat een voorwaarde zien die controleert of een getal even of oneven is.

number = 5

if number % 2 == 0
   print("The number is even")
else
   print("The number is odd")
end

The number is odd

In de expressie na if gebruiken we de modulus-operator, %, om te controleren of het getal 0 als restwaarde heeft als het door 2 wordt gedeeld. Dat evalueert naar false omdat de rest bij het delen van 5 door 2 gelijk is aan 1. Daarom wordt de else-clausule uitgevoerd. Laten we nu onze kennis van Booleaanse operatoren en voorwaardelijke statements gebruiken om een programma te schrijven dat controleert of een getal positief, negatief of nul is. 

number = 0

if number > 0
   print("The number is positive.")
elseif number == 0
   print("The number is equal to zero.")
else
   print("The number is negative.")

end

The number is equal to zero.

We voegen de nieuwe voorwaarde toe met de elseif-clausule. Je gebruikt elseif-clausules wanneer je twee of meer voorwaarden in exacte volgorde moet controleren. 

For-loops 

Een for-loop wordt gebruikt om te itereren en bewerkingen uit te voeren op elk element van een reeks (string, vector, tuple, set, enz.) in volgorde. De for-loop-syntax is in Julia eenvoudig. Laten we bijvoorbeeld een loop bouwen die elk element van een vector print:

languages = ["Julia", "Python", "R"]

for lang = languages
   println(lang)

end

Julia
Python
R

De for-loop begint met het sleutelwoord for. Vervolgens kies je een tijdelijke variabelenaam. In dit geval kiezen we lang, waarvan de waarde verandert terwijl we door de vector languages lopen. Om aan te geven dat we door languages itereren, schrijven we de naam na de toewijzingsoperator =.

Binnen de loop gebruiken we de functie println() om elk element van languages te printen, weergegeven door de tijdelijke variabele lang. lang heet een tijdelijke variabele omdat deze niet meer toegankelijk is zodra de loop klaar is.

Opmerking: Het verschil tussen print() en println() is dat println() items op nieuwe regels print.

Je kunt alles wat je tot nu toe hebt geleerd binnen for-loops gebruiken. Laten we bijvoorbeeld een array van 10 gehele getallen maken en alleen de oneven getallen printen:

integers_vector = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for i = integers_vector
   # Print only odd numbers
   if i % 2 == 1
       println(i)
   end
end

1
3
5
7
9

Vergeet niet zowel de for-loop als de if-statement af te sluiten met end.

Je kunt ook door strings itereren, omdat dit ook reeksen zijn. Hier printen we bijvoorbeeld elke letter in de string "Julia".

for letter = "Julia"
   println(letter)

end

J
u
l
i
a

Pakketten installeren in Julia 

Alle operatoren (+, -, *, ^), functies (print(), println(), typeof()) en sleutelwoorden (for, if, else) die we gebruiken, worden meegeleverd met de Julia-installatie. Maar de code in de installatie is niet genoeg om al onze problemen op te lossen. We moeten pakketten installeren om tools en functies voor extra functionaliteit te laden. Pakketten zijn bibliotheken met vooraf geschreven code (door andere programmeurs) die we aan onze Julia-installatie kunnen toevoegen en die ons helpen specifieke problemen op te lossen.

Zo installeren we twee pakketten genaamd DataFrames en CSV die ons helpen informatie in CSV-bestanden te manipuleren. Zo doe je dat:

using Pkg
Pkg.add("DataFrames")
Pkg.add("CSV")

De klasse Pkg is een globale Julia-pakketmanager. De functie add() voegt nieuwe pakketten toe aan de installatie. Om alle functienamen uit de bibliotheken te importeren, importeren we ze met het sleutelwoord using bovenaan onze scripts.

using DataFrames
using CSV

We gebruiken hun functies in de volgende sectie.

Aan de slag met DataFrames 

Een DataFrame is een speciaal datatype in datawetenschaps­talen zoals Julia, Python of R, ontworpen om met tabellen te werken. Het meest populaire bestandsformaat voor het opslaan van tabellen is een CSV (comma-separated values). De bibliotheek DataFrame heeft de tools om zulke bestanden te laden en de informatie erin te manipuleren.

CSV-bestanden importeren

Voor deze tutorial importeren we de diamonds-dataset. Het bestand diamonds.csv ziet er zo uit:

Bekijk de diamonds-dataset hier

De eerste regel heet de header en bevat de kolomnamen. Laten we hem laden met de pakketten CSV en DataFrames.

# Load in the diamonds DataFrame
diamonds = DataFrame(CSV.File("data/diamonds.csv"))
typeof(diamonds)

DataFrame

We geven het pad naar het CSV-bestand door aan CSV.File(), dat vervolgens wordt doorgegeven aan de functie DataFrame(). De output van typeof() laat zien dat de operatie geslaagd is.

Eenvoudige datamanipulatie 

Het eerste wat je altijd doet met een nieuw DataFrame, is een paar rijen printen om te zien hoe het eruitziet. Dat kan met de functie first().

# Print the first 7 rows of diamond
first(diamonds, 7)

7 × 10 DataFrame

De eerste 7 rijen van de diamonds-dataset

De functie first() retourneert de eerste n rijen van een DataFrame. Zoals we zien zijn er 6 numerieke en 3 categorische (tekst)kolommen. De index wordt in Julia DataFrames ook als kolom geteld. 

Er is ook de functie last() die vergelijkbaar werkt met first(). Je raadt al wat die doet op basis van de naam. Juist, die haalt de laatste n rijen op.

Een andere nuttige functie is size(). Die print het aantal rijen en kolommen van een DataFrame.

# Print the dimensions of diamonds
size(diamonds)

(10000, 10)

De onze heeft 10 duizend rijen en 10 kolommen (inclusief de index). Met het blote oog kun je niet alle 10k rijen beoordelen, dus gebruiken we samenvattende statistieken om een gevoel te krijgen voor de verdeling van de kolommen in onze dataset. Daarvoor gebruiken we de functie describe()

# Summary statistics of diamonds using describe()
describe(diamonds)

10 × 7 DataFrame

Output van de functie describe()
De output is een samenvattingstabel met 7 kolommen. De kolommen min, max, mean en median zijn alleen van toepassing op numerieke kolommen. In de kolom eltype zie je de datatypen van elke kolom in diamonds. De getallen naast String verwijzen naar de lengte van de langste string in die kolom.
Je kunt ook de volgende syntax gebruiken om individuele kolommen uit het DataFrame te selecteren.
# Extracting the first 10 rows of the cut column
diamonds[:, :cut][begin:10]
10-element PooledArrays.PooledArray{String15,UInt32,1,Array{UInt32,1}}:

"Ideal"
"Ideal"
"Ideal"
"Premium"
"Fair"
"Premium"
"Very Good"
"Ideal"
"Ideal"
"Premium"
De eerste dubbele punt binnen de haken selecteert alle rijen. Daarna specificeren we de kolomnaam na een komma en nog een dubbele punt (zonder aanhalingstekens). Vervolgens gebruiken we indexering op de geretourneerde array om de eerste tien rijen te selecteren. Om de bovenstaande code nog eenvoudiger te maken, zouden we de eerste tien rijen direct binnen de eerste haken kunnen selecteren zoals hieronder:
# Extracting the first 10 rows of the cut column
diamonds[1:10, :carat]
10-element PooledArrays.PooledArray{String15,UInt32,1,Array{UInt32,1}}:

"Ideal"
"Ideal"
"Ideal"
"Premium"
"Fair"
"Premium"
"Very Good"
"Ideal"
"Ideal"
"Premium"
Om meerdere kolommen te selecteren, zet je de kolomnamen (met dubbele punt) tussen haken.
# Extracting the first 5 rows of the cut, carat, price columns
diamonds[1:5, [:carat, :cut, :price]]
5 × 3 DataFrame

De eerste 5 rijen en 3 kolommen van de diamonds-dataset
Laten we de functie describe() alleen op de numerieke kolommen draaien
# Running describe on numeric columns only
describe(diamonds[:, [:carat, :depth, :table, :price, :x, :y]])

describe() uitvoeren op alleen numerieke kolommen
Om het DataFrame oplopend te sorteren op basis van een kolom gebruik je de functie sort():
# Sort diamonds and see the first 5 rows
sorted_diamonds = sort(diamonds, :price)
first(sorted_diamonds, 5)

De gesorteerde samenvattingstabel
Om aflopend te sorteren, wikkel je de functie order() om de kolomnaam.
# Sort diamonds in descending order and see the first 5 rows
sorted_diamonds = sort(diamonds, order(:price, rev=true))
first(sorted_diamonds, 5)



De gesorteerde samenvattingstabel, aflopend

Top! Je kunt nu DataFrames laden en basale data-exploratie uitvoeren.
Meer leren over Julia 
Hoewel Julia een jonge programmeertaal is, zijn er al volop resources om de taal onder de knie te krijgen. Hier zijn er een paar om je skills te boosten:

De opkomst van Julia — Is het de moeite waard om het in 2022 te leren?
Overstappen van MATLAB naar Julia
Bekijk onze cheat sheets, over alle datatools en -technologieën, waaronder Julia
Bekijk onze Introduction to Julia-cursus