Engee 文档
Notebook

与其他语言的显着差异

虽然Julia语法对MATLAB用户来说可能很熟悉，但Julia不是MATLAB的克隆。 它们之间存在重要的语法和功能差异。 下面列出了一些值得注意的Julia差异，这些差异可能会让习惯MATLAB的用户感到困惑。

与matlab的区别

  1. Julia中数组的索引用方括号表示：A[i,j]。
In [ ]: 
Pkg.add(["LinearAlgebra"])
In [ ]: 
A = [1 2 3; 4 5 6; 7 8 9]
i = 2
j = 3
element = A[i, j]
println(element)

6
  1. 当Julia中的数组被分配给另一个变量时，它不会被复制。 分配A=B后，更改B的元素将导致它们更改为A。
In [ ]: 
B = [1, 2, 3]
A = B
B[1] = 10
println(A)

[10, 2, 3]
  1. 在Julia中，传递给函数的值不会被复制。 如果函数修改了数组，这些更改将对调用者可见。
In [ ]: 
function modify_array(arr)
    arr[1] = 100
end

A = [1, 2, 3]
modify_array(A)
println(A)

[100, 2, 3]
  1. 在Julia中，使用赋值运算符时数组不会自动递增。 而在MATLAB中，使用表达式a(4)=3.2，您可以创建一个数组a=[0 0 0 3.2]，并使用表达式a(5)=7，将其增加到A=[0 0 0 3.2 7]，在Julia中，如果a的长度小于5或 Julia有推送功能！ 然后追加！，它允许您比MATLAB中的a（end+1）=val更有效地放大矢量类型对象。
In [ ]: 
A = [1, 2, 3]
push!(A, 4)
println(A)

B = [5, 6, 7]
append!(B, [8, 9])
println(B)

[1, 2, 3, 4]
[5, 6, 7, 8, 9]
  1. 虚数单位sqrt（-1）在Julia中用常数im表示，而不是像MATLAB中那样用i或j表示。
In [ ]: 
z = 2 + 3im
println(z)
println("Действительная часть: ", real(z)) 
println("Мнимая часть: ", imag(z)) 

2 + 3im
Действительная часть: 2
Мнимая часть: 3
  1. 在Julia中，没有小数点分隔符的数字字面值（例如，42）创建整数，而不是浮点数。 因此，如果某些操作期望浮点数，则可能会导致超出范围的错误。 例如，julia>a=-1;2^a将返回此错误，因为结果不是整数（有关更多信息，请参阅有关超出范围的错误的常见问题部分）。
In [ ]: 
a = 42  # целое число
b = 42.0 # число с плавающей запятой
c = float(42) # явное преобразование к типу Float64
println(a)
println(b)
println(c)

42
42.0
42.0
  1. 如果Julia需要返回或分配多个值，则使用元组，例如(a,b)=(1,2)或a,b=1,2。 Julia没有nargout函数，该函数通常在MATLAB中用于根据返回值的数量执行其他操作。 可选参数和命名参数可用于类似目的。
In [ ]: 
function get_values()
    return 1, 2
end

x, y = get_values()
println(x)
println(y)

1
2
  1. Julia有真正的一维数组。 列向量的大小为N，而不是Nx1。 例如，表达式rand(N)创建一维数组。
In [ ]: 
v = [1, 2, 3] # одномерный массив
Out[0]:
3-element Vector{Int64}:
 1
 2
 3
  1. 在Julia中，构造[x,y,z]总是创建一个包含三个元素的数组：x,y和z。-要按第一个（"垂直"）维度连接，请调用vcat(x,y,z)函数或使用分号([x;y;z])作为分隔符。 -要连接第二个（"水平"）维度，请调用hcat（x，y，z）函数或使用空格（[x y z]）作为分隔符。 -要创建块矩阵（在前两个维度上连接），请调用hvcat函数或将空格和分号组合为分隔符（[a b;c d]）。
In [ ]: 
A = [1, 2, 3]
B = [4, 5, 6]
C = [7, 8, 9]

D = vcat(A, B, C) # вертикальная конкатенация
println(D)

E = hcat(A, B, C) # горизонтальная конкатенация
println(E)

F = [A; B; C] # разделитель ";"
println(F)

