Примечательные отличия от других языков¶
Хотя пользователям MATLAB синтаксис Julia может показаться знакомым, Julia не является клоном MATLAB. Между ними есть важные синтаксические и функциональные различия. Ниже перечислены некоторые примечательные отличия Julia, которые могут сбить с толку пользователей, привыкших к MATLAB.
Отличия от матлаб¶
- Индексы массивов в Julia указываются в квадратных скобках: A[i,j].
In [ ]:
A = [1 2 3; 4 5 6; 7 8 9]
i = 2
j = 3
element = A[i, j]
println(element)
- Когда массив в Julia присваивается другой переменной, он не копируется. После присваивания A = B изменение элементов B приведет к их изменению в A.
In [ ]:
B = [1, 2, 3]
A = B
B[1] = 10
println(A)
- В Julia значения, передаваемые в функцию, не копируются. Если функция изменяет массив, эти изменения будут видны вызывающей стороне.
In [ ]:
function modify_array(arr)
arr[1] = 100
end
A = [1, 2, 3]
modify_array(A)
println(A)
- В 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] = 7 выдает ошибку, если длина a меньше 5 или если имя a впервые используется в этом операторе. В Julia есть функции push! и append!, которые позволяют увеличивать объекты типа Vector гораздо эффективнее, чем a(end+1) = val в MATLAB.
In [ ]:
A = [1, 2, 3]
push!(A, 4)
println(A)
B = [5, 6, 7]
append!(B, [8, 9])
println(B)
- Мнимая единица sqrt(-1) представлена в Julia константой im, а не i или j, как в MATLAB.
In [ ]:
z = 2 + 3im
println(z)
println("Действительная часть: ", real(z))
println("Мнимая часть: ", imag(z))
- В Julia числовые литералы без десятичного разделителя (например, 42) создают целые числа, а не числа с плавающей запятой. В результате некоторые операции могут приводить к ошибке выхода за пределы области, если они ожидают число с плавающей запятой. Например, julia> a = -1; 2^a выдаст такую ошибку, так как результат не целочисленный (подробные сведения см. в разделе FAQ об ошибках выхода за пределы области).
In [ ]:
a = 42 # целое число
b = 42.0 # число с плавающей запятой
c = float(42) # явное преобразование к типу Float64
println(a)
println(b)
println(c)
- Если в 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)
- В Julia есть истинные одномерные массивы. Векторы столбцов имеют размер N, а не Nx1. Например, выражение rand(N) создает одномерный массив.
In [ ]:
v = [1, 2, 3] # одномерный массив
Out[0]:
- В 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)
- В 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)
- Функции в Julia возвращают результат вычисления последнего выражения или выражения с ключевым словом return. Перечислять имена возвращаемых переменных в определении функции не нужно (подробные сведения см. в разделе Ключевое слово return).
In [ ]:
function sum(x, y)
x + y
end
result = sum(2, 3)
println(result)
- В Julia при вызове функции без аргументов необходимо использовать круглые скобки, например rand().
In [ ]:
function example()
println("Функция без аргументов")
end
example()
- В Julia не рекомендуется ставить точку с запятой в конце выражений. Результаты выражений не выводятся на экран автоматически (кроме как в интерактивной командной строке), поэтому строки кода нет необходимости заканчивать точкой с запятой. Для вывода на экран определенных данных можно использовать функцию println или макрос @printf.
In [ ]:
a = 2
b = 3
c = a + b
println(c)
- В Julia, если A и B — массивы, операции логического сравнения, такие как A == B, не возвращают массив логических значений. Вместо этого используйте A .== B или аналогичные выражения для других логических операторов, таких как < и >.
In [ ]:
A = [1, 2, 3]
B = [2, 2, 3]
result = A .== B
println(result)
- В Julia операторы &, | и ⊻ (xor) выполняются побитово, так же, как, соответственно, and, or и xor в MATLAB. Их приоритет такой же, как у побитовых операторов в Python (но не такой, как в C). Они могут применяться к скалярным значениям или поэлементно к массивам, а также использоваться для объединения логических массивов. Однако обратите внимание на различие в очередности операций: могут потребоваться круглые скобки (например, для выбора элементов A, равных 1 или 2, используйте выражение (A .== 1) .| (A .== 2)).
In [ ]:
a = 5
b = 3
result = a & b
println(result)
A = [true, false, true]
B = [false, true, true]
result = A .& B
println(result)
- В 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)
- Функция svd в Julia возвращает сингулярные значения в виде вектора, а не плотной диагональной матрицы.
In [ ]:
using LinearAlgebra
A = [1 2; 3 4]
U, S, V = svd(A)
println(S)
- В Julia символ ... не применяется для продолжения строк кода. Вместо этого неполное выражение автоматически продолжается в следующей строке.
In [ ]:
a = 2 +
3
println(a)
- Структуры (struct) в Julia не поддерживают динамическое добавление полей во время выполнения, в отличие от классов (class) в MATLAB. Вместо этого используйте 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])
- В Julia каждый модуль имеет собственную глобальную область или пространство имен, в то время как в MATLAB глобальная область только одна.
In [ ]:
module MyModule
global_var = 10
function my_function()
println(global_var)
end
end
MyModule.my_function()
- В MATLAB идиоматическим способом удаления ненужных значений является использование логического индексирования, как в выражении x(x>3) или в операторе x(x>3) = [] для изменения x на месте. В Julia с этой целью предоставляются функции более высокого порядка filter и filter!, которые позволяют использовать выражения filter(z->z>3, x) и filter!(z->z>3, x) в качестве альтернативы для x[x.>3] и x = x[x.>3]. Функция filter! позволяет реже прибегать к временным массивам.
In [ ]:
A = [1, 2, 3, 4, 5]
filtered_A = filter(x -> x > 3, A)
println(filtered_A)
filter!(x -> x > 3, A)
println(A)
- Извлечение (или «разыменование») всех элементов массива ячеек, например vertcat(A{:}) в MATLAB, записывается в Julia с помощью оператора расширения (splat-оператор), например 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)
- В Julia функция adjoint производит сопряженное транспонирование; в MATLAB adjoint предоставляет присоединенную матрицу (классическое сопряжение), то есть выполняет транспонирование матрицы алгебраических дополнений.
In [ ]:
A = [1+2im 3+4im]
adj_A = adjoint(A)
println(adj_A)
- В Julia выражение (a ^ b ^ c) вычисляется как a^ (b^c), в то время как в MATLAB — как (a ^ b) ^ c.
In [ ]:
a = 3
b = 2
c = 3
result = a^(b^c)
println(result)
Отличия от Python¶
- В Julia блоки for, if, while и т. д. заканчиваются ключевым словом end, а не отступом, как в Python. Нет ключевого слова pass.
In [ ]:
for i in 1:5
println(i)
end
- В Julia строки обозначаются двойными кавычками, используются для многострочных текстов три пары двойных кавычек. Также, для символов используются одинарные кавычки.
In [ ]:
str1 = "Hello, World!"
str2 = """Это много-
строчный текст."""
char1 = 'c'
Out[0]:
- В Julia для конкатенации строк используется оператор *, а не +, как в Python. Для повтора строк используется оператор ^, а не *.
In [ ]:
str1 = "Hello, "
str2 = "World!"
concatenated_str = str1 * str2
repeated_str = str2 ^ 3
println(concatenated_str)
println(repeated_str)
- В Julia списки соответствуют типу Vector{Any} или более общему типу Vector{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]:
- Индексирование массивов в Julia начинается с единицы, в отличие от Python, где индексация начинается с нуля.
In [ ]:
array = [1, 2, 3, 4, 5]
println(array[1]) # Выведет 1
- При индексировании срезов в Julia последний элемент включается, в отличие от Python. a[2:3] в Julia эквивалентно a[1:3] в Python.
In [ ]:
array = [1, 2, 3, 4, 5]
println(array[2:3]) # Выведет [2, 3]
- В 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
- Для индексирования до последнего элемента в Julia используется ключевое слово end. x[1:] в Python эквивалентно x[2:end] в Julia.
In [ ]:
array = [1, 2, 3, 4, 5]
println(array[2:end]) # Выведет [2, 3, 4, 5]
- В Julia индексирование диапазона имеет формат x[start:step:stop], а в Python - x[start:(stop+1):step]. Поэтому x[0:10:2] в Python эквивалентно x[1:2:10] в Julia.
In [ ]:
array = [1, 2, 3, 4, 5]
println(array[1:2:end]) # Выведет [1, 3, 5]
- В Julia отсутствует синтаксис продолжения строк. Если строка содержит полноценное выражение, то она считается завершенной. В противном случае строка продолжается. Для продолжения выражения можно использовать круглые скобки.
In [ ]:
a = (
1 + 2 +
3
)
println(a) # Выведет 6
- В 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
- В Julia значения по умолчанию аргументов функции вычисляются при каждом вызове метода, в отличие от Python, где значения вычисляются только при определении функции.
In [ ]:
function f(x = rand())
return x
end;
In [ ]:
println(f()) # Выполните ячейку несколько раз
- В 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
- В Julia тип Int соответствует машинному целочисленному типу (Int32 или Int64), в то время как в Python int может иметь произвольную длину.
In [ ]:
x = Int64(2) ^ Int64(64)
println(x) # Выведет 0
- Мнимая единица в Julia представлена константой im, в то время как в Python используется j.
In [ ]:
println(2im) # Выведет 0 + 2im
- В Julia оператор возведения в степень обозначается ^, а не **, как в Python.
In [ ]:
println(2 ^ 3) # Выведет 8
- Пустое значение в Julia обозначается константой nothing типа Nothing, в то время как в Python используется объект None типа NoneType.
In [ ]:
x = nothing
println(x) # Выведет nothing
- В Julia оператор * выполняет матричную операцию, в то время как в Python выполняется поэлементное умножение. В Julia для поэлементного умножения используется оператор .*.
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]
- В Julia оператор ' возвращает сопряжение вектора, в то время как оператор транспонирования .T в Python возвращает исходный вектор.
In [ ]:
x = [1 2 3]
println(x') # Выведет [1; 2; 3]
- В 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"
- В 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
- Вызов метода экземпляра класса в 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
- Структура в 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");
- В Julia тернарный оператор записывается как x > 0 ? 1 : -1, в то время как в Python используется условное выражение 1 if x > 0 else -1.
In [ ]:
x = 10
result = x > 0 ? 1 : -1
println(result) # Выведет 1
- В Julia обработка исключений осуществляется с помощью конструкции try-catch-finally, в отличие от Python, где используется try-except-finally.
In [ ]:
try
# Код, который может вызвать исключение
catch ex
# Обработка исключения
finally
# Выполнение кода, который будет выполнен в любом случае
end
Вывод:¶
В данном примере были продемонстрированы основные синтаксические и функциональные различия, отличающие Julia от Matlab и Python.