Julia-Programmier-Tutorial für Einsteiger

Wie installiere und starte ich Julia?

Die Installation von Julia ist unkompliziert. Lade den Installer für dein Betriebssystem auf dieser Seite der Julia-Website herunter und setze das Häkchen, um Julia zum System-PATH hinzuzufügen. Wenn du julia in die Kommandozeile eingibst und folgende Ausgabe erhältst, läuft alles korrekt.

Installation und Start der Programmiersprache Julia

Sowohl PyCharm als auch VSCode bieten Julia-Plugins mit Syntax-Highlighting und Debugging. Da Data Scientists jedoch häufig in JupyterLab arbeiten, lässt sich dort auch leicht ein Julia-Kernel hinzufügen. Öffne im Terminal die julia-Eingabeaufforderung und gib diese zwei Zeilen ein:

using Pkg
add("IJulia")

Der Code installiert das Paket IJulia in deiner Julia-Umgebung. Starte laufende JupyterLab-Sitzungen neu, dann solltest du Julia im Launcher sehen.

Julia in JupyterLab

Grundlegende Julia-Syntax

In diesem Abschnitt behandeln wir die Grundlagen der Julia-Syntax, darunter Variablen, Datentypen, Operatoren, Vektoren und mehr.

Operatoren

In Programmiersprachen stehen spezielle Zeichen, sogenannte Operatoren, für bestimmte mathematische oder logische Operationen. Unten siehst du die gebräuchlichsten Operatoren, etwa für Addition, Subtraktion, Multiplikation, Division und mehr.

Hinweis: In Julia werden Kommentare mit einem einzelnen # geschrieben. Alles, was nach dem # steht, wird vom Programm ignoriert (bis zum Zeilenende).

# Addition in Julia
37 + 73

110

# Subtraktion in Julia
17 - 19

-2

# Multiplikation in Julia
29 * 33

957

# Division in Julia
22 / 7

3.142857142857143

# Rückwärtsdivision in Julia, das Obige entspricht 0 / 5.
5 \ 0

0

# Der Restoperator in Julia 
98456 % 23

16

# Potenzieren mit Exponent 2 (Quadrieren)
(22 / 7) ^ 2

9.877551020408163

# Potenzieren mit Exponent 3 (Kubieren)
-7 ^ 3

-343

# Potenzieren mit Exponent 0.5 (Quadratwurzel)
(355 / 133) ^ 0.5

1.633760365638372

Variablen

Wir verwenden Variablen, um Informationen zu speichern. Damit kannst du über einen Namen bequem auf einen Wert verweisen. Im Beispiel speichern wir die Zahl 73 in der Variablen a und den String "Hello world!" in der Variablen word (auf die verschiedenen Datentypen in Julia gehen wir gleich ein). Wenn du den Variablennamen in die Konsole eingibst, wird ihr Wert ausgegeben.

# Die Zahl 73 in der Variablen a speichern
a = 73
a

73

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

Hello world!

Alle Julia-Operatoren und -Funktionen funktionieren genauso mit Variablen.

# Zwei numerische Variablen multiplizieren
a = 73
b = 37
a * b

2701

In Variablennamen kannst du alphanumerische Zeichen inklusive Unterstrichen verwenden. Es gibt jedoch gängige Konventionen. Variablennamen:

• verwenden lower_snake_case (klein geschrieben, Wörter durch Unterstrich getrennt)
• dürfen nicht mit einer Zahl beginnen.

Einführung in Datentypen in Julia

Datentypen geben an, welche Werte eine Variable annehmen kann und welche Operationen darauf zulässig sind. Julia kennt viele Datentypen, hier sind die wichtigsten Grundlagen.

Den Datentyp einer Variable ermittelst du mit der Funktion typeof():

# Den Typ von 3.14 abfragen
typeof(3.14)

Float64

Bei Operationen in Julia solltest du die Auswirkungen unterschiedlicher Datentypen im Blick behalten. Zum Beispiel ergibt die Multiplikation eines Floats mit einem Integer wieder einen Float.

# Kontostand als Integer
balance = 100

# Zinssatz als Float
interest_rate = 1.05

# Neuer Kontostand
new_balance = balance * interest_rate

typeof(new_balance)

Float64

Hingegen führen Operationen zwischen Strings und numerischen Datentypen oft zu einem Fehler, wie hier:

# Kontostand als Integer
balance = 100

# Zinssatz als String
interest_rate = “5%”

# Neuer Kontostand
new_balance = balance * interest_rate

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

Datentypen in Julia konvertieren

In Julia kannst du Datentypen mit eingebauten Funktionen umwandeln. Die folgende Tabelle zeigt gängige Konvertierungen.

Mit Zeichen und Strings in Julia arbeiten

