Переменные · Язык Julia

Переменная в Julia — это имя, связанное (или связанное) со значением. Это полезно, когда вы хотите сохранить значение (например, полученное после некоторой математики) для дальнейшего использования. Например:

  # Присвойте значение 10 переменной x
Юлия> х = 10
10

# Выполнение математики со значением x
Юлия> x + 1
11

# Переназначить значение x
Юлия> х = 1 + 1
2

# Вы можете назначать значения других типов, например строки текста
julia> x = "Hello World!"
"Привет мир!"  

Julia предоставляет чрезвычайно гибкую систему именования переменных.Имена переменных чувствительны к регистру и не имеют семантического значения (то есть язык не будет обрабатывать переменные по-разному в зависимости от их имен).

  юлия> x = 1.0
1.0

Юлия> у = -3
-3

julia> Z = "Моя строка"
"Моя строка"

julia> customary_phrase = "Привет, мир!"
"Привет мир!"

julia> UniversalDeclarationOfHumanRightsStart = "人 人生 而 自由 ， 在 尊严 和 权利 上 一律 平等。"
"人 人生 而 自由 ， 在 尊严 和 权利 上 一律 平等。"  

Разрешены имена Unicode (в кодировке UTF-8):

  julia> δ = 0.(2)  -  вкладка . (Если вы где-то найдете символ, например, в чужом коде, который вы не умеете набирать, справка REPL скажет вам: просто введите ? , а затем вставьте символ.) 
 
 Джулия даже позволит вам при необходимости переопределите встроенные константы и функции (хотя это не рекомендуется во избежание возможных недоразумений): 
 
  julia> pi = 3
3

Юлия> пи
3

Юлия> sqrt = 4
4  
 Однако, если вы попытаетесь переопределить встроенную константу или функцию, которая уже используется, Джулия выдаст вам ошибку:
  julia> pi
π = 3.1415926535897 ...

Юлия> пи = 3
ОШИБКА: невозможно присвоить значение переменной MathConstants.pi из модуля Main

Юлия> sqrt (100)
10.0

Юлия> sqrt = 4
ОШИБКА: невозможно присвоить значение переменной Base.sqrt из модуля Main  
 Имена переменных должны начинаться с буквы (A-Z или a-z), подчеркивания или подмножества кодовых точек Unicode больше 00A0; в частности, категории символов Unicode Lu / Ll / Lt / Lm / Lo / Nl (буквы), Sc / So (валюта и другие символы) и несколько других буквоподобных символов (e.г. подмножество математических символов Sm). Последующие символы также могут включать! и цифры (0-9 и другие символы в категориях Nd / No), а также другие кодовые точки Unicode: диакритические знаки и другие модифицирующие знаки (категории Mn / Mc / Me / Sk), некоторые соединители пунктуации (категория Pc), простые числа, и еще несколько персонажей.
 Операторы, такие как  + , также являются допустимыми идентификаторами, но анализируются особым образом. В некоторых контекстах операторы могут использоваться как переменные; например  (+)  относится к функции сложения, а  (+) = f  переназначит ее.Большинство инфиксных операторов Unicode (в категории Sm), например  ⊕ , анализируются как инфиксные операторы и доступны для определяемых пользователем методов (например, вы можете использовать  const ⊗ =  крон, чтобы определить  ⊗  как инфиксный Кронекера). Операторы также могут иметь суффикс с модифицирующими знаками, простыми числами и дополнительными / надстрочными индексами, например  + ̂ₐ ″  анализируется как инфиксный оператор с тем же приоритетом, что и  + . Между оператором, заканчивающимся буквой нижнего или верхнего индекса, и последующим именем переменной требуется пробел.Например, если  + ᵃ  - оператор, то  + ᵃx  должно быть записано как  + ᵃ x , чтобы отличить его от  + ᵃx , где  ᵃx  - имя переменной.
 Единственными явно запрещенными именами для переменных являются имена встроенных ключевых слов:
  julia> else = false
ОШИБКА: синтаксис: неожиданное "еще"

julia> try = "Нет"
ОШИБКА: синтаксис: неожиданный "="  
 Некоторые символы Юникода считаются эквивалентными в идентификаторах.Различные способы ввода комбинированных символов Unicode (например, акцентов) рассматриваются как эквивалентные (в частности, идентификаторы Julia нормализованы по NFC). Символы Unicode  ɛ  (U + 025B: строчная латинская буква e) и  µ  (U + 00B5: микрознак) обрабатываются как эквивалент соответствующих греческих букв, поскольку первые легко доступны с помощью некоторых методов ввода.
 Хотя Джулия налагает несколько ограничений на допустимые имена, стало полезно принять следующие соглашения:
 Имена переменных в нижнем регистре.
 Разделение слов может быть обозначено подчеркиванием ( '_' ), но использование подчеркивания не рекомендуется, если иначе имя будет трудно читать.
 Имена  типа  s и  Module  начинаются с заглавной буквы, а разделение слов отображается верхним регистром вместо подчеркивания.
 Имена функции   s и макроса   s в нижнем регистре, без подчеркивания.
 Функции, которые пишут в свои аргументы, имеют имена, заканчивающиеся на ! .Их иногда называют «изменяющими» или «на месте» функциями, потому что они предназначены для изменения своих аргументов после вызова функции, а не просто для возврата значения.
 Дополнительные сведения о стилистических соглашениях см. В Руководстве по стилю.
 Целые числа и числа с плавающей запятой · Язык Julia 
 Целые числа и значения с плавающей запятой являются основными строительными блоками арифметики и вычислений. Встроенные представления таких значений называются числовыми примитивами, а представления целых чисел и чисел с плавающей запятой в виде непосредственных значений в коде известны как числовые литералы.Например,  1  - целочисленный литерал, а  1.0  - литерал с плавающей запятой; их двоичные представления в памяти как объекты являются числовыми примитивами.
 Julia предоставляет широкий спектр примитивных числовых типов, и над ними определен полный набор арифметических и побитовых операторов, а также стандартных математических функций. Они отображаются непосредственно на числовые типы и операции, которые изначально поддерживаются на современных компьютерах, что позволяет Джулии в полной мере использовать вычислительные ресурсы.Кроме того, Julia предоставляет программную поддержку арифметики произвольной точности, которая может обрабатывать операции с числовыми значениями, которые не могут быть эффективно представлены в собственных представлениях оборудования, но за счет относительно более низкой производительности.
 Ниже приведены примитивные числовые типы Джулии:
 Кроме того, полная поддержка сложных и рациональных чисел построена на основе этих примитивных числовых типов. Все числовые типы взаимодействуют естественным образом без явного приведения типов, благодаря гибкой, расширяемой пользователем системе продвижения типов.
 Буквенные целые числа представлены стандартным образом:
  julia> 1
1

Юлия> 1234
1234  
 Тип по умолчанию для целочисленного литерала зависит от того, имеет ли целевая система 32-битную или 64-битную архитектуру:
  # 32-битная система:
Юлия> typeof (1)
Int32

# 64-битная система:
Юлия> typeof (1)
Int64  
 Внутренняя переменная Julia  Sys.WORD_SIZE  указывает, является ли целевая система 32-битной или 64-битной:
  # 32-битная система:
Юлия> Sys.WORD_SIZE
32

# 64-битная система:
julia> Sys.WORD_SIZE
64  
 Джулия также определяет типы  Int  и  UInt , которые являются псевдонимами для системных целочисленных типов со знаком и без знака соответственно:
  # 32-битная система:
Юлия> Инт
Int32
Юлия> UInt
UInt32

# 64-битная система:
Юлия> Инт
Int64
Юлия> UInt
UInt64  
 Целочисленные литералы большего размера, которые не могут быть представлены только 32-битными, но могут быть представлены в 64-битных, всегда создают 64-битные целые числа, независимо от типа системы:
  # 32-битная или 64-битная система:
Юлия> typeof (3000000000)
Int64  
 Целые числа без знака вводятся и выводятся с использованием префикса  0x  и шестнадцатеричных (основание 16) цифр  0-9a-f  (цифры с большой буквы  A-F  также работают для ввода).Размер беззнакового значения определяется количеством используемых шестнадцатеричных цифр:
  julia> x = 0x1
0x01

Юлия> typeof (x)
UInt8

Юлия> х = 0x123
0x0123

Юлия> typeof (x)
UInt16

Юлия> х = 0x1234567
0x01234567

Юлия> typeof (x)
UInt32

Юлия> x = 0x123456789abcdef
0x0123456789abcdef

Юлия> typeof (x)
UInt64

Юлия> х = 0x11112222333344445555666677778888
0x11112222333344445555666677778888

Юлия> typeof (x)
UInt128  
 Это поведение основано на наблюдении, что при использовании беззнаковых шестнадцатеричных литералов для целочисленных значений они обычно используются для представления фиксированной числовой последовательности байтов, а не просто целочисленного значения.
 Также поддерживаются двоичные и восьмеричные литералы:
  julia> x = 0b10
0x02

Юлия> typeof (x)
UInt8

Юлия> х = 0o010
0x08

Юлия> typeof (x)
UInt8

Юлия> х = 0x00000000000000001111222233334444
0x00000000000000001111222233334444

Юлия> typeof (x)
UInt128  
 Что касается шестнадцатеричных литералов, двоичные и восьмеричные литералы создают беззнаковые целочисленные типы. Размер элемента двоичных данных - это минимально необходимый размер, если первая цифра литерала не равна  0 .В случае начальных нулей размер определяется минимально необходимым размером для литерала, который имеет ту же длину, но начальную цифру  1 . Это позволяет пользователю контролировать размер. Значения, которые не могут быть сохранены в  UInt128 , не могут быть записаны как такие литералы.
 Двоичные, восьмеричные и шестнадцатеричные литералы могут быть подписаны цифрами –, непосредственно предшествующими беззнаковому литералу. Они производят целое число без знака того же размера, что и литерал без знака, с дополнением значения до двух:
  julia> -0x2
0xfe

Юлия> -0x0002
0xfffe  
 Минимальные и максимальные представимые значения примитивных числовых типов, таких как целые числа, задаются функциями  typemin  и  typemax :
  julia> (typemin (Int32), typemax (Int32))
(-2147483648, 2147483647)

julia> для T в [Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UInt128]
           println ("$ (lpad (T, 7)): [$ (typemin (T)), $ (typemax (T))]")
       конец
   Int8: [-128,127]
  Int16: [-32768,32767]
  Int32: [-2147483648,2147483647]
  Int64: [-9223372036854775808,9223372036854775807]
 Int128: [-170141183460469231731687303715884105728,170141183460469231731687303715884105727]
  UInt8: [0,255]
 UInt16: [0,65535]
 UInt32: [0,4294967295]
 UInt64: [0,18446744073709551615]
UInt128: [0,340282366920938463463374607431768211455]  
 Значения, возвращаемые  typemin  и  typemax , всегда относятся к заданному типу аргумента.(В приведенном выше выражении используется несколько функций, которые еще предстоит внедрить, в том числе для циклов, строк и интерполяции, но они должны быть достаточно легкими для понимания пользователями, имеющими некоторый опыт программирования.)
 Поведение при переполнении 
 В Julia превышение максимальное представимое значение данного типа приводит к циклическому поведению:
  julia> x = typemax (Int64)
