数组、向量和矩阵 AnyMath
导言
用于处理数据、参数和复杂结构 AnyMath 使用数组，向量和矩阵。 这些结构在语言中实现 Julia，允许您高效地存储和处理数值信息，包括计算结果、信号和模型参数。 本文讨论了他们每个人的具体情况。
在Julia中，数组，向量和矩阵的元素的编号从 1，而不是与 0 就像其他语言一样。 最后一个元素有一个索引 结束. 这对应于数学传统，其中索引也从一个开始。 例如，数组的第一个元素 a=[1,2,3] 可透过 a[1]，而最后一个是通过 a[完]. 有关更多信息，请参阅部分 下面。
|
数组是一个广义的多维容器，可以包含任何类型的元素。 Julia中的数组支持任意数量的维度，这使得它们成为存储和处理数据的通用工具。:
A = rand(2, 2, 3)输出
2×2×3 Array{Float64, 3}:
[:, :, 1] =
0.159525 0.787948
0.358068 0.124023
[:, :, 2] =
0.228296 0.292929
0.712896 0.0253828
[:, :, 3] =
0.3547 0.837655
0.474441 0.201402数组可以是动态的，也可以是静态的。:
***动态数组*是在程序执行过程中其大小可以改变的数组。 它们存储在内存中，可能会扩展，这使得它们更灵活，但对于计算密集型任务来说不太理想。
+ 例子：:
+
dynamic_array = [1, 2, 3]
dynamic_array[2] = 5 # Присваивание значения
push!(dynamic_array, 4) # Добавление элемента
deleteat!(dynamic_array, 3) # Удаление элемента с индексом 3+ .输出
Details
4-element Vector{Int64}:
1
5
3
4***静态数组*是固定大小的数组，在创建阶段设置。 它们作为连续的数据块存储在内存中，这允许通过最小化内存管理的开销来更快地执行操作。
+
| 静态数组在其大小小于100-200个元素时有效。 如果大小超过100-200个元素，则通常使用动态数组。 |
+
在Julia中，静态数组由StaticArrays提供。jl包。 因此，为了使用它们，您必须 连接这个包使用命令 使用StaticArrays.
+ 例子：:
+
using StaticArrays
static_array = @SVector [1, 2, 3]+ .输出
Details
3-element SVector{3, Int64} with indices SOneTo(3):
1
2
3+
代码中使用了macrofootnote：[Julia中的宏是从符号开始的特殊结构 @，它在执行代码之前转换代码。] @SVector，它创建一个固定大小的静态一维数组（向量）。 静态数组还有其他有用的宏。:
+ .静态数组的宏_
Details
-
@SVector-创建固定大小的不可变静态向量。 例子：:@SVector[1,2,3]. -
@MVector-创建一个固定大小的可变静态向量。 例子：:@MVector[1,2,3]. -
@SMatrix-创建固定大小的不可变静态矩阵。 例子：:@SMatrix[1 2;3 4]. -
@MMatrix-创建一个固定大小的可变静态矩阵。 例子：:@MMatrix[1 2;3 4]. -
@SizedArray-将常规数组转换为固定大小的静态数组。 例子：:@SizedArray兰德(2,2). -
@SArray-创建一个共享的不可变静态数组，它可以是一个向量，一个矩阵，也可以是一个较大维数的数组。 例子：:@SArray rand（2，2，2）. -
@MArray-创建一个共享的可变静态数组。 例子：:@MArray rand（2，2，2）. -
@StaticArray-创建任何形状的不可变数组的通用宏。 例子：:@StaticArray兰德（2，2）. -
@MutableStaticArray-用于创建可变静态数组的通用宏。 例子：:@MutableStaticArray兰德（2，2）. -
@零-创建一个用零填充的静态数组。 例子：:@零（SVector，3）创建一个由三个零组成的向量。 -
@一个-创建一个充满单位的静态数组。 例子：:@ones（SMatrix，2，2）创建一个2x2单位矩阵。 -
@填充-创建一个用指定值填充的静态数组。 例子：:@填充(SVector,3,42)创建一个由三个元素组成的向量，值为42。 -
@静态—通过应用静态数组的属性，优化代码块在编译阶段的执行。例子：:
@static if length(SVector(1, 2, 3)) == 3 println("Размер 向量а равен 3") end
|
与C++不同，Julia中的数组可以存储不同类型的元素。 如果元素的类型可以减少到一个共同的（例如 如果元素类型不能简化为公共类型（例如，数字和字符串），那么Julia将将数组转换为类型 这使得数组在Julia中变得灵活，但值得记住的是，使用 |
向量是表示使用索引访问的元素序列的一维数组。 在Julia中，向量可以创建为*列向量*或*行向量*，但它们的语法和数据类型会有所不同。:
*使用逗号或列条目创建列向量:
+
v = [1, 2, 3] # Вектор-столбец+ 或
+
v = [1
2
3] # Вектор-столбец+ .输出
Details
3-element Vector{Int64}:
1
2
3*Julia没有单独的字符串向量类型。 相反，一串数字表示为1×N矩阵。:
+
r = [1 2 3] # Матрица 1 × 3+ .输出
Details
1×3 Matrix{Int64}:
1 2 3|
在Julia中，数组中的分隔符定义了它们的结构: *逗号( + **分号( + |
矩阵*是一个二维数组，表示一个数字表或其他组织成行和列的对象。 在Julia中，矩阵被创建为具有两个维度的数组:
M = [1 2 3; 4 5 6]输出
2×3 Matrix{Int64}:
1 2 3
4 5 6在Julia中划分为向量和矩阵允许您有效地组织内存中的数据，这对于快速数值计算非常重要。 向量使用一维存储，使得处理数据序列更容易，而矩阵以二维形式组织，这使得执行线性代数（乘法和转置）更容易。 这种分离有助于优化高速缓冲存储器和处理器资源的使用，从而提高计算效率。
数组、向量和矩阵之间的差异
尺寸:
数组是具有任意维数的容器。 数组具有任意数量的维度，并且 尺寸(A) 它可以返回，例如，（2, 2, 3).
向量是一维数组。 向量总是具有相同的维度，并且函数 尺寸(v) 返回元组 (n,)，在哪里 n -矢量的长度。
**矩阵是一个二维数组。 矩阵的维数为2， 尺寸(M) 返回元组 (n,m)，在哪里 n -行数，以及 m -列数。
|
元组是一种不可变的数据结构，可以包含多个不同类型的元素。 在Julia中，元组用于表示逻辑上相关但不需要修改的值。 例如，函数的结果 与向量和矩阵不同，元组不是数组，也不用于执行算术运算。 它具有固定数量的元素和不可变结构，这使得它对于从函数返回多个值或传递参数非常有用。 |
-
实现功能: 处理数组的方法和函数适用于向量和矩阵。 但是，每种数据类型都有自己的优化算法。 在Julia中，向量和矩阵是数组的特殊情况，其中向量具有维数
1，和矩阵 —2. -
初始化和语法: **具有任意维度的数组由Array函数或使用生成器（形式为表达式
[… 为。..]). 例如，对于Array:A = Array{Float64}(undef, 2, 2, 3)在这里，undef是一个关键字，用于创建数组而不初始化元素。 这意味着将分配数组的内存，但其元素的值将保持未定义（它们可能是随机的）。
带有生成器的示例:
array = [i^2 for i in 1:5] # Каждый элемент массива – квадрат числа от 1 до 5**向量创建为一维数组，元素用逗号分隔:
v = [1, 2, 3]**矩阵写成用分号分隔的行（
;），并且行中的元素用空格或制表符分隔:M = [1 2 3; 4 5 6] -
存储在内存中:
*具有大量维度的阵列使用更通用的数据存储方法，这会在执行操作时增加开销。
上述差异塑造了具体的应用领域。:
*数组用于为更复杂的数据建模：三维模型、图像数组或多维时间序列。 *矢量最常用于一维数据：时间序列，坐标和信号。 *矩阵表示二维结构：图像，表格，线性方程组。
处理数组、向量和矩阵的基本功能
Julia为处理数组提供了广泛的功能，包括向量和矩阵。 有关函数及其签名的详细信息，请参阅 数组.
|
用符号标记的函数 运算符用于提供对此类函数元素的访问 |
以下是主要功能的列表，并附有简要说明和示例。:
创造
函数名称 |
资料描述 |
例子： |
|
创建元素等于零的数组。 创建对象的类型取决于传递的参数：一维数组（向量）、二维数组（矩阵）或多维数组。 |
zeros(3) zeros(2, 2) zeros(2, 2, 3) 这里:
|
|
创建一个元素等于1的数组。 创建对象的类型取决于传递的参数：一维数组（向量）、二维数组（矩阵）或多维数组。 |
ones(3) ones(2, 2) ones(2, 2, 3) 这里:
|
|
创建一个用区间内分布均匀的随机数填充的数组 |
rand(3) rand(2, 2) rand(2, 2, 3) 这里:
|
|
创建一个用指定值填充的数组。 创建对象的类型取决于传递的参数：一维数组（向量）、二维数组（矩阵）或多维数组。 |
fill(7, 3) fill(5, 2, 2) fill(75, 2, 2, 3) 这里:
|
|
通过转换指定的范围或可迭代对象来创建数组。 创建的对象类型取决于所使用的输入。 |
collect(1:3) collect(reshape(1:4, 2, 2)) collect(reshape(1:12, 2, 2, 3)) 这里:
|
结构的变化
函数名称 |
资料描述 |
例子： |
|
将元素添加到一维数组（向量）的末尾。 仅适用于可变（动态）数组。 结束索引([indexing])也可用于添加元素。 |
v = [1, 2, 3] push!(v, 4) m = reshape(1:6, 2, 3) # push! нельзя применить к матрице или многомерному массиву. 这里:
|
|
删除并返回一维数组（向量）中的最后一个元素。 仅适用于可变（动态）数组。 |
v = [1, 2, 3, 4] last_element = pop!(v) m = reshape(1:6, 2, 3) # pop! нельзя применить к матрице или многомерному массиву. 这里:
|
|
将元素插入一维数组（向量）的指定位置。 仅适用于可变（动态）数组。 |
v = [1, 2, 4, 5] insert!(v, 3, 3) m = reshape(1:6, 2, 3) # insert! нельзя применить к матрице или многомерному массиву. 这里:
|
|
从一维数组（向量）中删除指定索引处的元素。 仅适用于可变（动态）数组。 |
v = [1, 2, 3, 4, 5] deleteat!(v, 3) m = reshape(1:6, 2, 3) # deleteat! нельзя применить к матрице или многомерному массиву. 这里:
|
尺寸加工
函数名称 |
资料描述 |
例子： |
|
以元组的形式返回数组、矩阵或向量的大小，其中每个值对应于特定维度的大小。 |
v = [1, 2, 3] size(v) m = reshape(1:6, 2, 3) size(m) a=零（2，2，3） 尺寸(a) 这里:
|
|
修改一维数组（向量）的大小。 如果新的大小大于当前的大小，则新元素将初始化为默认值。 |
v = [1, 2, 3] resize!(v, 5) resize!(v, 2) m = reshape(1:6, 2, 3) # resize! нельзя применить к матрице или многомерному массиву. 这里:
|
|
返回数组、向量或矩阵中元素的总数，无论其维数如何。 |
v = [1, 2, 3] length(v) m = reshape(1:6, 2, 3) length(m) a = zeros(2, 2, 3) length(a) 这里:
|
|
返回数组、向量或矩阵的维数（维数）。 |
v = [1, 2, 3] ndims(v) m = reshape(1:6, 2, 3) ndims(m) a = zeros(2, 2, 3) ndims(a) 这里:
|
|
修改数组、矩阵或向量的维数，将其转换为具有指定行数和列数的新数组。 新数组中的元素数必须与原始数组中的元素数相匹配。 |
v = [1, 2, 3, 4, 5, 6] m = reshape(v, 2, 3) a = [1, 2, 3, 4, 5, 6, 7, 8, 9] b = reshape(a, 3, 3) c = reshape(a, 1, 9) 这里:
|
线性代数_
函数名称 |
资料描述 |
例子： |
|
返回行与列交换的转置数组或矩阵。 对于一维数组（矢量），结果取决于其方向。 |
v = [1, 2, 3] vt = transpose(v) m = [1 2; 3 4; 5 6] mt = transpose(m) 这里:
|
* |
计算方阵的行列式。 它是LinearAlgebra软件包的一部分（需要安装该软件包）。 行列式是表征矩阵属性（例如，其可逆性）的标量。 |
m1 = [2 3; 1 4] det(m1) m2 = [1 2 3; 4 5 6; 7 8 10] det(m2) m3 = [0 1; 2 3] det(m3) 这里:
|
|
计算方阵的逆矩阵。 逆矩阵仅存在于具有非零行列式的矩阵，即对于那些可反转的矩阵。 功能 |
m1 = [2 3; 1 4] inv(m1) m2 = [1 2 3; 0 1 4; 5 6 0] inv(m2) m3 = [1 2; 3 4] inv(m3) 这里:
|
* |
特征值和矩阵向量的计算。 例如:
|
m1 = [4 1; 2 3] eigvals(m1) eigvecs(m1) m2 = [1 2 3; 4 5 6; 7 8 9] eigvals(m2) eigvecs(m2) 这里:
|
|
计算向量或矩阵的范数。 范数是测量的数值特征 «大小» 向量或矩阵。 默认情况下，计算欧几里德范数。 |
v = [3, 4] norm(v) m = [1 2; 3 4] norm(m) norm(v, 1) # 3 + 4 = 7.0 norm(m, Inf) #√30 ≈ 5.477 这里:
|
检查
函数名称 |
资料描述 |
例子： |
|
检查数组、向量或矩阵是否为空。 申报表 |
# Проверка пустого и непустого 向量а v1 = [] v2 = [1, 2, 3] isempty(v1) isempty(v2) # Проверка пустой и непустой матрицы m1 = reshape([], 0, 0) m2 = [1 2; 3 4] isempty(m1) isempty(m2) # Проверка пустого и непустого массива a1 = Int[] a2 = [1, 2, 3, 4] isempty(a1 isempty(a2) 这里: *对于向量:
*对于矩阵:
*对于数组:
|
|
检查对象是否为null。 申报表 它支持数字类型，以及数组，矩阵和向量（在Julia中，如果所有元素都为零，则对象被视为null）。 |
# Проверка числа x = 0 y = 5 iszero(x) # true iszero(y) # false # Проверка 向量а v1 = [0, 0, 0] v2 = [0, 1, 0] iszero(v1) # true iszero(v2) # false # Проверка матрицы m1 = zeros(2, 2)нулями m2 = [1 0; 0 0]элементом iszero(m1) # true iszero(m2) # false # Проверка многомерного массива a1 = zeros(2, 2, 2) a2 = reshape([1, 0, 0], 1, 3) iszero(a1) # true iszero(a2) # false 这里: 对于数字:
对于向量:
对于矩阵:
对于多维数组:
|
|
检查矩阵是否对称。 申报表 |
# Симметричная 矩阵 m1 = [1 2 3; 2 4 5; 3 5 6] issymmetric(m1) # true # Несимметричная 矩阵 m2 = [1 0 0; 0 4 5; 3 5 6] issymmetric(m2) # false # Квадратная, но несимметричная 矩阵 m3 = [1 2; 3 4] issymmetric(m3) # false # Несимметричная прямоугольная 矩阵 m4 = [1 2; 2 3; 3 4] issymmetric(m4) # false 这里: *对于矩阵 +
矩阵 + +
*对于矩阵 +
矩阵 + +
*对于矩阵 +
矩阵 + +
*对于矩阵 +
矩阵 |
转换
函数名称 |
资料描述 |
例子： |
|
将矩阵或多维数组转换为向量。 它返回一个一维数组，其中元素取自原始矩阵或数组的列。 如果参数已经是一个向量，则返回不变。 |
# Преобразование матрицы в 向量 m = [1 2; 3 4] v1 = vec(m) # [1, 3, 2, 4] # Преобразование трехмерного массива в 向量 a = zeros(2, 2, 2) a[:, :, 1] .= [1 2; 3 4] a[:, :, 2] .= [5 6; 7 8] v2 = vec(a) # [1, 3, 2, 4, 5, 7, 6, 8] # Преобразование 向量а (без изменений) v = [1, 2, 3] v3 = vec(v) # [1, 2, 3] *矩阵 + 功能 + *对于三维阵列 +
原始数组 +
+ +
对于向量 +
如果对象已经是向量，则 + |
|
多维数组的维度（轴）的重新排列。 允许您在不更改数据本身的情况下更改测量顺序，创建具有重新排列轴的新数组。 |
这里:
|
|
数组的水平和垂直组合（串联）。
|
# Горизонтальное объединение (hcat) v1 = [1, 2, 3] v2 = [4, 5, 6] h_result = hcat(v1, v2) #垂直池(vcat) v3=[7，8，9] v_result=vcat（v1，v3） #组合矩阵 m1=[1 2;3 4] m2=[5 6;7 8] hcat_result=hcat（m1，m2） vcat_result=vcat（m1，m2） 这里:
|
|
创建数组、向量或矩阵的独立副本。 对副本所做的更改不会影响原始对象，反之亦然。 |
v = [1, 2, 3] v_copy = copy(v) v[1] = 10 # Изменяем оригинал println(v) # [10, 2, 3] println(v_copy) # [1, 2, 3] 这里: *更改原始元素（ |
|
创建数组的深层副本，递归复制所有嵌套结构。 对副本的更改不会影响原件。 在Julia中，默认赋值不会传输值，而是对对象的引用。 如果您需要创建独立副本，有两种方法。:
|
A = [[1, 2], [3, 4]] B = copy(A) # Неглубокая копия C = deepcopy(A) # Глубокая копия B[1][1] = 99 println(A) # [[99, 2], [3, 4]] — A изменился, потому что B и A связаны println(C) # [[1, 2], [3, 4]] — Глубокая копия не изменилась 这里: *更改原始元素中的嵌套元素（ |
|
允许您使用自动大小匹配（广播）对数组元素执行操作。 有关详细信息，请参阅 这里。 |
# Пример с 向量ом v = [1, 2, 3] v_squared = broadcast(x -> x^2, v) # Пример с матрицей m = [1 2; 3 4] m_doubled = broadcast(x -> x * 2, m) # Пример с разными размерами массивов a = [1, 2, 3] b = [4, 5] result = broadcast(+, a, b') 这里:
|
使用数组的相关性
数组是处理数据的方便而灵活的工具，但Julia还有其他结构可能更适合某些任务。 有关更多信息，请参阅下文。
建议使用数组时
*通过索引快速访问元素—数组将元素按顺序存储在内存中，这允许通过索引即时访问任何元素。 例如, arr[3] 它将立即返回数组的第三个元素。 它被称为*随机访问*，它及时工作。 O(1) （该操作在恒定时间内执行，无论输入数据的大小如何，即按索引访问元素需要相同的时间，无论数组有多大）。
*在末尾有效地添加和删除-如果您需要频繁地添加或删除数组末尾的项，请使用这些函数 推！ （添加元素）和 爸爸！ （删除最后一个元素）。 这些操作执行得非常快，因为它们不需要重新排列其他元素。
*使用固定数量的数据-如果您事先知道将存储多少元素，则数组的工作效率特别高。 它们会立即分配内存，从而最大限度地减少调整大小的开销。
*矢量计算和线性代数-Julia针对处理数组进行了优化，特别是数字数组。 如果您正在使用矩阵，向量或执行线性代数运算，数组是最佳选择。 例如，用于处理矩阵的函数，例如 点, 交叉，或通过数组进行操作 广播(.+, .*），它们与数组一起工作得更快。
当不推荐使用数组时
*频繁地在中间或开头添加或删除元素-如果需要频繁地在数组的开头或中间插入或删除元素。 例如，函数 插入！ (插入)及 deleteat！ （删除）需要移位所有后续元素，这使得它们对于大型数组效率低下。 备选方案：使用 德克 从包 数据结构。jl，其针对两端的插入和缺失进行了优化。
*通过键搜索元素-如果您需要通过唯一键（例如，通过用户名或ID）快速查找元素，则数组不适合，因为它们会搜索所有元素（这是相当长的时间）。 替代方案：使用 Dict,Dict （字典），它允许您通过键快速查找项目。
*结构的频繁调整大小-如果数据结构频繁更改（例如，在任意位置添加或删除元素），数组将无效。 备选方案：考虑使用 套装, Dict,Dict 或列表结构，如 名单 从包 数据结构。jl。
*使用不可变数据—Julia中的数组是可变的，这意味着它们的元素可以在创建后更改。 如果你需要一个不可变的数据结构，最好使用元组。 它们不允许您更改它们的元素，这使得它们便于存储常量数据。 例如:
+
t = (1, 2, 3)
t[1] = 10 # Ошибка! Кортежи неизменяемы字符串和字符的数组、矩阵和向量
在Julia中，数组，矩阵和向量可以包含字符串或字符以及数字。
# 向量 строк
v = ["apple", "banana", "cherry"]
println(v[1]) # apple
# Матрица символов
m = ['a' 'b'; 'c' 'd']
println(m[1, 2]) # b
# Трехмерный массив строк
a = [["a", "b"], ["c", "d"]]
println(a[1][2]) # "b"*行向量-每行存储为一维数组的元素。 *符号矩阵是一个二维数组，其中每个元素都是一个符号。 *字符串的三维数组-支持文本数据的任意数量的维度。
Julia中的数组默认是动态的，但在显式更改之前，它们的长度是固定的。 这意味着在创建数组时，它的当前长度保持不变，直到使用特殊方法，例如 推！, 追加！ 或 调整大小！. 这样做是为了提高性能：固定长度操作更快，因为它们不需要持续的内存重新分配。
更复杂的结构 结束，如 结束+1，不允许您直接为数组元素赋值，因为这样的操作超出了当前长度。 要添加新元素，您需要显式增加数组的大小。 例如，可以使用 调整大小！:
a = [10, 20, 30]
resize!(a, length(a) + 1) # Расширяем массив на 1 элемент
a[end] = 40 # Присваиваем значение новому элементу
println(a) # [10, 20, 30, 40]与 结束 它们可用于索引和使用现有数组边界内的索引执行算术运算。 例如:
-
a[完]-访问最后一个项目。 -
a[结束-1]-从末端访问第二个元素。 -
a[1:完]-获取整个阵列。 -
a[1:结束-1]-获取除最后一个以外的所有项目。
在Julia中，不能直接为带有索引的元素赋值 结束+1 或超出数组当前长度的任何索引。 要更改数组的大小，必须使用特殊方法，例如 调整大小！, 推！ 或 追加！.
|
索引数组
Julia中的索引从一个开始，这意味着数组的第一个元素有一个索引 1. 还支持特殊索引。 结束，它指示数组的最后一个元素或相应维度的大小。 索引示例:
a = [10, 20, 30, 40]
println(a[1]) # 10 — первый элемент
println(a[end]) # 40 — последний элемент
# Индексация матриц
m = [1 2; 3 4]
println(m[1, end]) # 2 — последний элемент первой строки*索引 1 始终指向第一个元素。
* 结束 它用于引用一维和多维数组中的最后一个元素。
*对于矩阵，第一个索引是行号，第二个是列号。
索引的其他变体:
*您可以使用范围一次访问多个数组元素:
+
b = [1, 2, 3, 4, 5]
println(b[2:end]) # [2, 3, 4, 5] — элементы со второго до последнего*选择具有一定步骤的元素:
+
b = [1, 2, 3, 4, 5]
println(b[1:2:end]) # [1, 3, 5] — элементы с шагом 2+
|
在朱莉娅，表达像 在这个例子中 |
*选择满足特定条件的元素（有关详细信息，请参阅逻辑索引）:
+
b = [1, 2, 3, 4, 5]
println(b[b .> 3]) # [4, 5] — элементы больше 3在Julia中，范围不仅可以直接设置，还可以使用变量设置。 例如:
arr = [10, 20, 30, 40, 50]
a = 1:2:5 # Задаем диапазон в переменной
println(arr[a]) # [10, 30, 50]逻辑索引
Julia中的逻辑索引允许您根据逻辑数组返回的条件选择数组元素（真的/错误）与原始数组相同的维度。 此方法对于过滤数据很有用。
+ 例子：:
# Исходный массив
a = [10, 20, 30, 40, 50]
# Условие: выбрать элементы больше 25
filtered = a[a .> 25] # [30, 40, 50]
println(filtered)
#条件：是10的倍数的元素
过滤=a[a。% 10 .== 0] # [10, 20, 30, 40, 50]
println(过滤)这里:
*操作员 . 条件之前（.>, .==)表示逐元素操作。 文中提供了此类操作的更详细描述。 矢量化和逻辑索引.
*逻辑数组 [假，假，真，真，真] 它将用于选择适当的元素。
具有多维数组的示例:
# Матрица 2x3
m = [1 2 3; 4 5 6]
# Условие: выбрать элементы больше 3
filtered = m[m .> 3] # [4, 5, 6]
println(filtered)处理数组、向量和矩阵的运算符
Julia提供了简化处理数组的运算符，无论它们是一维（向量），二维（矩阵）还是更复杂的多维结构。 以下是用于索引、转换和组合数据的主要运算符。:
*操作员 : 它用于沿着某个维度选择数组的所有元素或创建范围。
+ 例子：:
+
# Исходный массив
m = [1 2 3; 4 5 6; 7 8 9]
# Все элементы первой строки
println(m[1, :]) # [1, 2, 3]
# Все элементы второго столбца
println(m[:, 2]) # [2, 5, 8]
# Диапазон индексов
println(m[1:2, 1:2]) # [1 2; 4 5]*操作员 ' 它用于共轭
（实数的换位）。 它只适用于数字数组。
+ 例子：:
+
# Вектор-строка
v = [1 2 3]
# Транспонирование в столбец
println(v') # [1; 2; 3;;]+
对于用复数转置数组，运算符 ' 它还返回复共轭结果。 如果您只需要将行转换为列（没有共轭），则使用该函数 转置,转置.
|
|
若要转置具有非数字元素（例如，字符串或自定义类型）的数组，请使用函数 如果您申请运营商 |
*操作员 ; 它用于垂直组合数组，即添加行。
+ 例子：:
+
# Исходные 向量ы
a = [1, 2, 3]
b = [4, 5, 6]
# Вертикальная конкатенация
result = [a; b]
println(result) # 6-element Vector{Int64}:[1; 2; 3; 4; 5; 6]使用以下方法迭代数组 为
在Julia中，可以通过使用循环方便地迭代数组。 为. 让我们来看看通过以下方式处理数组的主要方法 为. 以下语法用于遍历数组的所有元素:
arr = [10, 20, 30, 40]
for x in arr
println(x)
end输出
10
20
30
40有时不仅需要获取值，还需要获取它们的索引。 要做到这一点，请使用 每个索引，从而自动选择最优索引方法:
arr = ["a", "b", "c"]
for i in eachindex(arr)
println("Элемент ", i, ": ", arr[i])
end输出
Элемент 1: a
Элемент 2: b
Элемент 3: c获取索引和值的另一种方法是函数 枚举:
arr = ["apple", "banana", "cherry"]
for (i, val) in enumerate(arr)
println("$i: $val")
end输出
1: apple
2: banana
3: cherry嵌套循环可用于多维数组。:
matrix = [1 2 3; 4 5 6]
for i in 1:size(matrix, 1) # Проход по строкам
for j in 1:size(matrix, 2) # Проход по столбцам
println("matrix[$i, $j] = ", matrix[i, j])
end
end输出
matrix[1, 1] = 1
matrix[1, 2] = 2
matrix[1, 3] = 3
matrix[2, 1] = 4
matrix[2, 2] = 5
matrix[2, 3] = 6而不是嵌套循环，您可以使用 为 直接:
matrix = [1 2 3; 4 5 6]
for x in matrix
println(x)
end输出
1
4
2
5
3
6Julia遍历列中的元素，而不是行。 要通过行绕过阵列，您可以使用 排列,排列 或 每个月:
for row in eachrow(matrix)
println(row)
end输出
[1, 2, 3]
[4, 5, 6]