Tutoriel de programmation Julia pour débutants

Comment installer et exécuter Julia ? 

L’installation de Julia est simple. Téléchargez l’installeur adapté à votre système d’exploitation sur cette page du site Julia et cochez l’option pour ajouter Julia au PATH système. Si vous tapez julia dans la ligne de commande et obtenez la sortie suivante, tout fonctionne correctement.

Installation et exécution du langage Julia

PyCharm et VSCode proposent des extensions Julia avec coloration syntaxique et débogage. Comme les data scientists travaillent souvent dans JupyterLab, il est aussi facile d’y ajouter un noyau Julia. Après avoir ouvert l’invite julia dans le terminal, saisissez simplement ces deux lignes :

using Pkg
add("IJulia")

Ce code ajoute le paquet IJulia à votre installation Julia. Redémarrez vos sessions JupyterLab en cours : l’option Julia doit apparaître dans le Launcher.

Julia exécuté dans JupyterLab

Syntaxe de base de Julia

Cette section couvre les fondamentaux de la syntaxe Julia : variables, types de données, opérateurs, vecteurs, etc.

Opérateurs  

En programmation, on utilise des caractères spéciaux appelés opérateurs pour représenter des opérations mathématiques ou logiques. Voici les plus courants : addition, soustraction, multiplication, division, etc. 

Remarque : en Julia, les commentaires se notent avec le caractère unique #. Tout ce qui suit # est ignoré par le programme (jusqu’à la fin de la ligne).

# Addition en Julia
37 + 73

110

# Soustraction en Julia
17 - 19

-2

# Multiplication en Julia
29 * 33

957

# Division en Julia
22 / 7

3.142857142857143

# Division inversée en Julia, ci‑dessus équivaut à 0 / 5.
5 \ 0

0

# L'opérateur de reste (modulo) en Julia 
98456 % 23

16

# Élever au carré
(22 / 7) ^ 2

9.877551020408163

# Élever au cube
-7 ^ 3

-343

# Racine carrée (puissance 0,5)
(355 / 133) ^ 0.5

1.633760365638372

Variables

En programmation, nous utilisons des variables pour stocker des informations. Elles permettent de référencer facilement une valeur par un nom. Par exemple, nous stockons ici le nombre 73 dans la variable a, et la chaîne “Hello world!” dans la variable “word” (nous verrons les différents types de données de Julia juste après). Taper le nom d’une variable dans la console affiche sa valeur.

# Stocker le nombre 73 dans la variable a
a = 73
a

73

# Stocker "Hello world!" dans word
word = "Hello world!"
word

Hello world!

Tous les opérateurs et fonctions de Julia s’utilisent de la même manière sur des variables.

# Multiplier deux variables numériques
a = 73
b = 37
a * b

2701

Vous pouvez utiliser tout caractère alphanumérique dans les noms de variables, y compris le soulignement. Toutefois, certaines conventions s’appliquent : les noms de variables :

• sont en lower_snake_case (minuscules avec des mots séparés par un underscore) ;
• ne peuvent pas commencer par un chiffre.

Introduction aux types de données dans Julia 

Les types informent le programme des valeurs qu’une variable peut prendre et des opérateurs utilisables sans erreur. Julia propose de nombreux types ; voici les plus basiques.

Le type d’une variable peut être affiché avec la fonction typeof() :

# Obtenir le type de 3.14
typeof(3.14)

Float64

Lors d’opérations en Julia, attention aux conséquences liées aux types. Par exemple, multiplier un flottant par un entier renvoie un flottant.

# Solde bancaire en entier
balance = 100

# Taux d'intérêt en flottant
interest_rate = 1.05

# Nouveau solde en flottant
new_balance = balance * interest_rate

typeof(new_balance)

Float64

À l’inverse, effectuer des opérations entre chaînes de caractères et types numériques provoque souvent une erreur, comme ci‑dessous.

# Solde bancaire en entier
balance = 100

# Taux d'intérêt en chaîne
interest_rate = “5%”

# Nouveau solde en flottant
new_balance = balance * interest_rate

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

Conversion de types en Julia 

Il est possible de convertir des types en Julia grâce à des fonctions intégrées. Le tableau ci‑dessous récapitule quelques conversions courantes. 

Travailler avec les caractères et les chaînes en Julia 

Nous avons vu les types caractère et chaîne à la section précédente. Plongeons maintenant dans les opérations courantes sur les chaînes. Pour rappel, une chaîne est une suite ordonnée de caractères (du texte) encadrée de guillemets doubles. 

