Управляющие конструкции Julia

Операторы управления потоком реализуются путем задания одного или нескольких условных операторов в программе. Когда условие истинно, выполняется указанный программный код; когда условие ложно, выполняется другой указанный код.

Julia предоставляет большое количество операторов управления потоком:

  • Составные выражения:beginи;。

  • Условные выражения:if-elseif-elseи?:(тернарный оператор).

  • Сокращённое вычисление:логические операторы&&(and) и||(or), а также цепочные сравнения.

  • Операторы циклов:циклы:whileиfor。

  • Обработка исключений:try-catch、errorиthrow。

  • Задача (корутина):yieldto。


Составные выражения

begin ... endВыражение может последовательно вычислить несколько подвыражений и вернуть значение последнего подвыражения:

Пример

julia> z = begin
           x = 1
           y = 2
           x + y
       end
3

Поскольку эти выражения очень короткие, их можно просто разместить в одной строке, что и является источником;цепочки:

Пример

julia> z = (x = 1; y = 2; x + y)
3

В реальном использовании не требуется, чтобы блок begin был многострочным, или чтобы цепочка с ; была однострочной:

Пример

julia> begin x = 1; y = 2; x + y end
3

julia> (x = 1;
        y = 2;
        x + y)
3

Условные выражения

Условное выражение может определить, какой блок кода выполнить, исходя из значения логического выражения.

Синтаксис if-elseif-else:

if boolean_expression 1
   /*Когда логическое выражение1истинно, выполнить*/
elseif boolean_expression 2
   /*Когда логическое выражение2истинно, выполнить*/
elseif boolean_expression 3
   /*Когда логическое выражение3истинно, выполнить*/
else
   /*Когда ни одно из вышеуказанных условий не истинно, выполнить*/

Инструкцияifможет сопровождаться необязательной инструкциейelse if...else, которую можно использовать для проверки нескольких условий.

При использовании операторов if...else if...else следует учитывать следующие моменты:

  • После if может следовать ноль или один else, причём else должен идти после всех else if.
  • После if может следовать ноль или более else if, и else if должны идти перед else.
  • Как только else if успешно совпадает, остальные else if или else не проверяются.

Ниже представлен анализ условного синтаксиса if-elseif-else:

Пример

if x < y
    println("x is less than y")
elseif x > y
    println("x больше y")
else
    println("x равно y")
end

Если выражение x < y истинно, выполняется соответствующий блок кода; в противном случае вычисляется условное выражение x > y. Если оно истинно, выполняется соответствующий блок кода; если ни одно выражение не истинно, выполняется блок кода else.

Пример

julia> function test(x, y)
           if x < y
               println("x is less than y")
           elseif x > y
               println("x больше y")
           else
               println("x равно y")
           end
       end
проверить (обобщённую функцию с 1 методом)

julia> test(1, 2)
x меньше y

julia> test(2, 1)
x больше y

julia> test(1, 1)
x равно y

Тернарный оператор

Тернарный оператор?:похож на синтаксис if-elseif-else:

a ? b : c

В?предыдущем выражении a — условное выражение. Если условие a истинно, тернарный оператор вычисляет выражение b до :; если условие a ложно, он выполняет выражение c после :.

Примечание:?и:Пробелы вокруг обязательны. Выражение вида a?b:c не является допустимым тернарным выражением (но переносы строк после ? и : разрешены).

Пример

julia> x = 1; y = 2;

julia> println(x < y ? "less than" : "not less than")
знак меньше

julia> x = 1; y = 0;

julia> println(x < y ? "less than" : "not less than")
не меньше

Если выражение x < y истинно, весь тернарный оператор выполняет строку "less than"; в противном случае он выполняет строку "not less than".

Цепочка и вложенность тернарных операторов:

Пример

julia> test(x, y) = println(x < y ? "x is less than y"    :
                            x > y ? "x is greater than y" : "x is equal to y")
проверить (обобщённую функцию с 1 методом)

julia> test(1, 2)
x меньше y

julia> test(2, 1)
x больше y

julia> test(1, 1)
x равно y

