Julia Dictionnaires et ensembles

Dans les chapitres précédents, nous avons apprisles tableaux Juliaetles tuples Julia。

Les tableaux sont un type de collection. De plus, Julia dispose d'autres types de collections, tels que les dictionnaires et les ensembles (listes de collections non ordonnées).


Dictionnaire

Un dictionnaire est un modèle de conteneur mutable qui peut stocker des objets de tout type.

Chaque paire clé-valeur dans le dictionnairekey=>valueest séparée par=>un deux-points, et chaque paire clé-valeur est séparée par une virgule,et l'ensemble du dictionnaire est entouré d'accolades{}comme suit :

Créer un dictionnaire

La syntaxe pour créer un dictionnaire est la suivante :
Dict("key1" => value1, "key2" => value2,,…, "keyn" => valuen)

L'exemple suivant crée un dictionnaire simple, où la clé A correspond à la valeur 1, et la clé B correspond à la valeur 2 :

Dict("A"=>1, "B"=>2)

Exemple

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} avec 2 entrées :
  "B" => 2
  "A" => 1

julia>

Utilisez une boucle for pour créer un dictionnaire :

Exemple

julia> first_dict = Dict(string(x) => sind(x) for x = 0:5:360)
Dict{String, Float64} avec 73 entrées :
  "285" => -0.965926
  "310" => -0.766044
  "245" => -0.906308
  "320" => -0.642788
  "350" => -0.173648
  "20"  => 0.34202
  "65"  => 0.906308
  "325" => -0.573576
  "155" => 0.422618
  "80"  => 0.984808
  "335" => -0.422618
  "125" => 0.819152
  "360" => 0.0
  "75"  => 0.965926
  "110" => 0.939693
  "185" => -0.0871557
  "70"  => 0.939693
  "50"  => 0.766044
  "190" => -0.173648
  ⋮     => ⋮

Touche

Les clés d'un dictionnaire sont uniques. Si nous attribuons une valeur à une clé existante, nous ne créons pas une nouvelle clé, mais modifions la clé existante.

Rechercher une clé

Nous pouvons utiliser la fonction haskey() pour vérifier si le dictionnaire contient la clé spécifiée :

Exemple

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} avec 2 entrées :
  "B" => 2
  "A" => 1

julia> haskey(first_dict, "A")
false

julia> haskey(D, "A")
vrai

julia> haskey(D, "Z")
false

Vous pouvez également utiliser la fonctionin()pour vérifier si le dictionnaire contient la paireclé/valeur:

Exemple

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} avec 2 entrées :
  "B" => 2
  "A" => 1

julia> in(("A" => 1), D)
vrai

julia> in(("X" => 220), first_dict)
false

Ajouter une paire clé/valeur

Nous pouvons ajouter une nouvelle paire clé/valeur à un dictionnaire existant comme suit :

Exemple

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} avec 2 entrées :
  "B" => 2
  "A" => 1

julia> D["C"] = 3
3

julia> D
Dict{String, Int64} avec 3 entrées :
  "B" => 2
  "A" => 1
  "C" => 3

Supprimer une paire clé/valeur

Nous pouvons utiliser la fonctiondelete!()pour supprimer une clé d'un dictionnaire existant :

Exemple

julia> delete!(D, "C")
Dict{String, Int64} avec 2 entrées :
  "B" => 2
  "A" => 1

Obtenir toutes les clés d'un dictionnaire

Nous pouvons utiliser la fonctionkeys()pour obtenir toutes les clés du dictionnaire :

Exemple

julia> keys(D)
KeySet pour a Dict{String, Int64} avec 2 entrées. Clés:
  "B"
  "A"

julia>

Valeur

Chaque clé dans un dictionnaire a une valeur correspondante.

Afficher toutes les valeurs d'un dictionnaire

Nous pouvons utiliser la fonctionvalues()pour afficher toutes les valeurs du dictionnaire :

Exemple

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} avec 2 entrées :
  "B" => 2
  "A" => 1

julia> values(D)
ValueIterator pour a Dict{String, Int64} avec 2 entrées. Valeurs:
  2
  1

julia>

Dictionnaire comme un itérable

Nous pouvons traiter un dictionnaire comme un itérable pour afficher les paires clé/valeur :

Exemple

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} avec 2 entrées :
  "B" => 2
  "A" => 1

julia> for kv in D
         println(kv)
       end  
"B" => 2
"A" => 1

Dans l'exemple,kvest un tuple contenant chaque paire clé/valeur.

Tri de dictionnaire

Les dictionnaires ne sont pas ordonnés, mais nous pouvons utiliser la fonction sort() pour trier un dictionnaire :

Exemple

julia> example_dict = Dict("R" => 100, "S" => 220, "T" => 350, "U" => 400, "V" => 575, "W" => 670)
Dict{String, Int64} avec 6 entrées :
  "S" => 220
  "U" => 400
  "T" => 350
  "W" => 670
  "V" => 575
  "R" => 100

julia> for key in sort(collect(keys(example_dict)))
         println("$key => $(example_dict[key])")
       end
R => 100
S => 220
T => 350
U => 400
V => 575
W => 670

Nous pouvons utiliser le type de données SortedDict du paquet DataStructures.ji pour maintenir un dictionnaire toujours trié.

Pour utiliser le paquet DataStructures, vous devez d'abord l'installer. Vous pouvez ajouter SortedDict dans le mode Pkg du REPL à l'aide de la commande add.

Dans le REPL, entrez le symbole]pour entrer enpkgmode.

Entrer en mode pkg

julia> ]               # Entrez ] pour passer en mode pkg

