Julia 笔记系列：

唠唠闲话

近期刷 LeetCode 题，在“先写 Python 后 Julia”的 coding 模式下体会了两门语言的差异。本篇介绍 Python 编程习惯在 Julia 中的实现，绝大多数情况下，Julia 的实现方式更灵活且有两个鲜明特性：类型派发和函数式。

Ps：LeetCode.jl 项目 提供部分 LeetCode 习题的 Julia 解答。对于有代码的问题，可以学习别人写的 Julia 代码风格和技巧，其他问题则可以自行补充和提交，两全其美。

跳转链接：类型转化，列表, 元组，字典，元素添加，删除，查找，包含，最大最小值，排序反转，逻辑判断，字符串，生成器，索引处理，向量化，IO 编程，函数式，面向对象，以及类的“继承”

数据和操作

数组部分参考了这篇教程。

  1. Python 类型转化用 int, float, str，Julia 规则如下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    # 整数 -> 浮点数（与 Python 方法相同）
    Float32(1)
    Float64(2)

    # 浮点数 -> 整数
    # 类似 Python 的 int，但是浮点数与整数的差值必须小于精度值
    Int(1.0) 
    # 下边报错
    # Int(1.001) 
    # 四舍五入
    round(Int, 1.1)
    # 取上整
    ceil(Int, 1.1)
    # 取下整
    floor(Int, 1.1)

    # 整数，浮点数 -> 字符串
    string(1), string(1.)

    # 字符串 -> 整数，浮点数
    parse(Int, "12")
    parse(Float, "1e2")

  2. Python 的 list -> Julia 的 Vector 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    # 与 Python 规则相同，等价写法是 Int[1, 2, 3]
    l1 = [1, 2, 3] 
    # 列表需要指定数据类型
    l2 = Float[1, 2, 3] 
    # 空列表必须指明类型
    l3 = Int[]; l4 = Float64[] 
    # 取复杂性更高的类型，等价于 mat = Float64[1, 2] 
    l5 = [1, 2.] 
    # 用 `类型(数据)` 的方式转化数据格式
    l6 = Vector{Float}([1,2,3]) 
    # collect 类似于 list 命令
    l7 = collect(1:5)
    # 列表拼接
    l8 = vcat(l1, l2)
    • Python 的 range(start, stop+1, step) -> Julia 的切片 start:step:stop，注意规则区别
    • collect 将可迭代对象转化为列表(Vector)，类似于 Python 的 list 操作
    • Julia 的列表拼接要用 vcat 或有时可以用 append!，而 + 操作是列表的元素相加，与 Python 的 + 不同

  3. Python 的 tuple -> Julia 的 Tuple 和 NTuple 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    # 直接用圆括号定义
    t1 = (1, ) 
    # 用类型转化的方式定义
    t2 = Tuple([1,2,3]) 
    # 取前 3 个构成元组
    t3 = Tuple{Int,Int,Int}(1:10) 
    # 上一命令的等价写法
    t4 = NTuple{3,Int}(1:10) 
    # 元组拼接，类似于 Python 语法的 (*t1, t2)
    t5 = (t1..., t2...)

    在 Python 中，+ 运算可以拼接元组，但在 Julia 中不能直接这么操作；当然，也可以手写拼接函数

    1
    concatenate(t1::Tuple, t2::Tuple) = (t1, t2...)

  4. Python 的 dict -> Julia 的 Dict 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    # 空字典，需指定键和键值的类型
    dic = Dict{Char, Int}() 
    # 等同于 Dict{Any, Any}() 不建议
    dic = Dict() 
    # 创建字典并初始化
    dic = Dict{Int, Int}(1=>2, 2=>3) 
    # 判断是否包含键值，不能用 1 in dic
    haskey(dic, 1)
    1 ∈ keys(dic) # 等价写法
    # 删除指定键，并返回键值
    pop!(dic, 1)

  5. 元素添加

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    data = [1, 2, 3]
    # 追加一个元素
    push!(data, 3) 
    # 追加多个
    push!(data, 4, 5) 
    # 同 push!
    append!(data, 1, 2) 
    # 用列表追加多个元素
    append!(data, [1,2,3]) 
    # 用混合方式，追加多个元素
    append!(data, 1:5, [1,2], 3) 
    # 追加列表
    res = [[1, 2], [2, 3]]
    append!(res, [[1, 3]]) 
    # 注意 res 的元素类型为 Vector{Int}，追加信息不能直接写 [1, 3]
    # 在列表前边追加
    insert!(data, 1, 2)
    • push! 和 append! 的功能类似 Python 列表的 .append 和 .extend，但也有区别
    • append! 追加的内容可以是元素，或者列表，迭代器等
    • 当 append! 追加元素时，相当于 Python 的 .append
    • 当 append! 追加列表一类时，将把列表展开再加入，相当于 Python 的 .extend
    • 此外 push! 追加内容只能是元素，追加列表时，将把列表作为一个元素加入

  6. 元素删除操作

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    data = collect(1:10)
    # 删除最后一个元素，返回被删除值
    pop!(data) 
    # 删除第一个元素，返回被删除值
    popfirst!(data) 
    # 删除指定位置的元素，返回列表本身
    deleteat!(data, 2) 
    # 删除多个元素，返回列表本身
    deleteat!(collect(1:10), 1:4) 
    # 删除类似名称
    names = ["foo", "bar", "foo", "rex", "zong"]
    deleteat!(names, findall(names, ==("foo"))) 
    # 清空内容
    empty!(names) 
    # 保留指定元素，删除其他
    filter(==(1), 1:5) 
    # 删除指定元素，原地修改
    filter!(!=("a"), ["a", "b", "c"])
    • Julia 的等号支持函数式编程，比如 ==(1) 相当于 i->(i==1)，注意括号不可省略
    • pop! 不能删除列表的中间元素，而要用 deleteat!，且返回值是列表本身
    • Julia 1.7 中，还增加了 keepat! 函数
    1
    2
    keepat!(collect(1:10), 2:3) # 只保留指定索引部分
    keepat!(collect(1:10), 2) # 只保留第 2 个元素

  7. 定义函数，常见有四种方式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    # 匿名函数，相当于 Python 的 lambda
    f1 = i -> i
    f2 = (i, j) -> i + j
    # 符合数学形式的函数定义
    f3(i, j) = i + j
    # 类似 Python 的 def
    function f4(i, j)
        i + j
    end
    # 支持创建函数的符号
    ==(1) # 相当于 i->(i==1)
    ≥(2) # 相当于 i->(i>=2)
    • 使用 function 定义函数时，末尾数值将默认作为 return 的结果，而不需要显式写 return
    • 此外，Julia 还支持 do 语法创建匿名函数，比如
    1
    2
    3
    open("xxx.txt", "r") do x
        ...
    end

    等价于先将 do 主体写成函数，再传入 open 的第一个参数

    1
    2
    3
    4
    function f(x)
         ...
    end
    open(f, "xxx.txt", "r")

  8. 查找，Python 的 .index -> Julia 的 findfirst 等函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    data = collect(1:5)
    # 第一参为函数
    # 返回计算为真的第一个位置
    findfirst(==(2), data) 
    # 找不到时，返回 nothing
    findfirst(==(6), data) 
    # 在字符串中匹配字符
    findfirst('a', "abca")
    # 从后往前匹配 
    findlast('a', "abca") 
    # 匹配字符串，返回匹配到的切片
    findfirst("ab", "abca")
    # 匹配所有结果，返回列表 
    findall("ab", "abca")
    • 由于第一参支持输入函数，这些工具比 Python 的 .index 能处理更复杂的问题
    • findall 不支持直接匹配字符 findall('a', "abca")，而要用 findall(==('a'), "abca")

  9. Julia 提供了很多“包含”关系的函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    # 判断元素是否在列表中
    1 in [1, 2, 3]
    1 ∈ [1, 2, 3] # \in + <tab>
    # 判断元素不在列表中
    1 ∉ [1, 2, 3] # \notin + <tab>
    # 判断子集
    [1, 2] ⊆ [1, 2, 3] # \subseteq + <tab>
    # 函数式
    filter(∈(1:2), [1, 2, 3])

    相关表格如下，其中最后两个符号没有定义函数

    函数 快捷键
    ⊆ \subseteq + <tab>
    ⊈ \subseteq + <tab> + \not + <tab>
    ⊇ \supseteq + <tab>
    ⊉ \supseteq + <tab> + \not + <tab>
    ∈ \in + <tab>
    ∉ \notin + <tab>
    ∋ \ni + <tab>
    ∌ \ni + <tab> + \not + <tab>
    ⊂ \subset + <tab>
    ⊄ \subset + <tab> + \not + <tab>

  10. 最大最小值

