Функции в Julia

Функция — это набор инструкций, которые вместе выполняют задачу.

В Julia функция — это объект, который отображает кортеж значений аргументов в возвращаемое значение.

В Julia используйтеfunction. Базовый синтаксис определения функции:

function functionname(args)
   expression
   expression
   expression
   ...
   expression
end

По умолчанию значение, возвращаемое функцией, — это значение последнего вычисленного выражения, поэтому, как видно выше, нет оператораreturn. Конечно, если вы используете ключевое словоreturn, функция немедленно вернёт значение:.

Пример

julia> function f(x,y)
           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

Если функция должна вернуть несколько значений, можно использовать кортеж:

Пример

julia> function mul(x,y)
                  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

Пример

julia> f(a) = a * a
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

Тип возвращаемого значения

Мы можем использовать::оператор, чтобы указать возвращаемый тип функции.

Пример

julia> function g(x, y)::Int8
           return x * y
       end;

julia> typeof(g(1, 2))
Int8

Приведенный выше пример функции игнорирует типы x и y и возвращает значение типа Int8.

Необязательные аргументы

В функциях мы можем задавать значения по умолчанию для параметров, так что если параметр не передан, для вычисления можно использовать значение по умолчанию:

В следующем примере определяется функция pos с тремя параметрами, где параметр cz имеет значение по умолчанию 0. При вызове функции этот параметр можно опустить:

Пример

julia> function pos(ax, by, cz=0)
         println("$ax, $by, $cz")
      end
pos (обобщенная функция с 2 методами)

julia> pos(10, 30)
10, 30, 0

julia> pos(10, 30, 50)
10, 30, 50

Именованные аргументы

Иногда функции, которые мы определяем, требуют большого числа аргументов, но вызов этих функций может быть затруднительным, поскольку мы можем забыть порядок, в котором нужно передавать аргументы. Например:

function foo(a, b, c, d, e, f)
...
end

Мы можем забыть порядок аргументов, в результате чего получится следующий вызов функции:

foo("25", -5.6987, "hello", 56, good, 'ABC')
或
foo("hello", 56, "25", -5.6987, 'ABC', good)

Это выглядит очень запутанно.

Ключевые аргументы Julia позволяют идентифицировать аргументы по имени, а не только по позиции, что делает такие сложные функции простыми в использовании и расширении.

Чтобы пометить аргументы ключевыми словами, нужно использовать точку с запятой после непомеченных аргументов функции;, за которой следует одна или несколько пар ключ-значениеkey=value, как показано ниже:

Пример

julia> function foo(a, b ; c = 10, d = "hi")
         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"

С именованными аргументами позиция аргументов не так важна. Мы также можем вызвать вышеприведённую функцию так:

Пример

julia> foo(c=pi, d =22/7, "Hello", "Example")
a is Hello
b is Example
"c => π, d => 3.142857142857143"

Анонимные функции

Анонимная функция — это функция без имени.

Анонимные функции объявляются динамически во время выполнения. Помимо отсутствия имени, они такие же, как стандартные функции.

В Julia анонимные функции можно использовать во многих местах, например в map() и генераторах списков.

После использования анонимных функций наш код становится более лаконичным.

Синтаксис анонимных функций использует символ->。

Пример

julia> x -> x^2 + 2x - 1
#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, который применяет функцию к каждому элементу массива, а затем возвращает новый массив, содержащий полученные значения:

Пример

julia> map(round, [1.2, 3.5, 1.7])
3-элементный Vector{Float64}:
 1.0
 4.0
 2.0

Если функция преобразования, переданная в качестве первого аргумента в map, уже существует, то можно использовать её имя напрямую. Но обычно функция, которую нужно использовать, ещё не определена, поэтому удобнее использовать анонимную функцию:

Пример

julia> map(x -> x^2 + 2x - 1, [1, 3, -1])
3-элементный Vector{Int64}:
  2
 14
 -2

Анонимные функции, принимающие несколько аргументов, можно записывать с помощью синтаксиса (x,y,z)->2x+y-z, а анонимные функции без аргументов записываются как ()->3. Такой способ записи функций без аргументов может показаться немного странным, но он очень необходим для ленивых вычислений. Это использование оборачивает блок кода в функцию без аргументов и позже вызывает её как f.

Например, рассмотрим вызов get:

Пример

get(dict, key) do
    # значение по умолчанию вычисляется здесь
    time()
end

Приведённый выше код эквивалентен вызову get с анонимной функцией, содержащей этот код. Он заключён между do и end, как показано ниже:

get(()->time(), dict, key)

Здесь вызов time откладывается за счёт оборачивания его в анонимную функцию без аргументов. Эта анонимная функция вызывается только тогда, когда в dict отсутствует запрошенный ключ.


Вложенность функций и рекурсия

В Julia функции могут быть вложенными.

В следующем примере функция add1 вложена в функцию add():

Пример

julia> function add(x)
         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.

Пример

julia> sum(x) = x > 1 ? sum(x-1) + x : x
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-го члена, каждый член этой последовательности равен сумме двух предыдущих членов.

Пример

julia> fib(x) = x < 2 ? x : fib(x-1) + fib(x-2)
fib (generic function with 1 method)

julia> fib(10)
55

julia> fib(20)
6765

Map

Формат определения Map следующий:

map(func, coll)

Здесь func — это функция, которая по очереди применяется к каждому элементу коллекции coll. Map обычно содержит анонимную функцию и возвращает новую коллекцию.

Пример

julia> map(A -> A^3 + 3A - 3, [10,3,-2])
3-элементный Array{Int64,1}:
 1027
   33
  -17

Filter

Формат определения Filter следующий:

filter(function, collection)

Функция filter возвращает копию коллекции, удаляя элементы, для которых результат вызова функции равен false.

Пример

julia> array = Int[1,2,3]
3-элементный Array{Int64,1}:
 1
 2
 3
 
julia> filter(x -> x % 2 == 0, array)
1-элементный Array{Int64,1}:
 2
Другие расширения