Wir haben die Datentypen Char und String schon gesehen. Jetzt schauen wir uns typische Operationen darauf an. Zur Erinnerung: Ein String ist eine geordnete Folge von Zeichen in Anführungszeichen.

# Ein String ist eine Folge von Zeichen
word = "Hello world!"
word

"Hello world!"

Mehrzeilige Strings schreibst du mit dreifachen Anführungszeichen:

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

This is a
multi-line string.

Aus Strings kannst du Informationen und Eigenschaften auf verschiedene Arten extrahieren. Klammerindizes greifen einzelne Zeichen oder Bereiche basierend auf ihrer Position ab. Im Beispiel steht 1:3 für die Zahlenfolge von 1 bis 3, inklusive.

text = "Julia is a high-level, dynamic programming language"
# Das erste Zeichen in text per Index auslesen
text[1]

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

# Die ersten drei Zeichen per Index auslesen
text[1:3]

"Jul"

Oben haben wir 1 in die Klammern gesetzt und das erste Zeichen erhalten. Alternativ kannst du auch den speziellen Operator begin verwenden:

# Erstes Zeichen mit dem begin-Operator auslesen
text[begin]

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

Ein einzelnes extrahiertes Zeichen aus einem String hat den Datentyp Char.

# Den Typ des vierten Zeichens ermitteln
typeof(text[4])

Char

# Den Typ des vierten Zeichens ermitteln
typeof(text[4])

Schneidest du mehrere Zeichen aus, ist das Ergebnis wieder ein String.

# Den Typ der ersten 5 Zeichen ermitteln
typeof(text[begin:5])

String

Hier schneiden wir die ersten fünf Zeichen von text aus. Beide Indizes links und rechts vom Doppelpunkt sind inklusive. Anders als in Python werden negative Indizes nicht unterstützt. Stattdessen nutzt du den end-Operator mit einer negativen Zahl. Um z. B. das drittletzte Zeichen zu holen, schreibst du:

# Drittletztes Zeichen im String
text[end-2]

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

Häufige String-Operationen in Julia

Mit length() zählst du die Anzahl der Zeichen in einem String.

# Anzahl der Zeichen in einem String
length(text)

51

Häufig willst du Strings zusammenfügen. Das geht mit der Funktion string(), der du mehrere Strings durch Kommata getrennt übergibst.

# Einen String aus "Julia", "is", "awesome" zusammensetzen
string("Julia ", "is ", "awesome!")

"Julia is awesome!"

Du kannst Strings auch mit dem *-Operator verketten.

# Einen String durch Multiplikation verketten
"73 " * "is " * "the " * "best " * "prime."

"73 is the best prime."

In beiden Fällen gilt: Leerräume zwischen Wörtern nicht vergessen. Eine weitere Möglichkeit ist, einen String mehrfach zu wiederholen. Das geht mit dem Operator ^ (Potenzieren):

# Einen String mit dem Potenzoperator wiederholen
"Three times the fun!" ^ 3

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

Arrays in Julia

Ein weiterer zentraler Datentyp in Julia sind Arrays. Sie sind Listen von Werten in eckigen Klammern []. Je nach Dimension heißen sie unterschiedlich:

• Eindimensionale Arrays heißen Vektoren.
• Zweidimensionale Arrays heißen Matrizen.
• Dreidimensionale und höhere heißen einfach Arrays.

In diesem Tutorial konzentrieren wir uns auf Vektoren. Du erstellst sie, indem du Elemente in Klammern setzt:

# Einen Vektor mit drei Integern definieren
x = [1, 2, 3]

3-element Vector{Int64}:
1
2
3

# Den Typ von x abfragen
typeof(x)

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

Der Vektor x hat den Typ Vector, also ein Alias für ein eindimensionales Array (alias for Array{Int64, 1}). Alle Elemente sind vom Typ Int64. Das muss aber nicht immer so sein. Hier ein Vektor mit gemischten Typen:

# Einen Vektor mit verschiedenen Datentypen definieren
array = [1, "Hello", 22/7]

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

Wie du siehst, steht im Typparameter Any, was für gemischte Datentypen steht. Du kannst sogar Vektoren in Vektoren schachteln.

# Einen Vektor mit verschiedenen Datentypen, inkl. eines Vektors, definieren
array = [1, 2, 3, ["Hello", 73]]

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

length() funktioniert bei Vektoren wie bei Strings und zählt die Elemente im Array.

# Die Länge eines Vektors ermitteln
length(array)

3

Auch das Indexieren funktioniert ähnlich — hier greifen wir auf das erste und zweite Element zu.

# Erstes Element eines Vektors holen
array = [1, "Hello", 22/7]
array[begin]

1

# Letztes Element eines Vektors holen
array[end-1]

"Hello"

Boolesche Operatoren und numerische Vergleiche