9223372036854775807

Юлия> x + 1
-9223372036854775808

Юлия> х + 1 == typemin (Int64)
истина  
 Таким образом, арифметика с целыми числами Джулии на самом деле является формой модульной арифметики.19
10000000000000000000  

Ошибки деления

Целочисленное деление (функция div ) имеет два исключительных случая: деление на ноль и деление наименьшего отрицательного числа ( typemin ) на -1. В обоих случаях возникает ошибка DivideError . Функции остатка и модуля ( rem и mod ) вызывают DivideError , когда их второй аргумент равен нулю.

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

  julia> 1.0
1.0

Юлия> 1.
1.0

Юлия> 0,5
0,5

Юлия> .5
0,5

Юлия> -1,23
-1,23

Юлия> 1e10
1.0e10

Юлия> 2,5e-4
0,00025  

Все приведенные выше результаты представляют собой значения Float64 . Буквальные значения Float32 можно ввести, написав f вместо e :

  julia> x = 0.5f0
0.5f0

Юлия> typeof (x)
Float32

Юлия> 2.5f-4
0.00025f0  

Значения можно легко преобразовать в Float32 :

  julia> x = Float32 (-1.5)
-1,5f0

Юлия> typeof (x)
Float32  

Шестнадцатеричные литералы с плавающей запятой также допустимы, но только как Float64 значений, где p предшествует показателю с основанием 2:

  julia> 0x1p0
1.0

Юлия> 0x1.8p3
12.0

Юлия> х = 0x.4p-1
0,125

Юлия> typeof (x)
Float64  

Также поддерживаются числа с плавающей запятой половинной точности ( Float16 ), но они реализованы программно и используют Float32 для вычислений.

  julia> sizeof (Float16 (4.))
2

Юлия> 2 * Float16 (4.)
Float16 (8.0)  

Знак подчеркивания _ может использоваться как разделитель цифр:

  julia> 10_000, 0.000_000_005, 0xdead_beef, 0b1011_0010
(10000, 5.0e-9, 0xdeadbeef, 0xb2)  

Ноль с плавающей запятой

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

  julia> 0.0 == -0,0
истинный

Юлия> битовая строка (0,0)
«0000000000000000000000000000000000000000000000000000000000000000»

Юлия> битовая строка (-0.0)
«1000000000000000000000000000000000000000000000000000000000000000»  

Специальные значения с плавающей запятой

Существуют три указанных стандартных значения с плавающей запятой, которые не соответствуют какой-либо точке в строке вещественного числа:

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

  julia> 1 / Inf
0,0

Юлия> 1/0
Inf

Юлия> -5/0
-Inf

Юлия> 0,000001 / 0
Inf

Юлия> 0/0
NaN

Юлия> 500 + Инф
Inf

Юлия> 500 - Инф
-Inf

Юлия> Инф + Инф
Inf

Юлия> Инф - Инф
NaN

Юлия> Инф * Инф
Inf

Юлия> Инф / Инф
NaN

Юлия> 0 * Инф
NaN  

Функции typemin и typemax также применимы к типам с плавающей запятой:

  julia> (typemin (Float16), typemax (Float16))
(-Inf16, Inf16)

Юлия> (typemin (Float32), typemax (Float32))
(-Inf32, Inf32)

Юлия> (typemin (Float64), typemax (Float64))
(-Inf, Inf)  

Машинный эпсилон

Большинство действительных чисел не могут быть точно представлены числами с плавающей запятой, поэтому для многих целей важно знать расстояние между двумя соседними представляемыми числами с плавающей запятой, что часто бывает известный как машина эпсилон.-52 как значения Float32 и Float64 соответственно. Функция eps также может принимать значение с плавающей запятой в качестве аргумента и выдает абсолютную разницу между этим значением и следующим представимым значением с плавающей запятой. То есть eps (x) дает значение того же типа, что и x , так что x + eps (x) является следующим представимым значением с плавающей запятой больше, чем x :

  julia> eps (1.0)
2.220446049250313e-16

Юлия> eps (1000.)
1.1368683772161603e-13

Юлия> eps (1e-27)
1.793662034335766e-43

Юлия> eps (0.0)
5.0e-324  

Расстояние между двумя соседними представляемыми числами с плавающей запятой непостоянно, но меньше для меньших значений и больше для больших значений. Другими словами, представимые числа с плавающей запятой являются наиболее плотными в строке вещественных чисел около нуля и экспоненциально становятся разреженными по мере удаления от нуля. По определению eps (1.0) совпадает с eps (Float64) , поскольку 1.0 - это 64-битное значение с плавающей запятой.

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

  julia> x = 1.25f0
1,25f0

Юлия> nextfloat (x)
1.2500001f0

Юлия> prevfloat (x)
1.2499999f0

Юлия> битовая строка (prevfloat (x))
«00111111100111111111111111111111»

Джулия> битовая строка (х)
«00111111101000000000000000000000»

Юлия> битовая строка (nextfloat (x))
«00111111101000000000000000000001»  

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

Режимы округления

Если число не имеет точного представления с плавающей запятой, оно должно быть округлено до подходящего представимого значения. Однако способ, которым выполняется это округление, может быть изменен, если требуется, в соответствии с режимами округления, представленными в стандарте IEEE 754.

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

Предпосылки и ссылки

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

Чтобы разрешить вычисления с целыми числами произвольной точности и числами с плавающей запятой, Джулия оборачивает библиотеку арифметики множественной точности GNU (GMP) и Библиотека GNU MPFR соответственно.Типы BigInt и BigFloat доступны в Julia для целых чисел произвольной точности и чисел с плавающей запятой соответственно.

Конструкторы существуют для создания этих типов из примитивных числовых типов, и строковый литерал @big_str или parse может использоваться для их создания из AbstractString s. BigInt также можно вводить как целочисленные литералы, если они слишком велики для других встроенных целочисленных типов. Обратите внимание, что поскольку в Base нет целочисленного типа без знака произвольной точности (в большинстве случаев достаточно BigInt ), можно использовать шестнадцатеричные, восьмеричные и двоичные литералы (в дополнение к десятичным литералам).66) / 3 2.459565876494606882133333333333333333333333333333333333333333333333333333333344e + 19 Юлия> факториал (BigInt (40)) 8153247897734345611269596115894272000000000

Однако преобразование типа между примитивными типами выше и BigInt / BigFloat не является автоматическим и должно быть явно указано.

  Юлия> x = typemin (Int64)
-9223372036854775808

Юлия> х = х - 1
9223372036854775807

Юлия> typeof (x)
Int64

Юлия> у = BigInt (typemin (Int64))
-9223372036854775808

Юлия> у = у - 1
-9223372036854775809

Юлия> typeof (y)
BigInt  

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

  julia> setrounding (BigFloat, RoundUp) do
           BigFloat (1) + синтаксический анализ (BigFloat, "0,1")
       конец
1.10000000000000000000000000000000000000000000000000000000000000000000000003

julia> setrounding (BigFloat, RoundDown) делать
           BigFloat (1) + синтаксический анализ (BigFloat, "0,1")
       конец
1.0999999999999999999999999999999999999999999999999999999999999999999999999986