1
2
3
4
5
6
7
8
data = [1, 2, 3]
# 多个元素最大值
max(1, 2, 3) 
# 最大值
maximum(data)
# 用 ... 将数据打开，相当于 Python 的 * 
max(data...) 
min;minimum; # 最小值用法同上

函数式用法：Python 的 max 返回取值最大的数值（定义域），而 Julia 的 maximum 返回最大函数值（值域）

1
2
3
4
## Python 情形
max([1,2,3], key=lambda i: -i) # 返回数据 1
## Julia 情形
maximum(-, [1,2,3]) # 返回 -1

通过论坛发现，Python 类似功能可以用 findmax 或 argmax 实现，不过需要 Julia 1.7 版本，较低版本的实现方式相对绕一点

1
2
3
4
5
# Julia 1.6 及以下版本
data = [1,2,3]
data[argmax((-).data)]
# Julia 1.7 及以上版本
argmax(-, data)
  1. 排序，反转
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
   # 类似 Python 的 reversed，但返回数据而不是生成器
   reverse("12") 
   # 原地修改，并返回本身，类似 Python 的 .reverse()
   reverse!([1, 2]) 
   # 排序，类似 Python 的 sorted，但返回数据而不是生成器
   sort([1, 2]) 
   # 原地修改的排序，并返回本身，类似 Python 的 .sort()
   sort!([1, 2]) 
   # 函数式
   # 类似 Python 的 sorted([1, 2, 3], key = lambda i:-i) 
   sort([1,2,3];by=-) 
   ```    
   
11. 布尔判断：Python 中，判断条件可以用空字符串，空列表，`None` 代表 `False`，但 Julia 需显式指出<span id="bool"></span>
   ```py
   isempty(Int[]) # 判断列表是否空
   !isempty([1,2]) # 判断列表是否非空
   isnothing(nothing) # 判断是否是 nothing
   i === nothing # 等价写法，三等号类似 Python 的 is
   isempty("") # 字符串判断同列表
  • Julia 中与或非为 &&, ||, ! 而不能用 and, or, not
  • 算符 ! 支持函数式，比如 !f 等价与 g(...) = !f(...)
    布尔值构成的列表类型为 BitVector 或 Vector{Bool}，结合索引可以有妙用，比如
