Bases
Hello World
println ajoute un saut de ligne, print non
println("Hello, World!")
print("No newline")Commentaires
#= =# pour les commentaires multi-lignes
# Single-line comment
#=
Multi-line
comment
=#
# Docstring
"""docstring"""REPL
ans stocke le résultat précédent
$ julia
julia> 1 + 1
2
julia> ans # previous result
2Interpolation de chaînes
$ pour les variables, $(expression) pour les expressions
name = "Alice"
age = 30
println("$name is $age")
println("$(age * 2)")Comparaisons chaînées
Julia prend en charge les comparaisons chaînées
x = 5
1 < x < 10 # true
1 <= x <= 10 # trueVariables
Affectation de variables
Les noms de variables Unicode sont pris en charge
x = 10
name = "Alice"
π = 3.14159 # supports Unicode
δ = 0.001Constantes
const déclare une constante globale
const PI = 3.14159
const MAX_SIZE = 100
# const declares a constantAnnotations de type
:: pour annoter les types
x::Int = 10
y::Float64 = 3.14
function f(x::Int)::String
string(x)
endAffectation multiple
L'affectation multiple est prise en charge
a, b, c = 1, 2, 3
x, y = y, x # swap
(a, b) = (1, 2)Types
Types de base
typeof donne le type
typeof(42) # Int64
typeof(3.14) # Float64
typeof("hi") # String
typeof(true) # Bool
typeof('a') # CharConversion de type
Utilisez le nom du type comme fonction de conversion
Int(3.14) # 3
Float64(3) # 3.0
String(42) # "42"
Char(65) # 'A'Types abstraits
abstract type définit un type abstrait
abstract type Animal end
abstract type Dog <: Animal end
# <: denotes subtype relationshipStructs
struct est immuable
struct Point
x::Float64
y::Float64
end
p = Point(1.0, 2.0)
p.x # 1.0Structs mutables
mutable struct autorise la modification des champs
mutable struct Counter
count::Int
end
c = Counter(0)
c.count += 1Types paramétriques
T est un paramètre de type
struct Point{T}
x::T
y::T
end
p = Point{Float64}(1.0, 2.0)
q = Point{Int}(1, 2)Dispatch multiple
Surcharge de fonctions
Fonctionnalité centrale de Julia : le dispatch multiple
function describe(x::Int)
"integer: $x"
end
function describe(x::String)
"string: $x"
end
describe(42) # "integer: 42"
describe("hi") # "string: hi"Méthodes paramétriques
where spécifie les paramètres de type
function norm(p::Point{T}) where T
sqrt(p.x^2 + p.y^2)
end
# Works for all types TMéthodes de repli
Une méthode sans annotation de type sert de valeur par défaut
function describe(x)
"unknown: $x"
end
# No type annotation, matches all argumentsAmbiguïté de méthodes
Attention à éviter toute ambiguïté entre méthodes
f(x::Int, y) = 1
f(x, y::Int) = 2
# f(1, 1) raises an ambiguity error
# Need to define f(x::Int, y::Int) = 3Fonctions
Définition de fonction
return est optionnel : la dernière expression est renvoyée
function add(a, b)
return a + b
end
# Shorthand
add(a, b) = a + bFonctions anonymes
-> définit une fonction anonyme
f = x -> x^2
f(5) # 25
map(x -> x * 2, [1, 2, 3])Valeurs de retour multiples
Renvoie un tuple pour plusieurs valeurs
function divrem2(a, b)
return a ÷ b, a % b
end
q, r = divrem2(10, 3)Arguments nommés
Après ; viennent les arguments nommés
function plot(x, y; style="line", color="blue")
# style and color are keyword arguments
end
plot(1:10, 1:10, color="red")Arguments variadiques
... collecte les arguments variadiques
function sumall(args...)
sum(args)
end
sumall(1, 2, 3, 4) # 10Bloc do
Le bloc do transmet une fonction anonyme
map([1, 2, 3]) do x
x ^ 2
end
# Equivalent to map(x -> x^2, [1,2,3])Flux de contrôle
if-elseif-else
Expression conditionnelle
if x > 0
println("positive")
elseif x < 0
println("negative")
else
println("zero")
endOpérateur ternaire
Opérateur ternaire : condition ? true_value : false_value
result = x > 0 ? "pos" : "neg"
# Chained
result = x > 0 ? "pos" : x < 0 ? "neg" : "zero"Boucle for
Itération avec for in
for i in 1:5
println(i)
end
for (i, v) in enumerate(arr)
println(i, v)
endBoucle while
Boucle while
i = 1
while i <= 5
println(i)
i += 1
endbreak et continue
&& évalue en court-circuit pour les conditions
for i in 1:10
i == 5 && break
i % 2 == 0 && continue
println(i)
endTableaux
Créer des tableaux
Les tableaux sont stockés en column-major
a = [1, 2, 3, 4, 5]
b = [1 2 3; 4 5 6] # 2x3 matrix
c = zeros(3, 3)
d = ones(5)
e = rand(2, 2)Indexation des tableaux
Les indices commencent à 1
a = [10, 20, 30, 40, 50]
a[1] # 10 (1-based)
a[end] # 50
a[2:4] # [20, 30, 40]
a[[1, 3]] # [10, 30]Opérations sur les tableaux
Le suffixe ! signifie une modification en place
push!(a, 60) # add to end
pop!(a) # remove from end
append!(a, b) # concatenate
sort(a) # sort (returns new array)
sort!(a) # in-place sortCompréhension de tableaux
Similaire aux compréhensions de listes
[x^2 for x in 1:5]
# [1, 4, 9, 16, 25]
[x^2 for x in 1:10 if x % 2 == 0]
# [4, 16, 36, 64, 100]Broadcasting
L'opérateur . effectue le broadcasting
a = [1, 2, 3]
a .^ 2 # [1, 4, 9]
f.(a) # apply f to each element
a .+ 10 # [11, 12, 13]Tuples
Tuples
Les tuples sont immuables
t = (1, 2, 3)
t[1] # 1
t[2] # 2
# Named tuple
nt = (name="Alice", age=30)
nt.name # "Alice"Destructuring
Affectation par destructuration de tuple
a, b, c = (1, 2, 3)
(first, second) = (10, 20)
# Ignore
_, y = (1, 2)Dictionnaires
Créer des dictionnaires
Dict crée un dictionnaire
d = Dict("a" => 1, "b" => 2)
d2 = Dict(:name => "Alice", :age => 30)
d["c"] = 3 # addAccès et modification
[] pour accéder et modifier
d = Dict("a" => 1, "b" => 2)
d["a"] # 1
d["a"] = 10 # modify
delete!(d, "b") # deleteItération
Itérez sur les paires clé-valeur
for (k, v) in d
println(k, " => ", v)
end
keys(d) # all keys
values(d) # all valuesOpérations sur les dictionnaires
Fonctions courantes des dictionnaires
haskey(d, "a") # true
get(d, "x", 0) # default value 0
get!(d, "x", 0) # add if missing
merge(d1, d2) # mergeChaînes
Bases des chaînes
Les indices des chaînes peuvent être non contigus (UTF-8)
s = "Hello World"
length(s) # 11
s[1] # 'H'
s[1:5] # "Hello"
lastindex(s) # 11Opérations sur les chaînes
Fonctions de chaînes courantes
uppercase("hi") # "HI"
lowercase("HI") # "hi"
reverse("hello") # "olleh"
strip(" hi ") # "hi"Recherche et remplacement
Rechercher et remplacer
s = "Hello World"
findfirst("World", s) # 7:11
occursin("World", s) # true
replace(s, "World" => "Julia") # "Hello Julia"Split et Join
split et join
split("a,b,c", ",") # ["a", "b", "c"]
join(["a", "b"], "-") # "a-b"
split("hello", "") # ['h','e','l','l','o']Fonctions mathématiques
Maths de base
Fonctions mathématiques intégrées
abs(-5) # 5
sqrt(16) # 4.0
cbrt(27) # 3.0
sign(-5) # -1
floor(3.7) # 3.0
ceil(3.2) # 4.0Fonctions trigonométriques
En radians
sin(π/2) # 1.0
cos(0) # 1.0
tan(π/4) # 1.0
asin(1) # 1.5707... (π/2)Logarithme et exponentielle
log est le logarithme naturel
log(ℯ) # 1.0 (natural log)
log2(8) # 3.0
log10(100) # 2.0
exp(1) # 2.718... (ℯ)Valeurs spéciales
Constantes mathématiques et valeurs spéciales
π # 3.14159...
ℯ # 2.71828...
Inf # positive infinity
NaN # not a number
im # imaginary unitAlgèbre linéaire
Opérations matricielles
Bibliothèque standard LinearAlgebra
using LinearAlgebra
A = [1 2; 3 4]
A' # transpose
inv(A) # inverse matrix
det(A) # determinant
rank(A) # rankDécomposition matricielle
Diverses décompositions de matrices
A = [1.0 2.0; 3.0 4.0]
F = lu(A) # LU decomposition
F = qr(A) # QR decomposition
F = svd(A) # SVD decomposition
F = eigen(A) # eigendecompositionOpérations vectorielles
Opérations sur les vecteurs
v1 = [1, 2, 3]
v2 = [4, 5, 6]
dot(v1, v2) # dot product
cross(v1, v2) # cross product
norm(v1) # norm
v1 ⋅ v2 # dot product (Unicode)Statistiques
Statistiques de base
Bibliothèque standard Statistics
using Statistics
data = [1, 2, 3, 4, 5]
mean(data) # 3.0
median(data) # 3.0
std(data) # standard deviation
var(data) # varianceQuantiles
Calcul de quantiles
using Statistics
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
quantile(data, 0.25) # 3.25
quantile(data, 0.5) # 5.5
quantile(data, 0.75) # 7.75Corrélation et covariance
Coefficient de corrélation et covariance
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
cor(x, y) # 1.0 (correlation coefficient)
cov(x, y) # covarianceTracé de graphiques
Tracé de base
Plots.jl est la bibliothèque de tracé principale
using Plots
x = 1:10
y = x .^ 2
plot(x, y, title="Quadratic", label="x^2")Nuage de points
scatter dessine un nuage de points
using Plots
x = rand(50)
y = rand(50)
scatter(x, y, markersize=5, color=:red)Sous-graphiques
layout contrôle la disposition des sous-graphiques
using Plots
p1 = plot(1:10, 1:10)
p2 = plot(1:10, (1:10).^2)
plot(p1, p2, layout=(2, 1))Sauvegarde d'image
savefig enregistre l'image
using Plots
p = plot(sin, 0, 2π)
savefig(p, "sine.png")DataFrames
Créer un DataFrame
DataFrames.jl est similaire à pandas
using DataFrames
df = DataFrame(
name = ["Alice", "Bob", "Carol"],
age = [25, 30, 35],
city = ["NYC", "LA", "SF"]
)Accéder aux données
Accès par lignes et colonnes
df.name # column
df[1, :] # first row
df[:, :age] # age column
df[1:2, :] # first two rowsFiltrer et trier
Filtrage et tri
using DataFrames
filter(:age => >(28), df) # age > 28
sort(df, :age) # sort by age
sort(df, :age, rev=true) # descendingGrouper et agréger
groupby + combine pour l'agrégation par groupes
using DataFrames, Statistics
combine(groupby(df, :city), :age => mean => :avg_age)E/S de fichiers
Lire et écrire du texte
Le bloc open do referme automatiquement le fichier
# Write
open("output.txt", "w") do f
write(f, "Hello World")
end
# Read
content = read("input.txt", String)Lire ligne par ligne
eachline itère ligne par ligne
for line in eachline("data.txt")
println(line)
end
# Or
lines = readlines("data.txt")Fichiers CSV
CSV.jl gère les fichiers CSV
using CSV, DataFrames
df = CSV.read("data.csv", DataFrame)
CSV.write("output.csv", df)Fichiers JSON
JSON.jl gère le JSON
using JSON
data = JSON.parsefile("data.json")
JSON.print("output.json", data)Modules
Définir un module
export déclare l'interface publique
module MyModule
export greet, add
greet(name) = println("Hello $name")
add(a, b) = a + b
end # moduleImporter un module
Différence entre using et import
using MyModule # imports exported names
using MyModule: greet # selective import
import MyModule # needs MyModule.greet
import MyModule: add # selective importModules standards
Modules de la bibliothèque standard
using Dates # date and time
using LinearAlgebra # linear algebra
using Statistics # statistics
using Random # random numbersMacros
Définir une macro
Les macros opèrent sur l'AST à la compilation
macro sayhi(name)
return :(println("Hi, $name"))
end
@sayhi "Alice" # Hi, AliceCitation d'expressions
:() crée un objet expression
ex = :(1 + 2)
# :(1 + 2)
dump(ex)
# Expr
# head: Symbol call
# args: Array[...]Macros courantes
Macros courantes intégrées
@time sleep(1) # timing
@assert 1 == 1 # assertion
@show x # print variable name and value
@elapsed sleep(0.1) # return only time
@which sin(1) # view method locationMétaprogrammation
Construction d'expressions
Expr construit un AST
ex = Expr(:call, :+, 1, 2)
eval(ex) # 3
# Equivalent to
eval(:(1 + 2)) # 3Génération de code
Boucle pour générer du code
for op in (:+, :-, :*, :/)
eval(:(f($op, a, b) = $op(a, b)))
end
f(+, 1, 2) # 3Hygiène des macros
L'hygiène des macros évite les conflits de variables
macro setx(val)
return :(x = $val)
end
# Variables in macros are hygienic and won't pollute the caller's scopeCalcul parallèle
Multithreading
La macro @threads pour les boucles parallèles
# Start: julia --threads=4
Threads.nthreads() # 4
Threads.@threads for i in 1:100
results[i] = compute(i)
endCalcul distribué
Bibliothèque standard Distributed
using Distributed
addprocs(4) # add 4 worker processes
@everywhere function work(x)
x ^ 2
end
pmap(work, 1:100) # parallel mapAppel distant
Appel distant asynchrone
using Distributed
ref = @spawnat :any sqrt(16)
fetch(ref) # 4.0
# @spawnat executes on a specified processCoroutines
Task
Task est la coroutine de Julia
t = Task(() -> begin
println("running")
return 42
end)
schedule(t)
wait(t)Channel
Channel permet la communication entre coroutines
ch = Channel(32)
put!(ch, 1)
put!(ch, 2)
take!(ch) # 1
take!(ch) # 2Producteur-consommateur
Les coroutines implémentent le modèle producteur-consommateur
function producer(ch)
for i in 1:5
put!(ch, i)
end
end
task = @task producer(Channel(10))
for val in task
println(val)
endGestion des exceptions
try-catch
Structure try-catch-finally pour la gestion des exceptions.
try
risky()
catch e
println("Error: $e")
finally
cleanup()
endLever une exception
throw lève un objet exception
throw(ErrorException("something wrong"))
throw(DomainError(-1, "negative"))
error("generic error")Exception personnalisée
Héritez du type Exception
struct MyError <: Exception
msg::String
end
throw(MyError("custom error"))Assertion
La macro @assert
@assert x > 0 "x must be positive"
# Throws AssertionError when condition is falseRegex
Expressions régulières
r"" crée une regex
re = r"\d+"
occursin(re, "abc123") # true
match(re, "abc123") # RegexMatchMatch
match renvoie le résultat du premier match
m = match(r"(\w+)@(\w+)", "user@host")
m.match # "user@host"
m.captures # ["user", "host"]
m[1] # "user"Trouver tout
eachmatch itère sur tous les matches
for m in eachmatch(r"\d+", "a1b2c3")
println(m.match)
end
# 1, 2, 3Remplacement
replace prend en charge les regex
replace("a1b2c3", r"\d" => "#")
# "a#b#c#"
replace("hello", r"l" => "L" => count=1)
# "heLlo"DateTime
Créer une date
Bibliothèque standard Dates
using Dates
now() # current time
Date(2024, 1, 15) # date
DateTime(2024, 1, 15, 10, 30) # datetimeFormatage
Formatage et parsing
using Dates
dt = now()
Dates.format(dt, "yyyy-mm-dd HH:MM:SS")
Date("2024-01-15", "yyyy-mm-dd")Arithmétique des dates
Types d'intervalles de temps
using Dates
d1 = Date(2024, 1, 1)
d2 = d1 + Day(30) # add 30 days
diff = d2 - d1 # 30 days
Day(1) + Hour(12) # datetime arithmeticPackages
Installer des packages
Pkg.add installe des packages
using Pkg
Pkg.add("Plots")
Pkg.add(["DataFrames", "CSV"])
Pkg.rm("Plots") # removeGestion des packages
Commandes Pkg courantes
Pkg.status() # view installed
Pkg.update() # update all
Pkg.instantiate() # install per Project.toml
Pkg.activate("env") # activate environmentEnvironnements
Gestion des environnements de projet
# Project.toml defines dependencies
# Manifest.toml locks versions
Pkg.activate("myproject") # activate environment
Pkg.resolve() # resolve dependenciesGestionnaire Pkg
Mode Pkg du REPL
] entre en mode Pkg du REPL
julia> ]
pkg> add Plots
pkg> rm Plots
pkg> status
pkg> update
pkg> test PlotsCréer un package
generate crée un squelette de package
pkg> generate MyPackage
# Directory structure
# MyPackage/
# Project.toml
# src/MyPackage.jlMode développement
dev installe en mode développement
pkg> dev ./MyPackage # local development
pkg> dev MyPackage # dev version from GitHub
pkg> free MyPackage # exit development modeInteropérabilité
Appeler du C
ccall appelle des fonctions C
ccall((:sqrt, "libm"), Float64, (Float64,), 16.0)
# 4.0Appeler du Python
PyCall.jl appelle Python
using PyCall
np = pyimport("numpy")
np.array([1, 2, 3])
np.mean([1, 2, 3])Appeler du R
RCall.jl appelle R
using RCall
R"sd(c(1,2,3,4,5))" # call R codeCalcul GPU
Tableaux CUDA
CUDA.jl prend en charge les GPU NVIDIA
using CUDA
a = CUDA.ones(1000)
b = CUDA.zeros(1000)
c = a .+ b # operations on GPUKernel GPU
@cuda lance un kernel GPU
using CUDA
function kernel!(a)
i = threadIdx().x
if i <= length(a)
@inbounds a[i] *= 2
end
return
end
@cuda threads=256 kernel!(a)GPU AMD
AMDGPU.jl prend en charge les GPU AMD
using AMDGPU
a = ROCArray(ones(100))
b = a .* 2 # operations on AMD GPUSnippets Julia associés
Copy-paste ready code for common tasks.
Diffusion et vectorisation
Applique une fonction élément par élément sur des tableaux avec la syntaxe point et @.
Dispatch multiple
Sélectionne les méthodes selon les types à l'exécution de tous les arguments, pas seulement le récepteur.
Types paramétriques et performance
Définit des conteneurs génériques et stables qui se compilent en code spécialisé.
Macros et expressions
Manipule les arbres de syntaxe de Julia comme des données de première classe via :expr et macro.
Multithreading et calcul distribué
Parallélise les boucles avec @threads et délègue des tâches avec @spawn / pmap.
Opérations sur DataFrame (DataFrames.jl)
Filtre, transforme, groupe et joint des données tabulaires avec DataFrames.jl.
Conseils de performance : @inbounds, @fastmath, vues
Écrire du Julia à la vitesse du C en supprimant les vérifications de bornes, évitant les allocations et utilisant des vues.
Résoudre des ODE avec DifferentialEquations.jl
Définit et résout numériquement une ODE à valeur initiale avec pas adaptatif.
Was this helpful?