Julia 数组

runoob 2023-04-07 原文

Julia 数组

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

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

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

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

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

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

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

[A, B, C, ...]

创建一维数组

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

实例

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

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

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

实例

julia> arr =[1, "RUNOOB", 2.5, pi]
4-element Vector{Any}:
1
"RUNOOB"
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","RUNOOB","GOOGLE"]
3-element Vector{String}:
"Taobao"
"RUNOOB"
"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","RUNOOB","GOOGLE"]
3-element Vector{String}:
"Taobao"
"RUNOOB"
"GOOGLE"

julia> arr2[1]
"Taobao"

julia> arr2[end]
"GOOGLE"

指定数组类型及维度

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

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 用于设置数组未初始化为任何已知值，这就是我们在输出中得到随机数的原因。

创建二维数组和矩阵

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

实例

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

使用范围函数来创建数组

省略号 ...

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

实例

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

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）的元组

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)$ 半开区间中的均匀分布且服从一阶独立同分布 ^[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> zeros((2, 3))
2×3 Matrix{Float64}:
0.0 0.0 0.0
0.0 0.0 0.0

有关Julia 数组的更多相关文章

ruby-on-rails - 在 Ruby 中循环遍历多个数组 - 2
我有多个ActiveRecord子类Item的实例数组，我需要根据最早的事件循环打印。在这种情况下，我需要打印付款和维护日期，如下所示:ItemAmaintenancerequiredin5daysItemBpaymentrequiredin6daysItemApaymentrequiredin7daysItemBmaintenancerequiredin8days我目前有两个查询，用于查找maintenance和payment项目(非排他性查询)，并输出如下内容:paymentrequiredin...maintenancerequiredin...有什么方法可以改善上述(丑陋的)代
ruby - 多次弹出/移动 ruby 数组 - 2
我的代码目前看起来像这样numbers=[1,2,3,4,5]defpop_threepop=[]3.times{pop有没有办法在一行中完成pop_three方法中的内容？我基本上想做类似numbers.slice(0,3)的事情，但要删除切片中的数组项。嗯...嗯，我想我刚刚意识到我可以试试slice! 最佳答案是numbers.pop(3)或者numbers.shift(3)如果你想要另一边。关于ruby-多次弹出/移动ruby数组，我们在StackOverflow上找到一
ruby - 将数组的内容转换为 int - 2
我需要读入一个包含数字列表的文件。此代码读取文件并将其放入二维数组中。现在我需要获取数组中所有数字的平均值，但我需要将数组的内容更改为int。有什么想法可以将to_i方法放在哪里吗？ClassTerraindefinitializefile_name@input=IO.readlines(file_name)#readinfile@size=@input[0].to_i@land=[@size]x=1whilex 最佳答案只需将数组映射为整数:@land边注如果你想得到一条线的平均值，你可以这样做:values=@input[x]
ruby - 通过 erb 模板输出 ruby 数组 - 2
我正在使用puppet为ruby程序提供一组常量。我需要提供一组主机名，我的程序将对其进行迭代。在我之前使用的bash脚本中，我只是将它作为一个puppet变量hosts=>"host1,host2"我将其提供给bash脚本作为HOSTS=显然这对ruby不太适用——我需要它的格式hosts=["host1","host2"]自从phosts和putsmy_array.inspect提供输出["host1","host2"]我希望使用其中之一。不幸的是，我终其一生都无法弄清楚如何让它发挥作用。我尝试了以下各项:我发现某处他们指出我需要在函数调用前放置“function_”……这
ruby - 检查数组是否在增加 - 2
这个问题在这里已经有了答案:Checktoseeifanarrayisalreadysorted?(8个答案)关闭9年前。我只是想知道是否有办法检查数组是否在增加？这是我的解决方案，但我正在寻找更漂亮的方法:n=-1@arr.flatten.each{|e|returnfalseife
ruby - 如果指定键的值在数组中相同，如何合并哈希 - 2
我有一个这样的哈希数组:[{:foo=>2,:date=>Sat,01Sep2014},{:foo2=>2,:date=>Sat,02Sep2014},{:foo3=>3,:date=>Sat,01Sep2014},{:foo4=>4,:date=>Sat,03Sep2014},{:foo5=>5,:date=>Sat,02Sep2014}]如果:date相同，我想合并哈希值。我对上面数组的期望是:[{:foo=>2,:foo3=>3,:date=>Sat,01Sep2014},{:foo2=>2,:foo5=>5:date=>Sat,02Sep2014},{:foo4=>4,:dat
ruby - 在 Ruby 中用键盘诅咒数组浏览 - 2
我正在尝试在Ruby中制作一个cli应用程序，它接受一个给定的数组，然后将其显示为一个列表，我可以使用箭头键浏览它。我觉得我已经在Ruby中看到一个库已经这样做了，但我记不起它的名字了。我正在尝试对soundcloud2000中的代码进行逆向工程做类似的事情，但他的代码与SoundcloudAPI的使用紧密耦合。我知道cursesgem，我正在考虑更抽象的东西。广告有没有人见过可以做到这一点的库或一些概念证明的Ruby代码可以做到这一点？最佳答案我不知道这是否是您正在寻找的，但也许您可以使用我的想法。由于我没有关于您要完成的工作
ruby - 如何在 Grape 中定义哈希数组？ - 2
我使用Ember作为我的前端和GrapeAPI来为我的API提供服务。前端发送类似:{"service"=>{"name"=>"Name","duration"=>"30","user"=>nil,"organization"=>"org","category"=>nil,"description"=>"description","disabled"=>true,"color"=>nil,"availabilities"=>[{"day"=>"Saturday","enabled"=>false,"timeSlots"=>[{"startAt"=>"09:00AM","endAt"=>
ruby - 使用多个数组创建计数 - 2
我正在尝试按0-9和a-z的顺序创建数字和字母列表。我有一组值value_array=['0','1','2','3','4','5','6','7','8','9','a','b'，'光盘'，'e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','','u','v','w','x','y','z']和一个组合列表的数组，按顺序，这些数字可以产生x个字符，比方说三个list_array=[]和一个当前字母和数字组合的数组(在将它插入列表数组之前我会把它变成一个字符串，]current_combo['0','0','0']
ruby - 在哈希的键数组中追加元素 - 2
查看我的Ruby代码:h=Hash.new([])h[0]=:word1h[1]=h[1]输出是:Hash={0=>:word1,1=>[:word2,:word3],2=>[:word2,:word3]}我希望有Hash={0=>:word1,1=>[:word2],2=>[:word3]}为什么要附加第二个哈希元素(数组)？如何将新数组元素附加到第三个哈希元素？最佳答案如果您提供单个值作为Hash.new的参数(例如Hash.new([])，完全相同的对象将用作每个缺失键的默认值。这就是您所拥有的，那是你不想要的。您可以改用

Julia 数组

Julia 数组

创建一维数组

实例

实例

实例

实例

实例

指定数组类型及维度

实例

创建二维数组和矩阵

实例

实例

实例

实例

实例

使用范围函数来创建数组

省略号 ...

实例

collect() 函数

实例

实例

range() 函数

实例

实例

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

实例

实例

实例

实例

Julia 数组基本函数

Julia构造和初始化

实例

有关Julia 数组的更多相关文章

随机推荐