Copyright © 1998-2023 maxiaoke.com All rights reserved.

当前位置:　 首页>> 技术小册>> Julia入门教程

小册名称：Julia入门教程

数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。

Julia 支持数组数据结构，它可以存储一个大小不是固定的，类型可以相同也可以不同的顺序集合。

Julia 数组是可变类型集合，用于列表、向量、表格和矩阵。

Julia 数组的索引键值可以使用整数表示，数组的大小不是固定的。

Julia 提供了很多函数帮助我们来操作数组，比如数组添加元素，合并数组等。

Julia 数组用方括号 […] 指定，多个元素使用逗号 , 分隔。

创建一个一维数组(即一个向量)语法为:

  1. [A, B, C, ...]

创建一维数组

下面实例创建了一个简单的一维数组：

实例

  1. julia> arr = [1,2,3]
  2. 3-element Vector{Int64}:
  3.  1
  4.  2
  5.  3

上面的实例中我们创建了一个包含 3 个元素的一维数组，每个元素都是一个 64 位整数，这个一维数组绑定到变量 arr 中。

数组元素的类型也可以不一样：

实例

  1. julia> arr =[1, "maxiaoke", 2.5, pi]
  2. 4-element Vector{Any}:
  3.  1
  4.   "maxiaoke"
  5.  2.5
  6.  π = 3.1415926535897...

上面的实例中我们创建了一个包含 4 个元素不同类型的一维数组， pi 是常量 π，每个元素都是一个 64 位整数，这个一维数组绑定到变量 arr 中。

当然也可以强制指定类型：

实例

  1. julia> arr = Int64[1,2,3]
  2. 3-element Vector{Int64}:
  3.  1
  4.  2
  5.  3
  6. julia> arr2 = String["Taobao","maxiaoke","GOOGLE"]
  7. 3-element Vector{String}:
  8.  "Taobao"
  9.  "maxiaoke"
  10.  "GOOGLE"

以上实例数组 arr 限制只能输入整数，arr2 限制只能输入字符串。

我们也可以创建一个空数组：

实例

  1. julia> arr = Int64[]
  2. Int64[]
  4. julia> arr2 = String[]
  5. String[]

创建的数组可以直接使用索引值来访问，第一个值的索引为 1（不是 0），第二个值索引为 2，以此类推，最后一个可以使用 end 表示：

实例

  1. julia> arr = Int64[1,2,3]
  2. 3-element Vector{Int64}:
  3.  1
  4.  2
  5.  3
  7. julia> arr[2]
  8. 2
  9. julia> arr2 = String["Taobao","maxiaoke","GOOGLE"]
  10. 3-element Vector{String}:
  11.  "Taobao"
  12.  "maxiaoke"
  13.  "GOOGLE"
  15. julia> arr2[1]
  16. "Taobao"
  18. julia> arr2[end]
  19. "GOOGLE"

指定数组类型及维度

我们还可以使用以下语法指定数组的类型和维度:

  1. Array{type}(undef, dims...)

undef 表示数组未初始化。

dims… 可以是维度的单多元组，也可以是维度作为可变参数时的一组值。

dims… 数字表示元素个数，多个维度使用逗号 , 分隔。

实例

  1. julia> array = Array{Int64}(undef, 3)    # 表示一维数组，数组有 3 个元素
  2. 3-element Vector{Int64}:
  3.  4834342704
  4.  4377305096
  5.           0
  7. julia> array = Array{Int64}(undef, 3, 3, 3)    # 表示 3 维数组，每个维度数组有 3 个元素
  8. 3×3×3 Array{Int64, 3}:
  9. [:, :, 1] =
  10.  4562265712  0  0
  11.           1  0  0
  12.           0  0  0
  14. [:, :, 2] =
  15.  0  0  0
  16.  0  0  0
  17.  0  0  0
  19. [:, :, 3] =
  20.  0  0  0
  21.  0  0  0
  22.  0  0  0

以上实例中，数组的类型我们放在花括号中 {}， undef 用于设置数组未初始化为任何已知值，这就是我们在输出中得到随机数的原因。

创建二维数组和矩阵

我们可以将数组元素中的逗号 , 省略掉或者使用两个冒号 ;;，这样就可以创建一个二维数组了，如下实例：

实例

  1. julia> [1 2 3 4]
  2. 1×4 Matrix{Int64}:
  3.  1  2  3  4
  4. julia> [1;; 2;; 3;; 4]
  5. 1×4 Matrix{Int64}:
  6.  1  2  3  4

注意：第一行输出的 1×4 Matrix{Int64}:，1x4 表示一行四列的矩阵。

虽然只有一行，也是二维数组，因为 Julia 只认可列向量，而不认可所谓的行向量。

要添加另一行，只需添加分号 ;，看以下实例：

