Julia 的数据类型（笔记）

                     

贡献者： addis

1. 变量类型

　　 参考 Julia 文档。

• Julia 是动态类型的语言。具体类型不能互相作为子类，只能作为抽象类的子类（sub type）。
• Julia 中所有的值都是对象。C++ 中 float, double 等不是对象，只有 struct, class 定义的才是对象。Julia 中的对象没有成员函数。
• 可以在 literal、变量、表达式、函数定义后面加上 ::变量类型 用于确认它具有该类型，如果类型不符会产生异常。如果 变量类型 是抽象的，那么表达式只能是它的一个子类。
• 只有 “值” 有类型，而不是变量具有类型。变量只是个名字而已
• 抽象和具体的类都可以使用其他类作为参数

　　 常见类型 Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64（即 Int）, UInt64, Int128, UInt128, Float16, Float32, Float64, ComplexF16, ComplexF32 和 ComplexF64

　　 BigInt 是任意大小的整数，BigFloat 是任意精度浮点数。

julia> BigFloat(2.1) # 2.1 here is a Float64
2.100000000000000088817...

julia> BigFloat("2.1") # the closest BigFloat to 2.1
2.099999999...99999986

julia> BigFloat("2.1", RoundUp)
2.100000000...0000021

julia> BigFloat("2.1", precision=128)
2.0999999...995

julia> BigFloat("2.1", RoundUp, precision=128)
2.100000000...00000000000007

　　 使用 typeof(var) 来询问变量类型，用 isa(var, type) 来确定类型。sizeof(变量或类型) 来查看类型的字节数

• setprecision(二进制精度); 可以设置运算默认的精度
• BigFloat(pi) 会默认为上面设置的精度，BigFloat(pi, precision=...) 可以临时改变精度，但是 BigFloat(pi, precision=...)*2 仍然是上面设置的精度，因为乘法使用上面设置的精度。
• pi 的加减乘除都得到 Float64 类型。

逻辑类型

• Bool 类型的值可以是 true 或者 false
• any([true, false, ...]) 和 all([trua, false, ...])

整数

• 整数 literal 的类型取决于它的大小，例如 typeof(3) 是 Int64；typeof(12345678902234567890) 是 Int128，typeof(1234567890223456789032345678904234567890) 是 BigInt。typemin(类型) 和 typemax(类型) 可以查看最大最小值。
• 两个相同类型的 Int 相加时，如果 overflow 会变成负数。两个不同类型的 Int 相加时，较小的类型会先转换为较大的类型。若 a = Int8(1)，a += 1 后 a 会变为 Int64。因为 1 相当于 Int64(1)。

浮点数

• 任何浮点数 literal 都是 Float64。
• eps(Float64) 返回 2.220446049250313e-16
• NaN 是 not a number，可以用 isnan(x) 来判断

2. 无理数

• pi 的类型是 Irrational{:π} 其中 :π 的类型是 Symbol（又例如 :abc，:a）注意 :pi 和 :π 是两个不同的 Symbol。
• BigFloat(pi, precision=500) 可以获得 500 位二进制的 pi。

3. 字符串类型

• 任何单个 UTF8 字符都属于 Char 类型。sizeof(Char) = 4，格式应该是 UTF32
• s = "abcde" 的类型是 String，注意 String 并不是 Array{Char, 1}！ s[i] 可以获取单个 Char，但是不能赋值，因为 String 是不可改变的（immutable）。
• 子串替换：s1 = replace(s, "bc" => "BC")。s1 也可以是 s 本身。
• s = s1*s2 拼接字符串（等效地：s = string(s1, s2)），s *= s1 append。
• s = s1^3 重复字符串 3 次，s ^= 3 同理。相当于 repeat(s1, 3)
• findfirst("abc", s) 搜索字符串，返回一个 UnitRange{Int64}，如 3:5。
• findnext("abc", s, ind) 从 ind 开始搜索下一个
• collect(s) 把字符串变为 Vector{Char}
• s = b"abcABC123" 的类型是 Base.CodeUnits{UInt8, String}，s[i] 的类型是 UInt8

4. 抽象类型

　　 声明抽象类型

