ApX 标志ApX 标志

趋近智

大模型显存计算器硬件课程定价
ApX 标志ApX 标志

趋近智

大模型显存计算器硬件课程定价

所有课程

Julia编程入门
章节 1: Julia 简介:设置与初次使用
Julia 是什么以及为何使用它?
Julia 在科学计算方面的优势
Julia在人工智能与数据科学生态系统中的地位
在您的系统上安装 Julia
使用 Julia REPL
选择您的Julia开发环境
编写和运行你的第一个 Julia 脚本
Julia 中的核心语法元素
获取Julia文档与支持
实践:环境配置与初始脚本编写
第 1 章测验
章节 2: 变量、数据类型和操作
定义变量与赋值数据
Julia 内置数据类型概览
使用数值:整数和浮点数
理解布尔逻辑
字符和字符串操作
使用类型注解提升清晰度
数据类型转换
声明用于固定值的常量
练习:变量、类型和基本操作
第 2 章测验
章节 3: 表达式与控制流结构
使用运算符构建表达式
算术与赋值运算
比较运算符和逻辑运算符
使用 if-elseif-else 控制程序流程
使用 for 循环重复任务
使用 while 循环进行条件迭代
修改循环行为:break 和 continue
三元运算符:简洁的条件语句
动手实践:实现决策逻辑
第 3 章测验
章节 4: 使用集合:数组、元组、字典和集合
Julia中数据结构的介绍
数组:有序、可变集合
数组的基本函数与操作
元组:固定大小的不可变序列
字典:存储键值数据
集合:唯一元素的集合
使用推导式高效创建集合
实践:使用 Julia 集合管理数据
第 4 章测验
章节 5: 函数:创建可复用代码
在 Julia 中定义和调用函数
理解函数实参与形参
为参数指定默认值
函数返回值
管理变量作用域和生命周期
编写简洁的匿名函数
多重派发:Julia 的一个独特功能
使用文档字符串为函数编写文档
动手实践:构建和使用自定义函数
第 5 章测验
章节 6: 模块、包与项目组织
使用模块组织代码
模块内容的导入与导出
运用 Julia 的标准库
Pkg 介绍:Julia 的包管理器
查找、添加和管理包
在项目中集成外部库
设置一个基本的 Julia 项目
实践:组织代码与管理依赖
第 6 章测验
章节 7: 输入、输出与文件系统操作
使用 print 和 println 显示输出
使用@printf格式化输出
接受用户输入
文件处理基础
从文件中读取数据
写入数据到文件
文件路径与目录管理
实践:编写文件操作脚本
第 7 章测验
章节 8: 错误处理与基本调试
Julia 程序中的错误来源
使用 try-catch 进行异常处理
使用 finally 保证代码执行
定义和抛出自定义错误
常见错误情况和处理方法
Julia 代码调试策略
Julia 调试工具简介
练习:编写健壮代码与错误处理
第 8 章测验
章节 9: 巩固知识,进阶Julia编程
Julia核心知识复习
多重派发的实际运用:简单示例
初识 DataFrames.jl:表格数据处理
使用 Plots.jl 进行数据可视化:概览
Julia 进阶学习指引
有用的Julia社区资源
应用所学:一个小项目
第 9 章测验

字典:存储键值数据

数组和元组在处理有序数据序列方面表现良好,但有时您需要一种通过特定标签或标识符而非数字位置来存储和获取信息的方式。这时,字典就派上用场了。字典在其他编程语言中常被称为映射、关联数组或哈希表,它们是存储键值对的集合。

想象一下一本词典:您查找一个词(独有的键)来找到它的定义(值)。同样,在 Julia 字典中,每个独有的键都与一个特定值关联。这种结构在您知道对应键后需要快速查找值的情况下非常实用。

与数组不同,数组按数字索引(在 Julia 中通常是 1, 2, 3,...)排序,而字典从数据访问的角度来看通常被认为是无序的。您不会要求字典中的“第三项”;您会要求“与此特定键关联的值”。(值得注意的是,Julia 的 Dict 类型自 Julia 1.0 版本以来确实保留了插入顺序,但主要交互模式仍然是基于键的查找。)

创建字典

您可以使用 Dict() 构造函数在 Julia 中创建字典。您可以创建一个空字典,或者使用键值对对其进行初始化。“对”操作符 => 用于将键与其值关联。

让我们创建一个可以存储任何类型键和值的空字典:

julia> scores = Dict()
Dict{Any, Any}()

这会创建一个字典,其中键和值都可以是 Any 类型,这意味着它们可以保存各种类型的数据。

通常,您会希望更具体地指定字典将保存的键和值的类型。这可以提高性能,并通过确保类型一致性来帮助及早发现错误。例如,要创建一个键为字符串(代表学生姓名)而值为整数(他们的分数)的字典:

julia> student_scores = Dict{String, Int}()
Dict{String, Int64}()

请注意,在典型的 64 位系统上,Julia 将 Int 推断为 Int64。Int64 是一种特定类型的整数,可以存储 64 位数字。

您也可以在创建字典时直接用值对其进行初始化:

julia> fruit_colors = Dict("apple" => "red", "banana" => "yellow", "grape" => "purple")
Dict{String, String} with 3 entries:
  "banana" => "yellow"
  "apple"  => "red"
  "grape"  => "purple"

在这种情况下,Julia 根据提供的初始数据推断键和值都是 String 类型。字典的一个重要属性是键必须是独有的。如果在初始化期间尝试添加重复的键,将使用与该键最后一次出现关联的值。

添加和修改元素

字典创建后,您可以添加新的键值对,或修改与现有键关联的值。这通过方括号表示法 [] 完成,类似于您访问数组元素的方式,但您使用的是键而不是数字索引。

要向现有字典添加新条目:

julia> student_scores["Alice"] = 95
95

julia> student_scores["Bob"] = 88
88

julia> student_scores
Dict{String, Int64} with 2 entries:
  "Bob"   => 88
  "Alice" => 95

如果您为字典中已存在的键赋值,Julia 会更新与该键关联的值。这对于更改数据很有用。

julia> student_scores["Alice"] = 97  # 爱丽丝提高了她的分数!
97

julia> student_scores
Dict{String, Int64} with 2 entries:
  "Bob"   => 88
  "Alice" => 97

访问值

要从字典中获取值,请在其键上使用方括号:

julia> alice_score = student_scores["Alice"]
97

如果您尝试访问字典中不存在的键,Julia 将抛出 KeyError。如果未处理这种类型的错误,它可能会停止您的程序。

julia> student_scores["Charlie"]
ERROR: KeyError: key "Charlie" not found
Stacktrace:
 [1] getindex(h::Dict{String, Int64}, key::String)
   @ Base ./dict.jl:499
 [2] top-level scope
   @ REPL[7]:1

为了安全地访问值并避免潜在错误,您可以首先使用 haskey() 函数检查键是否存在:

julia> haskey(student_scores, "Bob")
true

julia> haskey(student_scores, "Charlie")
false

一种更直接且安全地获取值的方法是使用 get() 函数。它接受三个参数 (parameter):字典、您要查找的键,以及如果未找到键则返回的默认值。

julia> charlie_score = get(student_scores, "Charlie", 0) # 如果 Charlie 未找到,则返回 0
0

julia> alice_score_safe = get(student_scores, "Alice", 0) # Alice 存在,因此返回她的分数
97

使用 get() 通常更受青睐,因为它将检查和获取结合到一个单一、简洁的操作中,使您的代码更简洁。

删除元素

您可以使用 pop! 或 delete! 等函数从字典中删除键值对。

pop!(dictionary, key) 函数会移除给定 key 的键值对并返回被移除的值。如果未找到键,它将抛出 KeyError,类似于直接访问。

julia> student_scores
Dict{String, Int64} with 2 entries:
  "Bob"   => 88
  "Alice" => 97

julia> bobs_score = pop!(student_scores, "Bob")
88

julia> student_scores
Dict{String, Int64} with 1 entry:
  "Alice" => 97

您还可以为 pop! 提供一个默认值,如果未找到键,该值将被返回,从而阻止错误:

julia> pop!(student_scores, "David", "Not Present") # David 不在字典中
"Not Present"

delete!(dictionary, key) 函数也会移除键值对。但是,它不会返回值,而是返回修改后的字典本身。如果未找到键,它不会导致错误。

julia> student_scores["Carol"] = 92
92

julia> student_scores
Dict{String, Int64} with 2 entries:
  "Carol" => 92
  "Alice" => 97

julia> delete!(student_scores, "Alice")
Dict{String, Int64} with 1 entry:
  "Carol" => 92

julia> student_scores
Dict{String, Int64} with 1 entry:
  "Carol" => 92

遍历字典

经常需要处理字典中的所有条目。Julia 提供了几种方便的方式,可以使用 for 循环遍历它们。

您可以直接遍历键值对。在循环的每一步中,您都会得到键及其对应的值。

julia> fruit_colors = Dict("apple" => "red", "banana" => "yellow", "grape" => "purple")
Dict{String, String} with 3 entries:
  "banana" => "yellow"
  "apple"  => "red"
  "grape"  => "purple"

julia> for (fruit, color) in fruit_colors
           println("The color of $fruit is $color.")
       end
The color of banana is yellow.
The color of apple is red.
The color of grape is purple.

如果您只需处理键,可以使用 keys() 函数:

julia> for fruit in keys(fruit_colors)
           println("$fruit is a known fruit.")
       end
banana is a known fruit.
apple is a known fruit.
grape is a known fruit.

类似地,如果您只需值,可以使用 values() 函数:

julia> for color in values(fruit_colors)
           println("We have a fruit with the color: $color.")
       end
We have a fruit with the color: yellow.
We have a fruit with the color: red.
We have a fruit with the color: purple.

keys() 和 values() 都返回迭代器。迭代器是高效的结构,允许您逐个访问元素,通常不会在内存中创建新的集合。

常用字典函数

Julia 提供了其他一些有用的函数用于处理字典:

  • length(my_dict): 返回字典中键值对的数量。
    julia> length(fruit_colors)
    3
    
  • isempty(my_dict): 如果字典没有条目则返回 true,否则返回 false。
    julia> isempty(fruit_colors)
    false
    julia> isempty(Dict()) # 一个空字典
    true
    
  • merge(dict1, dict2): 创建一个新字典,包含 dict1 和 dict2 中的所有键值对。如果一个键同时存在于两个字典中,新字典将使用 dict2(第二个参数 (parameter))中的值。原始字典不会被更改。
    julia> dict_a = Dict("a" => 1, "b" => 2)
    Dict{String, Int64} with 2 entries:
      "b" => 2
      "a" => 1
    
    julia> dict_b = Dict("b" => 3, "c" => 4) # "b" 也存在于 dict_a 中
    Dict{String, Int64} with 2 entries:
      "b" => 3
      "c" => 4
    
    julia> merged_dict = merge(dict_a, dict_b)
    Dict{String, Int64} with 3 entries:
      "b" => 3 # dict_b 中键 "b" 的值
      "c" => 4
      "a" => 1
    
    还有一个 merge!(dict1, dict2) 函数(带感叹号),它通过添加 dict2 中的条目来就地修改 dict1。

何时选择字典

字典是一种基本数据结构,在特定场景中尤其强大:

  • 通过标识符快速查找:当您需要基于独有标识符而非数据位置来快速获取数据时。例如,使用用户的独有用户名查找其个人资料信息。
  • 关联数据:当您想要存储数据对之间的关系或映射时。例子包括将单词映射到它们在文本文档中的频率,或将产品 ID 映射到它们的详细描述。
  • 计数:字典非常适合统计项目。您可以将项目本身用作键,将其计数用作值。
  • 灵活的数据表示:它们可以表示字段带有名称(键)的记录或对象。例如,像 Dict("name" => "Julia", "version" => 1.9, "is_awesome" => true) 这样的字典可以存储实体的各种属性。

与通过整数索引访问的有序序列——数组相比,字典(出于访问目的)是无序集合,通过各种类型(如字符串、数字或符号)的键进行访问。如果元素的顺序很重要,并且您通常按顺序或按其数字位置访问它们,那么数组通常是更好的选择。然而,如果您需要将独有键与值关联以便基于这些键快速直接获取,那么字典更适合。

让我们举例说明一个常见用例:统计单词列表中单词的频率。 假设我们有一个单词列表(数组):

julia> words = ["hello", "hello", "julia", "hello"]
6-element Vector{String}:
 "hello"
 ""
 "hello"
 "julia"
 ""
 "hello"

julia> word_counts = Dict{String, Int}() # 为计数创建一个空字典
Dict{String, Int64}()

julia> for word in words
           # 如果 'word' 已经是键,获取其计数。否则,默认为 0。
           # 然后,将此计数加 1 并更新字典。
           word_counts[word] = get(word_counts, word, 0) + 1
       end

julia> word_counts
Dict{String, Int64} with 3 entries:
  "julia" => 1
  "global" => 2
  "hello" => 3

在此示例中,get(word_counts, word, 0) 部分很重要的。它安全地获取 word 的当前计数。如果 word 是第一次遇到(因此尚未在 word_counts 中),get 返回默认值 0。然后我们将此计数加 1,并使用 word 作为键将其存回字典中。这是使用字典统计项目的常见且高效的模式。

下图显示了字典的简单表示:

字典中的每个条目都包含一个独有的键,该键与其对应的值关联。访问值是通过其键完成的,而不是通过其位置。

字典提供了一种灵活高效的方式来管理带标签的数据。随着您继续使用 Julia 编程,您会发现它们是处理广泛任务的不可或缺的工具,从简单的数据存储到构成更复杂算法的一部分。它们通过提供一种不同的、基于键的方法来组织和访问您的信息集合,从而有效地补充了数组和元组。

  • Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein, 2022 (MIT Press) - 一本关于数据结构和算法的权威教科书,详细解释了哈希表、其操作和性能特征。

© 2026 ApX Machine Learning