唠唠闲话
Julia 是一种高性能的动态编程语言，特别适用于数值分析和计算科学领域。它拥有一个强大的类型系统和灵活的多重分派机制，这使得代码易于编写同时还能保持接近 C 语言的运行速度。此外，Julia 也能无缝调用 C 和 Fortran 库，使得它能充分利用现有的高性能计算资源。
本系列教程旨在带领读者从零开始，逐步深入学习 Julia 编程。无论你是编程新手还是有经验的开发者，这些教程都将为你提供清晰的学习路径和丰富的示例代码，帮助你快速掌握 Julia 的核心技术和高级功能。
上节介绍了 Julia 的安装、配置及常用编译器。本篇将探讨 Julia 中的数据类型和函数，这是编程的基础内容。
相关链接：
- Julia 短课程（陈久宁） – GitHub 地址
Julia 的交互模式
概览
本节介绍 Julia 的五种交互模式，并重点介绍包管理模式，这五种模式分别为：
| 模式 | 说明 | 进入方式 |
|---|---|---|
| Julian 模式 | 执行 Julia 代码的地方 | 默认模式，在其他模式下通过退格键 Backspace 进入 |
| Pkg 模式 | Julia 装包时使用的模式 | 在 Julian 模式按 ] 进入 |
| Help 文档模式 | 查询文档时使用 | 在 Julian 模式下按 ? 进入 |
| Shell 模式 | 切换到系统命令行 | 在 Julian 模式下按 ; 进入 |
| Debug 模式 | 进入代码调试模式 | 安装 Debugger.jl 后使用 |
除了 Debug 模式，其他四种模式都会经常用到，进入方式不仅适用于终端，也适用于 Jupyter Notebook 等环境。
基本介绍
四种常见模式：
-
初始进入 Julia 时，显示的模式就是 Julian 模式，左侧是绿色的
julia>，页面显示如下：
-
在 Julian 模式下，按下
]进入 Pkg 模式（包管理模式），如下图：
-
在任意模式下，按退格键（键盘上的
Backspace）可以回到 Julian 模式。 -
在 Julian 模式下，按下
?进入 Help 模式，此时输入函数可以查看使用文档：
-
在 Julian 模式下，按下
;进入 Shell 模式，这个接触过 Linux 的应该懂怎么用。 -
Debug 模式个人目前用得不多，暂略。
包的安装
Julia 中安装工具包的方法很简单，有两种方式，一是使用 Pkg 模式，二是在 Julian 模式下调用 Pkg 模块。
-
方法一，输入
]进入 Pkg 模式，如下图，左侧括号显示 Julia 的开发环境，@v1.6代表 Julia 1.6 版本，使用默认环境：
-
输入
add <包名称>安装具体模块，比如下图，模块下载到用户主目录的.julia下：
-
方法二，退格回到 Julian 模式，输入
using Pkg导入包管理模块，再输入Pkg.add("<包名称>")安装模块，如下图，注意包名称要用引号包含起来：
-
包安装完成后，可以用
using <包名称>测试模块导入。
以上只涉及了 Pkg.add 命令，包管理还有很多常用命令，后续再单独写篇介绍，推荐阅读：Pkg 官方手册，Julia 读文档之包的实战。
Julia 的数据结构
基本语法
在 Julia 中，# 用于注释。为了方便学习，相关知识点都写在代码注释中。
-
@xxx是 宏 (macro) 的语法。宏可以实现“利用代码生成代码”。 -
演示常用的两种宏：
@show显示运算信息，表达式之间用空格隔开。@info类似@show，但以第一个变量为打印信息。
-
示例：
x, y = 1, 2 @show x + y # x + y = 3 @show x + y x - y # x + y = 3 \n x - y = -1 @info "记录信息" x y x + y显示结果：
数据类型
整型和浮点数类型
x = 1
@show typeof(x) # 默认整型
λ = .1
@show typeof(λ) # .1 等同于 0.1
输出内容：
- Julia 支持使用 LaTeX，比如 λ \lambda λ 通过
\lambda+<TAB>输入；下标 c i c_i ci 通过c\_i+<TAB>输入。 - 在 Julia 中，“数值 * 变量”用连接简记，比如
2x等同于2 * x。
其他数值类型
@show typeof(1 + im) # im 代表虚数 i
@show typeof(1.0 + 2im) # 浮点虚数
@show 1 / 0 # 无穷大
@show 0 * Inf # 不定数
@show typeof(Inf) # Float64
@show typeof(NaN) # Float64
@show typeof(pi) # 无理数
@show typeof(missing) # 缺失类型，用于统计
@show 2 * missing # missing
@show typeof(nothing) # 相当于 Python 的 None
输出内容：
字符相关
@show typeof('c') # 单引号代表字符
@show typeof("c") # 双引号代表字符串
@show 'c' == "c" # 数据结构不同
@show "c"[1] === 'c' # 字符串用索引取出的数据类型是字符
@show "c"[:] == 'c' # 切片取出字符串
@show "hello " * "world" # 字符串拼接用 *
@show "hi" ^ 3 # 字符串复制用 ^
var = 2333
@show "hello $var" # 使用 $ 插入实际变量
@show "hello $(var / 10)" # 插入运算结果
输出内容：
字符转数值
使用 parse，不能直接用 Int 或 Float64：
@show parse(Int, "1") # Int 类型
@show parse(Float64, "1") # Float 类型
输出内容：
容器数据类型
列向量
使用 [] 得列向量 Vector：
@show x = [1, 2, 3] # Vector (column vector)
@show typeof(x) # 等同于 Array{Int64, 1}
@show Vector(3:5) # Vector(3:5) = [3, 4, 5]
输出内容：
切片规则
左闭右闭，首位索引为1，末位索引为 end：
x = [1, 2, 3]
@show x[1:end-1] # end-1 倒数第二位置
@show x[:] # 取全部
@show x[:] === x # 切片创建了新对象
输出内容：
切片两端留空代表取全部，此时得到的是新对象；和 Python 不同的是，切片不能只写一侧，比如 x[2:]。
常用属性
size(x): 尺寸，返回Tuple{Int64}类型length(x): 长度，类似 Python 的leneltype(x): 元素类型
矩阵
@show y = [1 2 3] # 空格分列，分号换行
@show [1 2 3 4; 5 6 7 8]
@show [1 2 3 4
5 6 7 8] # 支持用换行号换行
@show typeof(y) # 行向量为矩阵类型
@show size(y) # 矩阵形状
@show size(x) # 列向量形状
@show x == y # false | 矩阵尺寸不同，返回否
@show x' == y # 向量转置，数据格式化为矩阵，类型相等
@show y' == x # x 仍是向量，y 是 3*1 矩阵
输出内容：
元组（不可变类型）
x = (1, 2, 3.)
@show typeof(x) # 元组会单独记录每个位置的数据结构
@show x = 1, 2, 3. # 定义时括号可省
@show x, y = 1, 2 # 同 Python 的拆包功能
@show x, y = 1, 2, 3, 4, 5 # 拆包多余部分被丢弃
输出内容：
容器内使用 ... 展开序列
x = [1, 2, 3]
@show (0, x[2:end]...) [3, x...]
输出内容：
元组的拆分组合操作运行很快
modify_first!(t::Tuple, x) = (x, t[2:end]...)
t = (1, 2, 3)
@btime modify_first!($t, 0)
字典
注意：初始化后，字典键值类型确定，新键值必须保持类型一致。
# Dict{Any, String} with 3 entries
d = Dict(1 => "item1","2" => "item2",(3, 4) => "item3-4") # 创建字典
@show d[1] # 取出元素
d[3] = "item3" # 新增键值
# d[2] = 2 # 报错，与字符串类型不符
@show typeof(1 => 2) # 创建使用了 Pair 类型
items = (x => x^2 for x in 1:5) # 先创建 Pair
@show d = Dict(items) # 再生成字典
输出内容：
命名元组
可以简单理解为不可变的字典类型：
d = (x = "first item", y = "second item")
@show typeof(d) # 命名元组
@show d[:x] # 使用 Symbol 取出元素
@show d.y # 使用 . 取出函数
注意键名必须是变量，不能为数值之类：
集合交并补操作
x = [1, 2, 3]
y = [2, 3, 4]
@show setdiff(x, y) # setdiff(x, y) = [1]
@show union(x, y) # union(x, y) = [1, 2, 3, 4]
@show intersect(x, y) # intersect(x, y) = [2, 3]
输出内容：
列表生成器和迭代器
和 Python 类似：
@info "列表生成器" [i for i in -0.5:0.2:1]
@info "迭代器" (i for i in -0.5:0.2:1)
输出内容：
由于迭代器不需要创建中间变量来存储所有结果，在内存使用上是比较高效的：
clamp(x, lo=0, hi=1) = x < lo ? lo : x > hi ? hi : x
f_list() = Dict([x => clamp(x) for x in -0.5:0.2:1.5])
f_generator() = Dict((x => clamp(x) for x in -0.5:0.2:1.5))
@btime f_list() # 使用列表生成器
@btime f_generator() # 使用迭代器
输出内容：
Julia 的函数
基本使用
-
用关键字
function定义函数：# 如果没有 return ，默认返回最后一个变量 function f(x, y)tmp = x + yreturn tmp end -
用单行定义函数：
f(x, y) = x + y -
三元表达式
cond ? true_rst : false_rst，注意?和:前后要留空格：greater(a, b) = a > b ? true : false @show greater(1, 2)
-
用
=预定义参数值：f(x, y=10) = x + y @show f(1) f(1, 2) # 使用预定义
注意：与 Python 不同，Julia 函数的默认值是在函数调用时确定的，因此如果预定义值为可变对象，下次调用将重新创建，不必担心被修改。 -
函数指定参数类型，类似 C++ 的重载：
f(x::Tuple) = "input tuple" f(x::Int) = "input int" @show f((1, 2)) # 输入元组 @show f(1) # 输入整型
-
可变参数用
...，类似 Python 的*：f(x, y...) = y # 定义函数 @show f(1) # 可变参为空元组 @show f(1, 2, 3, 4)
-
关键词参数：
f(x; y, z=10) = x + y + z # 分号隔开关键字 @show f(0, y=2) # z 取默认值，y 用关键字赋值 # f(1, 2, 3) # 报错，必须用关键字赋值 f(x) = 0 # 函数重载只比对关键字前的部分 @show f(0) # 函数被重置
-
当函数修改变量信息时，约定上，函数名末尾追加
!：x = [2, 1] sort(x) @show x # x 不变 sort!(x) @show x # x 改变
Julia 编写函数时，可以写两个版本，一个带!允许修改变量，运算速度快；再写一个不带!的版本，通过调用第一个函数来定义。
函数式编程
一等公民
在 Julia 中，函数是“一等公民”（First-class citizen）。在编程语言中，一等公民是指支持所有操作的实体，这些操作通常包括作为参数传递、从函数返回、修改并分配给变量等。比如 int 类型，它支持作为参数传递，可以从函数返回，也可以赋值给变量，因此它是一等公民。类似的，函数作为一等公民，意味着可以把函数赋值给变量或存储在数据结构中，也可以把函数作为其他函数的参数或者返回值。一般来说，函数式编程语言、动态语言和现代编程语言中，函数都会作为一等公民。
Julia 与函数式编程
-
Julia 里的符号可以当函数来用，比如：
@show +(1, 2) # 相当于 1 + 2 -
高阶函数：
f = x -> x^2 # 匿名函数 map(f, 1:5) # [1, 4, 9, 16, 25] | 函数作用在右侧数据上，返回向量 map((x, y) -> x + y, 1:5, 6:10) # [7, 9, 11, 13, 15] | 二元函数支持输入值为函数的还有
reduce、mapreduce、foreach、sum、filter等。这部分和 MMA 类似，就不仔细介绍了。 -
do创建一个匿名函数并将其作为第一个参数传递给函数调用：map(1:5) do xreturn x^2 end # 相当于 function f(x)return x^2 end map(f, 1:5)
Curry 化
柯里化，指把接受多个参数的函数变换成接受多个单一参数的函数的技术。
例如 > 是一个二参函数，可以通过指定一参来创建一个新函数：
filter(>(3), 1:10)
这里 >(3) 就是一个柯里化的函数，它接受一个参数，返回一个函数。
一般的，在 Julia 中可以用 Base.Fix1 或 Base.Fix2 来实现柯里化：
f(x, y) = x + y
f1 = Base.Fix1(f, 1)
f1.(1:5) # [2, 3, 4, 5, 6]
面向对象
和 Mathematica 一样，Julia 不支持面向对象，不能继承方法。但面向对象的很多功能可以用结构体及多重派发替代。
Julia 中的抽象对象，某种程度上可以替代继承的功能，我们下一节会详细介绍。
总结
本节内容，介绍了 Julia 的交互模式，基本的数据结构，函数及函数式编程。这些基础知识将为进一步深入学习 Julia 奠定坚实的基础。
