1. 变量与常量

1.1 定义

虽然 Julia 允许我们随意改变一个变量的类型，但是这样做往往会对程序的性能造成不小的负面影响。我们可以在编程的时候用附加类型标识符的方式让变量的类型固定下来，比如：y::Int64。操作符::可以将类型标识符附加到程序中的变量和表达式之后。

我们可以使用关键字const来定义一个常量。在 Julia 中，常量是一种特殊的变量：const A = 2020
关于变量作用域，变量默认都是local的，使用global可以突破限制。注意下面的1:5是UnitRange类型，如果是1:2:5，则是StepRange类型。

操作符<:用于表示当前类型直接继承自哪一个抽象类型，可以在定义和声明中使用:

julia> abstract type Jewelry end
julia> struct Necklace <: Jewelry end
julia> struct Ring <: Jewelry end
julia> mutable struct JewelryShop{T<:Jewelry}
           showcase1::Showcase{Necklace}
           showcase2::Showcase{Ring}
           showcase3::Showcase{Jewelry}
           showcase4::Showcase{T}
       end
1
2
3
4
5
6
7
8
9

1.2 数值类型

使用typeof查看变量类型

julia> typeof(2020)
Int64
1
2

在Julia的类型图中，Any是一个唯一的顶层类型，union是唯一一个底层类型。Julia 中具体的数值类型一共有 19 个。罗列如下：
布尔类型：Bool
有符号整数类型：BigInt、Int8、Int16、Int32、Int64和Int128
无符号整数类型：UInt8、UInt16、UInt32、UInt64和UInt128
浮点数类型：BigFloat、Float16、Float32和Float64
复数类型：Complex
有理数类型：Rational
无理数类型：Irrational

抽象类型不能被实例化，而Int64/Float64等都是抽象类型的具体类型，抽象类型不能直接使用，类似于C++中的抽象类。抽象类型有：

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
1
2
3
4
5
6

1.3 复合类型

可以用来构造复杂的类，也叫自定义类型。

2.4 参数化类型（关键）

初学者看懂julia的代码，这段是关键。参数化类型类似于c++中的template，通过参数的形式代表整个类型族群。
像Ref{T}这样的参数化类型，我们可以用任何一个类型的名称替换掉T，从而表示一种确定的类型，如Ref{String}，这样我们就用一个表达式，涵盖了所有的数据类型：

Julia 已经预定义了不少的参数化类型，对它们的进一步说明如下：

• Ref{T}：它是专门用来做引用的类型。要想让它成为某一个类型的引用类型，我们就需要在其花括号中填入那个类型的名称。例如，Ref{UInt32}就表示针对UInt32类型的引用类型。
• Union{Types…}：这个类型的花括号中可以有多个类型名称，叫做类型共用体。这使它可以表示为针对那些类型的联合类型，从而让那些类型的值都成为这个联合类型的实例。例如，Union{Integer, AbstractString}就联合了Integer类型和AbstractString类型，从而使整数值和字符串值都变成了它的实例。
  
• Complex{T<:Real}：代表复数的的类型。因为复数的实部和虚部都必须是实数，所以Complex类型的参数一定要是Real类型的子类型。
• SubString{T<:AbstractString}：代表子字符串的类型。由于子字符串值只能基于字符串值创建，因此SubString类型的参数必须继承自AbstractString。

where关键字用于对参数的类型进行界定：

2. 基本数据结构

2.1 元组

元组（tuple）是一种很简单的容器。使用()定义，和python类似。
tuple中可以加入变量名，叫namedTuple，使用.进行调用：

元组类型的最后一个参数可以是Vararg，表示后面可以跟任意多个参数：

用collect()可以将数值tuple 转换为 array：

julia> collect((1,2,3))
3-element Array{Int64,1}:
 1
 2
 3
1
2
3
4
5

2.2 字典

字典使用关键字Dict定义，并且用=>进行赋值。带=>的部分叫做pair，pair数组可以强制转换为dict。字典使用[ ]进行调用：

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);
julia> a = Dict([(1, "a"), (2, "b"), (3, "c")])
Dict{Int64,String} with 3 entries:
  2 => "b"
  3 => "c"
  1 => "a"
julia> a[1]
"a"
julia> k = ["a","b"]; v = [1,2]
julia> Dict(k.=>v)
1
2
3
4
5
6
7
8
9
10

使用value可以获得包含所有值的迭代器。

2.3 向量、矩阵

在julia中，数组和矩阵都是Array格式，和numpy不一样。高于二维的数组，需要使用reshape的方式定义。

• 向量：定义为Array{T}(undef, dims) ，undef是UndefInitializer()的缩写
  列向量：[1;2;3]
  行向量：[1 2 3]
  显式声明：p = Array{Float64}(undef, 3, 1)
  向量的元素可以是tuple：pairs = Array{Tuple{Int64,Int64}}(undef, 3)，或者这样声明：pairs = [(2,3),(1,2),(3,4)]
  如果要初始化，则用fill：fill(1.0, (2,3))

• 矩阵：其实就是二维向量，比如[1 2 3;4 5 6]
  下标访问：A[1,2]
  转置：transpose(A)或A’
  函数和numpy基本一致

使用[:]的方式进行数组/矩阵拷贝。

再来看矩阵拼接中的三种方式：

• , ：相当于np.array([a,b])
• ;：相当于np.vstack([a,b])
• • 空格：相当于np.hstack([a,b])

矩阵运算分两种，逐点计算和矩阵计算：



如果还是不会用，就使用numpy吧：

3. 字符串

3.1 基础知识

• ASCII：美国标准代码-信息交换。
• Unicode 是一个针对书面字符和文本的通用字符编码标准。它定义了多语言文本数据在国际间交换的统一方式，并为全球化软件创建了基础。Unicode 编码标准以 ASCII 编码集作为出发点，并突破了 ASCII 只能对拉丁字母进行编码的限制。在 Unicode 编码标准中，代码空间由从0到10FFFF的十六进制整数组成。这就意味着，有 1114112 个代码点可以用于表示抽象字符。Unicode 编码标准的惯用法是使用十六进制形式来表示代码点的数值，并使用U+作为前缀。比如，英文字母字符’a’的 Unicode 代码点就是U+0061。在 Unicode 编码标准的模型中，编码格式用于确定怎样将代码空间中的每一个整数（或者说代码点）都表示成包含若干个代码单元的序列。
• Unicode 编码标准中存在多种编码格式。其中有一种编码格式叫做 UTF-8。UTF 是 Unicode Transformation Format 的缩写。

对于字符和字符串，Julia 通常都会采用 UTF-8 编码格式将它们转换成二进制数并进行存储。

julia> 'a'
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
julia> '\u4e2d'
'中': Unicode U+4e2d (category Lo: Letter, other)
1
2
3
4

3.2 基本操作

• 搜索：用findfirst、findprev、findnext
• 拼接：可以直接用逗号，可以用*拼接（注意和python用+不一样），可以用cmd里面的$（变量索引）：
  
• 替换、分割、合并：replace用=>，split默认用空格，使用join合并数组
  

4. 表达式

4.1 Symbol和Quate

使用:构造一个symbol，或者直接用Symbol来定义；如果是多行表达式，使用quote…end实现

4.2 使用方法

使用dump来查看symbol，使用eval来解析symbol：