编程宝库 - 技术改变世界

编程宝库

Search

Julia

Julia 基本语法

Julia 元组

Julia 数组

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

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

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

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

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

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

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

[A, B, C, ...]

1. 创建一维数组

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

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

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

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

julia> arr =[1, "codebaoku", 2.5, pi] 
4-element Vector{Any}: 
1 
"codebaoku" 
2.5 
π = 3.1415926535897...

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

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

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

julia> arr2 = String["Taobao","codebaoku","GOOGLE"]
3-element Vector{String}: 
"Taobao" 
"codebaoku" 
"GOOGLE"

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

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

julia> arr = Int64[]
Int64[]

julia> arr2 = String[]
String[]

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

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

julia> arr[2] 
2 

julia> arr2 = String["Taobao","codebaoku","GOOGLE"] 
3-element Vector{String}: 
"Taobao" 
"codebaoku" 
"GOOGLE" 

julia> arr2[1] 
"Taobao" 

julia> arr2[end] 
"GOOGLE"

2. 指定数组类型及维度

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

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

undef 表示数组未初始化。

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

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

julia> array = Array{Int64}(undef, 3)    # 表示一维数组，数组有 3 个元素
3-element Vector{Int64}:
 4834342704
 4377305096
          0

julia> array = Array{Int64}(undef, 3, 3, 3)    # 表示 3 维数组，每个维度数组有 3 个元素
3×3×3 Array{Int64, 3}:
[:, :, 1] =
 4562265712  0  0
          1  0  0
          0  0  0

[:, :, 2] =
 0  0  0
 0  0  0
 0  0  0

[:, :, 3] =
 0  0  0
 0  0  0
 0  0  0

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

3. 创建二维数组和矩阵

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

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

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

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

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

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

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

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

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

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

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

2x3 表示两行三列的数组。

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

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

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

4. 使用范围函数来创建数组

省略号 ...

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

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

collect() 函数

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

collect(start:step:stop)

start 为开始值，step 为步长，stop 为结束值。

该函数返回数组。

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

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

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

collect(element_type, start:step:stop)

以下范例创建一个浮点型数组：

julia> collect(Float64, 1:2:5)
3-element Vector{Float64}:
 1.0
 3.0
 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 为长度。

julia> range(1, length=100)
1:100

julia> range(1, stop=100)
1:100

julia> range(1, step=5, length=100)
1:5:496

julia> range(1, step=5, stop=100)
1:5:96

julia> range(1, 10, length=101)
1.0:0.09:10.0

julia> range(1, 100, step=5)
1:5:96

julia> range(stop=10, length=5)
6:10

julia> range(stop=10, step=1, length=5)
6:1:10

julia> range(start=1, step=1, stop=10)
1:1:10

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

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

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

julia> collect(range(1,stop=10))
10-element Vector{Int64}:
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
julia> collect(range(1, length=15, stop=150))
15-element Vector{Float64}:
   1.0
  11.642857142857142
  22.285714285714285
  32.92857142857143
  43.57142857142857
  54.214285714285715
  64.85714285714286
  75.5
  86.14285714285714
  96.78571428571429
 107.42857142857143
 118.07142857142857
 128.71428571428572
 139.35714285714286
 150.0

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

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

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

A = [ F(x,y,...) for x=rx, y=ry, ... ]

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

julia> [n^2 for n in 1:10]
10-element Vector{Int64}:
   1
   4
   9
  16
  25
  36
  49
  64
  81
 100

创建二维数组：

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

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

以下范例创建一个数组：

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

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

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

5. Julia 数组基本函数

函数	描述
`eltype(A)`	`A` 中元素的类型
`length(A)`	`A` 中元素的数量
`ndims(A)`	`A` 的维数
`size(A)`	一个包含 `A` 各个维度上元素数量的元组
`size(A,n)`	`A` 第 `n` 维中的元素数量
`axes(A)`	一个包含 `A` 有效索引的元组
`axes(A,n)`	第 `n` 维有效索引的范围
`eachindex(A)`	一个访问 `A` 中每一个位置的高效迭代器
`stride(A,k)`	在第 `k` 维上的间隔（stride）（相邻元素间的线性索引距离）
`strides(A)`	包含每一维上的间隔（stride）的元组

6. Julia构造和初始化

Julia 提供了许多用于构造和初始化数组的函数。在下列函数中，参数 dims ... 可以是一个元组 tuple 来表示维数，也可以是一个可变长度的整数值作为维数。大部分函数的第一个参数都表示数组的元素类型 T 。如果类型 T 被省略，那么将默认为 Float64。

函数	描述
`Array{T}(undef, dims...)`	一个没有初始化的密集 `Array`
`zeros(T, dims...)`	一个全零 `Array`
`ones(T, dims...)`	一个元素均为 1 的 `Array`
`trues(dims...)`	一个每个元素都为 `true` 的 `BitArray`
`falses(dims...)`	一个每个元素都为 `false` 的 `BitArray`
`reshape(A, dims...)`	一个包含跟 `A` 相同数据但维数不同的数组
`copy(A)`	拷贝 `A`
`deepcopy(A)`	深拷贝，即拷贝 `A`，并递归地拷贝其元素
`similar(A, T, dims...)`	一个与`A`具有相同类型（这里指的是密集，稀疏等）的未初始化数组，但具有指定的元素类型和维数。第二个和第三个参数都是可选的，如果省略则默认为元素类型和 `A` 的维数。
`reinterpret(T, A)`	与 `A` 具有相同二进制数据的数组，但元素类型为 `T`
`rand(T, dims...)`	一个随机 `Array`，元素值是 [ 0 , 1 ) [0, 1) [0,1) 半开区间中的均匀分布且服从一阶独立同分布
`randn(T, dims...)`	一个随机 `Array`，元素为标准正态分布，服从独立同分布
`Matrix{T}(I, m, n)`	`m` 行 `n` 列的单位矩阵（需要先执行 `using LinearAlgebra` 来才能使用 `I`）
`range(start, stop=stop, length=n)`	从 `start` 到 `stop` 的带有 `n` 个线性间隔元素的范围
`fill!(A, x)`	用值 `x` 填充数组 `A`
`fill(x, dims...)`	一个被值 `x` 填充的 `Array`

zeros() 创建数组范例，元素初始值都是 0:

julia> zeros(Int8, 2, 3)
2×3 Matrix{Int8}:
 0  0  0
 0  0  0

julia> zeros(Int8, (2, 3))
2×3 Matrix{Int8}:
 0  0  0
 0  0  0

julia&gt zeros((2, 3))
2×3 Matrix{Float64}:
 0.0  0.0  0.0
 0.0  0.0  0.0

下一节：Julia 元组

Julia 教程

Python 的元组与数组类似，都是有序的元素集合，不同之处在于元组的元素不能修改。另外元组使用小括号 (...)，数组使用方括号 [...]。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可，数组中的很多函数也 ...

Julia 基本语法

Julia 元组