实例

  1. julia> [1 2; 3 4]
  2. 2×2 Matrix{Int64}:
  3.  1  2
  4.  3  4

也可以使用冒号 : 和空格 来实现，看以下实例：

实例

  1. julia> [1:2  3:4]
  2. 2×2 Matrix{Int64}:
  3.  1  3
  4.  2  4

注意：第一行输出的 2×2 Matrix{Int64}:，2×2 表示两行两列的矩阵。

我们也可以在方括号 [] 中嵌入多个长度相同的一维数组，并用空格分隔来创建二维数组：

实例

  1. julia> [[1,2] [3,4] [5,6]]
  2. 2×3 Matrix{Int64}:
  3.  1  3  5
  4.  2  4  6
  5. 2x3 表示两行三列的数组。

下面我们通过灵活运用分号 ; 和空格 创建一个两行三列和三行两列的二维数组：

实例

  1. julia> [[1;2] [3;4] [5;6]]
  2. 2×3 Matrix{Int64}:
  3.  1  3  5
  4.  2  4  6
  6. julia> [[1 2]; [3 4]; [5 6]]
  7. 3×2 Matrix{Int64}:
  8.  1  2
  9.  3  4
  10.  5  6

使用范围函数来创建数组

省略号 …
可以使用省略号 … 来创建一个数组，实例如下：

实例

  1. julia> [0:10...]
  2. 11-element Vector{Int64}:
  3.   0
  4.   1
  5.   2
  6.   3
  7.   4
  8.   5
  9.   6
  10.   7
  11.   8
  12.   9
  13.  10

collect() 函数

collect() 函数语法格式如下：

collect(start:step:stop)
start 为开始值，step 为步长，stop 为结束值。

该函数返回数组。

以下实例值为 1，步长为 2，结束值为 13：

实例

  1. julia> collect(1:2:13)
  2. 7-element Vector{Int64}:
  3.   1
  4.   3
  5.   5
  6.   7
  7.   9
  8.  11
  9.  13

collect() 函数也可以指定类型，语法格式如下：

collect(element_type, start:step:stop)
以下实例创建一个浮点型数组：

实例

  1. julia> collect(Float64, 1:2:5)
  2. 3-element Vector{Float64}:
  3.  1.0
  4.  3.0
  5.  5.0

range() 函数

range() 函数可以生存一个区间范围并指定步长，可以方便 collect() 函数 调用。

range() 函数语法格式如下：

range(start, stop, length) range(start, stop; length, step) range(start; length, stop, step) range(;start, length, stop, step)
start 为开始值，step 为步长，stop 为结束值，length 为长度。

实例

  1. julia> range(1, length=100)
  2. 1:100
  4. julia> range(1, stop=100)
  5. 1:100
  7. julia> range(1, step=5, length=100)
  8. 1:5:496
  10. julia> range(1, step=5, stop=100)
  11. 1:5:96
  13. julia> range(1, 10, length=101)
  14. 1.0:0.09:10.0
  16. julia> range(1, 100, step=5)
  17. 1:5:96
  19. julia> range(stop=10, length=5)
  20. 6:10
  22. julia> range(stop=10, step=1, length=5)
  23. 6:1:10
  25. julia> range(start=1, step=1, stop=10)
  26. 1:1:10

如果未指定长度 length，且 stop - start 不是 step 的整数倍，则将生成在 stop 之前结束的范围。

  1. julia> range(1, 3.5, step=2)
  2. 1.0:2.0:3.0

使用 range() 和 collect() 创建数组：

实例

  1. julia> collect(range(1,stop=10))
  2. 10-element Vector{Int64}:
  3.   1
  4.   2
  5.   3
  6.   4
  7.   5
  8.   6
  9.   7
  10.   8
  11.   9
  12.  10
  13. julia> collect(range(1, length=15, stop=150))
  14. 15-element Vector{Float64}:
  15.    1.0
  16.   11.642857142857142
  17.   22.285714285714285
  18.   32.92857142857143
  19.   43.57142857142857
  20.   54.214285714285715
  21.   64.85714285714286
  22.   75.5
  23.   86.14285714285714
  24.   96.78571428571429
  25.  107.42857142857143
  26.  118.07142857142857
  27.  128.71428571428572
  28.  139.35714285714286
  29.  150.0

使用推导式和生成器创建数组

创建数组的另一种有用方法是使用推导。

数组推导式语法格式如下：

  1. A = [ F(x,y,...) for x=rx, y=ry, ... ]
  2. F(x,y,...) 取其给定列表中变量 x，y 等的每个值进行计算。值可以指定为任何可迭代对象，但通常是 1:n 或 2:(n-1) 之类的范围，或者像 [1.2, 3.4, 5.7] 这样的显式数组值。结果是一个 N 维密集数组，将变量范围 rx，ry 等的维数拼接起来得到其维数，并且每次 F(x,y,...) 计算返回一个标量。