Для удобства цепочечной передачи значений операторы соединяются справа налево.

Подобно if-elseif-else, выражения до и после:выполняются соответствующим образом только тогда, когда условное выражение истинно или ложно:

Пример

julia> v(x) = (println(x); x)
v (обобщённая функция с 1 методом)

julia> 1 < 2 ? v("yes") : v("no")
да
"yes"

julia> 1 > 2 ? v("yes") : v("no")
нет
"no"

Сокращённое вычисление

В Julia операторы&&и||соответствуют логическим"и"и"или"операциям.

  • В выраженииa && b, подвыражениеbвыполняется только тогда, когдаaявляетсяtrue; если a ложно, возвращается непосредственно false.
  • В выраженииa || b, подвыражениеbвыполняется только тогда, когдаaявляетсяfalse; если a истинно, возвращается непосредственно a.

&& Пример

julia> isodd(3) && @warn("Нечётное число!")
┌ Предупреждение: Нечётное число!
└ @ Main REPL[5]:1

julia> isodd(4) && @warn("Нечётное число!")
false

|| Пример

julia> isodd(3) || @warn("Нечётное число!")
истина

julia> isodd(4) || @warn("Нечётное число!")
┌ Предупреждение: Нечётное число!
└ @ Main REPL[8]:1

Оба оператора && и || зависят от правой стороны, но && имеет более высокий приоритет, чем ||. См. пример:

Пример

julia> t(x) = (println(x); true)
t (обобщённая функция с 1 методом)

julia> f(x) = (println(x); false)
f (обобщённая функция с 1 методом)

julia> t(1) && t(2)
1
2
истина

julia> t(1) && f(2)
1
2
false

julia> f(1) && t(2)
1
false

julia> f(1) && f(2)
1
false

julia> t(1) || t(2)
1
истина

julia> t(1) || f(2)
1
истина

julia> f(1) || t(2)
1
2
истина

julia> f(1) || f(2)
1
2
false

Операторы циклов

Операторы цикла используютwhileиforдва ключевых слова для реализации.

Ниже приведён пример циклаwhile:

Пример

julia> i = 1;

julia> while i <= 5
           println(i)
           global i += 1
       end
1
2
3
4
5

Цикл while вычисляет условное выражение (i <= 5). Пока оно истинно, он продолжает выполнять тело цикла while. Когда условное выражение ложно, то есть когда i = 6, цикл завершается.

Цикл for удобнее в использовании. Приведённый выше пример, реализованный с помощью цикла for, выглядит так:

Пример

julia> for i = 1:5
           println(i)
       end
1
2
3
4
5

Здесь1:5— объект диапазона, представляющий последовательность чисел 1, 2, 3, 4, 5.

Цикл for выполняет итерации по этим значениям, присваивая каждое значение переменной i.

Очень важное различие между циклом for и предыдущим циклом while — это область видимости, то есть видимость переменных. Если переменная i не была введена в другой области видимости, внутри цикла for она видна только в пределах цикла for и не видна снаружи или после него. Чтобы проверить эту особенность, вам нужен новый экземпляр интерактивного сеанса или новое имя переменной:

Пример

julia> for j = 1:5
           println(j)
       end
1
2
3
4
5

julia> j
ERROR: UndefVarError: j not defined

В целом компоненты цикла for можно использовать для итерации по любому контейнеру. В этом случае по сравнению с = другое (но полностью идентичное) ключевое словоinor∈используется чаще, потому что оно делает код более понятным:

Пример

julia> for i in [1,4,0]
           println(i)
       end
1
4
0

julia> for s ∈ ["foo","bar","baz"]
           println(s)
       end
foo
bar
baz

Для удобства мы можем завершить цикл while до того, как проверяемое условие станет ложным, или остановить цикл for до достижения конца итерируемого объекта. Это можно сделать с помощью ключевого словаbreak:

Пример

julia> i = 1;

julia> while true
           println(i)
           if i >= 5
               break
           end
           global i += 1
       end
1
2
3
4
5

julia> for j = 1:1000
           println(j)
           if j >= 5
               break
           end
       end
1
2
3
4
5