G = [A B C] # разделитель пробел
println(G)

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1 4 7; 2 5 8; 3 6 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1 4 7; 2 5 8; 3 6 9]
  1. 在Julia中，构造a:b和a:b:c创建AbstractRange对象。 要创建一个完整的矢量，如在MATLAB中，请使用collect(a:b)方法。 但是，您通常不需要调用collect。 在大多数情况下，AbstractRange对象的行为类似于常规数组，但由于值的"懒惰"计算，它的效率更高。 这种创建特殊对象而不是完整数组的模式经常被使用，包括使用range等函数和enumerate和zip等迭代器。 特殊对象通常可以用作常规数组。
In [ ]: 
range = 1:5
vector = collect(range)
println(vector)

[1, 2, 3, 4, 5]
  1. Julia中的函数返回使用关键字return计算最后一个表达式或表达式的结果。 您不需要在函数定义中列出返回变量的名称（有关详细信息，请参阅return关键字）。
In [ ]: 
function sum(x, y)
    x + y
end

result = sum(2, 3)
println(result)

5
  1. 在Julia中，调用不带参数的函数时，必须使用括号，如rand()。
In [ ]: 
function example()
    println("Функция без аргументов")
end

example()

Функция без аргументов
  1. 在Julia中，不建议在表达式末尾放分号。 表达式的结果不会自动显示（交互式命令行除外），因此不需要用分号结束代码行。 您可以使用println函数或@printf宏在屏幕上显示某些数据。
In [ ]: 
a = 2
b = 3
c = a + b
println(c)

5
  1. 在Julia中，如果A和B是数组，则a==B等逻辑比较操作不会返回布尔值数组。 相反，使用A。==B或其他逻辑运算符（如<和>）的类似表达式。
In [ ]: 
A = [1, 2, 3]
B = [2, 2, 3]
result = A .== B
println(result)

Bool[0, 1, 1]
  1. 在Julia中，运算符&、|和⊻(xor)是按位执行的，就像MATLAB中的and、or和xor一样。 它们的优先级与Python中的按位运算符相同（但与C中的不同）。 它们可以应用于标量值或零碎应用于数组，也可以用于组合逻辑数组。 但是，请注意操作顺序的差异：可能需要括号（例如，要选择等于1或2的元素，请使用表达式（A）。== 1) .|(一．== 2)).
In [ ]: 
a = 5
b = 3
result = a & b
println(result)

A = [true, false, true]
B = [false, true, true]
result = A .& B
println(result)

1
Bool[0, 0, 1]
  1. 在Julia中，集合元素可以使用展开运算符（splat运算符）作为参数传递给函数。..，例如xs=[1,2];f（xs。..).
In [ ]: 
function sum_elements(x, y, z)
    return x + y + z
end

values = [1, 2, 3]
result = sum_elements(values...)
println(result)

6
  1. Julia中的svd函数返回奇异值作为向量而不是密集对角矩阵。
In [ ]: 
using LinearAlgebra
A = [1 2; 3 4]
U, S, V = svd(A)
println(S)

[5.464985704219043, 0.3659661906262575]
  1. 朱莉娅有一个符号。.. 它不用于继续代码行。 相反，不完整的表达式会在下一行自动继续。
In [ ]: 
a = 2 +
    3
println(a)

5
  1. 与MATLAB中的类不同，Julia中的结构不支持在运行时动态字段添加。 使用Dict代替。 Julia中的字典不是有序的。
In [ ]: 
struct MyStruct1
    field1::Int
end

s = MyStruct1(10)
println(s.field1)

# Используем словарь для добавления поля field2
s_dict = Dict(:field1 => s.field1, :field2 => 20)
println(s_dict[:field2])

10
20
  1. 在Julia中，每个模块都有自己的全局作用域或命名空间，而在MATLAB中只有一个全局作用域。
In [ ]: 
module MyModule
    global_var = 10
    
    function my_function()
        println(global_var)
    end
end

MyModule.my_function()

10

WARNING: replacing module MyModule.
  1. 在MATLAB中，删除不必要值的惯用方法是使用逻辑索引，如表达式x(x>3)或运算符x(x>3)=[]中更改x。 Julia提供高阶函数filter和filter！ 为此，允许表达式过滤器（z->z>3，x）和过滤器！(z->z>3,x)用作x[x.>3]和x=x[x.>3]的替代。 的过滤功能！ 它允许您较少使用临时数组。