实例

  1. julia> [n^2 for n in 1:10]
  2. 10-element Vector{Int64}:
  3.    1
  4.    4
  5.    9
  6.   16
  7.   25
  8.   36
  9.   49
  10.   64
  11.   81
  12.  100

创建二维数组：

实例

  1. julia> [n*m for n in 1:10, m in 1:10]
  2. 10×10 Matrix{Int64}:
  3.   1   2   3   4   5   6   7   8   9   10
  4.   2   4   6   8  10  12  14  16  18   20
  5.   3   6   9  12  15  18  21  24  27   30
  6.   4   8  12  16  20  24  28  32  36   40
  7.   5  10  15  20  25  30  35  40  45   50
  8.   6  12  18  24  30  36  42  48  54   60
  9.   7  14  21  28  35  42  49  56  63   70
  10.   8  16  24  32  40  48  56  64  72   80
  11.   9  18  27  36  45  54  63  72  81   90
  12.  10  20  30  40  50  60  70  80  90  100

也可以在没有方括号的情况下编写（数组）推导，从而产生称为生成器的对象。

以下实例创建一个数组：

实例

  1. julia> collect(n^2 for n in 1:5)
  2. 5-element Vector{Int64}:
  3.   1
  4.   4
  5.   9
  6.  16
  7.  25

以下表达式在不分配内存的情况下对一个序列进行求和：

实例

  1. julia> sum(1/n^2 for n=1:1000)
  2. 1.6439345666815615

Julia 数组基本函数

  1. 函数    描述
  2. eltype(A)    A 中元素的类型
  3. length(A)    A 中元素的数量
  4. ndims(A)    A 的维数
  5. size(A)    一个包含 A 各个维度上元素数量的元组
  6. size(A,n)    A 第 n 维中的元素数量
  7. axes(A)    一个包含 A 有效索引的元组
  8. axes(A,n)    第 n 维有效索引的范围
  9. eachindex(A)    一个访问 A 中每一个位置的高效迭代器
  10. stride(A,k)    在第 k 维上的间隔（stride）（相邻元素间的线性索引距离）
  11. strides(A)    包含每一维上的间隔（stride）的元组
  12. Julia构造和初始化
  13. Julia 提供了许多用于构造和初始化数组的函数。在下列函数中，参数 dims ... 可以是一个元组 tuple 来表示维数，也可以是一个可变长度的整数值作为维数。大部分函数的第一个参数都表示数组的元素类型 T 。如果类型 T 被省略，那么将默认为 Float64。
  1. 函数    描述
  2. Array{T}(undef, dims...)    一个没有初始化的密集 Array
  3. zeros(T, dims...)    一个全零 Array
  4. ones(T, dims...)    一个元素均为 1 的 Array
  5. trues(dims...)    一个每个元素都为 true 的 BitArray
  6. falses(dims...)    一个每个元素都为 false 的 BitArray
  7. reshape(A, dims...)    一个包含跟 A 相同数据但维数不同的数组
  8. copy(A)    拷贝 A
  9. deepcopy(A)    深拷贝，即拷贝 A，并递归地拷贝其元素
  10. similar(A, T, dims...)    一个与A具有相同类型（这里指的是密集，稀疏等）的未初始化数组，但具有指定的元素类型和维数。第二个和第三个参数都是可选的，如果省略则默认为元素类型和 A 的维数。
  11. reinterpret(T, A)    与 A 具有相同二进制数据的数组，但元素类型为 T
  12. rand(T, dims...)    一个随机 Array，元素值是 
  13. [0,1)[0,1) 半开区间中的均匀分布且服从一阶独立同分布 [1]
  14. randn(T, dims...)    一个随机 Array，元素为标准正态分布，服从独立同分布
  15. Matrix{T}(I, m, n)    m 行 n 列的单位矩阵 （需要先执行 using LinearAlgebra 来才能使用 I）
  16. range(start, stop=stop, length=n)    从 start 到 stop 的带有 n 个线性间隔元素的范围
  17. fill!(A, x)    用值 x 填充数组 A
  18. fill(x, dims...)    一个被值 x 填充的 Array
  19. zeros() 创建数组实例，元素初始值 都是 0:

实例

  1. julia> zeros(Int8, 2, 3)
  2. 2×3 Matrix{Int8}:
  3.  0  0  0
  4.  0  0  0
  6. julia> zeros(Int8, (2, 3))
  7. 2×3 Matrix{Int8}:
  8.  0  0  0
  9.  0  0  0
  11. julia> zeros((2, 3))
  12. 2×3 Matrix{Float64}:
  13.  0.0  0.0  0.0
  14.  0.0  0.0  0.0

该分类下的相关小册推荐：

暂无相关推荐.