1
2
3
4
5
b = collect(1:8)
a = iseven.(b)
b[a] # [2, 4, 6, 8] | 返回判断为真的数值
reverse!(@view(b[a])) # 将偶数部分取反，原地修改
print(b) # [1, 8, 3, 6, 5, 4, 7, 2] | 修改后的结果

  1. 常见算符，注意与 Python 的区别

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    # 下整除，输入 \div + tab 键，对应 Python 的 //
    2 ÷ 3 
    # 异或 \xor，对应 Python 的 ^
    2 ⊻ 3 
    # 与或非，异或 \xor, 同非 \nor， 与非 \nand
    &, |, ~, ⊻, ⊽, ⊼
    # 乘方，对应 Python 的 **
    2 ^ 3 
    # 问号表达式，类似 expr1 if true else expr2
    true ? expr1 : expr2 
    # 代表有理数 1/2
    1 // 2

  2. 字符串操作，注意双引号 "" 代表字符串，单引号 '' 代表字符，而在 Python 中二者没有区别

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    # 字符串拼接，对应 Python 的 +
    "abc" * "def" 
    # 字符串复制，对应 Python 的 *
    "abc" ^ 3 
    # Julia 的字符串允许换行号，而 Python 需要三个引号
    "
    多行字符串"
    # 左切，对应 Python 的 .lstrip
    lstrip("---abc---", '-') 
    # 右切，默认去除空格
    rstrip("---abc---", '-') 
    # 第二参允许用列表代表除去多个，但不能用字符串
    strip("-*-abc-*", ['-', '*']) 
    # 使用 $ 在字符串中插入变量
    "1+1=$(1+1)" 
    # 字符运算按 ASCII 表和 Unicode 进行
    'a' + 1 == 'b' 
    # 字符支持切片操作
    collect('a':'z') 
    # 判断是否包含字符
    'a' in "abc" 
    # 判断是否包含于字符串，注意不能直接用 in
    occursin("ab", "abc") 
    # 函数式用法，筛选 "abcd" 的子串
    filter(occursin("abcd"), ["abc", "def"])
    # 判断是否包含该字符串
    contains("abc", "ab")
    # 函数式用法，筛选包含 "ab" 的字符串
    filter(contains("ab"), ["abc", "def"])

    相关函数还有 split, join, replace 等就不一一演示了，其中 replace 支持正则匹配，比如

    1
    2
    # 用 `r""` 代表正则表达式，如果需要提取结果，替代结果使用 s""
    replace("Dog chase Cat", r"(.*) chase (.*)" => s"\g<2> is chased by \g<1>")

    关于 Python 和 Julia 的正则表达式区别，参考这篇正则表达式 | Python/Julia/Shell 语法详解

  3. 生成器和 for 循环

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    # 列表生成器，类似 Python 的语法
    [i for i in 1:9] 
    # Julia for 循环中的 in 可以用 = 代替
    [i for i = 1:9 if i < 6] 
    # 迭代器
    (i for i in 1:9) 
    # 多元列表循环，注意循环变量要用括号包住
    for (i, j) in zip(1:3, 1:5) 
       println(i,j) # 打印 3 次
    end
    # 双重 for 循环的简写，注意中间用逗号隔开
    for i in 1:3, j in 1:5 
       println(i,j) # 打印 3 * 5 = 15 次
    end
    # for 循环临时创建变量为内部变量
    # 外部查看 i, j 将报错
    print(i, j)

    Julia 的 for 循环中，无论是生成器形式还是一般形式，变量 i,j 与外部不共享；而 Python 生成器中的 i 与外部不共享，for 循环的 i 与外部共享

  4. 索引处理

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    data = collect(1:10)
    # 获取切片而不创建新对象
    @view data[1:3]
    # 创建二维数组
    mat = fill(1, 3, 4)
    # 用 CartesianIndices 创建索引集
    inds = CartesianIndices(mat)
    # 创建索引
    I, J = CartesianIndex.([(1,1), (1,2)])
    # 判断索引是否越界
    I + J ∈ inds
    # 用 eachindex 遍历数组
    for i in eachindex(mat)
       mat[i]
    end
    • 和 Python 一样，Julia 的切片将创建新对象，但用 @view 可以读取原内存片段
    • @view 获取切片而不创建新对象，这一特性有许多妙用，比如实现快速排序算法时，传值不需要传递索引
    • 用 CartesianIndices 获取索引信息，这种操作可读性更好，且利于一般化处理
    • 用 eachindex 代替切片 for i in 1:length(data) 更直接
    • 值得注意的是，Julia 中的矩阵是列优先存储，也即按 mat[1, 1], ..., mat[n, 1] 的顺序。在遍历 Julia 数组时，因尽量按内存数据进行，以提升运行效率。

  5. Julia 的向量化

    1
    2
    3
    4
    5
    6
    7
    f(i) = i ^ 2
    # 用 . 代表向量化
    f.(1:4) # [1, 4, 9, 16]
    # 与上一命令等同
    map(f, 1:4) 
    # 使用宏 @. 声明运算为向量化，效果等同于 f.(1:4) .+ 2
    @. f(1:4) + 2

    Julia 的列表做加减运算等同看成点集的运算

    1
    2
    [1, 2] + [2, 3] # [3, 5]
    [2, 3] - [1, 2] # [1, 1]

    使用向量化时，可以用 Ref 将某些数据看成整体，比如

    1
    2
    3
    nums = [[1,2], [2, 3], [4, 5]]
    # nums .- [1, 2] # 计算报错
    nums .- Ref([1, 2]) # 将 [1, 2] 看成标量

  6. 其他函数

    1
    2
    3
    4
    5
    6
    fill(2, 3, 3) # 生成常数矩阵
    zeros(2, 3) # 生成浮点零矩阵
    ones(Int, 4) # 生成整数向量
    rand(3) # 生成 3 个浮点数
    rand(Int, 5) # 生成 5 个整数，范围 -2^64 -> 2^64 -1
    rand(1:10, 3) # 从 1:10 中随机取 3 个数