Юлия> setprecision (40) делать
           BigFloat (1) + parse (BigFloat, "0.2-3 (х-1) + 1
3  

Приоритет числовых буквальных коэффициентов, используемых для неявного умножения, выше, чем у других двоичных операторов, таких как умножение ( * ) и деление (/, \ и // ). Это означает, например, что 1 / 2im равно -0,5im , а 6 // 2 (2 + 1) равно 1 // 1 .

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

  julia> (x-1) x
6  

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

  julia> (x-1) (x + 1)
ОШИБКА: MethodError: объекты типа Int64 не вызываются

Юлия> х (х + 1)
ОШИБКА: MethodError: объекты типа Int64 не вызываются  

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

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

Синтаксические конфликты

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

• Шестнадцатеричное целочисленное буквальное выражение 0xff можно интерпретировать как числовой литерал 0 , умноженный на переменную xff . Подобные неоднозначности возникают с восьмеричными и двоичными литералами, такими как 0o777 или 0b01001010 .
• Литеральное выражение с плавающей запятой 1e10 может быть интерпретировано как числовой литерал 1 , умноженный на переменную e10 , и аналогично с эквивалентной формой E .
• 32-битное буквальное выражение с плавающей запятой 1.5f22 можно интерпретировать как числовой литерал 1,5 , умноженный на переменную f22 .

Во всех случаях неоднозначность разрешается в пользу интерпретации как числовых литералов:

• Выражения, начинающиеся с 0x / 0o / 0b , всегда являются шестнадцатеричными / восьмеричными / двоичными литералами.
• Выражения, начинающиеся с числового литерала, за которым следует e или E , всегда являются литералами с плавающей запятой.
• Выражения, начинающиеся с числового литерала, за которым следует f , всегда являются 32-разрядными литералами с плавающей запятой.

В отличие от E , которое по историческим причинам эквивалентно e в числовых литералах, F - это просто еще одна буква и не ведет себя как f в числовых литералах. Следовательно, выражения, начинающиеся с числового литерала, за которым следует F , интерпретируются как числовой литерал, умноженный на переменную, что означает, например, что 1.5F22 равно 1.5 * F22 .

Julia предоставляет функции, которые возвращают литералы 0 и 1, соответствующие указанному типу или типу данной переменной.

Эти функции полезны в числовых сравнениях, чтобы избежать накладных расходов из-за ненужного преобразования типов.

Примеры:

  julia> ноль (Float32)
0,0f0

Юлия> ноль (1.0)
0,0

Юлия> один (Int32)
1

Юлия> один (BigFloat)
1.0  

Коллекции · Learn Julia the Hard Way

Таксономия коллекций

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

Думайте о коллекции , индексируемой , как о списке покупок — единственный способ идентифицировать отдельные элементы — это указать их положение. Если вы хотите обозначить, скажем, 1 пинта молока , вы называете его пятой записью в моем списке покупок . Доступ к элементам индексируемой коллекции осуществляется с помощью квадратных скобок collection [index] , например список покупок [5] .В отличие от большинства языков программирования и в резком контрасте с другими языками, такими как Python, индексы начинаются с 1, а не с 0. Индексируемая коллекция также равна коллекции с теми же элементами, если они находятся в одном порядке — таким образом, [1 , 3, 5, 7] == [3, 7, 1, 5] дает, как и следовало ожидать, false .

Ассоциативные коллекции напоминают страницу из телефонной книги (если кто-то из вас все еще помнит, что это за штука!).Вы бы не сказали, что ваш номер телефона находится на странице 217, в левом столбце, пятой снизу. Скорее, у вас будет ключ (ваше имя), по которому кто-нибудь сможет найти ваш номер телефона (значение ). Ассоциативные массивы соответствуют форме пары «ключ-значение». Следовательно, доступ к ним осуществляется не в форме collection [index] , а скорее в форме collection [key] . Ассоциативная коллекция не индексируется, поэтому порядок записей не имеет значения: две ассоциативные коллекции будут равны, если они содержат одинаковые пары ключ-значение, независимо от порядка.

Коллекции, которые не являются ни ассоциативными, ни индексируемыми, представляют собой довольно сложный случай. Наборы — единственная часто используемая коллекция, которая не является ни ассоциативной, ни индексируемой. Они также являются особенными из-за ограничения уникальности, то есть набор может содержать каждое значение один раз и только один раз. Набор не поддерживает обычно используемые методы доступа, но он поддерживает многие функции манипулирования коллекциями, такие как push! () и pop! () . Последний, если вам интересно, возвращает элементы в случайном порядке, поскольку отсутствие индекса означает, что наборы не упорядочиваются.Наборы не индексируются, следовательно, два набора, содержащие одинаковые элементы, будут считаться равными независимо от порядка.

Кроме того, коллекции могут быть изменяемыми или неизменяемыми . Проще говоря, изменяемая коллекция — это та, в которой вы можете изменять определенные значения после создания, в то время как в неизменяемой коллекции вы не можете этого сделать. Типичные неизменяемые коллекции — это, конечно, кортежи — после того, как вы присвоили значение кортежу, вы не можете изменить это значение (хотя вы можете присвоить другой кортеж или действительно совершенно другое значение переменной, содержащей кортеж).Наборы снова представляют собой особый случай — это то, что лучше всего можно было бы описать как псевдо-неизменяемый — нет способа получить доступ к значениям таким образом, чтобы они могли их изменить, поскольку вы обычно получаете доступ к элементу набора по его значению (которое достаточно в наборе благодаря ограничению уникальности).

Индексируемые коллекции

Доступ

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

  julia> prime_array = [2, 3, 5, 7, 11]
    5-элементный массив {Int64,1}:
      2
      3
      5
      7
     11

    julia> prime_array [3]
    5
  

В Юлии диапазон чисел записывается как начало: конец или начало: шаги: конец .Вы можете использовать диапазон для доступа к диапазону элементов:

  юлия> prime_array [2: 3]
    Двухэлементный массив {Int64,1}:
     3
     5
  

Диапазон всегда возвращает коллекцию, даже если он имеет длину 1. Это иллюстрируется разницей между prime_array [3] , вызовом, который мы сделали выше, и prime_array [3: 3] , который возвращает

  юлия> prime_array [3: 3]
    1-элементный массив {Int64,1}:
     5

    julia> prime_array [3: 3] == 5
    ложный
  

Вы можете получить доступ к последнему элементу индексируемой коллекции, используя [end] :

  julia> prime_array [конец]
     11
  

Между прочим, end ведет себя как число — поэтому prime_array [end-1] возвращает предпоследний элемент коллекции.

Настройка

Если индексируемая коллекция, которую вы используете, также является изменяемой (например, массив), любой из этих методов будет действовать как псевдопеременная и позволит вам присвоить ей значение. Таким образом, prime_array [end] = 12 изменит последний элемент prime_array на 12. Вы также не ограничены одним элементом: вызов prime_array [2: 4] = 0 приведет к

  юлия> prime_array
    5-элементный массив {Int64,1}:
      2
      0
      0
      0
     11
  

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

  julia> prime_array [2: 4] = [3,5,7]
    Трехэлементный массив {Int64,1}:
     3
     5
     7

    Юлия> prime_array
    5-элементный массив {Int64,1}:
      2
      3
      5
      7
     11
  

Распаковка

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

  джулия> актеры = [«Иэн МакКеллен», «Мартин Фриман», «Элайджа Вуд»]
    Трехэлементный массив {String, 1}:
     "Иэн МакКеллен"
     "Мартин Фриман"
     "Элайджа Вуд"

    джулия> гэндальф, бильбо, фродо = актеры
    Трехэлементный массив {String, 1}:
     "Иэн МакКеллен"
     "Мартин Фриман"
     "Элайджа Вуд"

    Джулия> Гэндальф
    "Иэн МакКеллен"
  

Распаковка также может использоваться для замены содержимого переменных:

  юлия> firstname = "Ирвинг"
    julia> lastname = "Вашингтон"

    Юлия> имя, фамилия = фамилия, имя
    («Вашингтон», «Ирвинг»)

    Юлия> фамилия
    "Ирвинг"
  

Общие функции

нажмите! добавляет значение в конец коллекции. поп! берет последний элемент списка, возвращает его и удаляет из коллекции.

  Юлия> array = [1,2,3,4]
    4-элементный массив {Int64,1}:
     1
     2
     3
     4

    Юлия> толкни! (массив, 5)
    5-элементный массив {Int64,1}:
     1
     2
     3
     4
     5

    julia> pop! (массив)
    5

    Юлия> массив
    4-элементный массив {Int64,1}:
     1
     2
     3
     4
  

добавить! , что несколько необычно, помещает элементы одной коллекции в конец другой коллекции:

  Джулия> array2 = [5,6,7]
    Трехэлементный массив {Int64,1}:
     5
     6
     7

    Юлия> добавить! (массив, массив2)
    7-элементный массив {Int64,1}:
     1
     2
     3
     4
     5
     6
     7
  

смена! и без переключения! — это передний эквивалент поп! и нажимайте! .Аналогично поп! , смена! извлекает первый элемент коллекции и удаляет его из коллекции (которая сдвигает его на ):

  юлия> сдвиг! (Массив)
    1
  

Аналогично push! , без переключения! помещает элемент в начало коллекции:

  julia> unshift! (Массив, 8)
    7-элементный массив {Int64,1}:
     8
     2
     3
     4
     5
     6
     7
  

Существует набор функций, начинающихся с find, таких как find () , findfirst () и findnext () , которые можно использовать для получения индекса или индексов значений в индексируемой коллекции, которые соответствуют определенное значение или пройдите тест.Эти функции имеют три общих свойства.

1. Их результат — это индекс или индексы искомого или проверенного значения для , причем индекс элемента n_th равен n , а не n-1 , как вы могли бы привыкнуть к другим языкам.
2. Вы можете использовать эти функции в двух основных формах: вы можете проверить значение или проверить функцию, и в этом случае результатами будут значения, для которых функция возвращает true .
3. Функция find сообщает вам, что они ничего не нашли, возвращает ноль, поскольку нет элемента с нулевым индексом.

Давайте попробуем найти объекты в следующем массиве : primes_and_one = [1,2,3,5,7,11,13,17,19,23]

findfirst () находит первое вхождение значения и возвращает его индекс (или ноль):

  юлия> findfirst (primes_and_one, 5)
    4
  

Как отмечалось выше, мы также можем передать функции find функцию — она ​​вернет значения, для которых функция вернет истинное значение .Мы не особо обсуждали функции, но общая идея должна быть вам знакома. Функция вида x -> x == 13 приводит к true , если значение x равно 13, и false в противном случае. Попробуем посмотреть, какое простое число первым равняется 13 (не ждите больших сюрпризов):

  юлия> findfirst (x -> x == 13, primes_and_one)
    7
  

Вы могли заметить, что в отличие от случая, когда вы искали конкретное значение, , где вы выполняете поиск по функции, функция идет первой .Это небольшая особенность, но она связана с тем, как Джулия определяет, что делать, в зависимости от того, что ему предоставлено. Намного больше об этом будет рассказано в главе [X].

find () возвращает массив результатов. Так, например, давайте воспользуемся функцией isinteger , чтобы увидеть, какие из наших простых чисел являются целыми числами (опять же, результат не должен шокировать):

  julia> найти (isinteger, primes_and_one)
    Массив из 10 элементов {Int64,1}:
      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
  

findnext () возвращает результаты, начиная с указанного индекса.Таким образом, если вы хотите узнать индекс первого нечетного числа после 3 в списке простых чисел, вы должны поступить следующим образом (используя функцию isodd , которая, как вы могли догадаться, возвращает true для нечетных целых чисел и ложь иначе):

  юлия> findnext (isodd, primes_and_one, 4)
    4
  

Подождите, а почему 4 ? Как вы, наверное, помните, Юлия имеет 1 индекс, а не 0. Следовательно, индекс «начинается перед» числом. Число после первого индекса — это первое число в последовательности и так далее.Таким образом, номер после третьего элемента в коллекции — это элемент рядом (= следующий) с индексом 4 , а не 3 .

Как вы могли заметить, когда вы используете функцию в качестве аргумента, вы не используете круглые скобки, которые обычно использовали бы для вызова функции. Это потому, что функция () означает, что вызывает эту функцию , а функция является просто ссылкой на сам объект функции.

Получить элементы, а не индексы

Пока мы получаем только индексы.Как нам получить настоящие элементы? Ответ, конечно же, заключается в использовании нашего волшебного синтаксиса [] (квадратные скобки). Мы также будем использовать это как хорошую возможность представить очень полезную функцию isprime () , которая возвращает true для простых чисел и false в противном случае:

  julia> импортные праймы

    Юлия> найти (isprime, primes_and_one)
    9-элементный массив {Int64,1}:
      2
      3
      4
      5
      6
      7
      8
      9
     10

    julia> primes_and_one [найти (isprime, primes_and_one)]
    9-элементный массив {Int64,1}:
      2
      3
      5
      7
     11
     13
     17
     19
     23
  

Фильтрация

Функция filter () работает аналогично функции find , за исключением того, что в этом случае возвращаются только элементы, удовлетворяющие условию (фактически, это сокращение для предыдущего листинга).

  julia> фильтр (isodd, primes_and_one)
    9-элементный массив {Int64,1}:
      1
      3
      5
      7
     11
     13
     17
     19
     23
  

filter () можно использовать на месте, используя ! после названия функции. Таким образом, использование filter! () изменяет фактический массив, а не возвращает отфильтрованную копию. Однако обратите внимание, что функции, оканчивающиеся на ! изменяют объект, поэтому, очевидно, тип, на который они действуют, должен быть изменяемым — поэтому вы не сможете filter! () кортеж, даже если вы сможете filter () it.

Сортировка

Функция sort () сортирует массив лексикографически, обычно в порядке возрастания:

  julia> sort ([- 3, 2, 1, 7])
    4-элементный массив {Int64,1}:
     -3
     1
     2
     7
  

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

  julia> sort ([- 3,2,1,7], by = abs)
    4-элементный массив {Int64,1}:
      1
      2
     -3
      7
  

Вы можете изменить порядок сортировки с помощью rev :

  julia> sort ([- 3,2,1,7], by = abs, rev = true)
    4-элементный массив {Int64,1}:
      7
     -3
      2
      1
  

И, к огромной радости таких ботаников, как я, вы можете выбрать алгоритм сортировки, используя alg .В настоящее время Юлия поддерживает три алгоритма сортировки ( InsertionSort , QuickSort и MergeSort ).

  julia> sort ([- 3,2,1,7], by = abs, rev = true, alg = MergeSort)
    4-элементный массив {Int64,1}:
      7
     -3
      2
      1
  

Для изменяемых индексируемых коллекций, таких как массивы, вы можете использовать sort! () , который выполняет сортировку «на месте». Конечно, вы также можете сортировать нечисловые элементы или все, для чего определена функция isless () , которая используется для внутренней сортировки.

  julia> sort ([«Байес», «Лаплас», «Пуассон», «Гаусс»])
    4-элементный массив {String, 1}:
     «Байесовский»
     «Гаусс»
     "Лаплас"
     "Пуассон"
  

Подсчет

count () сообщает количество экземпляров в коллекции, удовлетворяющих критерию:

  юлия> count (isodd, primes_and_one)
    9
  

all () и any () реализуют две математические концепции, известные как кванторы , причем all () представляет универсальный квантор \ forall , а any () реализует квантор существования.Эти функции проверяют, все ли или часть коллекции, соответственно, определенному критерию, и возвращают единственное значение истинности.

Наличие определенного значения

Чтобы узнать, имеет ли массив определенное значение среди его элементов, вы можете использовать в () :

  юлия> в (2, простые числа)
    истинный
  

Как ни странно, в синтаксисе in () игла стоит перед стогом сена, т.е. in (value, array) , где value обозначает искомое значение.

Особые типы

Массивы

Массивы (те, которые мы использовали в наших примерах до сих пор в этом разделе) являются изменяемыми индексируемыми коллекциями. Тип Array {T, N} указывает на размерный массив N , типы элементов которого являются подтипами T . Например, Array {Number, 2} — это двумерный массив. Типы его элементов происходят от Number (например, Int , Float64 ).

Доступ в многомерных массивах

Как получить доступ к элементам в многомерном массиве, особой форме индексируемой коллекции? Просто — в многомерном массиве индексы идут вниз по каждой строке, затем слева направо.Следовательно, этот массив

  Джулия> md_array = ["A" "B"; "КОМПАКТ ДИСК"]
    2x2 Массив {String, 2}:
     «А» «Б»
     "КОМПАКТ ДИСК"
  

будет проиндексирован следующим образом:

  md_array [1] = "А"
md_array [2] = "C"
md_array [3] = "B"
md_array [4] = "D"
  

Это немного противоречит здравому смыслу и отличается от обычной записи строки / столбца, где вы должны использовать array [row] [column] . Чтобы получить ячейку по строке и столбцу, используйте массив [строка, столбец] :

  юлия> md_array [1,2]
    "B"
  

Это обобщает для массивов более высоких измерений.

Кортежи

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

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

Следствием неизменности является то, что ни один из ! Функции работают с кортежами — но в то же время использование таких функций, как push () вполне допустимо, поскольку оно возвращает копию кортежа с добавленным элементом , который не изменяет исходный кортеж.

Ассоциативные коллекции: dicts

Ассоциативная коллекция — это разновидность неиндексированной коллекции, в которой хранятся (обычно) пары значений.Индексируемые коллекции, с которыми вы столкнулись, соответствуют примерам из реальной жизни, таким как список покупок или последовательный список вокзалов. С другой стороны, ассоциативные коллекции имеют ключ и значение (по этой причине их иногда называют парами ключ-значение ). Джулия, как и многие другие языки программирования, реализует ассоциативные коллекции в объекте, называемом dict (сокращение от dictionary ), который соответствует «картам», «хеш-таблицам» или «словарям» в других языках программирования.

Dict, как мы видели, обычно создается с помощью литерала dict

  dict = Dict ("a" => 1, "b" => 2, "c" => 3)
  

Ключ пары ключ-значение — уникальный , что означает, что, хотя несколько ключей могут указывать на одно и то же значение (и ключ может указывать на коллекцию как на значение), у вас не может быть повторяющихся ключей (в терминологии базы данных вы возможно, слышали, что это называется отношением «один ко многим» ().

Создание dicts

Помимо литерала Dict () , есть еще три способа создать dict.

Во-первых, вы можете создать dict, используя синтаксис понимания для dicts. Пример:

  [i => sqrt (i) для i = 1: 2: 15]
  

Это создает словарный запас с квадратным корнем из каждого нечетного числа от 1 до 15. В этом случае i может быть любым итеративным — хотя диапазоны используются наиболее часто, нет причин, по которым

  Dict (i => sqrt (i) для i = [2, 5, 6, 8, 12, 64])
  

не будет одинаково действительным.

Во-вторых, вы также можете создать пустой словарь. Dict () создаст пустой словарь, разрешающий любые элементы, а Dict {type1, type2} () создаст пустой словарь, который разрешает любые элементы с ключами type1 и значениями type2 .

Наконец, более ранние версии Julia использовали для поддержки того, что иногда называют zip-создание dict, а именно ввода двух кортежей одинаковой длины, один для ключей и один для значений.Сейчас это считается устаревшим — он все еще работает, но вы не должны его использовать. Вместо этого правильный синтаксис: Dict (zip (ks, vs)) :

  ks = ("a", "b", "c")
    vs = ("1", "2", "3")

    Юлия> Dict (zip (ks, vs))
    Dict {String, String} с 3 записями:
      "c" => "3"
      "b" => "2"
      "а" => "1"
  

Доступ

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

  julia> statisticians = Dict ("Gosset" => "1876-1937", "Pearson" => "1857-1936", "Galton" => "1822-1911")
    Dict {String, String} с 3 записями:
      "Гальтон" => "1822-1911"
      "Пирсон" => "1857-1936"
      "Госсет" => "1876-1937"

    Юлия> статистики ["Госсет"]
    «1876-1937»
  

Одним из недостатков синтаксиса скобок является то, что если для предоставленного ключа нет записи, Джулия выдаст ошибку:

  юлия> статистики ["Кендалл"]
    ОШИБКА: ключ не найден: «Кендалл»
     в getindex в dict.jl: 644
  

Альтернативная форма доступа к словарю — использование функции get () , которая принимает значение по умолчанию:

  julia> get (статистики, «Пирсон», «Извините, я не знаю, когда жил этот человек»).
    «1857-1936»

    julia> get (статистики, «Кендалл», «Простите, я не знаю, когда жил этот человек»).
    «Прости, я не знаю, когда жил этот человек».
  

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

  julia> get (статистики, "Кендалл")
    ОШИБКА: `get` не имеет метода, соответствующего get (:: Dict {String, String}, :: String)
  

Получить или создать (

Поскольку dicts изменяемы, get! () может попытаться получить доступ к значению по своему ключу и создать его, если он не найден, а затем вернуть новое значение. Его синтаксис идентичен get () :

  julia> get! (Статистики, «Кендалл», «Извините, я не знаю, когда жил этот человек.")
    «Прости, я не знаю, когда жил этот человек».

    Юлия> статистики
    Dict {String, String} с 4 записями:
      "Гальтон" => "1822-1911"
      "Пирсон" => "1857-1936"
      "Кендалл" => "Извините, я не знаю, когда жил этот человек".
      "Госсет" => "1876-1937"
  

pop! () возвращает массив значений ключа, соответствующий ключу. Если ключ не существует, он возвращает необязательное значение по умолчанию или выдает ошибку:

  юлия> поп! (Статистики, "Госсет")
    «1876-1937»

    Юлия> статистики
    Dict {String, String} с 3 записями:
      "Гальтон" => "1822-1911"
      "Пирсон" => "1857-1936"
      "Кендалл" => "1907-1983"
  

Изменить значения

Чтобы изменить значение, откройте его с помощью синтаксиса скобок, затем присвойте ему новое значение:

  юлия> статистики ["Кендалл"] = "1907-1983"
    «1907–1983»

    Юлия> статистики
    Dict {String, String} с 4 записями:
      "Гальтон" => "1822-1911"
      "Пирсон" => "1857-1936"
      "Кендалл" => "1907-1983"
      "Госсет" => "1876-1937"
  

Проверка наличия ключа или пары «ключ-значение»

Чтобы проверить наличие ключа, не извлекая его, вы можете использовать haskey () :

  юлия> хаски (статистики, "Гальтон")
    истинный

    julia> haskey (статистики, "Байесовцы")
    ложный
  

Вы также можете проверить наличие пары ключ-значение в dict, используя функцию in () , с которой вы, возможно, знакомы по массивам.Обратите внимание, что запись пары ключ-значение в этом случае будет в форме кортежа (ключ, значение) , а не использовать символ ассоциативного массива => :

  julia> in (("Байес", "1702-1761"), статистики)
    ложный
  

Получение ключей или значений

Чтобы получить все ключи словаря, используйте keys () . При этом будет получен объект типа KeyIterator , который выполняет именно то, что предполагает название — выполняет итерацию по ключам массива.Это будет полезно позже, когда мы захотим перебирать словарь по ключам:

  юлия> ключи (статистики)
    KeyIterator для Dict {String, String} с 3 записями. Ключи:
      «Гальтон»
      "Пирсон"
      "Кендалл"
  

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

  юлия> ценности (статистики)
    ValueIterator для Dict {String, String} с 3 записями. Значения:
      «1822-1911»
      «1857-1936»
      «1907–1983»
  

Сортировка

Вы могли заметить, что словарный запас неупорядочен.Даже dict, сгенерированный ссылкой на диапазон, такой как показанный выше, не будет иметь никакого определенного порядка:

  julia> [i => sqrt (i) for i = 1: 2: 15]
    Dict {Int64, Float64} с 8 записями:
      7 => 2,6457513110645907
      9 => 3,0
      13 => 3,605551275463989
      3 => 1,7320508075688772
      11 => 3,31662474
      5 => 2,23606797749979
      15 => 3,872983346207417
      1 => 1,0
  

Это связано с тем, что dicts не индексируются, поэтому нет упорядочения, которое имело бы внутренний смысл.Однако иногда нам нравятся отсортированные словари. К сожалению, сортировка dicts не так проста, как сортировка массивов: sort (статистики) сообщает нам, что 'sort' не имеет метода сопоставления sort (:: Dict {String, String}) . Следовательно, вы должны написать свою собственную функцию сортировки, которая сначала преобразует статистиков из dict в массив кортежей из 2 элементов. Это связано с тем, что функция sort () не имеет определенных методов для dicts, но может сортировать массивы, включая кортежи, где она сортируется по первому элементу в кортеже.Затем он перебирает результат и снова представляет его в виде словаря:

  результат = Dict {String, String}
    for (k, v) в сортировке (собрать (статистики))
        результат [k] => v
        println (результат)
    конец
  

Это дает ожидаемый результат:

  Гальтон => 1822-1911 гг.
    Кендалл => 1907-1983 гг.
    Пирсон => 1857-1936 гг.
  

Если вы хотите, чтобы вывод был на месте или давал реальный dict, вам придется немного дополнить свой код:

  результат = Dict ()
    for (k :: String, v :: String) в sort (collect (статистики))
        setindex! (результат, v, k)
    конец

    Юлия> результат
    Dict {Any, Any} с 3 записями:
      "Гальтон" => "1822-1911"
      "Пирсон" => "1857-1936"
      "Кендалл" => "1907-1983"
  

Объединение

Функция merge () объединяет два или более словаря.

  юлия> математики = Dict ("Gauss" => "1777-1855", "Leibniz" => "1646-1716", "Abel" => "1802-1829")
    Dict {String, String} с 3 записями:
      "Авель" => "1802-1829"
      "Лейбниц" => "1646-1716"
      "Gauss" => "1777-1855"

    julia> merge (математики, статистики)
    Dict {String, String} с 6 записями:
      "Авель" => "1802-1829"
      "Гальтон" => "1822-1911"
      "Лейбниц" => "1646-1716"
      "Gauss" => "1777-1855"
      "Пирсон" => "1857-1936"
      "Кендалл" => "1907-1983"
  

Его двойник, merge! () , объединяет их на месте, перезаписывая первый упомянутый dict, оставляя второй нетронутым.

  julia> merge! (Математики, статистики)
    Dict {String, String} с 6 записями:
      "Авель" => "1802-1829"
      "Гальтон" => "1822-1911"
      "Лейбниц" => "1646-1716"
      "Gauss" => "1777-1855"
      "Пирсон" => "1857-1936"
      "Кендалл" => "1907-1983"

    Юлия> математики
    Dict {String, String} с 6 записями:
      "Авель" => "1802-1829"
      "Гальтон" => "1822-1911"
      "Лейбниц" => "1646-1716"
      "Gauss" => "1777-1855"
      "Пирсон" => "1857-1936"
      "Кендалл" => "1907-1983"

    Юлия> статистики
      Dict {String, String} с 3 записями:
      "Гальтон" => "1822-1911"
      "Пирсон" => "1857-1936"
      "Кендалл" => "1907-1983"
  

Неиндексируемые неассоциативные коллекции: наборы

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

Создание наборов

Для создания набора используйте функцию конструктора Set () . Вы можете создать набор, который принимает любой тип данных

  юлия> простые числа = Set ()
    Установить {Any} ({})
  

— или вы можете указать, какие типы данных он будет принимать:

  julia> primes = Set {Int64} ()
    Установить {Int64} ({})
  

Вы можете создавать и заполнять наборы за один раз, перечисляя элементы, окруженные фигурными скобками {} , и если вы заключите элементы в квадратные скобки [] вместо фигурных скобок {} Джулия угадает тип:

  юлия> mersenne_primes_set = Установить ([3, 7, 31, 127])
    Установить ([7,31,3,127])
  

Установить операции

обладают некоторыми уникальными функциями, которые позволяют решать определенные проблемы, хорошо известные из теории множеств: каждая из функций union () , correct () и setdiff () , соответственно, реализует объединение, пересечение и разность множеств.Давайте посмотрим, как мы можем использовать это, чтобы найти некоторые сходства между актерами двух блокбастеров, Властелин колец и Матрица .

Во-первых, давайте создадим две декорации с актерами из каждого фильма:

  lotr_actors = Set ([«Элайджа Вуд», «Иэн МакКеллен», «Вигго Мортенсен», «Хьюго Уивинг»])
    matrix_actors = Set ([«Киану Ривз», «Лоуренс Фишберн», «Хьюго Уивинг»]
  

Чтобы найти общих актеров, мы можем использовать correct () :

  юлия> пересечь (lotr_actors, matrix_actors)
    Набор (Строка ["Хьюго Уивинг"])
  

Чтобы найти актеров, которые снялись только в Властелине колец , но не в Матрица , мы можем использовать setdiff () , который показывает все элементы, которые есть в первом Set , но не во втором:

  юлия> setdiff (lotr_actors, matrix_actors)
     Набор (Строка [«Элайджа Вуд», «Иэн МакКеллен», «Вигго Мортенсен»])
  

Наконец, мы можем увидеть актеров, которые играли в любом из фильмов, используя union () :

  юлия> союз (lotr_actors, matrix_actors)
    Набор (Строка [«Элайджа Вуд», «Иэн МакКеллен», «Хьюго Уивинг», «Киану Ривз», «Лоуренс Фишберн», «Вигго Мортенсен»])
  

Коллекции и виды

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

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

  юлия> mersenne_primes = [3, 7, 31, 127, 8191, 131071]
    6-элементный массив {Int64,1}:
          3
          7
         31 год
        127
       8191
     131071
  

После создания массива REPL сообщает нам, что это массив, состоящий из шести элементов, все из которых имеют тип Int64 — тип 64-битного целого числа со знаком (не волнуйтесь, если это пока для вас мало что значит, мы будем обсуждать различные целочисленные типы в главе [X]).Кроме того, он сообщает нам, что у нас есть одномерный массив.

Выведение типов и разнородные типы

А что, если я хочу немного поиграться и перемешать? Рассмотрим следующий массив:

  julia> not_really_mersenne_primes = [3, 7, «картофель», 127, π, «валлаби»]
     6-элементный массив {Any, 1}:
          3
          7
           "картошка"
          127
          π = 3,1415926535897 ...
          "валлаби"
  

Как вы уже догадались, Джулия не знает, что с этим делать, так как мы добавили смесь целых чисел, строк и константы для хорошей меры.Следовательно, он сообщает нам, что он определил тип коллекции как Any — тип, который применяется ко всем объектам.

Вывод типа и пустые коллекции

Другой крайний случай — пустое множество. У Джулии есть специальный тип None — подтип Any — который применяется к пустому набору:

  юлия> empty_set = []
    0-элементный массив {None, 1}
  

Learn Julia за Y минут

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

Это основано на версии Julia 1.0.0.

 # Однострочные комментарии начинаются с символа решетки (решетки).
# = Можно писать многострочные комментарии
   поставив '# =' перед текстом и '= #'
   после текста. Они также могут быть вложенными.
знак равно

#################################################################################################### ##
## 1. Примитивные типы данных и операторы
#################################################################################################### ##

# Все в Julia - это выражение.19 # => 1.0e19

# Побитовые операторы
~ 2 # => -3 # побитовое не
3 & 5 # => 1 # побитовое и
2 | 4 # => 6 # побитовое или
xor (2, 4) # => 6 # побитовое xor
2 >>> 1 # => 1 # логический сдвиг вправо
2 >> 1 # => 1 # арифметический сдвиг вправо
2 << 1 # => 4 # логический / арифметический сдвиг влево

# Используйте функцию bitstring, чтобы увидеть двоичное представление числа.
битовая строка (12345)
# => "0000000000000000000000000000000000000000000000000011000000111001"
битовая строка (12345.0)
# => "0100000011001000000111001000000000000000000000000000000000000000"

# Логические значения примитивны
истинный
ложный

# Логические операторы
! истина # => ложь
! ложь # => истина
1 == 1 # => верно
2 == 1 # => ложь
1! = 1 # => ложь
2! = 1 # => верно
1 <10 # => верно
1> 10 # => ложь
2 <= 2 # => верно
2> = 2 # => верно
# Сравнения могут быть связаны, как в Python, но в отличие от многих других языков
1 <2 <3 # => верно
2 <3 <2 # => ложь

# Строки создаются с помощью "
"Это строка."

# Символьные литералы пишутся с '
'а'

# Строки закодированы в UTF8, поэтому такие строки, как «π» или «☃», не эквивалентны напрямую
# В массив одиночных символов.
# Только если они содержат только символы ASCII, их можно безопасно проиндексировать.
ascii ("Это строка") [1] # => 'T'
# => 'T': ASCII / Unicode U + 0054 (категория Lu: буква, верхний регистр)
# Остерегайтесь, Джулия индексирует все, начиная с 1 (как MATLAB), а не от 0 (как в большинстве языков).
# В противном случае рекомендуется перебирать строки (карта, циклы и т. Д.).# Строку можно сравнить лексикографически в словарном порядке:
"хорошо"> "пока" # => верно
"хорошо" == "хорошо" # => верно
"1 + 2 = 3" == "1 + 2 = $ (1 + 2)" # => верно

# $ (..) можно использовать для интерполяции строк:
"2 + 2 = $ (2 + 2)" # => "2 + 2 = 4"
# Вы можете заключить любое выражение Julia в круглые скобки.

# Печать - это просто
println («Я Джулия. Приятно познакомиться!») # => Я Джулия. Рад встрече!

# Еще один способ форматирования строк - это макрос printf из stdlib Printf.
используя Printf #, так вы загружаете (или импортируете) модуль
@printf "% d меньше% f \ n" 4.5 5,3 # => 5 меньше 5,300000


#################################################################################################### ##
## 2. Переменные и коллекции
#################################################################################################### ##

# Вы не объявляете переменные перед назначением им.
someVar = 5 # => 5
someVar # => 5

# Доступ к ранее не назначенной переменной является ошибкой
пытаться
    someOtherVar # => ОШИБКА: UndefVarError: someOtherVar не определен
поймать е
    println (e)
конец

# Имена переменных начинаются с буквы или подчеркивания.
# После этого вы можете использовать буквы, цифры, знаки подчеркивания и восклицательные знаки.SomeOtherVar123! = 6 # => 6

# Вы также можете использовать определенные символы юникода
# здесь ☃ - символы Unicode "снеговик", см. http://emojipedia.org/%E2%98%83%EF%B8%8F, если он отображается здесь неправильно
☃ = 8 # => 8
# Они особенно удобны для математических обозначений, например, константа π
2 * π # => 6.283185307179586

# Примечание о правилах именования в Julia:
#
# * Разделение слов может быть обозначено подчеркиванием ('_'), но использование
# подчеркивание не рекомендуется, если имя не будет трудночитаемым
#   иначе.#
# * Имена типов начинаются с заглавной буквы, и отображается разделение слов
# с CamelCase вместо подчеркивания.
#
# * Названия функций и макросов в нижнем регистре, без подчеркивания.
#
# * Функции, которые изменяют свои входные данные, имеют имена, заканчивающиеся на!. Эти
# функции иногда называют изменяющими функциями или функциями на месте.

# Массивы хранят последовательность значений, индексированных целыми числами от 1 до n:
a = Int64 [] # => 0-элементный массив {Int64,1}

# Литералы одномерного массива могут быть записаны со значениями, разделенными запятыми.b = [4, 5, 6] # => Трехэлементный массив {Int64,1}: [4, 5, 6]
b = [4; 5; 6] # => Трехэлементный массив {Int64,1}: [4, 5, 6]
б [1] # => 4
b [конец] # => 6

# В двумерных массивах используются значения, разделенные пробелами, и строки, разделенные точкой с запятой.
матрица = [1 2; 3 4] # => 2 × 2 Массив {Int64,2}: [1 2; 3 4]

# Массивы определенного типа
b = Int8 [4, 5, 6] # => 3-элементный массив {Int8,1}: [4, 5, 6]

# Добавить материал в конец списка с помощью push! и добавить!
# По соглашению восклицательный знак '!' добавляется к именам функций
# которые изменяют свои аргументы
push! (a, 1) # => [1]
push! (a, 2) # => [1,2]
push! (a, 4) # => [1,2,4]
push! (a, 3) # => [1,2,4,3]
добавить! (a, b) # => [1,2,4,3,4,5,6]

# Удалить с конца с помощью pop
поп! (b) # => 6
б # => [4,5]

# Вернем обратно
push! (b, 6) # => [4,5,6]
б # => [4,5,6]

a [1] # => 1 # помните, что Юлия индексирует с 1, а не с 0!

# конец - это сокращение для последнего индекса.Его можно использовать в любом
# выражение для индексации
а [конец] # => 6

# у нас также есть popfirst! и вперед!
popfirst! (а) # => 1
a # => [2,4,3,4,5,6]
pushfirst! (a, 7) # => [7,2,4,3,4,5,6]
a # => [7,2,4,3,4,5,6]

# Имена функций, оканчивающиеся восклицательными знаками, указывают на то, что они изменяют
# их аргумент.
arr = [5,4,6] # => 3-элементный массив {Int64,1}: [5,4,6]
sort (прибл) # => [4,5,6]
arr # => [5,4,6]
sort! (прибл) # => [4,5,6]
arr # => [4,5,6]

# Взгляд за пределы - это ошибка BoundsError
пытаться
    а [0]
    # => ОШИБКА: BoundsError: попытка доступа к 7-элементному массиву {Int64,1} в
    # индекс [0]
    # => Stacktrace:
    # => [1] getindex (:: Array {Int64,1}, :: Int64) в.\ array.jl: 731
    # => [2] область верхнего уровня отсутствует: 0
    # => [3] ...
    # => в выражении, начинающемся с ... \ LearnJulia.jl: 180
    а [конец + 1]
    # => ОШИБКА: BoundsError: попытка доступа к 7-элементному массиву {Int64,1} в
    # index [8]
    # => Stacktrace:
    # => [1] getindex (:: Array {Int64,1}, :: Int64) в. \ Array.jl: 731
    # => [2] область верхнего уровня отсутствует: 0
    # => [3] ...
    # => в выражении, начинающемся с ... \ LearnJulia.jl: 188
поймать е
    println (e)
конец

# Ошибки перечисляют строку и файл, из которого они произошли, даже если он в стандартном
# библиотека.Вы можете заглянуть в папку share / julia внутри папки julia, чтобы
# найти эти файлы.

# Вы можете инициализировать массивы из диапазонов
a = [1: 5;] # => 5-элементный массив {Int64,1}: [1,2,3,4,5]
a2 = [1: 5] # => 1-элементный массив {UnitRange {Int64}, 1}: [1: 5]

# Вы можете посмотреть диапазоны с синтаксисом среза.
a [1: 3] # => [1, 2, 3]
a [2: end] # => [2, 3, 4, 5]

# Удалять элементы из массива по индексу с помощью splice!
arr = [3,4,5]
сращивание! (arr, 2) # => 4
arr # => [3,5]

# Объедините списки с помощью add!
б = [1,2,3]
добавить! (a, b) # => [1, 2, 3, 4, 5, 1, 2, 3]
a # => [1, 2, 3, 4, 5, 1, 2, 3]

# Проверить наличие в списке с помощью in
in (1, a) # => истина

# Изучить длину с длиной
длина (а) # => 8

# Кортежи неизменяемы.tup = (1, 2, 3) # => (1,2,3)
typeof (tup) # => Кортеж {Int64, Int64, Int64}
tup [1] # => 1
пытаться
    tup [1] = 3
    # => ОШИБКА: MethodError: нет соответствия метода
    # setindex! (:: Tuple {Int64, Int64, Int64}, :: Int64, :: Int64)
поймать е
    println (e)
конец

# Многие функции массива также работают с кортежами
длина (туп) # => 3
tup [1: 2] # => (1,2)
in (2, tup) # => истина

# Вы можете распаковывать кортежи в переменные
a, b, c = (1, 2, 3) # => (1,2,3)
а # => 1
б # => 2
с # => 3

# Кортежи создаются, даже если вы опускаете скобки
d, e, f = 4, 5, 6 # => (4,5,6)
d # => 4
е # => 5
f # => 6

# Кортеж из 1 элемента отличается от содержащегося в нем значения
(1,) == 1 # => ложь
(1) == 1 # => верно

# Посмотрите, как легко поменять местами два значения
e, d = d, e # => (5,4)
d # => 5
е # => 4

# Словари сопоставления магазинов
emptyDict = Dict () # => Dict {Any, Any} с 0 записями

# Вы можете создать словарь, используя литерал
fillDict = Dict ("one" => 1, "two" => 2, "three" => 3)
# => Dict {String, Int64} с 3 записями:
# => "два" => 2, "один" => 1, "три" => 3

# Найдите значения с помощью []
fillDict ["один"] # => 1

# Получить все ключи
ключи (fillDict)
# => База.KeySet для Dict {String, Int64} с 3 записями. Ключи:
# => «два», «один», «три»
# Примечание - ключи словаря не отсортированы или в том порядке, в котором вы их вставили.

# Получить все значения
значения (fillDict)
# => Base.ValueIterator для Dict {String, Int64} с 3 записями. Значения:
# => 2, 1, 3
# Примечание. То же, что и выше, относительно порядка ключей.

# Проверяем наличие ключей в словаре с помощью in, haskey
in (("one" => 1), fillDict) # => true
in (("two" => 3), fillDict) # => false
haskey (fillDict, "один") # => true
haskey (fillDict, 1) # => ложь

# Попытка найти несуществующий ключ вызовет ошибку
пытаться
    fillDict ["четыре"] # => ОШИБКА: KeyError: ключ "четыре" не найден
поймать е
    println (e)
конец

# Используйте метод get, чтобы избежать этой ошибки, указав значение по умолчанию
# get (словарь, ключ, defaultValue)
get (fillDict, «один», 4) # => 1
get (fillDict, «четыре», 4) # => 4

# Используйте наборы для представления коллекций неупорядоченных уникальных значений
emptySet = Set () # => Set (Любой [])
# Инициализировать набор значениями
fillSet = Set ([1, 2, 2, 3, 4]) # => Set ([4, 2, 3, 1])

# Добавить дополнительные значения в набор
push! (fillSet, 5) # => Set ([4, 2, 3, 5, 1])

# Проверяем, находятся ли значения в наборе
in (2, fillSet) # => истина
in (10, fillSet) # => false

# Есть функции для множественного пересечения, объединения и разницы.otherSet = Set ([3, 4, 5, 6]) # => Set ([4, 3, 5, 6])
перекресток (fillSet, otherSet) # => Set ([4, 3, 5])
union (fillSet, otherSet) # => Set ([4, 2, 3, 5, 6, 1])
setdiff (Set ([1,2,3,4]), Set ([2,3,5])) # => Set ([4, 1])

#################################################################################################### ##
## 3. Поток управления
#################################################################################################### ##

# Сделаем переменную
someVar = 5

# Вот оператор if. Отступы не имеют смысла в Юлии.
если someVar> 10
    println ("someVar полностью больше 10.")
elseif someVar <10 # Это предложение elseif не является обязательным.
    println ("someVar меньше 10")
else # Предложение else тоже необязательно.
    println ("someVar действительно 10.")
конец
# => выводит "some var меньше 10"

# Циклы For перебирают итерации.
# Итерируемые типы включают Range, Array, Set, Dict и AbstractString.
for animal = ["собака", "кошка", "мышь"]
    println ("$ animal - млекопитающее")
    # Вы можете использовать $ для интерполяции переменных или выражений в строки.# В этом особом случае скобки не нужны: $ animal и $ (animal) дают одно и то же
конец
# => собака - млекопитающее
# => кошка - млекопитающее
# => мышь - млекопитающее

# Вы можете использовать 'in' вместо '='.
для животного в ["собака", "кошка", "мышь"]
    println ("$ animal - млекопитающее")
конец
# => собака - млекопитающее
# => кошка - млекопитающее
# => мышь - млекопитающее

для пары в Dict ("собака" => "млекопитающее", "кошка" => "млекопитающее", "мышь" => "млекопитающее")
    от, до = пара
    println ("$ from - это $ to")
конец
# => мышь - млекопитающее
# => кошка - млекопитающее
# => собака - млекопитающее

for (k, v) в Dict ("собака" => "млекопитающее", "кошка" => "млекопитающее", "мышь" => "млекопитающее")
    println ("$ k - это $ v")
конец
# => мышь - млекопитающее
# => кошка - млекопитающее
# => собака - млекопитающее

# While зацикливается, пока выполняется условие
пусть x = 0
    в то время как x <4
        println (x)
        x + = 1 # Сокращение для приращения на месте: x = x + 1
    конец
конец
# => 0
# => 1
# => 2
# => 3

# Обработка исключений с помощью блока try / catch
пытаться
    ошибка ("помощь")
поймать е
    println ("поймал, $ e")
конец
# => поймал ErrorException ("помощь")

#################################################################################################### ##
## 4.Функции
#################################################################################################### ##

# Ключевое слово function создает новые функции
# имя функции (список аргументов)
#   тело...
# конец
функция add (x, y)
    println ("x - это $ x, y - $ y")

    # Функции возвращают значение своего последнего оператора
    х + у
конец

добавить (5, 6)
# => x равно 5, а y равно 6
# => 11

# Компактное назначение функций
f_add (x, y) = x + y # => f_add (общая функция с 1 методом)
f_add (3, 4) # => 7

# Функция также может возвращать несколько значений в виде кортежа
fn (x, y) = x + y, x - y # => fn (общая функция с 1 методом)
fn (3, 4) # => (7, -1)

# Вы можете определять функции, которые принимают переменное количество
# позиционные аргументы
функция varargs (args...)
    вернуть аргументы
    # используйте ключевое слово return для возврата в любое место функции
конец
# => varargs (общая функция с 1 методом)

varargs (1, 2, 3) # => (1,2,3)

# ... называется знаком.
# Мы просто использовали его в определении функции.
# Его также можно использовать в вызове функции,
# где он поместит содержимое массива или кортежа в список аргументов.
add ([5,6] ...) # это эквивалентно add (5,6)

х = (5, 6) # => (5,6)
add (x ...) # это эквивалентно add (5,6)


# Вы можете определять функции с необязательными позиционными аргументами
значения функции по умолчанию (a, b, x = 5, y = 6)
    вернуть "$ a $ b и $ x $ y"
конец
# => значения по умолчанию (общая функция с 3 методами)

по умолчанию ('h', 'g') # => "h g and 5 6"
defaults ('h', 'g', 'j') # => "h g and j 6"
defaults ('h', 'g', 'j', 'k') # => "h g and j k"
пытаться
    defaults ('h') # => ERROR: MethodError: нет метода, соответствующего значениям по умолчанию (:: Char)
    defaults () # => ERROR: MethodError: нет метода, соответствующего значениям по умолчанию ()
поймать е
    println (e)
конец

# Вы можете определять функции, которые принимают аргументы ключевого слова
function keyword_args (; k1 = 4, name2 = "hello") # обратите внимание на;
    return Dict ("k1" => k1, "name2" => name2)
конец
# => keyword_args (общая функция с 1 методом)

keyword_args (name2 = "ness") # => ["name2" => "ness", "k1" => 4]
keyword_args (k1 = "mine") # => ["name2" => "hello", "k1" => "mine"]
keyword_args () # => ["name2" => "привет", "k1" => 4]

# Вы можете комбинировать все виды аргументов в одной функции
функция all_the_args (normalArg, optionalPositionalArg = 2; keywordArg = "foo")
    println ("нормальный аргумент: $ normalArg")
    println ("необязательный аргумент: $ optionalPositionalArg")
    println ("аргумент ключевого слова: $ keywordArg")
конец
# => all_the_args (общая функция с двумя методами)

all_the_args (1, 3, keywordArg = 4)
# => нормальный аргумент: 1
# => необязательный аргумент: 3
# => ключевое слово arg: 4

# У Джулии есть первоклассные функции
функция create_adder (x)
    сумматор = функция (у)
        вернуть x + y
    конец
    возвратный сумматор
конец
# => create_adder (универсальная функция с 1 методом)

# Это "устойчивый лямбда-синтаксис" для создания анонимных функций
(x -> x> 2) (3) # => верно

# Эта функция идентична реализации create_adder выше.функция create_adder (x)
    у -> х + у
конец
# => create_adder (универсальная функция с 1 методом)

# Вы также можете назвать внутреннюю функцию, если хотите
функция create_adder (x)
    функция сумматора (y)
        х + у
    конец
    сумматор
конец
# => create_adder (универсальная функция с 1 методом)

add_10 = create_adder (10) # => (:: getfield (Main, Symbol ("# сумматор # 11")) {Int64})
                          # (общая функция с 1 методом)
add_10 (3) # => 13


# Есть встроенные функции высшего порядка
карта (add_10, [1,2,3]) # => [11, 12, 13]
filter (x -> x> 5, [3, 4, 5, 6, 7]) # => [6, 7]

# Мы можем использовать составные части списков
[add_10 (i) for i = [1, 2, 3]] # => [11, 12, 13]
[add_10 (i) for i in [1, 2, 3]] # => [11, 12, 13]
[x вместо x в [3, 4, 5, 6, 7], если x> 5] # => [6, 7]

#################################################################################################### ##
## 5.Типы
#################################################################################################### ##

# У Юлии есть система типов.
# Каждое значение имеет тип; переменные сами по себе не имеют типов.
# Вы можете использовать функцию `typeof`, чтобы получить тип значения.
typeof (5) # => Int64

# Типы - это первоклассные значения
typeof (Int64) # => Тип данных
typeof (Тип данных) # => Тип данных
# DataType - это тип, представляющий типы, включая самого себя.

# Типы используются для документации, оптимизации и отправки.
# Они не проверяются статически.# Пользователи могут определять типы
# Они похожи на записи или структуры на других языках.
# Новые типы определяются с помощью ключевого слова `struct`.

# имя структуры
# field :: OptionalType
# ...
# конец
struct Tiger
    длина хвоста :: Float64
    Coatcolor # без аннотации типа - это то же самое, что и `:: Any`
конец

# Аргументами конструктора по умолчанию являются свойства
# типа в том порядке, в котором они указаны в определении
tigger = Тигр (3,5, «оранжевый») # => Тигр (3,5, «оранжевый»)

# Тип дублирует функцию конструктора для значений этого типа
sherekhan = typeof (тигр) (5.6, «огонь») # => Тигр (5.6, «огонь»)

# Эти типы структурного стиля называются конкретными типами
# Они могут быть созданы, но не могут иметь подтипы.
# Другой тип типов - это абстрактные типы.

# abstract Name
абстрактный тип Cat end # просто имя и точка в иерархии типов

# Абстрактные типы не могут быть созданы, но могут иметь подтипы.
# Например, Number - это абстрактный тип
подтипы (Number) # => 2-элементный массив {Any, 1}:
                  # => Сложный
                  # => Настоящее
подтипы (Cat) # => 0-элементный массив {Any, 1}

# AbstractString, как следует из названия, также является абстрактным типом
подтипы (AbstractString) # => 4-элементный массив {Any, 1}:
                          # => Строка
                          # => Подстрока
                          # => SubstitutionString
                          # => Тест.GenericString

# У каждого типа есть супертип; используйте функцию `supertype`, чтобы получить его.
typeof (5) # => Int64
супертип (Int64) # => Подписанный
супертип (со знаком) # => Целое число
супертип (Целое число) # => Реальный
супертип (Реальный) # => Число
супертип (Число) # => Любой
супертип (супертип (Подписанный)) # => Реальный
супертип (Любой) # => Любой
# Все эти типы, кроме Int64, абстрактны.
typeof ("fire") # => Строка
супертип (Строка) # => AbstractString
# То же и здесь со String
супертип (SubString) # => AbstractString

# <: оператор подтипа
struct Lion <: Cat # Lion - это подтип Cat
    гриваЦвет
    рев :: AbstractString
конец

# Вы можете определить больше конструкторов для вашего типа
# Просто определите функцию с тем же именем, что и тип
# и вызовем существующий конструктор, чтобы получить значение правильного типа
Лев (рев :: AbstractString) = Лев ("зеленый", рев)
# Это внешний конструктор, потому что он находится вне определения типа

struct Panther <: Cat # Panther также является подтипом Cat
    цвет глаз
    Пантера () = новый («зеленый»)
    # Panthers будет иметь только этот конструктор, но не конструктор по умолчанию.конец
# Использование внутренних конструкторов, таких как Panther, дает вам контроль
# о том, как могут быть созданы значения типа.
# По возможности следует использовать внешние конструкторы, а не внутренние.

#################################################################################################### ##
## 6. Множественная отправка
#################################################################################################### ##

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

# Определения для льва, пантеры, тигра
функция мяу (животное :: Лев)
    animal.roar # доступ к свойствам типа через точечную нотацию
конец

функция мяу (животное :: пантера)
    "гррр"
конец

функция мяу (животное :: Тигр)
    "rawwwr"
конец

# Тестирование функции мяуканья
мяу (тигр) # => "rawwwr"
мяу (Lion ("коричневый", "ROAAR")) # => "ROAAR"
мяу (Пантера ()) # => "гррр"

# Просмотрите иерархию локальных типов
Тигр <: Cat # => false
Лев <: Cat # => правда
Пантера <: Cat # => true

# Определение функции, которая принимает Cats
функция pet_cat (cat :: Cat)
    println ("Кот говорит $ (мяу (кот))")
конец
# => pet_cat (общая функция с 1 методом)

pet_cat (Lion ("42")) # => Кот говорит 42
пытаться
    pet_cat (tigger) # => ОШИБКА: MethodError: нет метода, соответствующего pet_cat (:: Tiger)
поймать е
    println (e)
конец

# В объектно-ориентированных языках обычна однократная отправка;
# это означает, что метод выбирается на основе типа первого аргумента.# В Julia все типы аргументов способствуют выбору наилучшего метода.

# Давайте определим функцию с большим количеством аргументов, чтобы увидеть разницу
функция бой (t :: Tiger, c :: Cat)
    println ("Тигр $ (t.coatcolor) побеждает!")
конец
# => бой (общая функция с 1 методом)

бой (тигр, пантера ()) # => Оранжевый тигр побеждает!
бой (тигр, Лев ("РЕВ")) # => Оранжевый тигр побеждает!

# Давайте изменим поведение, когда Кот конкретно Лев
fight (t :: Tiger, l :: Lion) = println ("$ (l.maneColor) -гривый лев побеждает! ")
# => бой (общая функция с двумя методами)

бой (тигр, пантера ()) # => Оранжевый тигр побеждает!
бой (тигр, Лев ("РЕВ")) # => Зеленогривый лев побеждает!

# Нам не нужен Тигр, чтобы сражаться
fight (l :: Lion, c :: Cat) = println ("Победившая кошка говорит $ (мяу (c))")
# => бой (общая функция с 3 методами)

бой (Лев ("балуга!"), Пантера ()) # => Победоносный кот говорит гррр
пытаться
    бой (Пантера (), Лев ("RAWR"))
    # => ERROR: MethodError: нет метода сопоставления боя (:: Panther, :: Lion)
    # => Ближайшие кандидаты:
    # => бой (:: Тигр, :: Лев) в...
    # => бой (:: Тигр, :: Кот) в ...
    # => бой (:: Lion, :: Cat) в ...
    # => ...
поймать е
    println (e)
конец

# Также пусть кошка идет первой
fight (c :: Cat, l :: Lion) = println ("Кот бьет Льва")
# => бой (общая функция с 4 методами)

# Это предупреждение связано с тем, что неясно, какой бой будет вызван:
пытаться
    бой (Лев ("RAR"), Lion ("коричневый", "rarrr"))
    # => ERROR: MethodError: fight (:: Lion, :: Lion) неоднозначно. Кандидаты:
    # => fight (c :: Cat, l :: Lion) в Main at...
    # => бой (l :: Lion, c :: Cat) в Main at ...
    # => Возможное исправление, определение
    # => бой (:: Lion, :: Lion)
    # => ...
поймать е
    println (e)
конец
# Результат может быть другим в других версиях Юлии

fight (l :: Lion, l2 :: Lion) = println ("Львы приходят к ничьей")
# => бой (общая функция с 5 методами)
бой (Lion ("RAR"), Lion ("коричневый", "rarrr")) # => Львы приходят к ничьей


# Под капотом
# Вы можете взглянуть на llvm и сгенерированный код сборки.

square_area (l) = l * l # square_area (общая функция с 1 методом)

square_area (5) # => 25

# Что произойдет, если мы введем в поле square_area целое число?
code_native (площадь_квадрата, (Int32,), синтаксис =: intel)
    #.текст
    #; Функция square_area {
    #; Расположение: REPL [116]: 1 # Prologue
    # push rbp
    # mov rbp, rsp
    #; Функция *; {
    #; Расположение: int.jl: 54
    # imul ecx, ecx # Square l и сохраните результат в ECX
    #;}
    # mov eax, ecx
    # pop rbp # Восстановить старый базовый указатель
    # ret # Результат по-прежнему будет в EAX
    # nop dword ptr [rax + rax]
    #;}

code_native (площадь_квадрата, (Float32,), синтаксис =: intel)
    #.текст
    #; Функция square_area {
    #; Расположение: REPL [116]: 1
    # push rbp
    # mov rbp, rsp
    #; Функция *; {
    #; Расположение: float.jl: 398
    # vmulss xmm0, xmm0, xmm0 # Скалярное умножение с одинарной точностью (AVX)
    #;}
    # pop rbp
    # ret
    # nop word ptr [rax + rax]
    #;}

code_native (площадь_квадрата, (Float64,), синтаксис =: intel)
    # .text
    #; Функция square_area {
    #; Расположение: REPL [116]: 1
    # push rbp
    # mov rbp, rsp
    #; Функция *; {
    #; Расположение: поплавок.jl: 399
    # vmulsd xmm0, xmm0, xmm0 # Скалярное умножение двойной точности (AVX)
    #;}
    # pop rbp
    # ret
    # nop word ptr [rax + rax]
    #;}

# Обратите внимание, что julia будет использовать инструкции с плавающей запятой, если любой из
# аргументы являются числами с плавающей запятой.
# Посчитаем площадь круга
circle_area (r) = pi * r * r # circle_area (общая функция с 1 методом)
circle_area (5) # 78.53981633974483

code_native (область_круга, (Int32,), синтаксис =: intel)
    #.текст
    #; Функция circle_area {
    #; Расположение: REPL [121]: 1
    # push rbp
    # mov rbp, rsp
    #; Функция *; {
    #; Расположение: operator.jl: 502
    #; Функция *; {
    #; Расположение: promotion.jl: 314
    #; Функция продвижения; {
    #; Расположение: promotion.jl: 284
    #; Функция _promote; {
    #; Расположение: promotion.jl: 261
    #; Функция convert; {
    #; Расположение: number.jl: 7
    #; Тип функции; {
    #; Расположение: float.jl: 60
    # vcvtsi2sd xmm0, xmm0, ecx # Загрузить целое число (r) из памяти
    # movabs rax, 497710928 # Загрузить pi
    #;}}}}}
    #; Функция *; {
    #; Расположение: поплавок.jl: 399
    # vmulsd xmm1, xmm0, qword ptr [rax] # pi * r
    # vmulsd xmm0, xmm1, xmm0 # (pi * r) * r
    #;}}
    # pop rbp
    # ret
    # nop dword ptr [rax]
    #;}

code_native (область_круга, (Float64,), синтаксис =: intel)
    # .text
    #; Функция circle_area {
    #; Расположение: REPL [121]: 1
    # push rbp
    # mov rbp, rsp
    # movabs rax, 497711048
    #; Функция *; {
    #; Расположение: операторы.jl: 502
    #; Функция *; {
    #; Расположение: promotion.jl: 314
    #; Функция *; {
    #; Расположение: float.jl: 399
    # vmulsd xmm1, xmm0, qword ptr [rax]
    #;}}}
    #; Функция *; {
    #; Расположение: float.jl: 399
    # vmulsd xmm0, xmm1, xmm0
    #;}
    # pop rbp
    # ret
    # nop dword ptr [rax + rax]
    #;}
 

Есть предложение? Возможно, поправка? Откройте вопрос в репозитории Github или сделайте запрос на перенос самостоятельно!

Массивы, кортежи, диапазоны и другие фундаментальные типы — количественная экономика с Джулией

MethodError: нет подходящего метода * (:: Array {Float64,1}, :: Array {Float64,1})
Ближайшие кандидаты:
  * (:: Любой, :: Любой,! Соответствующий :: Любой,! Соответствующий :: Любой...) по адресу operator.jl: 529
  * (! Matched :: Adjoint {# s662, # s661}, где # s661 <: Union {DenseArray {T, 2}, Base.ReinterpretArray {T, 2, S, A}, где S, где A <: Union {SubArray { T, N, A, I, true}, где I <: Union {Tuple {Vararg {Real, N}, где N}, Tuple {AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, Base.ReshapedArray {T, 2, A, MI}, где MI <: Tuple {Vararg {Base.MultiplicativeInverses.SignedMultiplicativeInverse {Int64}, N}, где N}, где A <: Union {Base.ReinterpretArray {T , N, S, A}, где S, где A <: Union {SubArray {T, N, A, I, true}, где I <: Union {Tuple {Vararg {Real, N}, где N}, Tuple {AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, где N, где T, SubArray {T, N, A, I, true}, где I <: Union {Tuple {Vararg {Real, N}, где N}, Tuple {AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, SubArray {T, 2, A, I, L}, где L, где I < : Кортеж {Vararg {Union {Int64, AbstractRange {Int64}, Base.AbstractCartesianIndex}, N}, где N}, где A <: Union {Base.ReinterpretArray {T, N, S, A}, где S, где A <: Union {SubArray {T, N, A, I, true}, где I <: Union {Tuple {Vararg {Real, N}, где N}, Tuple {AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, где N, где T, Base.ReshapedArray {T , N, A, MI}, где MI <: Tuple {Vararg {Base.MultiplicativeInverses.SignedMultiplicativeInverse {Int64}, N}, где N}, где A <: Union {Base.ReinterpretArray {T, N, S, A}, где S, где A <: Union {SubArray {T, N, A, I, true}, где I <: Union {Tuple {Vararg {Real, N}, где N}, Tuple {AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, где N, где T, SubArray {T, N, A, I, true}, где I <: Union {Tuple {Vararg {Real, N}, где N}, Tuple {AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, где N, где T, DenseArray}}, где # s662, :: Union {DenseArray {S, 1}, Base.ReinterpretArray {S, 1, S1, A}, где S1, где A <: Union {SubArray {T, N, A, I, true}, где I <: Union {Tuple {Vararg {Real, N}, где N}, Tuple { AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, Base.ReshapedArray {S, 1, A, MI}, где MI <: Tuple {Vararg {Base.MultiplicativeInverses.SignedMultiplicativeInverse {Int64}, N}, где N}, где A <: Union {Base.ReinterpretArray {T, N, S, A}, где S, где A <: Union {SubArray {T, N, A, I, true}, где I < : Union {Tuple {Vararg {Real, N}, где N}, Tuple {AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, где N, где T, SubArray {T, N, A, I, true}, где I <: Union {Tuple {Vararg {Real, N}, где N}, Tuple {AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, SubArray {S, 1, A, I, L}, где L, где I <: Tuple {Vararg {Union {Int64, AbstractRange {Int64}, Base.AbstractCartesianIndex}, N}, где N}, где A <: Union {Base.ReinterpretArray {T, N, S, A}, где S, где A <: Union {SubArray {T, N, A, I, true}, где I <: Union {Tuple {Vararg {Real, N}, где N}, Tuple {AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, где N, где T, Base.ReshapedArray {T , N, A, MI}, где MI <: Tuple {Vararg {Base.MultiplicativeInverses.SignedMultiplicativeInverse {Int64}, N}, где N}, где A <: Union {Base.ReinterpretArray {T, N, S, A}, где S, где A <: Union {SubArray {T, N, A, I, true}, где I <: Union {Tuple {Vararg {Real, N}, где N}, Tuple {AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, где N, где T, SubArray {T, N, A, I, true}, где I <: Union {Tuple {Vararg {Real, N}, где N}, Tuple {AbstractUnitRange, Vararg {Any, N}, где N}}, где A <: DenseArray, где N, где T, DenseArray}, где N, где T, DenseArray}}), где {T <: Union {Complex {Float32}, Complex {Float64}, Float32, Float64}, S} в / buildworker / worker / package_linux64 / build / usr / share / julia / s. tdlib / v1.4 / LinearAlgebra / SRC / matmul.jl: 106
  * (! Matched :: Adjoint {# s662, # s661}, где # s661 <: LinearAlgebra.AbstractTriangular, где # s662, :: AbstractArray {T, 1}, где T) в / buildworker / worker / package_linux64 / build / usr / share /julia/stdlib/v1.4/LinearAlgebra/src/triangular.jl:1971
  ...

Трассировки стека:
 [1] область верхнего уровня в In [74]: 1 

Повысьте уровень своих словарей Julia. Используйте тип данных dict в полной мере… | by Emmett Boudreau

Одна из самых крутых особенностей Джулии - это возможность использовать синтаксические выражения.То же самое и со словарем, поскольку со словарем можно делать довольно интересные вещи, используя синтаксические выражения. Это действительно здорово для статистических вычислений, потому что может сделать доступным простой и более производительный вариант с довольно аккуратным синтаксисом. Мне лично нравится использовать синтаксические выражения для умножения матриц:

 det2 (A) = A [1,1] * A [2,2] * A [3,3] + A [1,2] * A [2, 3] * A [3,1] + A [1,3] * A [2,1] * A [3,2] - A [3,1] * A [2,2] * A [1,3 ] - A [3,2] * A [2,3] * A [1,1] - A [3,3] * A [2,1] * A [1,2] 

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

Это делает его намного быстрее.

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

Чтобы смягчить это, мы можем использовать метод get () для создания значения по умолчанию для нашего сценария, к которому мы будем прибегать в случае, если индекс, который мы ищем, не находится в словаре. Метод принимает 3 параметра; наш словарь, exampdict, наш ключ, который в этом примере: a, и наше значение по умолчанию, которое будет использоваться в случае, если этот ключ не найден в нашем словаре.

 exampdict = Dict (: a => 5,: b => 7,: c => 8) 
 a = get (exampdict,: a, 0) 

Как видите, хотя: d не смог быть доступным, потому что данных нет в словаре, мы все равно получили все наши значения соответственно, а также значение по умолчанию для d.

Используя метод in (), мы можем намного быстрее проверить ключ или пару. Это вернет логическое значение и принимает два параметра: ключ, который мы хотели бы найти, и словарь, в котором мы хотели бы искать.

 in ((: b => 8), exampdict) 

Благодаря множественной диспетчеризации Джулии, метод filter () можно использовать как для ключей словаря, так и где-либо еще. Используя filter (), мы можем фильтровать практически все и вся из нашего фрейма данных, что может быть представлено как условное. Здесь я комбинирую с условными выражениями, чтобы проверить ключи, начинающиеся с буквы K, которые также имеют значения ниже 4.

 strdict = Dict ("Orange" => 3, "Kiwi" => 2, "Kayak" => 5) 
 filter (кортеж -> начинается с (first (кортеж), "K") && last (tuple) <4, collect (strdict)) 

Излишне говорить, что filter (), безусловно, очень полезный метод! Этот метод можно использовать для чего угодно: от получения определенных ключей из словаря до избавления от пропущенных значений и значений ниже определенного числа.

Еще один красивый дьявол, возвращающийся с базы Джулии, - map (). Конечно, карта используется на разных языках и там тоже зарекомендовала себя. Однако в Julia мы можем сопоставить как ключи, так и значения словаря, например, мы могли бы сопоставить все клавиши верхнего регистра:

 map (uppercase, collect (keys (dict))) 

Это, безусловно, может быть полезно во многих ситуаций, но, на мой взгляд, filter () явно превосходит его!

11. Словари - Think Julia [Книга]

Словарь похож на массив, но более общий.В массиве индексы должны быть целыми числами; в словаре они могут быть (почти) любыми.

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

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

Функция Dict создает новый словарь без элементов (поскольку Dict - это имя встроенной функции, вам следует избегать его использования в качестве имени переменной):

  Юлия>   eng2sp   =   Dict   () 
  Dict {Any, Any} с 0 записями  

Типы ключей и значений в словаре указаны в фигурных скобках: здесь оба имеют тип Любой .

Словарь пуст. Для добавления элементов в словарь можно использовать квадратные скобки:

  julia>   eng2sp   [  «один»  ]   =   «uno»  ;  

В этой строке создается элемент, который преобразует ключ «one» в значение «uno» .