Julia字典

Julia字典字典Dict)是一种标准的关联型数集,分为键集合与值集合两部分。键集合的元素要求互不相同;值集合无特别要求。字典中的元素是无序的,表达的是键集到值集的映射关系(与Pair类同);而且对每一个键,值集合中有且仅有一个与之对应。

定义

字典类型的原型为:

Dict{K, V} <: AbstractDict{K, V}

其中,K为键的类型,V为值的类型。

在内部实现中,为保证键元素互不相同,Dict使用hash()函数生成键的哈希值并采用isequal()函数(与运算符==有差异,可参见前文)进行相异性判断。可以通过重载isequal()及hash()函数,定义自己的Dict类型。

使用构造函数创建Dict对象,只需将多个Pair对象作为参数即可,例如:

julia> Dict(1=>1.1, 2=>2.2)
Dict{Int64, Float64} with 2 entries:     # 自动推断Dict的类型参数
  2 => 2.2
  1 => 1.1

julia> Dict(1=>1.1, 2.2=>2)
Dict{Any, Any} with 2 entries:
  2.2 => 2
  1   => 1.1

Julia会自动推断键与值的类型。当然,我们也可以显式地限定Dict的类型,例如:

julia> Dict{Int32, Float32}(1=>1.1, 2=>2.2)
Dict{Int32, Float32} with 2 entries:
  2 => 2.2
  1 => 1.1

julia> Dict{Real, Real}(1=>1.1, 2.2=>2)
Dict{Real, Real} with 2 entries:
  2.2 => 2
  1    => 1.1

对于有连续性特点的元素,可结合遍历表达式及函数创建Dict对象,例如:

julia> function f(x)                      
      x^2
      end
  f (generic function with 1 method)

  julia> z = Dict(i=>f(i) for i = 1:5)          
  Dict{Int64, Int64} with 5 entries:
    4 => 16
    2 => 4
    3 => 9
    5 => 25
    1 =>   1

或者:

julia> z = Dict(i=>i^2 for i in 1:5)          
Dict{Int64, Int64} with 5 entries:
  4 => 16
  2 => 4
  3 => 9
  5 => 25
  1 => 1

也可以将已有的元组结构转换到Dict对象,例如:
Julia字典

数组结构同样也可以:

julia> b = [1=>1.1, 2=>2.2]
2-element Array{Pair{Int64, Float64},1}:   
  1=>1.1
  2=>2.2

julia> y = Dict(b)
Dict{Int64, Float64} with 2 entries:
    2 => 2.2
    1 => 1.1

元素访问

Dict对象中的元素访问可使用中括号的索引方式(索引值为键值)进行,例如:
Julia字典

再例如:

julia> p = Dict("A"=>1, "B"=>2)
Dict{String, Int64} with 2 entries:
  "B" => 2
  "A" => 1

julia> p["A"]
1

julia> p["B"]
2

如果索引的键不存在,可能会报错,例如:

julia> p["C"]
ERROR: KeyError: key "C" not found

但若提取Dict元素时直接赋值,键不存在时不会报错,而是直接将赋值中的对应关系新增到Dict对象中,例如:

julia> p["C"] = 4
4

julia> p
Dict{String, Int64} with 3 entries:
  "B" => 2
  "A" => 1
  "C" => 4

若原对应关系已经存在,则会改变原有的键值对应关系,例如:

julia> p["C"] = 3
3

julia> p
Dict{String, Int64} with 2 entries:
  "B" => 2
  "A" => 1
  "C" => 3

元素访问还可使用get()函数,好处是当元素不存在时能以指定的默认值返回,例如:

julia> get(p, "A", 1)      # 取得"A"的对应值,因为存在该键,所以返回原对应值3
3

julia> get(p, "D", 5)      # 取得"D"的对应值,因为该键不存在,所以返回默认值5
5

若希望键不存在时将默认值存入Dict中,则可使用get! ()函数,例如:

julia> get!(p, "D",5)       # 虽然"D"不存在,但同get()一样会返回默认值5
5

julia> p                     # 但经过get! ()函数调用,关系"D"=>5已经存入了字典p中
Dict{String, Int64} with 4 entries:
  "B" => 2
  "A" => 3
  "C" => 4
  "D" => 5

julia> get!(p, "D",1)       # "D"已经存在,直接返回内部的值而非默认值
5

如果发现某个键多余,可使用delete! ()函数将其删除,例如:

julia> delete!(p, "D")
Dict{String, Int64} with 3 entries:
  "B" => 2
  "A" => 3
  "C" => 4

该函数会在执行后返回修改后的Dict对象。
如果希望在删除某映射时同时取出,使用pop! ()函数即可:

julia> pop!(p, "C")
4

julia> p
Dict{String, Int64} with 2 entries:
  "B" => 2
  "A" => 3

该函数在删除指定键的同时,会将该键对应的值返回。

遍历

可通过length()函数或其成员字段count获知Dict中元素的个数,例如:

julia> length(p)
2

julia> p.count
2

若要遍历Dict所有元素,一个直接的方式是通过keys()函数取得其键集合。例如:

julia> p
Dict{String, Int64} with 2 entries:
  "B" => 2
  "A" => 3

julia> keys(p)
Base.KeySet for a Dict{String, Int64} with 3 entries. Keys:
  "B"
  "A"

该函数会生成键集的迭代器,然后便可使用for循环进行遍历:

julia> for k in keys(p)
          println(k)
        end
B
A

这样,通过键的遍历就可访问Dict中的所有元素了,即:

julia> for k in keys(p)
          println(k, "'s value is ", p[k])
        end
B's value is 2
A's value is 3

同样,可使用values()函数取得值集合并可直接遍历,例如:

julia> values(p)
Base.ValueIterator for a Dict{String, Int64} with 2 entries. Values:
  2
  3

julia> for v in values(p)
          println(v)
        end
2
3

如果希望将该函数获得的迭代器转为数组使用,对其调用collect()函数即可,即:

julia> collect(values(p))
2-element Array{Int64,1}:
  2
  3

酷客网相关文章:

赞(0)

评论 抢沙发

评论前必须登录!