Julia. Les premiers pas, deuxième partie.

using Dates

let # portée locale
    d = Dates.now()
    println("Daniel Hagnoul $d\n")
end

Daniel Hagnoul 2020-10-26T10:42:20.776

const, enum

const k_frais = 0.02

@enum FRUIT begin
    pommes = 1
    oranges = 2
    kiwis = 3
end

Tuple

let
    t = ('a', 'b', 1, 5) # ne peut pas être modifié

    println("t = $t ; deuxième élément de t = $(t[2]) ; dernier élément de t = $(t[end])")
end

t = ('a', 'b', 1, 5) ; deuxième élément de t = b ; dernier élément de t = 5

let
    t = (('a', 'b', 5), ("mot", "lettre", "nombre")) # tuple 2D

    println("le premier élément du deuxième tuple = $(t[2][1])\n")

    tn = (daniel = ("Daniel", "Belgique"), georges = ("Georges", "France")) # namedtuple

    println("tn.georges = $(tn.georges)")
end

le premier élément du deuxième tuple = mot

tn.georges = ("Georges", "France")

Dict

let
    d = Dict(
        "Daniel" => "Belgique",
        "Georges" => "France",
        "Nombre" => 2,
    )
end

Dict{String,Any} with 3 entries:
  "Georges" => "France"
  "Nombre"  => 2
  "Daniel"  => "Belgique"

let
    d = Dict{Int16, Float64}(
        1 => 2.05,
        2 => 7.24,
        3 => 12.9105,
    )

    println("d.2 = $(d[2])")

    d[7] = 102.77

    delete!(d, 1)
end

d.2 = 7.24
Dict{Int16,Float64} with 3 entries:
  7 => 102.77
  2 => 7.24
  3 => 12.9105

let
    d = Dict{Int16, Float64}(
        1 => 2.05,
        2 => 7.24,
        3 => 12.9105,
    )

    println("haskey(d, 7) = $(haskey(d, 7))\n")
    println("in(d, 2) = $(in(d, 2))\n")

    for kv in d
        println(kv)
    end

    println("\nkeys of d = $(keys(d))\n")
    println("values of d = $(values(d))")
end

haskey(d, 7) = false

in(d, 2) = false

2 => 7.24
3 => 12.9105
1 => 2.05

keys of d = Int16[2, 3, 1]

values of d = [7.24, 12.9105, 2.05]

Set

let
    st = Set(["Daniel", "Virgiles", "Jules", "Daniel"]) # valeur unique
end

Set{String} with 3 elements:
  "Jules"
  "Daniel"
  "Virgiles"

let
    st = Set{Int16}([1, 3, 5, 7])

    push!(st, 9)

    st_1 = Set{Int16}([11, 13, 15, 17, 3, 7])

    println("intersection de st avec st_1 = $(intersect(st, st_1))\n")

    println("union sans ! de st avec st_1 = $(union(st, st_1))") # union sans !

    println("st = $st\n")

    println("union avec ! de st avec st_1 = $(union!(st, st_1))") # union avec !

    println("st = $st")

    setdiff(st, st_1)
end

intersection de st avec st_1 = Set(Int16[7, 3])

union sans ! de st avec st_1 = Set(Int16[7, 9, 13, 3, 17, 11, 5, 15, 1])
st = Set(Int16[7, 9, 3, 5, 1])

union avec ! de st avec st_1 = Set(Int16[7, 9, 13, 3, 17, 11, 5, 15, 1])
st = Set(Int16[7, 9, 13, 3, 17, 11, 5, 15, 1])
Set{Int16} with 3 elements:
  9
  5
  1

Function

let
    function get_sum(x::Int64, y::Int64)::Int64
        return x + y
    end

    x, y = 2, 7

    println("somme de deux entiers = $(get_sum(x, y))\n")

    function get_sum_all(args...)::Float64
        s = 0.0
        for item in args
            s += item
        end
        return s
    end

    println("somme de n nombres = $(get_sum_all(2,4.05,8,16.05,32))")
end

somme de deux entiers = 9

somme de n nombres = 62.1

let
    #=
        Lorsque vous écrivez une fonction avec une longue liste d'arguments, 
        tôt ou tard, vous oublierez l'ordre dans lequel vous devez fournir 
        les arguments. Vous pouvez éviter ce problème en utilisant des mots 
        clés pour étiqueter les arguments. Utilisez un point-virgule après 
        les arguments non étiquetés de la fonction et suivez-le avec une 
        ou plusieurs paires mot-clé = valeur.

        FRUIT est l'enum globale déclarée plus haut
        k_frais est la const globale déclarée plus haut
    =#
    function payer(p ; g = 2, t = 0.21)
        r = p * (1.0 + k_frais)
        rt = r * (1.0 + t)
        return (g, rt)
    end

    genre, total = payer(125.47)

    println("Pour les $(FRUIT(genre)) le total TTC est de $(round(total, digits = 2)) €")
end

Pour les oranges le total TTC est de 154.86 €

let
    function make_adder(amount::Number)
        return function add(x::Number) # closure
            return x + amount
        end
    end

    add_two = make_adder(20);

    10.75 |> add_two # closure
end

30.75

struct

let
    mutable struct Client
        nom::String
        prénom::String
        compte::Float64
        id::Int
    end

    daniel = Client("Hagnoul", "Daniel", 25.07, 1234)

    daniel.prénom = "Élévire"

    println("prénom du Client daniel = $(daniel.prénom)")
end

prénom du Client daniel = Élévire

let
    abstract type Animal end

    mutable struct Dog <: Animal
        nom::String
        race::String
    end

    mutable struct Cat <: Animal
        nom::String
        race::String
    end

    wouky = Dog("Wouky", "Akita")
    pilou = Cat("Pilou", "Angora")

    function race(x::Animal)
        println("l'animal est de race $(x.race)\n")
    end

    race(pilou)
    race(wouky)
end

l'animal est de race Angora

l'animal est de race Akita

Licence Creative Commons Attribution 2.0 Belgique

---