# Une chaîne est une suite de caractères
word = "Hello world!"
word

"Hello world!"

Pour écrire une chaîne multilignes, utilisez des triples guillemets :

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

This is a
multi-line string.

Vous pouvez extraire des informations d’une chaîne de différentes manières. Par exemple, l’indexation entre crochets permet de récupérer des caractères individuels ou une plage selon leur position. Dans cet exemple, 1:3 désigne la séquence de 1 à 3 inclus.

text = "Julia is a high-level, dynamic programming language"
# Extraire le premier caractère par son index
text[1]

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

# Extraire les trois premiers caractères par leur index
text[1:3]

"Jul"

Ci‑dessus, nous avons mis 1 entre crochets, ce qui renvoie le premier caractère. Vous pouvez aussi utiliser l’opérateur spécial begin :

# Extraire le premier caractère avec l'opérateur begin
text[begin]

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

Quand vous extrayez un seul caractère d’une chaîne, son type est Char.

# Obtenir le type du quatrième caractère
typeof(text[4])

Char

# Obtenir le type du quatrième caractère
typeof(text[4])

En revanche, si vous découpez une chaîne pour extraire plusieurs caractères, la sortie est de type chaîne (String). 

# Obtenir le type des 5 premiers caractères
typeof(text[begin:5])

String

Ici, nous extrayons les cinq premiers caractères de text. Notez que les indices de part et d’autre des deux‑points sont inclusifs. Contrairement à Python, les indices négatifs ne sont pas pris en charge. Utilisez plutôt l’opérateur end avec un nombre négatif. Par exemple, pour récupérer le troisième caractère à partir de la fin :

# Le troisième à partir de la fin
text[end-2]

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

Opérations courantes sur les chaînes en Julia 

Utilisez length() pour compter le nombre de caractères d’une chaîne.

# Compter les caractères d'une chaîne
length(text)

51

Assembler plusieurs chaînes est une tâche fréquente. Vous pouvez le faire avec string() en passant les chaînes séparées par des virgules.

# Créer une seule chaîne à partir de "Julia", "is", "awesome"
string("Julia ", "is ", "awesome!")

"Julia is awesome!"

Vous pouvez aussi utiliser l’opérateur * (multiplication) pour concaténer des chaînes.

# Créer une chaîne en multipliant des chaînes
"73 " * "is " * "the " * "best " * "prime."

"73 is the best prime."

Dans les deux cas, n’oubliez pas d’ajouter des espaces entre les mots. Autre possibilité : répéter une même chaîne plusieurs fois. Voici comment faire avec l’opérateur d’exponentiation ^ :

# Créer une chaîne avec l'opérateur d'exponentiation
"Three times the fun!" ^ 3

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

Tableaux (arrays) en Julia 

Un autre type de données très courant en Julia est le tableau, appelé array. C’est une liste de valeurs encadrées de crochets []. On les nomme différemment selon leur dimension. 

• Les tableaux à une dimension sont des vecteurs.
• À deux dimensions, des matrices.
• À trois dimensions et plus, simplement des arrays.

Dans ce tutoriel, nous nous concentrons sur les vecteurs. Créez‑les en plaçant des éléments entre crochets, comme ci‑dessous.

# Définir un vecteur de trois entiers
x = [1, 2, 3]

3-element Vector{Int64}:
1
2
3

# Obtenir le type de x
typeof(x)

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

Le vecteur x est de type Vector, alias d’un tableau unidimensionnel (voir la sortie alias for Array{In664, 1}). Tous ses éléments sont de type Int64. Mais tous les éléments n’ont pas toujours le même type. Par exemple, voici un vecteur hétérogène. 

# Définir un vecteur avec des types variés
array = [1, "Hello", 22/7]

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

Comme vous le voyez, les éléments ont le type Any entre accolades, indiquant des types multiples. Vous pouvez même imbriquer des vecteurs.

# Définir un vecteur avec divers types, dont un autre vecteur
array = [1, 2, 3, ["Hello", 73]]

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

La fonction length() fonctionne comme pour les chaînes : elle compte le nombre d’éléments d’un array.

# Longueur d'un vecteur
length(array)

3

Les règles d’indexation sont similaires : ci‑dessous, nous indexons les premier et deuxième éléments du tableau.

# Premier élément d'un vecteur
array = [1, "Hello", 22/7]
array[begin]

1

# Avant-dernier élément d'un vecteur
array[end-1]

"Hello"

Opérateurs booléens et comparaisons numériques 