Без ключевого слова break цикл while выше никогда бы не завершился сам по себе, а цикл for выполнял бы итерации до 1000. Все эти циклы могут использовать break для досрочного завершения.

В некоторых сценариях необходимо напрямую завершить текущую итерацию и немедленно перейти к следующей. Для этого можно использовать ключевое словоcontinue:

Пример

julia> for i = 1:10
           if i % 3 != 0
               continue
           end
           println(i)
       end
3
6
9

Это несколько надуманный пример, потому что той же функциональности можно было бы достичь более кратко, инвертировав условие и поместив вызов println внутрь блока if. В практических приложениях после continue выполняется больше кода, и continue может вызываться в нескольких местах.

Несколько вложенных циклов for можно объединить в один внешний цикл, который можно использовать для создания декартова произведения их итерируемых объектов:

Пример

julia> for i = 1:2, j = 3:4
           println((i, j))
       end
(1, 3)
(1, 4)
(2, 3)
(2, 4)

С этим синтаксисом переменные итерации по-прежнему можно нормально использовать вместе с переменными цикла для индексации. Например,for i = 1:n, j = 1:iдопустимо, но использование оператора break внутри одного цикла приведёт к выходу из всего вложенного цикла, а не только из внутреннего. Каждый раз, когда выполняется внутренний цикл, переменным (i и j) присваиваются их текущие значения итерации. Поэтому присваивания i не видны последующим итерациям:

Пример

julia> for i = 1:2, j = 3:4
           println((i, j))
           i = 0
       end
(1, 3)
(1, 4)
(2, 3)
(2, 4)

Если этот пример переписать, используя ключевое слово for для каждой переменной, вывод будет другим: вторая и четвёртая переменные содержат 0.

Можно использовать zip для одновременного перебора нескольких контейнеров в одном цикле for:

Пример

julia> for (j, k) in zip([1 2 3], [4 5 6 7])
           println((j,k))
       end
(1, 4)
(2, 5)
(3, 6)

julia> for x in zip(0:15, 100:110, 200:210)
               println(x)
            end
(0, 100, 200)
(1, 101, 201)
(2, 102, 202)
(3, 103, 203)
(4, 104, 204)
(5, 105, 205)
(6, 106, 206)
(7, 107, 207)
(8, 108, 208)
(9, 109, 209)
(10, 110, 210)

// Обработка несовпадающего количества элементов
julia> for x in zip(0:10, 100:115, 200:210)
               println(x)
            end
(0, 100, 200)
(1, 101, 201)
(2, 102, 202)
(3, 103, 203)
(4, 104, 204)
(5, 105, 205)
(6, 106, 206)
(7, 107, 207)
(8, 108, 208)
(9, 109, 209)
(10, 110, 210)

Использование zip создаёт итератор, который представляет собой кортеж подытераторов для переданных ему контейнеров. Итератор zip перебирает все подытераторы по порядку, выбирая ii-й элемент каждого подытератора на ii-й итерации цикла for. Как только любой подытератор исчерпывается, цикл for останавливается.

Операторы for могут вкладывать несколько условий цикла, используя запятые,для разделения:

Пример

julia> for n in 1:5, m in 1:5
                  @show (n, m)
               end
(n, m) = (1, 1)
(n, m) = (1, 2)
(n, m) = (1, 3)
(n, m) = (1, 4)
(n, m) = (1, 5)
(n, m) = (2, 1)
(n, m) = (2, 2)
(n, m) = (2, 3)
(n, m) = (2, 4)
(n, m) = (2, 5)
(n, m) = (3, 1)
(n, m) = (3, 2)
(n, m) = (3, 3)
(n, m) = (3, 4)
(n, m) = (3, 5)
(n, m) = (4, 1)
(n, m) = (4, 2)
(n, m) = (4, 3)
(n, m) = (4, 4)
(n, m) = (4, 5)
(n, m) = (5, 1)
(n, m) = (5, 2)
(n, m) = (5, 3)
(n, m) = (5, 4)
(n, m) = (5, 5)

Генераторы

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

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

[выражениеforпеременнаяinсписок]
[out_exp_res for out_exp in input_list]

