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
Dict{String, Int64} avec 2 entrées :
"B" => 2
"A" => 1
julia>
Utilisez une boucle for pour créer un dictionnaire :
Exemple
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
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
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
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
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
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
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
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
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
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 DataStructuresPour 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> 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
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"
Nous pouvons utiliser la fonctionpush!()pour ajouter des éléments à un ensemble comme suit :
Exemple
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
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
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
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
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
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
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
1-element Array{Pair{Int64,String},1}:
100 => "X"
Fusionner les dictionnaires :
Exemple
Dict{Int64,String} avec 4 entrées :
100 => "X"
450 => "W"
220 => "Y"
300 => "Z"
Trouver la valeur minimale dans le dictionnaire :
Exemple
Dict{Int64,String} avec 2 entrées :
100 => "X"
220 => "Y"
julia> findmin(dict1)
("X", 100)