Julia - intro till ett nytt programmeringsspråk

Julia liknar på många sätt Python. Dels för att det ofta används till data science men också för att sättet man skriver koden på är ganska lik. En stor skillnad är dock att Julia är långt mycket snabbare på vissa sysslor och jämförs med att köra kompilerad kod som C.

Vill du ha den kod jag skrivit? Den finns att ladda ner här. Det är bara att ladda ner och sen köra i din Jupyter-miljö (som vi kommer gå igenom strax). Men vi går igenom koden på ett metodiskt sätt om du vill skriva själv.

Kort om Julia (och skillnader gentemot Python)

Julia är ett högnivå-språk och rätt enkelt att lära sig. Det vill säga det är ganska begripligt och beskrivande att läsa. En intressant skillnad mot nästan alla andra språk är att listor börjar med siffran 1 istället för 0 som är brukligt. Om du tänker dig nedan pseudokod:

Skriv ut första saken i listan x

Blir i Python exempelvis:

min_lista = ["kebab", "korv", "pizza"]
print(min_lista[0])

Eftersom man anser att den första positionen i en lista är position noll. Medan man i Julia skriver så här:

min_lista = ["kebab", "korv", "pizza"]
println(min_lista[1])

Det finns två skillnader. I Python skriver man ut med funktionen "print", medan samma sak heter ”println” i Julia (gissar att det står för printline). Den andra skillnaden är att om man vill skriva ut den första maträtten ur "min_lista” i Python så anropar man den på plats 0, medan man i Julia frågar efter plats 1.

Installera en enkel utvecklingsmiljö

Om du helt vill slippa installera kan du testa gratistjänsten JuliaBox (försvinner 31:a oktober, 2019). Hör av dig om du hittar annan bra miljö att köra direkt i webbläsaren. Det finns sätt att köra Julia i Google Colab, men jag har inte testat själv.

För att installera en lokal miljö:

  1. Anaconda - där du också installerar paketet Jupyter
  2. Julia Downloads - välj den versionen som passar din dator (Windows, macOS eller Linux)
  3. IJulia.jl: Julia kernel for Jupyter - för att Julia ska fungera i Jupyter. Se rubriken installation.

Men nedan kodning kommer att utgå ifrån JuliaBox.

Kom igång med JuliaBox

När du registrerat dig, klickat på länken i mejlet, gått tillbaka till JuliaBox.com, loggat in och fyllt i extra personuppgifter så är du igång. Du kommer ha en vy med Jupyters logga uppe till vänster, men ute till höger klickar du på ”New” och väljer en notebook med den högsta versionsnumret för Julia - i skrivande stund 1.0.3.


Psst! Visste du att Julia utgör de två första bokstäverna i Jupyter? "py"-delen är förstås Python, men samma miljö kan med lite kreativitet även användas för Swift eller C# om man hellre vill det.


Noll koll på Jupyter? Gör din första Notebook i Jupyter

Vi börjar med att skapa en ny Notebook.

  1. Först loggar du in på ditt konto hos JuliaBox och om du inte direkt landar i Jupyter så klicka på Jupyter i menyn.
  2. Sedan klickar du på knappen “New” ute till höger och väljer den Julia-versionen som har högst nummer.
  3. Nu kommer du landa i en Jupyter notebook i ett nytt webbläsarfönster.
  4. Namnge din notebook genom att byta ut “Untitled" som står högst upp.

Jupyter består av celler. Vissa celler där man skriver in kod, andra där man har dokumentation och förklaringar (skrivna i språket Markdown). Utan att göra något har du en cell från start. Klicka/markera den och välj “Markdown” istället för “Code” i dropdown-listen. Genom att välja Markdown kan du skriva dokumentation. Skriv nedan i den första cellen:

# Introduktion till Julia
Det här är min första notebook med Julia som språk.

För att färdigställa en cell kan du antingen trycka på knappen "Run" i verktygsfältet eller så kör du knappkommandot Ctrl + Enter. Nu kommer du ha en huvudrubrik (allt efter hashtaggen) och på raden under lite vanlig text. Kolla in Markdown Tutorial om du är förvirrad kring Markdown.

När detta är gjort behöver du en till cell. Tryck på plustecknet i verktygsfältet. Sedan väljer du att även denna cell är Markdown och skriver följande i cellen:

## 01 - Julia säger hej världen
Den klassiska uppgiften när man börjar med ett programmeringsspråk är att be den säga hej till världen.

När vi har två hashtaggar så är det alltså en underrubrik. Gissa om det går att ha tre eller fyra hashtaggar för att ha ännu djupare rubrikstruktur :)