abstract type 子类名 <: 母类名 end

声明后，可以用 类1 <: 类2 来判断是否符合该关系，返回一个 Bool。

　　 用 supertype(类) 可以查看某个类的母类，subtypes(类) 可以查看所有子类。

　　 例子

abstract type Number end
abstract type Real     <: Number end
abstract type AbstractFloat <: Real end
abstract type Integer  <: Real end
abstract type Signed   <: Integer end
abstract type Unsigned <: Integer end

最高级的抽象类是 Any，这里的 Number 就是 Any 的子类。

　　 以及

Complex{T<:Real} <: Number
Rational{T<:Integer} <: Real
Irrational{sym} <: AbstractIrrational

5. 原始类型

　　 原始类型（primitive type）是由 bit 组成的具体类型。Julia 可以自定义原始类型。定义原始类型的格式为

primitive type 类名 比特数 end
primitive type 类名 <: 父类名 比特数 end

例如

primitive type Float16 <: AbstractFloat 16 end
primitive type Float32 <: AbstractFloat 32 end
primitive type Float64 <: AbstractFloat 64 end

primitive type Bool <: Integer 8 end
primitive type Char <: AbstractChar 32 end

primitive type Int8    <: Signed   8 end
primitive type UInt8   <: Unsigned 8 end
primitive type Int16   <: Signed   16 end
primitive type UInt16  <: Unsigned 16 end
primitive type Int32   <: Signed   32 end
primitive type UInt32  <: Unsigned 32 end
primitive type Int64   <: Signed   64 end
primitive type UInt64  <: Unsigned 64 end
primitive type Int128  <: Signed   128 end
primitive type UInt128 <: Unsigned 128 end

6. 复合类型

　　 复合类型（composite） 类似于 C++ 中的 struct，但是不能有成员函数。

struct Foo
    bar # 抽象类型是 Any
    baz::Int
    qux::Float64
end

创建该类型的对象

foo = Foo("Hello, world.", 23, 1.5) # 叫做 constructor

• 要获取成员的值，用 foo.bar, foo.baz, foo.qux 等。用 struct 声明的复合类型值在生成后就不能被改变。如果 struct 里面有矩阵等，那么矩阵元仍然是 mutable 的（没有 lower level const）。
• 如果要支持成员改变，那么用 mutable struct 来声明即可。mutable struct 通常存在 heap 中而不是在 stack 中。
• 查看成员名称用 fieldnames(Foo或Foo的对象)，如果还要显示成员类型，用 dump(Foo)。
• ismutable(Foo) 可以判断是否 mutable struct。
• 要判断一个类型是 primitive 还是 struct，可以先打个 ? 进入 help 模式，然后再输入 Foo。等效地也可以用 @doc Foo。
• 定义 constructor 如：

  struct Person
      name::String
      age::Int
      function abc(name::String, age::Int, add::Int)
          new(name, age+add)
      end
  end
  

• 注意 struct 里面的函数并不能用于定义其他 “成员函数”。
• 要定义类型转换，可以定义一个新的 constructor，也可以定义一个函数 Base.convert(::Type{类型1}, f::类型2)，转换用 g = convert(类型1, f)

7. Type Unions

IntOrString = Union{Int, AbstractString}
1 :: IntOrString
"Hello!" :: IntOrString
1.0 :: IntOrString # 异常

但是，这和使用 <: 有什么区别？一个类只可能有一个非 Union 的母类，如果一个函数的参数想要支持两个母类不同的类怎么办？那就用 Union 即可。

　　 另外一个应用的例子是 Union{T, Nothing} 作为函数参数，这样这个参数就可以忽略了。

8. 含参类型

　　 复数类型 ComplexF16, ComplexF32 和 ComplexF64 是 Complex{Float16}, Complex{Float32} 和 Complex{Float64} 的别名。Complex 就是一个含参类型（parametric type）

　　 例如

struct Point{T}
    x::T
    y::T
end

那么 Point{Float64} 等都是合法的具体类型。

　　 Point 本身是一个抽象类，是其具体类的母类

julia> Point{Float64} <: Point
true
julia> Point{AbstractString} <: Point
true