Programmiersprachen nutzen Boolesche Werte zur Logik. Ein Boolean kann nur true oder false sein. Sie sind besonders nützlich bei numerischen Vergleichen und booleschen Operatoren. Schauen wir uns zuerst numerische Vergleiche an.

Operatoren für numerische Vergleiche in Julia

In der folgenden Tabelle findest du die gebräuchlichsten Vergleichsoperatoren in Julia. Wie die Beispiele zeigen, kannst du damit Booleans, Zahlenobjekte und mehr vergleichen. Beachte: Du kannst kleiner/gleich bzw. größer/gleich mit einem oder zwei Symbolen schreiben. Für die Ein-Symbol-Variante tippe \le und dann TAB bzw. \ge und dann TAB.

Boolesche Operatoren in Julia

Neben Vergleichsoperatoren gibt es boolesche Operatoren wie and und or. Damit kombinierst du mehrere Ausdrücke zu einem. Hier sind die wichtigsten Operatoren und ihre Verwendung.

Fortgeschrittene Julia-Syntax

Bedingungen in Julia

Mit Booleschen Werten und Operatoren schreibst du Bedingungen: Wenn etwas true ist, führe eine Aktion aus, sonst eine andere. Solche Konstrukte heißen if/else-Anweisungen. So schreibst du sie:

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

Wenn die Bedingung nach dem Schlüsselwort if zu true ausgewertet wird, läuft der if-Block, andernfalls der else-Block. Dieses Beispiel prüft, ob eine Zahl gerade oder ungerade ist.

number = 5

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

The number is odd

Wir nutzen den Modulo-Operator %, um zu prüfen, ob bei Division durch 2 der Rest 0 ist. Bei 5 ist der Rest 1, daher wird der else-Zweig ausgeführt. Jetzt kombinieren wir boolesche Operatoren und Bedingungen, um zu prüfen, ob eine Zahl positiv, negativ oder null ist.

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.

Die zusätzliche Bedingung fügen wir mit elseif ein. elseif nutzt du, wenn du zwei oder mehr Bedingungen in einer festen Reihenfolge prüfen willst.

For-Schleifen

For-Schleifen iterieren über Sequenzen (String, Vektor, Tupel, Set usw.) und führen pro Element Operationen aus. Die Syntax in Julia ist sehr direkt. Beispiel: Wir geben jedes Element eines Vektors aus.

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

for lang = languages
   println(lang)

end

Julia
Python
R

Die Schleife beginnt mit for. Dann wählen wir einen temporären Variablennamen, hier lang, dessen Wert sich beim Durchlaufen des Vektors languages ändert. Mit dem Zuweisungsoperator = geben wir an, über welche Sequenz iteriert wird.

Im Schleifenrumpf nutzen wir println(), um jedes Element von languages auszugeben. lang ist temporär und nach der Schleife nicht mehr verfügbar.

Hinweis: Der Unterschied zwischen print() und println() ist, dass println() jeweils in einer neuen Zeile ausgibt.

Alles, was du bisher gelernt hast, kannst du in For-Schleifen einsetzen. Erstellen wir z. B. ein Array mit 10 Integern und geben nur die ungeraden Zahlen aus:

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

for i = integers_vector
   # Nur ungerade Zahlen ausgeben
   if i % 2 == 1
       println(i)
   end
end

1
3
5
7
9

Vergiss nicht, sowohl die for-Schleife als auch die if-Anweisung mit end zu schließen.

Du kannst auch über Strings iterieren, da sie ebenfalls Sequenzen sind. Hier geben wir jedes Zeichen in "Julia" aus.

for letter = "Julia"
   println(letter)

end

J
u
l
i
a

Pakete in Julia installieren

Alle bisher genutzten Operatoren (+, -, *, ^), Funktionen (print(), println(), typeof()) und Schlüsselwörter (for, if, else) sind Teil der Julia-Standardinstallation. Für viele Aufgaben brauchst du jedoch zusätzliche Pakete. Pakete sind Bibliotheken mit vorbereitetem Code, den wir zu unserer Julia-Installation hinzufügen, um spezifische Probleme zu lösen.

Wir installieren zum Beispiel die Pakete DataFrames und CSV, mit denen wir CSV-Dateien einlesen und bearbeiten können. So geht’s:

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

Pkg ist der Paketmanager von Julia. Mit add() fügst du neue Pakete hinzu. Um alle Funktionen aus den Bibliotheken zu importieren, schreiben wir am Anfang des Skripts das Schlüsselwort using.

using DataFrames
using CSV

Im nächsten Abschnitt nutzen wir ihre Funktionen.

Erste Schritte mit DataFrames

Ein DataFrame ist ein spezieller Datentyp in Sprachen wie Julia, Python oder R, um mit tabellarischen Daten zu arbeiten. Das gängigste Dateiformat dafür ist CSV (Comma-Separated Values). Mit der DataFrame-Bibliothek können wir solche Dateien laden und die enthaltenen Daten verarbeiten.