IO 编程

内容参考官网教程。

基础部分

  1. 读入和输出

    1
    2
    3
    name = readline()
    println(name) # 换行打印
    print(name) # 不换行打印

    Python 版的 print 可如下实现

    1
    2
    3
    4
    5
    6
    function pyprint(args...; SEP::String = " ", END::String="")
         for (i, s) in  zip(args, fill(SEP, length(args)))
             print(i, s)
         end
         print(END)        
     end

    一些场景中，println 可能会等待循环结束才输出，这时可以用 flush(stdout) 强制输出。

  2. 标准信息流

    1
    2
    3
    4
    5
    stdout # 标准输出信息流
    stderr # 标准错误信息流
    stdin # 标准输入信息流
    ## 三者都是抽象类型 IO 的子类
    @. typeof([stdout, stderr, stdin]) <: IO

  3. 文件读写操作，两种语法

    1
    2
    3
    4
    5
    6
    ## 基本语法
    open(f::Function, args...; kwargs...)
    ## 使用 do 语法
    open(args...; kwargs) do x
        ...
    end

    示例，do 语法定义函数，并放在第一参

    1
    2
    3
    4
    5
    6
    7
    8
    9
    ## 使用 do 语法
    open("myfile.txt", "w") do io
        write(io, "Hello world!")
    end;
    ## 等价表述
    function f(io::IO)
        write(io, "Hello world!")
    end
    open(f, "myfile.txt", "w")

  4. mode 常用参数

    模式 描述 关键字定义
    r read none
    w write, create, truncate write = true
    a write, create, append append = true
    r+ read, write read = true, write = true
    w+ read, write, create, truncate truncate = true, read = true
    a+ read, write, create, append append = true, read = true