<: 相当于一个二元算符，输出 Bool。

　　 例子：

function norm(p::Point{Real})
    sqrt(p.x^2 + p.y^2)
end

constructor

p = Point{Float64}(1.0, 2.0)

9. 含参抽象类型

　　 含参抽象类型（Parametric Abstract Types） 例如

abstract type Pointy{T} end
struct Point{T} <: Pointy{T}
    x::T
    y::T
end

10. Pair

• "abc" => 1.23 的类型是 Pair{String, Float64}，令 p = "abc" => 1.23，那么 p.first 和 p.second 分别可以获取两个变量。
• Pair 同样是 immutable 的。

11. Tuple

　　 Tuple 是函数参数列表的抽象。例如两个元素的 tuple type 类似于如下的含参 struct 类型

struct Tuple2{A,B}
    a::A
    b::B
end

例子

julia> typeof((1,"foo",2.5))
Tuple{Int64, String, Float64}

julia> Tuple{Int,AbstractString} <: Tuple{Real,Any}
true

julia> Tuple{Int,AbstractString} <: Tuple{Real,Real}
false

• t = (值1, 值2, 值3, ...) 就是 Tuple
• 数组的元素类型必须相同，而 Tuple 的元素类型可以不同
• t = (1, "3.1", [1 2; 3 4]) 的类型是 Tuple{Int64, String, Matrix{Int64}}
• 数组的 length()，isempty()，reverse() 同样适用于 Tuple。
• t[i] 获取某个元素，但不能对其赋值！ Tuple 的元素永远不能改变！ Tuple 类型是 immutable 的。
• named tuple：x = (a=2, b="abc")，类型为 NamedTuple{(:a, :b), Tuple{Int64, String}}。然后可以使用 x.a 和 x.b 来获取元素。
• 单个元素的 tuple 如 (1,)，空 tuple 用 () 表示，类型为 Tuple{}。
• (x,y) = (1,"ab") 或者 x,y = (1,"ab") 会分别把元素赋值给 x, y。这可以用于函数返回多个值。

12. 类似 C++ 的数据结构

Set

• s = Set{Int64}() 生成某种类型的空 set。
• s = Set([1,2,3]) 把数组变为 Set（自动推导出类型 Set{Int64}）
• push!(s, 123, 23, 532) 添加若干元素。
• empty!(s) 清空集合。
• in(123, s) 查看某个元素是否存在
• union!(s1,s2) 计算并集，赋值给 s1，s = union(s1,s2) 计算并集，赋值给 s。

Dict

• d = Dict{key类型,Val类型}() 创建一个字典（哈希表），也可以直接用 Dict("ab"=>12, "bc"=>23)（会自动推导类型 Dict{String, Int64}）
• push!(d, key1=>val1, key2=>val2) 添加若干 entry，如果 key 已经存在，就覆盖 val。
• 添加新元素也可以用 a[key] = val。
• a[key] 获取对应的 val，如果 key 不存在则会出错。
• 删除一个元素用 delete!(d, key)
• keys(d) 表示所有存在的 key，类型是 Base.KeySet{key类型, Dict{key类型, val类型}}，不会复制值。
• vals(d) 同理，类型是 Base.ValueIterator{Dict{String, Int64}}
• 要循环，可以

  for (k, v) in d
     ...
  end
  

13. Vararg Tuple Types

14. Named Tuple Types

15. Parametric Primitive Types

16. UnionAll Types

17. Singleton types

18. Type{T} type selectors

19. Type Aliases

　　 使用等号。例如

# 32-bit system:
julia> UInt
UInt32

# 64-bit system:
julia> UInt
UInt64

实现方法

This is accomplished via the following code in base/boot.jl:

if Int === Int64
    const UInt = UInt64
else
    const UInt = UInt32
end

20. Operations on Types

julia> isa(1, Int)
true

julia> typeof(Rational{Int})
DataType

julia> typeof(Union{Real,String})
Union

julia> typeof(DataType)
DataType

julia> typeof(Union)
DataType

julia> supertype(Float64)
AbstractFloat

julia> supertype(Number)
Any

julia> supertype(AbstractString)
Any

julia> supertype(Any)
Any