Les langages utilisent des valeurs booléennes pour implémenter la logique. Un booléen ne peut prendre que deux valeurs : true ou false. Ils sont particulièrement utiles avec les comparaisons numériques et les opérateurs booléens. Commençons par les comparaisons.

Opérateurs de comparaison numérique en Julia

Le tableau ci‑dessous présente les opérateurs de comparaison les plus utilisés en Julia. Comme le montrent les exemples, vous pouvez comparer des booléens, des objets numériques, etc. Remarquez que vous pouvez écrire inférieur/égal ou supérieur/égal avec un ou deux symboles. Pour la version à un symbole, tapez \le puis TAB ou \ge puis TAB.

Opérateurs booléens en Julia

Au‑delà des comparaisons numériques, on utilise les opérateurs booléens (et/ou) pour combiner plusieurs expressions logiques en une seule. Voici les plus courants et leur utilisation. 

Syntaxe Julia intermédiaire

Instructions conditionnelles en Julia

À l’aide des valeurs et opérateurs booléens, vous pouvez écrire des conditions. Par exemple : si une expression est vraie, exécuter une opération ; sinon, en exécuter une autre. On parle d’instructions if/else. Voici la syntaxe :

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

Lorsque la condition après le mot‑clé if vaut true, le bloc if s’exécute ; sinon, c’est le bloc else. Cet exemple teste si un nombre est pair ou impair.

number = 5

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

The number is odd

Dans l’expression après if, nous utilisons l’opérateur modulo % pour vérifier si le reste de la division par 2 est 0. Ici, c’est faux car 5 divisé par 2 laisse un reste de 1. Le else s’exécute donc. Écrivons maintenant un programme qui indique si un nombre est positif, négatif ou nul. 

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.

Nous ajoutons une condition supplémentaire avec elseif. On l’utilise lorsqu’il faut vérifier deux conditions ou plus dans un ordre précis. 

Boucles for 

Une boucle for sert à itérer et appliquer des opérations à chaque élément d’une séquence (chaîne, vecteur, tuple, ensemble, etc.) dans l’ordre. La syntaxe est simple en Julia. Par exemple, affichons chaque élément d’un vecteur :

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

for lang = languages
   println(lang)

end

Julia
Python
R

La boucle commence avec le mot‑clé for. On choisit ensuite un nom de variable temporaire, ici lang, dont la valeur change à chaque itération sur languages. Pour indiquer la séquence à parcourir, on écrit son nom après l’opérateur d’affectation =.

Dans la boucle, nous utilisons println() pour afficher chaque élément de languages, représenté par la variable temporaire lang. On parle de variable temporaire car elle n’est pas accessible une fois la boucle terminée.

Remarque : la différence entre print() et println() est que println() ajoute un saut de ligne après chaque affichage.

Vous pouvez réutiliser tout ce que vous avez vu jusqu’ici dans des boucles for. Par exemple, créons un tableau de 10 entiers et n’affichons que les nombres impairs :

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

for i = integers_vector
   # N'afficher que les nombres impairs
   if i % 2 == 1
       println(i)
   end
end

1
3
5
7
9

N’oubliez pas de fermer à la fois la boucle for et la condition if par end.

Vous pouvez également itérer sur les chaînes puisqu’elles sont des séquences. Ici, nous affichons chaque lettre de "Julia".

for letter = "Julia"
   println(letter)

end

J
u
l
i
a

Installer des packages en Julia 

Tous les opérateurs (+, -, *, ^), fonctions (print(), println(), typeof()) et mots‑clés (for, if, else) utilisés jusqu’ici sont fournis par l’installation de base. Mais ce n’est pas suffisant pour couvrir tous les besoins. Il faut installer des packages pour ajouter des outils et fonctions supplémentaires. Les packages sont des bibliothèques de code pré‑écrit (par d’autres développeurs) que l’on ajoute à Julia pour résoudre des problèmes spécifiques.

Par exemple, installons deux packages : DataFrames et CSV, qui facilitent la manipulation de fichiers CSV. Voici comment faire :

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

Pkg est le gestionnaire de packages global de Julia. Sa fonction add() ajoute de nouveaux packages à l’installation. Pour importer tous les symboles fournis par ces bibliothèques, on les charge avec le mot‑clé using en tête de script.

using DataFrames
using CSV

Nous utiliserons leurs fonctions dans la section suivante.

Premiers pas avec DataFrames 