处理数据流

  1. 除了 write 还有其他几个函数支持 IO 写入

    1
    2
    3
    4
    5
    open("tmp.txt", "w") do io
        print(io, "hello ") # 写入到文件
        show(io, "world!") # 写入到文件
        print("hello world") # 输出到信息流
    end

    深度截图_选择区域_20220228114105

  2. 当 open 第一参的函数省略时，将返回 IO 变量

    1
    open(filename::AbstractString, [mode::AbstractString]; keywords...) -> IOStream

    先新建 IO 数据流，读写操作完毕再保存，比如

    1
    2
    3
    4
    5
    6
    7
    # 以写方式打开
    io = open("tmp.txt", write=true)
    write(io, "hello world") # 返回写入的字符数目
    ;cat tmp.txt # 此时修改未保存
    close(io) # 保存修改
    ;cat tmp.txt # 文件已改动
    rm("tmp.txt") # 删除文件

    深度截图_选择区域_20220228120534

  3. 如果不想创建临时文件，可以使用缓冲区处理 IO 数据流（目前较少用到）

    1
    2
    3
    4
    5
    # 创建缓冲区，默认可读可写，无上界，数据类型为 UInt8
    io = IOBuffer(UInt8[], read=true, write=true)
    write(io, "write into buffer ", b"zone") ## 写入内容
    io.size # 查看缓冲区长度
    String(take!(io)) # 将所有内容取出，并转为字符串形式