или

[выражениеforпеременнаяinсписокifcondition]
[out_exp_res for out_exp in input_list if condition]


Пример

julia> [X^2 for X in 1:5]
5-элементный Array{Int64,1}:
 1
 4
 9
 16
 25

Мы также можем указать тип элементов, которые хотим сгенерировать:

Пример

julia> Complex[X^2 for X in 1:5]
5-элементный Array{Complex,1}:
 1 + 0im
 4 + 0im
 9 + 0im
 16 + 0im
 25 + 0im

Обход массивов

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

Julia предоставляет функциюenumerate(iter); параметрiterявляется итерируемым объектом. Эта функция будет генерировать номера индексов, а также значение, соответствующее каждому индексу.

Пример

julia> a = ["a", "b", "c"];

julia> for (index, value) in enumerate(a)
           println("$index $value")
       end
1 a
2 b
3 c

julia> arr = rand(0:9, 4, 4)
4×4 Array{Int64,2}:
 7 6 5 8
 8 6 9 4
 6 3 0 7
 2 3 2 4
 
julia> [x for x in enumerate(arr)]
4×4 Array{Tuple{Int64,Int64},2}:
 (1, 7) (5, 6) (9, 5) (13, 8)
 (2, 8) (6, 6) (10, 9) (14, 4)
 (3, 6) (7, 3) (11, 0) (15, 7)
 (4, 2) (8, 3) (12, 2) (16, 4)

Обработка исключений

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

С помощьюtry / catch-конструкции исключения можно удобно обрабатывать.

Например, в приведённом ниже коде функция квадратного корня sqrt вызывает исключение. С помощью try / catch мы можем точно вывести информацию об исключении.

Пример

julia> try
         sqrt("ten")
       catch e
         println("Вам нужно ввести число")
       end
Вам нужно ввести число

Конструкция finally

При программировании с изменениями состояния или при использовании таких ресурсов, как файлы, часто необходимо выполнять очистку (например, закрывать файлы) при завершении кода. Поскольку исключения могут приводить к выходу из некоторых блоков кода до их нормального завершения, это может усложнить вышеописанную работу. Ключевое слово finally предоставляет способ выполнить определённый фрагмент кода при выходе из блока кода, независимо от того, как он завершается.

Вот пример, который гарантирует, что открытый файл будет закрыт:

Пример

f = open("file")
try
    # операции с файлом f
finally
    close(f)
end

Когда поток управления покидает блок try (например, при встрече return или при его нормальном завершении), будет выполнен close(f). Если блок try завершается из-за исключения, исключение продолжает распространяться. Блок catch можно использовать вместе с try и finally. В этом случае блок finally выполняется после того, как catch обработает ошибку.

Функция throw

Мы можем использовать throw для явного создания исключений.

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

Пример

julia> f(x) = x>=0 ? exp(-x) : throw(DomainError(x, "argument must be nonnegative"))
f (обобщённая функция с 1 методом)

julia> f(1)
0.36787944117144233

julia> f(-1)
ОШИБКА: DomainError с -1:
аргумент должен быть неотрицательным
Трассировка стека:
 [1] f(::Int64) в ./none:1

Обратите внимание, что DomainError без скобок — это не исключение, а тип исключения. Чтобы получить объект Exception, его нужно вызвать:

Пример

julia> typeof(DomainError(nothing)) <: Exception
истина

julia> typeof(DomainError) <: Exception
false

Кроме того, некоторые типы исключений принимают один или несколько аргументов для сообщения об ошибке:

Пример

julia> throw(UndefVarError(:x))
ОШИБКА: UndefVarError: x не определена

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

Пример

julia> struct MyUndefVarError <: Exception
           var::Symbol
       end

julia> Base.showerror(io::IO, e::MyUndefVarError) = print(io, e.var, " не определено")

Задача (сопрограмма)

Задача (сопрограмма) обеспечивает нелокальное управление потоком, что позволяет переключаться между временно приостановленными вычислительными задачами. Мы подробно рассмотрим это в следующей главе об асинхронном программировании.

Другие расширения