Wörterbücher und Mengen in Julia

In den vorherigen Kapiteln haben wir etwas überJulia ArraysundJulia Tupel gelernt。

Arrays sind eine Art von Sammlung. Darüber hinaus hat Julia andere Arten von Sammlungen, wie Wörterbücher und Mengen (ungeordnete Sammlungslisten).


Wörterbuch

Ein Wörterbuch ist ein veränderbares Container-Modell, das Objekte beliebigen Typs speichern kann.

Jedes Schlüssel-Wert-Paar im Wörterbuchkey=>valuePaar wird durch=>einen Doppelpunkt getrennt, und jedes Schlüssel-Wert-Paar wird durch ein Komma getrennt,und das gesamte Wörterbuch wird in geschweifte Klammern eingeschlossen{}wie folgt:

Wörterbuch erstellen

Die Syntax zum Erstellen eines Wörterbuchs lautet wie folgt:
Dict("key1" => value1, "key2" => value2,,…, "keyn" => valuen)

Das folgende Beispiel erstellt ein einfaches Wörterbuch, bei dem Schlüssel A dem Wert 1 entspricht und Schlüssel B dem Wert 2 entspricht:

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

Beispiel

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} mit 2 Einträgen:
  "B" => 2
  "A" => 1

julia>

Verwenden Sie eine for-Schleife, um ein Wörterbuch zu erstellen:

Beispiel

julia> first_dict = Dict(string(x) => sind(x) for x = 0:5:360)
Dict{String, Float64} mit 73 Einträgen:
  "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
  ⋮     => ⋮

Taste

Schlüssel in einem Wörterbuch sind eindeutig. Wenn wir einem vorhandenen Schlüssel einen Wert zuweisen, erstellen wir keinen neuen, sondern ändern den vorhandenen Schlüssel.

Einen Schlüssel finden

Wir können die Funktion haskey() verwenden, um zu prüfen, ob das Wörterbuch den angegebenen Schlüssel enthält:

Beispiel

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} mit 2 Einträgen:
  "B" => 2
  "A" => 1

julia> haskey(first_dict, "A")
false

julia> haskey(D, "A")
wahr

julia> haskey(D, "Z")
false

Sie können auch diein()-Funktion verwenden, um zu prüfen, ob das Wörterbuch dasSchlüssel/Wert-Paar enthält:

Beispiel

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} mit 2 Einträgen:
  "B" => 2
  "A" => 1

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

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

Schlüssel/Wert-Paar hinzufügen

Wir können ein neues Schlüssel/Wert-Paar wie folgt zu einem vorhandenen Wörterbuch hinzufügen:

Beispiel

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} mit 2 Einträgen:
  "B" => 2
  "A" => 1

julia> D["C"] = 3
3

julia> D
Dict{String, Int64} mit 3 Einträgen:
  "B" => 2
  "A" => 1
  "C" => 3

Schlüssel/Wert-Paar löschen

Wir können diedelete!()-Funktion verwenden, um einen Schlüssel aus einem vorhandenen Wörterbuch zu löschen:

Beispiel

julia> delete!(D, "C")
Dict{String, Int64} mit 2 Einträgen:
  "B" => 2
  "A" => 1

Alle Schlüssel in einem Wörterbuch abrufen

Wir können diekeys()-Funktion verwenden, um alle Schlüssel im Wörterbuch abzurufen:

Beispiel

julia> keys(D)
KeySet für a Dict{String, Int64} mit 2 Einträgen. Schlüssel:
  "B"
  "A"

julia>

Wert

Jeder Schlüssel in einem Wörterbuch hat einen entsprechenden Wert.

Alle Werte eines Wörterbuchs anzeigen

Wir können dievalues()verwenden, um alle Werte im Wörterbuch anzuzeigen:

Beispiel

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} mit 2 Einträgen:
  "B" => 2
  "A" => 1

julia> values(D)
ValueIterator für a Dict{String, Int64} mit 2 Einträgen. Werte:
  2
  1

julia>

Wörterbuch als Iterable

Wir können ein Wörterbuch als Iterable behandeln, um Schlüssel/Wert-Paare anzuzeigen:

Beispiel

julia> D=Dict("A"=>1, "B"=>2)
Dict{String, Int64} mit 2 Einträgen:
  "B" => 2
  "A" => 1

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

Im Beispiel istkvein Tupel, das jedes Schlüssel/Wert-Paar enthält.

Sortieren von Dictionaries

Dictionaries sind ungeordnet, aber wir können die Funktion sort() verwenden, um ein Dictionary zu sortieren:

Beispiel

julia> example_dict = Dict("R" => 100, "S" => 220, "T" => 350, "U" => 400, "V" => 575, "W" => 670)
Dict{String, Int64} mit 6 Einträgen:
  "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

Wir können den Datentyp SortedDict aus dem Paket DataStructures.ji verwenden, um ein Dictionary immer sortiert zu halten.

Um das Paket DataStructures zu verwenden, müssen Sie es zuerst installieren. Sie können SortedDict im Pkg-Modus der REPL mit dem Befehl add hinzufügen.