Un DataFrame est une structure conçue pour travailler avec des tableaux de données, très utilisée en Julia, Python ou R. Le format de fichier le plus courant pour stocker des tableaux est le CSV (comma‑separated values). La bibliothèque DataFrame fournit les outils pour charger ces fichiers et manipuler leur contenu.

Importer des fichiers CSV

Nous allons importer le jeu de données diamonds pour ce tutoriel. Le fichier diamonds.csv ressemble à ceci :

Accédez au dataset diamonds ici

La première ligne est l’en‑tête et contient les noms de colonnes. Chargeons‑le avec les packages CSV et DataFrames.

# Charger le DataFrame diamonds
diamonds = DataFrame(CSV.File("data/diamonds.csv"))
typeof(diamonds)

DataFrame

Nous passons le chemin du fichier CSV à CSV.File(), puis son résultat à DataFrame(). La sortie de typeof() confirme que le chargement a réussi.

Manipulations simples 

Avec un nouveau DataFrame, commencez toujours par afficher quelques lignes pour en avoir un aperçu. Utilisez pour cela la fonction first().

# Afficher les 7 premières lignes de diamonds
first(diamonds, 7)

7 × 10 DataFrame

Les 7 premières lignes du dataset diamonds

first() renvoie les n premières lignes d’un DataFrame. On observe 6 colonnes numériques et 3 catégorielles (texte). L’index est également compté comme une colonne dans les DataFrames Julia. 

La fonction last() fonctionne de manière similaire à first() : elle récupère les n dernières lignes.

Autre fonction utile : size(). Elle affiche le nombre de lignes et de colonnes.

# Dimensions de diamonds
size(diamonds)

(10000, 10)

Notre DataFrame compte 10 000 lignes et 10 colonnes (index inclus). Impossible d’inspecter 10 k lignes à l’œil nu ; on utilise donc des statistiques descriptives pour comprendre la distribution des colonnes. Pour cela, servez‑vous de describe().

# Statistiques descriptives de diamonds avec describe()
describe(diamonds)

10 × 7 DataFrame

Sortie de la fonction describe()

La sortie est un tableau récapitulatif avec 7 colonnes. Les colonnes min, max, mean et median ne s’appliquent qu’aux colonnes numériques. Dans la colonne eltype, vous voyez le type de données de chaque colonne de diamonds. Les nombres à côté de String indiquent la longueur de la chaîne la plus longue de la colonne.

Vous pouvez aussi sélectionner des colonnes individuelles avec la syntaxe suivante.

# Extraire les 10 premières lignes de la colonne cut
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"

Le premier deux‑points dans les crochets sélectionne toutes les lignes. On précise ensuite le nom de colonne après une virgule et un autre deux‑points (sans guillemets). Puis on indexe le tableau renvoyé pour ne garder que les dix premières lignes. Pour simplifier, on peut aussi sélectionner directement ces dix lignes dans les premiers crochets :

# Extraire les 10 premières lignes de la colonne carat
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"

Pour sélectionner plusieurs colonnes, placez les noms de colonnes (préfixés d’un deux‑points) dans des crochets.

# Extraire les 5 premières lignes des colonnes cut, carat, price
diamonds[1:5, [:carat, :cut, :price]]

5 × 3 DataFrame

Les 5 premières lignes et 3 colonnes du dataset diamonds

Lançons describe() uniquement sur les colonnes numériques.

# describe sur les seules colonnes numériques
describe(diamonds[:, [:carat, :depth, :table, :price, :x, :y]])

Exécution de describe() sur les colonnes numériques uniquement

Pour trier le DataFrame par ordre croissant selon une colonne, utilisez sort() :

# Trier diamonds et voir les 5 premières lignes
sorted_diamonds = sort(diamonds, :price)
first(sorted_diamonds, 5)

Tableau trié

Pour trier par ordre décroissant, encapsulez le nom de colonne avec order().

# Trier diamonds par ordre décroissant et voir les 5 premières lignes
sorted_diamonds = sort(diamonds, order(:price, rev=true))
first(sorted_diamonds, 5)

Tableau trié, ordre décroissant

Parfait ! Vous savez désormais charger des DataFrames et mener une première exploration.

Aller plus loin avec Julia 

Bien que Julia soit un langage jeune, il existe déjà une multitude de ressources pour le maîtriser. Voici de quoi accélérer vos compétences :

• La montée en puissance de Julia — vaut‑il la peine de l’apprendre en 2022 ?
• Passer de MATLAB à Julia
• Consultez nos fiches mémo couvrant tous les outils et technologies data, dont Julia
• Découvrez notre cours Introduction to Julia