文件操作

  1. 几个实用变量 
    1
    2
    3
    Base.PROGRAM_FILE # 文件的相对路径
    Base.source_path() # 文件的绝对路径
    Base.source_dir() # 查看路径名
    这些变量编写脚本时有很大用处，比如执行 
    1
    cd(Base.source_dir()) # 切换到脚本所在目录
    这一操作可以确保在不同位置执行这一脚本，都能正常运行（只要脚本位置放置准确）

函数式编程

  1. 谈到函数式编程，就不得不提到 Mathematica，我们先用 Julia 实现 MMA 里的一个有趣设定

    1
    2
    3
    4
    5
    6
    7
    8
    9
    Base.@kwdef mutable struct MMA
        name::String = "f"
        show::String = "f"
    end
    Base.show(io::IO, f::MMA) = print(io, f.show)
    (f::MMA)(args...)::MMA = MMA(f.name, "$(f.name)($(join(args,", ")))")
    Base.:(+)(f::MMA, g::MMA) = MMA(f.name, "$(f.show) + $(g.show)")
    # 初始化函数 f 和 g
    f, g = MMA(), MMA("g", "g")

    此处定义的结构体 MMA 可以抽象地解释函数作用后，发生的什么事情，比如
    深度截图_选择区域_20220227221625

  2. reduce 类似 MMA 的 Fold

    1
    2
    3
    4
    5
    6
    7
    foldl(=>, 1:4) # 左结合律下，依次调用
    # f(f(f(1, 2), 3), 4)
    foldr(=>, 1:4) # 右结合率
    # f(1, f(2, f(3, 4)))
    reduce(=>, 1:4) # 类似 foldl，但不保证左结合率
    reduce(f, 1:3; init='i') # 带上初值
    # f(f(f(i, 1), 2), 3)

    深度截图_选择区域_20220227192618
    注意 reduce 在满足结合律下才能使用，否则结果可能错误
    深度截图_选择区域_20220227192749

  3. mapreduce(f,g,data) 等同于 reduce(g, f.data)

    1
    2
    3
    mapreduce(f, g, 1:3)
    reduce(g, f.(1:3))
    # g(g(f(1), f(2)), f(3))

  4. filter 过滤数据，类似 MMA 的 Select

    1
    filter(isodd, 1:10)

  5. do 语法，创建匿名函数，并作为调用函数的首参，且支持类型派发

    1
    2
    3
    4
    5
    6
    7
    8
    func(data) do x::Vector
        ...
    end
    # 等同于
    function f(x::Vector)
        ...
    end
    func(f, data)

  6. 其他函数。。。等待补充

面向对象

更新：据说 ObjectOrient.jl 模块提供了更好的面向对象编程体验，但是我还没用过，有兴趣的可以试试