01. Börja från början - säg hej till världen

Nu ska vi stoppa in en cell till och den ska vara av typen "Code". Tryck på plustecknet i verktygsfältet och se till att du valt Code, annars kommer det inte köras som kod.

Så vad är vår första syssla till maskinen som vi ska instruera via Julia? En klassiker är att be maskinen säga hej till världen. Det gör vi på följande sätt genom att anropa funktionen println():

println(Julia säger hej till världen!)

När du skrivit ovanstående kod klickar du antingen på "Run" i verktygsfältet eller tangentbordkommandot Ctrl + Enter. Då kommer det hända något. Det kan vara så att du får ett felmeddelande. Det du då gör är att ta det felmeddelandet och klistra in som en Google-sökning. Det är inte ovanligt att man stavar fel och maskiner har inget som helst överseende för sådant.

Låt säga att jag glömt L:et i println(), då kommer felmeddelandet se ut så här:

UndefVarError: printn not defined

Ibland ser man direkt vad man gjort för fel, ibland känner man igen sitt felmeddelande. Du ska inte tro att rutinerade utvecklare inte skriver fel emellanåt :)

Vad gör ovanstående kod?

Vi använder funktionen println(), skriver in citationstecken (Shift + 2 alltså) och skriver vårt budskap. Det kommer sedan att skrivas ut ordagrant direkt under vår cell med kod. Det är så vi kan interagera med maskinen. Be den göra något och sedan berätta resultatet för oss.

02. Lite enkel matematik i Julia

Maskiner är väldigt bra på matematik. Allt som är siffror löser de hur lätt som helst. Så låt oss testa lite matte i Julia. Att skapa en ny cell i Jupyter kan du vid det här laget, så gör en sådan.

Kommentarer i kod

Och ja, vi introducerar också här hur man skriver kommentarer i sin kod. En kommentar är ett stycke text bakom en hashtagg och kommer inte köras av maskinen, de är mest där som en påminnelse för oss som läser och försöker förstå koden.

Variabler i Julia…

Är precis som variabler i nästan alla andra språk jag stött på. Men det här med att man kan definiera en variabels datatyp lämnar jag till en uppföljare till denna bloggpost. Så här långt behöver du bara tänka på en variabel som en behållare för något. Jag brukar likna variabelns namn som etiketten du hoppas sitter kvar på fryspåsen när du letar något gott i frysen.

Det finns massor med åsikter om hur den optimala namngivningsstandarden ser ut, men huvudsaken är att det finns lite omsorg bakom namnet. Precis som att du kanske inte sätter ditt liv i pant på att gissa innehållet i en ogenomskinlig fryspåse med etiketten “Rester 2016” är det bra om namnet avslöjar dess innehåll. Det är lätt att tro att man skrivit ett bra variabelnamn. Sen återkommer man till samma kod efter några veckor och kliar sig i huvudet.

# allt bakom en hashtag/brädgård är en kommentar
# denna kod körs inte
min_variabel = 3 + 9
println(min_variabel)

println(1 / 3)

I detta stycke med Julia-kod har vi två stycken println(), därför kommer det skrivas ut två saker under kod-cellen. Här introducerade vi kommentarer i kod och variabler.

03. Listor i Julia

Listor är egentligen inte konstigare än en samling av något. I detta kodexempel blir det en variabel som fylls med textsträngar med snabbmat. Listan kan förstås fyllas med heltal, decimaltal eller lite vad som helst.

Om du tidigare programmerat kommer du säkert reagera på att när vi på rad 2 hämtar den första saken ur listan skriver en etta innanför klammerparenteserna. Ja, så ser det ut i Julia. I alla andra språk jag skrivit hade man angett en nolla för att få ut det som ligger först i en lista. Så det som skrivs ut är alltså textsträngen “kebab”.

Senare kommer vår första iterator, en for-loop. Så som den är skriven här så jobbar den sig igenom hela listan tills den är klar. Varje sak i listan ges det tillfälliga variabelnamnet “mat” vilket vi inne i for-loopen skriver ut.

min_lista = ["kebab", "korv", "pizza"]
println(min_lista[1])

# Att det står \n i funktionen println() är inte ett skrivfel
# det ger en tom rad och bara estetiskt :)
println("\nNu skriver vi ut hela listan med mat:")
for mat in min_lista
    println(mat)
end

Glöm inte att skriva “end” på slutet, det gjorde jag. Något annat man kan missa är att det blir fel på indraget “inne” i en for-loop. Det ska alltså vara en tabb in från vänsterkanten för att detta ska fungera.

