Comment accéder aux tuples de valeur-clé dans l'ordre avant/arrière pour Dict et SortedDict? - Julia

Question

Étant donné un dictionnaire:

> d = Dict{Int, Int}(1=>123, 2=>51, 4=>23) 
Dict{Int64,Int64} with 3 entries: 
    4 => 23 
    2 => 51 
    1 => 123 

je pouvais accéder à la valeur d'un dictionnaire par sa clé, par exemple:

> d[4] 
23 

Ou je pourrais en boucle à travers les paires clé-valeur en tant que tels:

> for i in d 
     println(i) 
     end 
4=>23 
2=>51 
1=>123 

J'ai essayé d'accéder à la clé en tant que premier élément de la liste ou même i.key, mais cela ne semble pas être la bonne syntaxe:

julia> for i in d 
     println(i.key) 
     end 
ERROR: type Pair has no field key 
in macro expansion; at ./REPL[22]:2 [inlined] 
in anonymous at ./<missing>:? 

julia> for i in d 
     println(i[0]) 
     end 
ERROR: BoundsError: attempt to access 4=>23 
    at index [0] 
in getindex(::Pair{Int64,Int64}, ::Int64) at ./operators.jl:609 
in macro expansion; at ./REPL[23]:2 [inlined] 
in anonymous at ./<missing>:? 

Et puis je me suis souvenu que Julia n'est pas l'indice 0e, il devrait donc être:

> for i in d 
     println(i[1], ' ', i[2]) 
     end 
4 23 
2 51 
1 123 

> for i in d 
     println(i[1], ' ', i[2]) 
     end 
4 23 
2 51 
1 123 

Dans ce cas est le BoundsError un peu comme IndexError de Python lorsqu'un index de la liste n » t trouvé?

L'autre partie de la question est sur SortedDict, comment puis-je accéder au dernier élément Nième dans le SortedDict?

J'ai essayé d'utiliser la syntaxe d'index et j'ai récupéré la valeur mais pas le nombre de (key,value).

julia> import DataStructures: SortedDict 

julia> sd = SortedDict(d) 
DataStructures.SortedDict{Int64,Int64,Base.Order.ForwardOrdering} with 3 entries: 
    1 => 123 
    2 => 51 
    4 => 23 

julia> sd[end] 
23 

Aussi, comment puis-je trier le dictionnaire en fonction de la valeur?

Et, enfin, comment inverser le dict trié?

J'ai essayé d'utiliser Base.Order.ReverseOrding mais il a jeté un MethodError:

julia> sd = SortedDict{Base.Order.ReverseOrdering}(d) 
ERROR: MethodError: Cannot `convert` an object of type Dict{Int64,Int64} to an object of type DataStructures.SortedDict{Base.Order.ReverseOrdering,D,Ord<:Base.Order.Ordering} 
This may have arisen from a call to the constructor DataStructures.SortedDict{Base.Order.ReverseOrdering,D,Ord<:Base.Order.Ordering}(...), 
since type constructors fall back to convert methods. 
in DataStructures.SortedDict{Base.Order.ReverseOrdering,D,Ord<:Base.Order.Ordering}(::Dict{Int64,Int64}) at ./sysimg.jl:53 

Answer 1

Je ne suis pas un utilisateur de Python, mais la documentation pour IndexError ressemble à la documentation BoundsError. Notez que vous pouvez toujours interroger la documentation Julia actuelle avec ?, par ex.

?BoundsError 

Vous pouvez trier les clés de dictionnaire et valeurs:

d = Dict{Int,Int}(1 => 2, 3 => 4) 
k = sort(collect(keys(d)) ### collect() forms an array that you can sort 
v = sort(collect(values(d)) 

mais je ne vois pas pourquoi vous voulez trier par valeur. Pourquoi ne pas simplement utiliser les valeurs comme des clés?

Vous pouvez parcourir les clés ou les valeurs facilement:

for k in keys(d) ### or "for v in values(d)..." 
    println(k) 
end 

Lorsque vous utilisez SortedDict, assurez-vous qu'une telle commande est logique. Dans cet exemple de jouet, les clés de d sont des entiers, et elles ont un ordre logique avec isless et isequal; voir la documentation here.

Vous pouvez obtenir la dernière entrée d'un SortedDict avec last:

using DataStructures 
D = SortedDict(d) 
last(D) ### 3=>4 

Utilisez le module Reverse pour inverser l'ordre:

using Reverse 
D2 = SortedDict(d, Reverse)