Format de syntaxe pour ajouter un paquet :

add 包名

Après avoir ajouté le paquet DataStructures ci-dessous, les exemples suivants peuvent s'exécuter normalement :

(@v1.7) pkg> add DataStructures
Pour les paquets non enregistrés, vous pouvez spécifier directement une URL :
add https://github.com/fredrikekre/ImportMacros.jl

Paquets locaux :

add 本地路径/包名.jl

Exemple

julia> import DataStructures

julia> example_dict = DataStructures.SortedDict("S" => 220, "T" => 350, "U" => 400, "V" => 575, "W" => 670)
DataStructures.SortedDict{String, Int64, Base.Order.ForwardOrdering} avec 5 entrées :
  "S" => 220
  "T" => 350
  "U" => 400
  "V" => 575
  "W" => 670

julia> example_dict["R"] = 100
100

julia> example_dict
DataStructures.SortedDict{String, Int64, Base.Order.ForwardOrdering} avec 6 entrées :
  "R" => 100
  "S" => 220
  "T" => 350
  "U" => 400
  "V" => 575
  "W" => 670

Set

Un ensemble Julia est une collection d'objets sans doublons ; tous les éléments sont uniques.

Voici les différences entre un ensemble et les autres types de collections :

  • Les éléments d'un ensemble sont uniques
  • L'ordre des éléments dans un ensemble n'a pas d'importance

Les ensembles servent à créer des listes sans doublons.

Créer un Set

Avec le constructeur Set, nous pouvons créer un ensemble comme suit :

Exemple

julia> var_site = Set()
Set{Any}()

julia> num_primes = Set{Int64}()
Set{Int64}()

julia> var_site = Set{String}(["Google","Example","Taobao"])
Set{String} avec des 3 éléments :
  "Google"
  "Taobao"
  "Example"
De manière alternative, nous pouvons également utiliser la fonction push!(), comme pour les tableaux, pour ajouter des éléments aux ensembles comme suit −

Nous pouvons utiliser la fonctionpush!()pour ajouter des éléments à un ensemble comme suit :

Exemple

julia> push!(var_site, "Wiki")
Set{String} avec des 4 éléments :
  "Google"
  "Wiki"
  "Taobao"
  "Example"

Nous pouvons utiliser la fonctionin()pour vérifier si un élément existe dans l'ensemble :

Exemple

julia> in("Example", var_site)
vrai

julia> in("Zhihu", var_site)
false

Opérations courantes

L'union, l'intersection et la différence sont des opérations courantes que nous pouvons effectuer sur les ensembles. Les fonctions correspondant à ces opérations sontunion()、intersect()etsetdiff()。

Union

Pour deux ensembles A et B, l'ensemble formé en combinant tous leurs éléments est appelé l'union de l'ensemble A et de l'ensemble B.

Exemple

julia> A = Set{String}(["red","green","blue", "black"])
Set{String} avec des 4 éléments :
  "bleu"
  "vert"
  "noir"
  "rouge"

julia> B = Set(["rouge","orange","jaune","vert","bleu","indigo","violet"])
Set{String} avec des 7 éléments :
  "indigo"
  "jaune"
  "orange"
  "bleu"
  "violet"
  "vert"
  "rouge"


julia> union(A, B)
Set{String} avec des 8 éléments :
  "indigo"
  "vert"
  "noir"
  "jaune"
  "orange"
  "bleu"
  "violet"
  "rouge"

Intersection

L'intersection des ensembles A et B est l'ensemble contenant tous les éléments qui appartiennent à la fois à A et à B, et aucun autre élément.

Exemple

julia> intersect(A, B)
Set{String} avec des 3 éléments :
  "bleu"
  "vert"
  "rouge"

Différence

La différence des ensembles A et B est l'ensemble contenant tous les éléments qui appartiennent à A mais pas à B, c'est-à-dire en retirant les éléments qui se chevauchent entre B et A.

Exemple

julia> setdiff(A, B)
Set{String} avec 1 élément :
  "noir"

Exemples de fonctions courantes pour les dictionnaires et les ensembles

Dans les exemples suivants, les fonctions couramment utilisées dans les dictionnaires sont présentées, et elles s'appliquent également aux ensembles :

Créez deux dictionnaires dict1 et dict2 :

Exemple

julia> dict1 = Dict(100=>"X", 220 => "Y")
Dict{Int64,String} avec 2 entrées :
 100 => "X"
 220 => "Y"
 
julia> dict2 = Dict(220 => "Y", 300 => "Z", 450 => "W")
Dict{Int64,String} avec 3 entrées :
 450 => "W"
 220 => "Y"
 300 => "Z"

Union de dictionnaires :

Exemple

julia> union(dict1, dict2)
4-element Array{Pair{Int64,String},1}:
 100 => "X"
 220 => "Y"
 450 => "W"
 300 => "Z"
Intersection
julia> intersect(dict1, dict2)
1-element Array{Pair{Int64,String},1}:
 220 => "Y"

Différence entre dictionnaires :

Exemple

julia> setdiff(dict1, dict2)
1-element Array{Pair{Int64,String},1}:
 100 => "X"

Fusionner les dictionnaires :

Exemple

julia> merge(dict1, dict2)
Dict{Int64,String} avec 4 entrées :
 100 => "X"
 450 => "W"
 220 => "Y"
 300 => "Z"

Trouver la valeur minimale dans le dictionnaire :

Exemple

julia> dict1
Dict{Int64,String} avec 2 entrées :
 100 => "X"
 220 => "Y"
 
 
julia> findmin(dict1)
("X", 100)
Autres extensions