För lite nördhumor angående tabb och mellanslag: Tabs versus Spaces från serien Silicon Valley.

04. Dags för en enkel funktion i Julia

Funktioner har man för att kunna återanvända viss kod. Så den inte behöver skrivas på nytt om och om igen. När man väl skrivit en funktion kan man anropa den och på så sätt ha löst en specifik syssla en gång för alla.

Här kommer lite kod som inleds med en funktion:

function omkrets_rektangel(kortsida, langsida)
    omkrets = (kortsida * 2) + (langsida * 2)

    return omkrets
end

min_kortsida = 7
min_langsida = 9

# variabeln omkrets kommer innehålla 
# funktionens svar på (7 * 2) + (9 * 2)
# det vill säga siffran 32
omkrets = omkrets_rektangel(min_kortsida, min_langsida)

println(omkrets)

Först gjorde vi en funktion för att räkna ut en rektangels omkrets. När funktionen var avslutad skapade vi två variabler som innehöll längden på långsidan och kortsidan. Sedan blev det en variabel för rektangeln som sattes till värdet av omkrets-funktionen, som på samma rad matades med kort- och långsidans längder.

Detta är en abstraktion. Funktionen bryr sig inte om nästan någonting, den vet bara vad den ska göra med de två ingående värdena. Den har en formel, en algoritm, för vad den ska göra. Sen om vi matar den med text istället för siffror kommer den att krascha. Att validera datatyp kommer vi in på någon annan gång. Just nu är det viktigt att det är siffror vi skickar in i funktionen.

05. Nyttigheter i språket

Alla programmeringsspråk har inbyggda grejer i sitt "standardbibliotek" med färdigheter. Det är lite olika hur mycket man har tillgång till utan att börja importera extra bibliotek. Ett exempel på sådan färdighet är att vi inte behövde lära maskinen hur den skriver ut något på skärmen, vi anropar bara println() och maskinen vet redan vad det betyder. Samma sak med for-loopen, vi skrev på ett visst sätt och saker hände.

Ge mig variabelns datatyp

Några grejer jag tänkte lyfta fram är funktionen typeof() som gör att man får reda på vad en variabel/objekt är av för sort. Redan i första println() nedan kommer något nytt. Man kan skilja flera saker med kommatecken för att få dem utskrivna tillsammans. I detta fallet en förklarande textsträng innan resultatet av vad variabeln “rektangel” är för sorts datatyp.

Avrunda ett tal till två decimaler

Sen kommer vi in på avrundning av decimaltal, det görs rätt begripligt av funktionen round() där du först stoppar in talet du vill avrunda och sedan talar om antalet siffror till höger om decimaltecknet.

Under 2019 har jag kört en del workshops i programmering, där vi övat på maskininlärning genom språket Python. Ett sätt att visa hur annorlunda programmering är jämfört med att räkna med papper, penna och faktakunskaper är att ställa sig frågan vad talet Pi är. Hur många decimaler kan du och tror du att det är viktigt om du programmerar? Det visar sig att även i Julia är inte det talet längre bort än att skriva “pi”.

# vad var det för datatyp  variabeln 'omkrets' i 
# föregående kodexempel?
println("Datatyp: ", typeof(omkrets))

# ett delat  tre ger en massa decimalpositioner
en_tredjedel = 1 / 3
println(en_tredjedel)
# om vi dubblar 1/3 och avrundar till två decimaler
avrunda = round(en_tredjedel * 2, digits=2)
println(avrunda)

# hur många decimaler av pi kan du?
println("Pi är: ", pi)

Så hur skulle du skriva en egen funktion som räknar ut omkretsen på en cirkel? Formeln är som du kanske minns att π = omkrets / diameter, alternativt att omkretsen är omkrets = diameter * π

Avslutningsvis

Detta var en kort intro med den kod jag själv började med för att bekanta mig med Julia som programmeringsspråk. Det kommer säkert en eller flera uppföljare senare här i bloggen.

Julia känns som ett vettigt språk och liknar Python rätt mycket, vilket jag vid det här laget är mest van vid. Men sedan finns delar som att man skriver “end” för att avsluta. Jag är minst sagt ringrostig på Visual Basic, men minns det som att man där också skrev ut något liknande, vilket även gäller mallspråket Jinja. Till skillnad från C# som var mer Java-inspererat och kapslade in allt i måsvingar { … } vilket jag nog ändå föredrar så man slipper lusläsa sin kod var den misslyckade avskiljaren ska in.

Mer om Julia


Publicerad: 2019-10-14
Kategori: Digitalisering
Tagg: Julia Programmering Markdown Jupyter

‹ bloggen

Hör av dig