In [ ]: 
A = [1, 2, 3, 4, 5]
filtered_A = filter(x -> x > 3, A)
println(filtered_A)

filter!(x -> x > 3, A)
println(A)

[4, 5]
[4, 5]
  1. 提取（或"取消引用"）单元格数组的所有元素，例如vertcat（A{:}）在MATLAB中，它是使用扩展运算符（splat运算符）在Julia中编写的，例如vcat（A。..).
In [ ]: 
A = [1, 2]
B = [3, 4]
C = [5, 6]
array_of_arrays = [A, B, C]
concatenated_array = vcat(array_of_arrays...)
println(concatenated_array)

[1, 2, 3, 4, 5, 6]
  1. 在Julia中，adjoint函数执行共轭转置;在MATLAB中，adjoint提供了一个adjoint矩阵（经典共轭），即它执行代数补数的矩阵的转置。
In [ ]: 
A = [1+2im 3+4im]
adj_A = adjoint(A)
println(adj_A)

Complex{Int64}[1 - 2im; 3 - 4im;;]
  1. 在Julia中，表达式（abc）计算为a（bc），而在MATLAB中则计算为（ab）c。
In [ ]: 
a = 3
b = 2
c = 3
result = a^(b^c)
println(result)

6561

与Python的区别

  1. 在Julia中，for，if，while等块以end关键字结尾，而不是像在Python中那样缩进它们。 没有pass关键字。
In [ ]: 
for i in 1:5
    println(i)
end

1
2
3
4
5
  1. 在Julia中，行用双引号表示，三对双引号用于多行文本。 此外，单引号用于字符。
In [ ]: 
str1 = "Hello, World!"
str2 = """Это много-
строчный текст."""
char1 = 'c'
Out[0]:
'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
  1. Julia使用运算符进行字符串连接，而不是+，就像在Python中一样。 ^运算符用于重复行，而不是。
In [ ]: 
str1 = "Hello, "
str2 = "World!"
concatenated_str = str1 * str2
repeated_str = str2 ^ 3
println(concatenated_str)
println(repeated_str)

Hello, World!
World!World!World!
  1. 在Julia中，列表对应于向量{Any}类型或更通用的向量{T}类型，其中T是某种类型的元素。 更高效的数组，如NumPy数组，可以用数组Array{T}表示，其中T是特定类型的元素。
In [ ]: 
list1 = Any[1, "two", 3.0]
list2 = Vector{Int}(undef, 5)
array1 = Array{Int}(undef, 3, 3)
Out[0]:
3×3 Matrix{Int64}:
 3762813801648698725  3774918513298847538  7077182949550143800
 3762529018811868721  7364623875528025187      140502613063936
 3991368380935386977  3906925892200719205      140518684094896
  1. Julia中的索引数组从一个开始，不像Python中的索引从零开始。
In [ ]: 
array = [1, 2, 3, 4, 5]
println(array[1])  # Выведет 1

1
  1. 在Julia中索引切片时，包含最后一个元素，与Python中不同。 Julia中的a[2:3]相当于Python中的A[1:3]。
In [ ]: 
array = [1, 2, 3, 4, 5]
println(array[2:3])  # Выведет [2, 3]

[2, 3]
  1. Julia中允许使用具有任意索引的AbstractArray数组。 在Python中具有特殊含义的负索引在Julia中被写成a[end]和a[end-1]。
In [ ]: 
array = [1, 2, 3, 4, 5]
println(array[end])  # Выведет 5
println(array[end - 1])  # Выведет 4

5
4
  1. 要索引到Julia中的最后一个元素，使用end关键字。 Python中的x[1:]相当于Julia中的x[2:end]。
In [ ]: 
array = [1, 2, 3, 4, 5]
println(array[2:end])  # Выведет [2, 3, 4, 5]

[2, 3, 4, 5]
  1. 在Julia中，范围索引的格式为x[start:step:stop]，在Python-x中为[start:(stop+1):step]。 因此，Python中的x[0:10:2]相当于Julia中的x[1:2:10]。
In [ ]: 
array = [1, 2, 3, 4, 5]
println(array[1:2:end])  # Выведет [1, 3, 5]

[1, 3, 5]
  1. Julia没有行延续语法。 如果字符串包含完整的表达式，则认为它已完成。 否则，线路继续。 括号可用于继续表达式。
In [ ]: 
a = (
    1 + 2 +
    3
)
println(a)  # Выведет 6

