Функции в Julia
Функция — это набор инструкций, которые вместе выполняют задачу.
В Julia функция — это объект, который отображает кортеж значений аргументов в возвращаемое значение.
В Julia используйтеfunction. Базовый синтаксис определения функции:
function functionname(args) expression expression expression ... expression end
По умолчанию значение, возвращаемое функцией, — это значение последнего вычисленного выражения, поэтому, как видно выше, нет оператораreturn. Конечно, если вы используете ключевое словоreturn, функция немедленно вернёт значение:.
Пример
x + y
end
f (обобщённая функция с 1 методом)
julia> f(2,3)
5
julia> function bills(money)
if money < 0
return false
else
return true
end
end
bills (generic function with 1 method)
julia> bills(50)
истина
julia> bills(-50)
false
Если функция должна вернуть несколько значений, можно использовать кортеж:
Пример
x+y, x*y
end
mul (обобщённая функция с 1 методом)
julia> mul(5, 10)
(15, 50)
Когда функция содержит только одно выражение, можно опустить ключевое словоfunction, задать имя функции и параметры в левой части знака равенства, а выражение — в правой, подобно форме присваивания:
julia> f(x,y) = x + y f (generic function with 1 method)
Когда нет круглых скобок, выражениеfссылается на объект функции, который можно передавать как любое значение:
julia> g = f; julia> g(2,3) 5
Пример
f (обобщённая функция с 1 методом)
julia> f(5)
25
julia> func(x, y) = sqrt(x^2 + y^2)
func (обобщённая функция с 1 методом)
julia> func(5, 4)
6.4031242374328485
Как и имена переменных, символы Unicode также можно использовать в качестве имён функций:
julia> ∑(x,y) = x + y ∑ (generic function with 1 method) julia> ∑(2, 3) 5
Тип возвращаемого значения
Мы можем использовать::оператор, чтобы указать возвращаемый тип функции.
Пример
return x * y
end;
julia> typeof(g(1, 2))
Int8
Приведенный выше пример функции игнорирует типы x и y и возвращает значение типа Int8.
Необязательные аргументы
В функциях мы можем задавать значения по умолчанию для параметров, так что если параметр не передан, для вычисления можно использовать значение по умолчанию:
В следующем примере определяется функция pos с тремя параметрами, где параметр cz имеет значение по умолчанию 0. При вызове функции этот параметр можно опустить:
Пример
println("$ax, $by, $cz")
end
pos (обобщенная функция с 2 методами)
julia> pos(10, 30)
10, 30, 0
julia> pos(10, 30, 50)
10, 30, 50
Именованные аргументы
Иногда функции, которые мы определяем, требуют большого числа аргументов, но вызов этих функций может быть затруднительным, поскольку мы можем забыть порядок, в котором нужно передавать аргументы. Например:
...
end
Мы можем забыть порядок аргументов, в результате чего получится следующий вызов функции:
foo("25", -5.6987, "hello", 56, good, 'ABC')
或
foo("hello", 56, "25", -5.6987, 'ABC', good)
Это выглядит очень запутанно.
Ключевые аргументы Julia позволяют идентифицировать аргументы по имени, а не только по позиции, что делает такие сложные функции простыми в использовании и расширении.
Чтобы пометить аргументы ключевыми словами, нужно использовать точку с запятой после непомеченных аргументов функции;, за которой следует одна или несколько пар ключ-значениеkey=value, как показано ниже:
Пример
println("a is $a")
println("b is $b")
return "c => $c, d => $d"
end
foo (generic function with 1 method)
julia> foo(100,20)
a is 100
b is 20
"c => 10, d => hi"
julia> foo("Hello", "Example", c=pi, d=22//7)
a is Hello
b is Example
"c => π, d => 22//7"
С именованными аргументами позиция аргументов не так важна. Мы также можем вызвать вышеприведённую функцию так:
Пример
a is Hello
b is Example
"c => π, d => 3.142857142857143"
Анонимные функции
Анонимная функция — это функция без имени.
Анонимные функции объявляются динамически во время выполнения. Помимо отсутствия имени, они такие же, как стандартные функции.
В Julia анонимные функции можно использовать во многих местах, например в map() и генераторах списков.
После использования анонимных функций наш код становится более лаконичным.
Синтаксис анонимных функций использует символ->。
Пример
#1 (generic function with 1 method)
julia> function (x)
x^2 + 2x - 1
end
#3 (generic function with 1 method)
Приведённый выше пример создаёт функцию, которая принимает один параметрxи возвращает многочлен от текущего значенияx^2+2x-1функции.
Основное использование анонимных функций — передавать их функциям, которые принимают функции в качестве аргументов. Классический пример — map, который применяет функцию к каждому элементу массива, а затем возвращает новый массив, содержащий полученные значения:
Пример
3-элементный Vector{Float64}:
1.0
4.0
2.0
Если функция преобразования, переданная в качестве первого аргумента в map, уже существует, то можно использовать её имя напрямую. Но обычно функция, которую нужно использовать, ещё не определена, поэтому удобнее использовать анонимную функцию:
Пример
3-элементный Vector{Int64}:
2
14
-2
Анонимные функции, принимающие несколько аргументов, можно записывать с помощью синтаксиса (x,y,z)->2x+y-z, а анонимные функции без аргументов записываются как ()->3. Такой способ записи функций без аргументов может показаться немного странным, но он очень необходим для ленивых вычислений. Это использование оборачивает блок кода в функцию без аргументов и позже вызывает её как f.
Например, рассмотрим вызов get:
Пример
# значение по умолчанию вычисляется здесь
time()
end
Приведённый выше код эквивалентен вызову get с анонимной функцией, содержащей этот код. Он заключён между do и end, как показано ниже:
get(()->time(), dict, key)
Здесь вызов time откладывается за счёт оборачивания его в анонимную функцию без аргументов. Эта анонимная функция вызывается только тогда, когда в dict отсутствует запрошенный ключ.
Вложенность функций и рекурсия
В Julia функции могут быть вложенными.
В следующем примере функция add1 вложена в функцию add():
Пример
Y = x * 2
function add1(Y)
Y += 1
end
add1(Y)
end
add (generic function with 1 method)
julia> d = 10
10
julia> add(d)
21
Аналогично, функции в Julia также могут быть рекурсивными.
Рекурсия — это метод использования самой функции внутри определения функции.
Например:
Жила-была гора, в горе был храм, в храме старый монах рассказывал молодому монаху историю! Что это была за история? "Жила-была гора, в горе был храм, в храме старый монах рассказывал молодому монаху историю! Что это была за история? 'Жила-была гора, в горе был храм, в храме старый монах рассказывал молодому монаху историю! Что это была за история? ...'"
Ниже мы используем тернарный оператор для проверки рекурсии. Тернарный оператор работает с тремя операндамиexpr ? a : b, если expr истинно, значением является результат вычисления a, иначе — результат вычисления b.
Пример
sum (generic function with 1 method)
julia> sum(10)
55
Приведённый выше пример используется для вычисления суммы всех чисел до некоторого целого числа включительно. В этой рекурсии, поскольку есть базовый случай, то есть когда x равно 1, возвращается это значение.
Самый известный пример рекурсии — вычисление n-го числа Фибоначчи. Последовательность Фибоначчи — это такая последовательность: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368........
Начиная с 3-го члена, каждый член этой последовательности равен сумме двух предыдущих членов.
Пример
fib (generic function with 1 method)
julia> fib(10)
55
julia> fib(20)
6765
Map
Формат определения Map следующий:
map(func, coll)
Здесь func — это функция, которая по очереди применяется к каждому элементу коллекции coll. Map обычно содержит анонимную функцию и возвращает новую коллекцию.
Пример
3-элементный Array{Int64,1}:
1027
33
-17
Filter
Формат определения Filter следующий:
filter(function, collection)
Функция filter возвращает копию коллекции, удаляя элементы, для которых результат вызова функции равен false.
Пример
3-элементный Array{Int64,1}:
1
2
3
julia> filter(x -> x % 2 == 0, array)
1-элементный Array{Int64,1}:
2