Geben Sie in der REPL das Symbol]ein, um in denpkgModus zu wechseln.

pkg-Modus aufrufen

julia> ]               # ] eingeben, um in den Pkg-Modus zu wechseln

Syntax zum Hinzufügen eines Pakets:

add 包名

Nachdem wir das Paket DataStructures unten hinzugefügt haben, können die folgenden Beispiele normal ausgeführt werden:

(@v1.7) pkg> add DataStructures
Für nicht registrierte Pakete können Sie direkt eine URL angeben:
add https://github.com/fredrikekre/ImportMacros.jl

Lokale Pakete:

add 本地路径/包名.jl

Beispiel

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} mit 5 Einträgen:
  "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} mit 6 Einträgen:
  "R" => 100
  "S" => 220
  "T" => 350
  "U" => 400
  "V" => 575
  "W" => 670

Set

Ein Set in Julia ist eine Sammlung von Objekten ohne Duplikate; alle Elemente sind eindeutig.

Im Folgenden werden die Unterschiede zwischen einem Set und anderen Arten von Sammlungen beschrieben:

  • Elemente in einer Menge sind eindeutig
  • Die Reihenfolge der Elemente in einer Menge ist nicht wichtig

Mengen werden verwendet, um Listen ohne Duplikate zu erstellen.

Ein Set erstellen

Mit dem Set-Konstruktor können wir ein Set wie folgt erstellen:

Beispiel

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

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

julia> var_site = Set{String}(["Google","Example","Taobao"])
Set{String} mit 3 Elementen:
  "Google"
  "Taobao"
  "Example"
Alternativ können wir auch die push!()-Funktion wie bei Arrays verwenden, um Elemente wie folgt zu Mengen hinzuzufügen −

Wir können diepush!()-Funktion verwenden, um Mengenelemente wie folgt hinzuzufügen:

Beispiel

julia> push!(var_site, "Wiki")
Set{String} mit 4 Elementen:
  "Google"
  "Wiki"
  "Taobao"
  "Example"

Wir können diein()-Funktion verwenden, um zu prüfen, ob ein Element in der Menge vorhanden ist:

Beispiel

julia> in("Example", var_site)
wahr

julia> in("Zhihu", var_site)
false

Häufige Operationen

Vereinigung, Schnittmenge und Differenz sind einige gängige Operationen, die wir auf Mengen ausführen können. Die Funktionen, die diesen Operationen entsprechen, sindunion()、intersect()undsetdiff()。

Vereinigung

Für zwei Mengen A und B wird die Menge, die durch das Kombinieren aller ihrer Elemente gebildet wird, als Vereinigung der Mengen A und B bezeichnet.

Beispiel

julia> A = Set{String}(["red","green","blue", "black"])
Set{String} mit 4 Elementen:
  "blue"
  "green"
  "black"
  "red"

julia> B = Set(["red","orange","yellow","green","blue","indigo","violet"])
Set{String} mit 7 Elementen:
  "indigo"
  "yellow"
  "orange"
  "blue"
  "violet"
  "green"
  "red"


julia> union(A, B)
Set{String} mit 8 Elementen:
  "indigo"
  "green"
  "black"
  "yellow"
  "orange"
  "blue"
  "violet"
  "red"

Schnittmenge

Die Schnittmenge der Mengen A und B ist die Menge, die alle Elemente enthält, die sowohl zu A als auch zu B gehören, und keine anderen Elemente.

Beispiel

julia> intersect(A, B)
Set{String} mit 3 Elementen:
  "blue"
  "green"
  "red"

Unterschied

Die Differenz der Mengen A und B ist die Menge, die alle Elemente enthält, die zu A, aber nicht zu B gehören, das heißt, es werden die Elemente entfernt, die sich zwischen B und A überschneiden.

Beispiel

julia> setdiff(A, B)
Set{String} mit 1 Element:
  "black"

Beispiele für häufige Funktionen für Dictionaries und Sets

In den folgenden Beispielen werden Funktionen demonstriert, die häufig in Dictionaries verwendet werden, und sie gelten auch für Sets:

Erstelle zwei Dictionaries dict1 und dict2:

Beispiel

julia> dict1 = Dict(100=>"X", 220 => "Y")
Dict{Int64,String} mit 2 Einträgen:
 100 => "X"
 220 => "Y"
 
julia> dict2 = Dict(220 => "Y", 300 => "Z", 450 => "W")
Dict{Int64,String} mit 3 Einträgen:
 450 => "W"
 220 => "Y"
 300 => "Z"

Vereinigung von Dictionaries:

Beispiel

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

Wörterbuch-Differenz:

Beispiel

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

Wörterbücher zusammenführen:

Beispiel

julia> merge(dict1, dict2)
Dict{Int64,String} mit 4 Einträgen:
 100 => "X"
 450 => "W"
 220 => "Y"
 300 => "Z"

Den Minimalwert im Wörterbuch finden:

Beispiel

julia> dict1
Dict{Int64,String} mit 2 Einträgen:
 100 => "X"
 220 => "Y"
 
 
julia> findmin(dict1)
("X", 100)
Andere Erweiterungen