CSV-Dateien importieren

Für dieses Tutorial importieren wir den Diamonds-Datensatz. Die Datei diamonds.csv sieht so aus:

Hier findest du den Diamonds-Datensatz

Die erste Zeile ist der Header mit den Spaltennamen. Laden wir die Datei mit den Paketen CSV und DataFrames:

# Den Diamonds-DataFrame laden
diamonds = DataFrame(CSV.File("data/diamonds.csv"))
typeof(diamonds)

DataFrame

Wir übergeben den Pfad an CSV.File() und das Ergebnis an DataFrame(). Die Ausgabe von typeof() bestätigt den erfolgreichen Import.

Einfache Datenmanipulation

Der erste Schritt bei einem neuen DataFrame ist, sich ein paar Zeilen ausgeben zu lassen. Das machst du mit first().

# Die ersten 7 Zeilen von diamonds ausgeben
first(diamonds, 7)

7 × 10 DataFrame

Die ersten 7 Zeilen des Diamonds-Datensatzes

first() gibt die ersten n Zeilen eines DataFrames zurück. Hier sehen wir 6 numerische und 3 kategoriale (Text-)Spalten. In Julia-DataFrames wird auch der Index als Spalte gezählt.

Analog dazu gibt es last() für die letzten n Zeilen.

Nützlich ist auch size(). Diese Funktion gibt die Anzahl der Zeilen und Spalten aus.

# Die Dimensionen von diamonds ausgeben
size(diamonds)

(10000, 10)

Unser DataFrame hat also 10.000 Zeilen und 10 Spalten (inklusive Index). 10k Zeilen kann man nicht mit bloßem Auge überblicken. Deshalb nutzen wir Zusammenfassungsstatistiken, um ein Gefühl für die Verteilungen zu bekommen. Dafür verwenden wir describe().

# Zusammenfassende Statistiken für diamonds
describe(diamonds)

10 × 7 DataFrame

Ausgabe der Funktion describe()

Die Ausgabe ist eine Übersichtstabelle mit 7 Spalten. Min, Max, Mittelwert und Median gelten nur für numerische Spalten. In eltype siehst du die Datentypen der Spalten. Die Zahlen hinter String geben die Länge des längsten Strings der Spalte an.

Mit folgender Syntax wählst du einzelne Spalten aus dem DataFrame aus.

# Die ersten 10 Zeilen der Spalte cut extrahieren
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"

Der erste Doppelpunkt wählt alle Zeilen, danach folgt nach dem Komma der Spaltenname (ohne Anführungszeichen). Anschließend nutzen wir Indexierung, um die ersten zehn Zeilen zu nehmen. Noch kürzer geht es so, indem wir die ersten zehn Zeilen direkt im ersten Klammerpaar auswählen:

# Die ersten 10 Zeilen der Spalte carat extrahieren
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"

Um mehrere Spalten auszuwählen, stellst du die Spaltennamen (mit vorangestelltem Doppelpunkt) in eckige Klammern.

# Die ersten 5 Zeilen der Spalten cut, carat, price extrahieren
diamonds[1:5, [:carat, :cut, :price]]

5 × 3 DataFrame

Die ersten 5 Zeilen und 3 Spalten des Diamonds-Datensatzes

Lassen wir describe() nur auf den numerischen Spalten laufen:

# describe() nur auf numerischen Spalten ausführen
describe(diamonds[:, [:carat, :depth, :table, :price, :x, :y]])

describe() nur für numerische Spalten

Um den DataFrame aufsteigend nach einer Spalte zu sortieren, nutzt du sort():

# diamonds sortieren und die ersten 5 Zeilen ansehen
sorted_diamonds = sort(diamonds, :price)
first(sorted_diamonds, 5)

Die sortierte Übersichtstabelle

Für absteigende Sortierung umschließt du den Spaltennamen mit order() und setzt rev=true.

# diamonds absteigend sortieren und die ersten 5 Zeilen ansehen
sorted_diamonds = sort(diamonds, order(:price, rev=true))
first(sorted_diamonds, 5)

Die sortierte Übersichtstabelle, absteigend

Stark! Jetzt kannst du DataFrames laden und eine erste Exploration durchführen.

Mehr über Julia lernen

Obwohl Julia noch eine junge Sprache ist, gibt es bereits viele Ressourcen, um sie zu meistern. Hier sind einige davon, um deine Kompetenzen auszubauen:

• The rise of Julia — Is it worth learning in 2022?
• Progressing from MATLAB to Julia
• Schau dir unsere Cheat Sheets an — zu allen Data-Tools und -Technologien, inklusive Julia
• Teste unseren Introduction to Julia-Kurs