6
  1. 在Julia中，数组按列展开，而NumPy数组按行展开。 在Julia中遍历数组时，与NumPy相比，循环顺序应该颠倒。
In [ ]: 
A = [1 2; 3 4; 5 6]
for j in 1:size(A, 2), i in 1:size(A, 1)
    println(A[i, j])
end

1
3
5
2
4
6
  1. 在Julia中，函数参数的默认值是在每次调用方法时计算的，不像在Python中，只有在定义函数时才计算值。
In [ ]: 
function f(x = rand())
    return x
end;
In [ ]: 
println(f())  # Выполните ячейку несколько раз

0.975434444871681
  1. 在Julia中，命名参数必须以名称传递，与Python中不同。
In [ ]: 
function foo(a; b = 1, c = 2)
    return a + b + c
end

println(foo(10, b = 3, c = 4))  # Выведет 17, нельзя вызывать как println(foo(10, 3, 4)), в случае с Python

17
  1. 在Julia中，Int类型对应于机器整数类型（Int32或Int64），而在Python中int可以有任何长度。
In [ ]: 
x = Int64(2) ^ Int64(64)
println(x)  # Выведет 0

0
  1. Julia中的虚数单位由常量im表示，而在Python j中则使用。
In [ ]: 
println(2im)  # Выведет 0 + 2im

0 + 2im
  1. 在Julia中，指数运算符用^表示，而不是**，就像在Python中一样。
In [ ]: 
println(2 ^ 3)  # Выведет 8

8
  1. Julia中的空值由Nothing类型的nothing常量表示，而在Python中则使用NoneType类型的None对象。
In [ ]: 
x = nothing
println(x)  # Выведет nothing

nothing
  1. 在Julia中，*运算符执行矩阵运算，而在Python中，执行逐元素乘法。 在朱莉娅，该。*运算符用于元素乘法。
In [ ]: 
A = [1 2;
     3 4]
B = [5 6;
     7 8]
println(A * B)  # Выведет матрицу, [19 22; 43 50]

println(A .* B)  # Выведет матрицу, [5 12; 21 32]

[19 22; 43 50]
[5 12; 21 32]
  1. 在Julia中，运算符'返回向量的共轭，而转置运算符。Python中的T返回原始向量。
In [ ]: 
x = [1 2 3]
println(x')  # Выведет [1; 2; 3]

[1; 2; 3;;]
  1. 在Julia中，函数可以有几个特定的实现（方法），这些实现是根据参数的类型选择的。 在Python中，函数具有单一实现，不支持多态性。
In [ ]: 
function square(x::Number)
    return x * x
end

function square(x::String)
    return string(x, x)
end

println(square(2))  # Выведет 4
println(square("hello"))  # Выведет "hellohello"

4
hellohello
  1. Julia没有类，而是使用只包含数据而不包含方法的结构。
In [ ]: 
struct MyStruct
    x::Int
    y::Float64
end

function f(obj::MyStruct, z)
    return obj.x + obj.y + z
end

my_obj = MyStruct(1, 2.5)
println(f(my_obj, 3.5))  # Выведет 7.0

7.0
  1. 在Python中调用类实例方法对应于在Julia中调用函数。
In [ ]: 
struct MyType
    x::Int
end

function f(obj::MyType, y)
    return obj.x + y
end

my_obj = MyType(10)
println(f(my_obj, 5))  # Выведет 15

15
  1. Julia中的结构只能有一个抽象超类型，而Python类可以从多个超类继承。
In [ ]: 
abstract type Animal end

struct Dog <: Animal
    name::String
end

struct Cat <: Animal
    name::String
end

dog = Dog("Buddy")
cat = Cat("Whiskers");
  1. 在Julia中，三元运算符是否写为x>0？ 1:-1，而Python在x>0else-1时使用条件表达式1。
In [ ]: 
x = 10
result = x > 0 ? 1 : -1
println(result)  # Выведет 1

1
  1. 在Julia中，异常处理是使用try-catch-finally构造来执行的，与Python中使用try-except-finally不同。
In [ ]: 
try
    # Код, который может вызвать исключение
catch ex
    # Обработка исключения
finally
    # Выполнение кода, который будет выполнен в любом случае
end

结论:

此示例演示了将Julia与Matlab和Python区分开来的主要语法和功能差异。