字典 #

d1 = Dict("a" => 1, "b" => 2, "c" => 3)
d2 = Dict(:a => 1, :b => 2, :c => 3)
d3 = Dict{String, Int}()
d4 = Dict()

typeof(Dict("a" => 1))
typeof(Dict(:a => 1))
typeof(Dict{String, Int}())

Dict(["a", "b", "c"] .=> [1, 2, 3])
Dict(zip(["a", "b", "c"], [1, 2, 3]))
Dict([("a", 1), ("b", 2), ("c", 3)])

Dict(string(i) => i^2 for i in 1:5)
Dict(i => i^2 for i in 1:5 if i % 2 == 0)

d = Dict("a" => 1, "b" => 2, "c" => 3)
d["a"]
d["b"]

d = Dict("a" => 1, "b" => 2)
d["c"]
get(d, "c", 0)
get(d, "a", 0)
get(d, "c") do
    "default"
end

d = Dict("a" => 1, "b" => 2)
haskey(d, "a")
haskey(d, "c")
"a" in keys(d)
"c" ∈ keys(d)

d = Dict("a" => 1, "b" => 2, "c" => 3)
keys(d)
values(d)
pairs(d)
collect(keys(d))
collect(values(d))

d = Dict{String, Int}()
d["a"] = 1
d["b"] = 2
d

d = Dict("a" => 1, "b" => 2)
d["a"] = 10
d

d = Dict("a" => 1, "b" => 2, "c" => 3)
delete!(d, "a")
pop!(d, "b")
pop!(d, "c", 0)
empty!(d)

d = Dict("a" => 1)
get!(d, "a", 10)
get!(d, "b", 20)
d

d = Dict("a" => 1, "b" => 2)
getkey(d, "a", "default")
getkey(d, "c", "default")

d1 = Dict("a" => 1, "b" => 2)
d2 = Dict("c" => 3, "d" => 4)
merge(d1, d2)
merge(d1, Dict("b" => 20))

d1 = Dict("a" => 1, "b" => 2)
d2 = Dict("b" => 20, "c" => 3)
merge!(d1, d2)
d1

d = Dict("a" => 1, "b" => 2, "c" => 3, "d" => 4)
filter(p -> p.second > 2, d)
filter(p -> p.first in ["a", "b"], d)

d = Dict("a" => 1, "b" => 2, "c" => 3)
Dict(k => v^2 for (k, v) in d)
mapvals(f, d) = Dict(k => f(v) for (k, v) in d)
mapvals(x -> x^2, d)

d = Dict("a" => 1, "b" => 2, "c" => 3)
for (k, v) in d
    println("$k => $v")
end

d = Dict("a" => 1, "b" => 2, "c" => 3)
for k in keys(d)
    println(k)
end

d = Dict("a" => 1, "b" => 2, "c" => 3)
for v in values(d)
    println(v)
end

d = Dict("a" => 1, "b" => 2, "c" => 3)
for (i, (k, v)) in enumerate(d)
    println("$i: $k => $v")
end

d = Dict("a" => 1, "b" => 2, "c" => 3)
length(d)
isempty(d)
eltype(d)
keytype(d)
valtype(d)

d = Dict("a" => 1, "b" => 2, "c" => 3)
findfirst(p -> p.second == 2, d)
findall(p -> p.second > 1, d)
in(1, values(d))
in(("a", 1), pairs(d))

using Pkg
Pkg.add("OrderedCollections")

using OrderedCollections

od = OrderedDict("a" => 1, "b" => 2, "c" => 3)

d = Dict{String, Vector{Int}}()
get!(d, "a", Int[])
push!(get!(d, "a", Int[]), 1)

using OrderedCollections
dd = DefaultDict{String, Vector{Int}}(() -> Int[])
dd["a"]
push!(dd["a"], 1)

d = Dict{Symbol, Int}()
d[:a] = 1

d = Dict{Tuple{Int, Int}, Int}()
d[(1, 2)] = 3

struct Point
    x::Int
    y::Int
end

Base.hash(p::Point, h::UInt) = hash((p.x, p.y), h)
Base.:(==)(a::Point, b::Point) = a.x == b.x && a.y == b.y

d = Dict{Point, String}()
d[Point(1, 2)] = "A"

function word_count(text::String)
    words = split(lowercase(text))
    counts = Dict{String, Int}()
    for word in words
        w = strip(word, ['.', ',', '!', '?'])
        counts[w] = get(counts, w, 0) + 1
    end
    return counts
end

word_count("Hello world! Hello Julia!")

function group_by(arr, key_func)
    groups = Dict{eltype(key_func(first(arr))), Vector{eltype(arr)}}()
    for item in arr
        key = key_func(item)
        if !haskey(groups, key)
            groups[key] = []
        end
        push!(groups[key], item)
    end
    return groups
end

group_by([1, 2, 3, 4, 5, 6], x -> x % 2)

function memoize(f)
    cache = Dict{Tuple, Any}()
    function(args...)
        key = args
        if !haskey(cache, key)
            cache[key] = f(args...)
        end
        return cache[key]
    end
end

fib = memoize(function(n)
    n <= 1 ? n : fib(n-1) + fib(n-2)
end)

fib(40)

struct Config
    data::Dict{Symbol, Any}
end

Config() = Config(Dict{Symbol, Any}())

function Base.getindex(c::Config, key::Symbol)
    get(c.data, key, nothing)
end

function Base.setindex!(c::Config, value, key::Symbol)
    c.data[key] = value
end

function Base.haskey(c::Config, key::Symbol)
    haskey(c.data, key)
end

config = Config()
config[:host] = "localhost"
config[:port] = 8080
config[:host]