Julia 不支持面向对象编程，但借助类型系统和派发，能实现面向对象能做的绝大多数内容，举个例子

  1. 用结构体定义点集

    1
    2
    3
    4
    5
    ## 定义结构体，并用 @kwdef 定义初值
    Base.@kwdef struct Point
        dims::Int = 1
        data::Tuple = (0, )
    end

  2. Python 初始化 __init__ -> Julia 多重派发，定义两种初始化

    1
    2
    3
    4
    # 输入 Point((1,2,3)) 时
    Point(data::Tuple) = Point(length(data), data) 
    # 输入 Point(1,2,3) 时
    Point(args::Int...) = Point(length(args), args)

  3. Python 的显示 __repr__, __str__ -> Base.show

    1
    2
    3
    Base.show(io::IO, p::Point) = print(io, p.data)
    p = Point(1, 2, 3)
    string(p)

    深度截图_选择区域_20220227163936

  4. 加法重载 __add__ -> +

    1
    2
    3
    4
    5
    6
    7
    function Base.:(+)(p1::Point, p2::Point)::Point
        p1.dims != p2.dims && throw("dimension not matched!")
        Point(p1.data .+ p2.data) ## 借助向量化
    end
    p1 = Point(1,2,3)
    p2 = Point(0,-1,2)
    p1 + p2

    深度截图_选择区域_20220227161311

  5. 重载减号和负号 __sub__, __neg__ -> -

    1
    2
    3
    4
    5
    6
    7
    8
    9
    ## 重载减号
    function Base.:(-)(p1::Point, p2::Point)
        p1.dims != p2.dims && throw("dimension not matched!")
        Point(p1.data .- p2.data)
    end
    ## 重载负号
    function Base.:(-)(p::Point)
        Point(0 .- p1.data)
    end

  6. Julia 的 +-/*&|!% 等符号都属于函数，重新定义即可，特殊符号支持通过 LaTeX 输入。符号的“运算位置”不能更改，比如 * 为二元运算符，无法定义为形如 *p 的调用方式，相关讨论见这里。此外 Julia 提供了相关的宏 @infix，但不适用与 1.x 版本。

类的继承

Julia 的具体类型不能被继承，这种设定带来的好处远大于其弊端。但一些情况下，为了增加代码的复用性，可以用宏来实现“继承”，参见 ReusePatterns.jl 以及相关讨论。

为了实现“类的继承”，比较 “Julian” 的方式有两种，假设 B 要继承 A：

  1. B 将 A 当成属性，用宏 @forword 把与 A 相关的函数重新定义一遍 B 的版本，函数调用时只是把其中的属性 A 拿出来
  2. 定义“拟抽象”类型，介于抽象类型与具体类型之间，增加一些规则限定。

示例一，回退

  1. 定义结构体 Book

    1
    2
    3
    4
    5
    6
    7
    8
    9
    using ReusePatterns
    #####  Alice's code  #####
    struct Book
        title::String
        author::String
    end
    Base.show(io::IO, b::Book) = println(io, "$(b.title) (by $(b.author))")
    Base.print(b::Book) = println("In a hole in the ground there lived a hobbit...")
    author(b::Book) = b.author

  2. 定义结构体 PaperBook，并继承 Book 的方法

    1
    2
    3
    4
    5
    6
    7
    #####  Bob's code  #####
    struct PaperBook
        b::Book
        number_of_pages::Int
    end
    @forward((PaperBook, :b), Book)
    pages(book::PaperBook) = book.number_of_pages

  3. 定义结构体 Edition 继承 PaperBook 的方法

    1
    2
    3
    4
    5
    6
    struct Edition
        b::PaperBook
        year::Int
    end
    @forward((Edition, :b), PaperBook)
    year(book::Edition) = book.year

  4. 初始化结构体 Edition ，并使用已有的方法

    1
    2
    3
    4
    5
    6
    7
    8
    #####  Charlie's code  #####
    book = Edition(PaperBook(Book("The Hobbit", "J.R.R. Tolkien"), 374), 2013)

    print(author(book), ", ", pages(book), " pages, Ed. ", year(book))
    # J.R.R. Tolkien, 374 pages, Ed. 2013

    print(book)
    # In a hole in the ground there lived a hobbit...

  5. 使用宏 @forward((PaperBook, :b), Book) 时，先识别与 .b 相关的函数，接着为函数派发 PaperBook 的版本，新函数调用时直接以 .b 作为参数。

  6. 使用缺陷：

    • 如果涉及的方法数量非常多，或者方法定义分布在多个模块中，应用可能会很麻烦
    • 这种组合不是递归进行的，假设 B 继承 A， C 继承 B ，则 C 在初始化时要把 A 和 B 都先初始化，当继承的对象很多时，这将会非常不方便
    • 每个组合层引入了少量开销，从而导致性能损失

示例二，拟抽象类型

更自然的方式是使用宏 @quasiabstract ，暂略。