Skip to content

Julia Шпаргалка

Julia — высокоуровневый высокопроизводительный динамический язык для научных вычислений.

01

Основы

Первая программа Hello World

println добавляет перевод строки, print — нет

julia
println("Hello, World!")
print("No newline")

Комментарии

#= =# для многострочных комментариев

julia
# Single-line comment

#=
  Multi-line
  comment
=#

# Docstring
"""docstring"""

REPL (интерактивная среда)

ans хранит предыдущий результат

julia
$ julia
julia> 1 + 1
2
julia> ans  # previous result
2

Интерполяция строк

$ — для переменных, $(expression) — для выражений

julia
name = "Alice"
age = 30
println("$name is $age")
println("$(age * 2)")

Цепочки сравнений

Julia поддерживает цепочки сравнений (chained comparisons)

julia
x = 5
1 < x < 10  # true
1 <= x <= 10  # true
02

Переменные

Присваивание переменных

Поддерживаются имена переменных с Unicode-символами

julia
x = 10
name = "Alice"
π = 3.14159  # supports Unicode
δ = 0.001

Константы

const объявляет глобальную константу

julia
const PI = 3.14159
const MAX_SIZE = 100
# const declares a constant

Аннотации типов

:: — аннотация типа

julia
x::Int = 10
y::Float64 = 3.14
function f(x::Int)::String
  string(x)
end

Множественное присваивание

Поддерживается множественное присваивание

julia
a, b, c = 1, 2, 3
x, y = y, x  # swap
(a, b) = (1, 2)
03

Типы

Базовые типы

typeof возвращает тип значения

julia
typeof(42)       # Int64
typeof(3.14)     # Float64
typeof("hi")     # String
typeof(true)     # Bool
typeof('a')      # Char

Преобразование типов

Используйте имя типа как функцию преобразования

julia
Int(3.14)    # 3
Float64(3)   # 3.0
String(42)   # "42"
Char(65)     # 'A'

Абстрактные типы

abstract type объявляет абстрактный тип

julia
abstract type Animal end
abstract type Dog <: Animal end
# <: denotes subtype relationship

Структуры

struct создаёт неизменяемую структуру

julia
struct Point
  x::Float64
  y::Float64
end

p = Point(1.0, 2.0)
p.x  # 1.0

Изменяемые структуры

mutable struct разрешает изменять поля

julia
mutable struct Counter
  count::Int
end

c = Counter(0)
c.count += 1

Параметрические типы

T — параметр типа

julia
struct Point{T}
  x::T
  y::T
end

p = Point{Float64}(1.0, 2.0)
q = Point{Int}(1, 2)
04

Множественная диспетчеризация

Перегрузка функций

Ключевая особенность Julia — множественная диспетчеризация

julia
function describe(x::Int)
  "integer: $x"
end

function describe(x::String)
  "string: $x"
end

describe(42)      # "integer: 42"
describe("hi")    # "string: hi"

Параметрические методы

where задаёт параметры типа

julia
function norm(p::Point{T}) where T
  sqrt(p.x^2 + p.y^2)
end

# Works for all types T

Резервные методы

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

julia
function describe(x)
  "unknown: $x"
end

# No type annotation, matches all arguments

Неоднозначность методов

Внимательно избегайте неоднозначности методов (method ambiguity)

julia
f(x::Int, y) = 1
f(x, y::Int) = 2
# f(1, 1) raises an ambiguity error
# Need to define f(x::Int, y::Int) = 3
05

Функции

Определение функции

return необязателен — возвращается последнее выражение

julia
function add(a, b)
  return a + b
end

# Shorthand
add(a, b) = a + b

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

-> определяет анонимную функцию

julia
f = x -> x^2
f(5)  # 25

map(x -> x * 2, [1, 2, 3])

Несколько возвращаемых значений

Для нескольких значений возвращается кортеж (tuple)

julia
function divrem2(a, b)
  return a ÷ b, a % b
end

q, r = divrem2(10, 3)

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

После ; идут именованные (keyword) аргументы

julia
function plot(x, y; style="line", color="blue")
  # style and color are keyword arguments
end

plot(1:10, 1:10, color="red")

Вариативные аргументы

... собирает вариативные аргументы

julia
function sumall(args...)
  sum(args)
end

sumall(1, 2, 3, 4)  # 10

Блок do

Блок do передаёт анонимную функцию

julia
map([1, 2, 3]) do x
  x ^ 2
end
# Equivalent to map(x -> x^2, [1,2,3])
06

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

Условная конструкция if-elseif-else

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

julia
if x > 0
  println("positive")
elseif x < 0
  println("negative")
else
  println("zero")
end

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

Тернарный оператор: condition ? true_value : false_value

julia
result = x > 0 ? "pos" : "neg"

# Chained
result = x > 0 ? "pos" : x < 0 ? "neg" : "zero"

Цикл for

for in — перебор элементов

julia
for i in 1:5
  println(i)
end

for (i, v) in enumerate(arr)
  println(i, v)
end

Цикл while

Цикл while

julia
i = 1
while i <= 5
  println(i)
  i += 1
end

break и continue

&& — вычисление по короткому замыканию для условий

julia
for i in 1:10
  i == 5 && break
  i % 2 == 0 && continue
  println(i)
end
07

Массивы

Создание массивов

Массивы хранятся по столбцам (column-major)

julia
a = [1, 2, 3, 4, 5]
b = [1 2 3; 4 5 6]  # 2x3 matrix
c = zeros(3, 3)
d = ones(5)
e = rand(2, 2)

Индексация массивов

Индексы начинаются с 1

julia
a = [10, 20, 30, 40, 50]
a[1]      # 10 (1-based)
a[end]    # 50
a[2:4]    # [20, 30, 40]
a[[1, 3]] # [10, 30]

Операции с массивами

Суффикс ! означает изменение на месте (in-place)

julia
push!(a, 60)    # add to end
pop!(a)          # remove from end
append!(a, b)    # concatenate
sort(a)          # sort (returns new array)
sort!(a)         # in-place sort

Компрехеншены массивов

Аналог списковых включений

julia
[x^2 for x in 1:5]
# [1, 4, 9, 16, 25]

[x^2 for x in 1:10 if x % 2 == 0]
# [4, 16, 36, 64, 100]

Векторизация (broadcasting)

Оператор . для поэлементного применения (broadcasting)

julia
a = [1, 2, 3]
a .^ 2       # [1, 4, 9]
f.(a)        # apply f to each element
a .+ 10      # [11, 12, 13]
08

Кортежи

Кортежи

Кортежи неизменяемы

julia
t = (1, 2, 3)
t[1]  # 1
t[2]  # 2

# Named tuple
nt = (name="Alice", age=30)
nt.name  # "Alice"

Деструктуризация

Присваивание с деструктуризацией кортежа

julia
a, b, c = (1, 2, 3)
(first, second) = (10, 20)

# Ignore
_, y = (1, 2)
09

Словари

Создание словарей

Dict создаёт словарь

julia
d = Dict("a" => 1, "b" => 2)
d2 = Dict(:name => "Alice", :age => 30)
d["c"] = 3  # add

Доступ и изменение

[] — для доступа и изменения

julia
d = Dict("a" => 1, "b" => 2)
d["a"]      # 1
d["a"] = 10 # modify
delete!(d, "b")  # delete

Итерация

Перебор пар «ключ–значение»

julia
for (k, v) in d
  println(k, " => ", v)
end

keys(d)    # all keys
values(d)  # all values

Операции со словарями

Стандартные функции для словарей

julia
haskey(d, "a")    # true
get(d, "x", 0)     # default value 0
get!(d, "x", 0)    # add if missing
merge(d1, d2)      # merge
10

Строки

Основы строк

Индексы строк могут быть не непрерывными (UTF-8)

julia
s = "Hello World"
length(s)    # 11
s[1]         # 'H'
s[1:5]       # "Hello"
lastindex(s) # 11

Операции со строками

Стандартные строковые функции

julia
uppercase("hi")    # "HI"
lowercase("HI")    # "hi"
reverse("hello")   # "olleh"
strip("  hi  ")     # "hi"

Поиск и замена

Поиск и замена

julia
s = "Hello World"
findfirst("World", s)  # 7:11
occursin("World", s)   # true
replace(s, "World" => "Julia")  # "Hello Julia"

Разделение и объединение

split и join

julia
split("a,b,c", ",")   # ["a", "b", "c"]
join(["a", "b"], "-")  # "a-b"
split("hello", "")     # ['h','e','l','l','o']
11

Математические функции

Базовая математика

Встроенные математические функции

julia
abs(-5)      # 5
sqrt(16)    # 4.0
cbrt(27)    # 3.0
sign(-5)    # -1
floor(3.7)  # 3.0
ceil(3.2)   # 4.0

Тригонометрические функции

Аргументы в радианах

julia
sin(π/2)   # 1.0
cos(0)     # 1.0
tan(π/4)  # 1.0
asin(1)   # 1.5707... (π/2)

Логарифм и экспонента

log — натуральный логарифм

julia
log(ℯ)      # 1.0 (natural log)
log2(8)    # 3.0
log10(100) # 2.0
exp(1)     # 2.718... (ℯ)

Специальные значения

Математические константы и специальные значения

julia
π     # 3.14159...
ℯ     # 2.71828...
Inf   # positive infinity
NaN   # not a number
im    # imaginary unit
12

Линейная алгебра

Операции с матрицами

Стандартная библиотека LinearAlgebra

julia
using LinearAlgebra

A = [1 2; 3 4]
A'        # transpose
inv(A)    # inverse matrix
det(A)    # determinant
rank(A)   # rank

Разложение матриц

Различные матричные разложения

julia
A = [1.0 2.0; 3.0 4.0]
F = lu(A)    # LU decomposition
F = qr(A)    # QR decomposition
F = svd(A)   # SVD decomposition
F = eigen(A) # eigendecomposition

Векторные операции

Операции с векторами

julia
v1 = [1, 2, 3]
v2 = [4, 5, 6]
dot(v1, v2)    # dot product
cross(v1, v2)  # cross product
norm(v1)       # norm
v1 ⋅ v2       # dot product (Unicode)
13

Статистика

Базовая статистика

Стандартная библиотека Statistics

julia
using Statistics

data = [1, 2, 3, 4, 5]
mean(data)    # 3.0
median(data)  # 3.0
std(data)     # standard deviation
var(data)     # variance

Квантили

Вычисление квантилей

julia
using Statistics

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
quantile(data, 0.25)  # 3.25
quantile(data, 0.5)   # 5.5
quantile(data, 0.75)  # 7.75

Корреляция и ковариация

Коэффициент корреляции и ковариация

julia
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
cor(x, y)    # 1.0 (correlation coefficient)
cov(x, y)    # covariance
14

Построение графиков

Базовые графики

Plots.jl — основная библиотека для построения графиков

julia
using Plots

x = 1:10
y = x .^ 2
plot(x, y, title="Quadratic", label="x^2")

Точечная диаграмма

scatter строит точечную диаграмму (scatter plot)

julia
using Plots

x = rand(50)
y = rand(50)
scatter(x, y, markersize=5, color=:red)

Субграфики

layout управляет расположением субграфиков

julia
using Plots

p1 = plot(1:10, 1:10)
p2 = plot(1:10, (1:10).^2)
plot(p1, p2, layout=(2, 1))

Сохранение изображения

savefig сохраняет изображение

julia
using Plots

p = plot(sin, 0, 2π)
savefig(p, "sine.png")
15

Пакет DataFrames

Создание DataFrame

DataFrames.jl похож на pandas

julia
using DataFrames

df = DataFrame(
  name = ["Alice", "Bob", "Carol"],
  age = [25, 30, 35],
  city = ["NYC", "LA", "SF"]
)

Доступ к данным

Доступ по строкам и столбцам

julia
df.name      # column
df[1, :]     # first row
df[:, :age]  # age column
df[1:2, :]   # first two rows

Фильтрация и сортировка

Фильтрация и сортировка

julia
using DataFrames

filter(:age => >(28), df)  # age > 28
sort(df, :age)            # sort by age
sort(df, :age, rev=true)  # descending

Группировка и агрегация

groupby + combine для групповой агрегации

julia
using DataFrames, Statistics

combine(groupby(df, :city), :age => mean => :avg_age)
16

Файловый ввод-вывод

Чтение и запись текста

Блок open do автоматически закрывает файл

julia
# Write
open("output.txt", "w") do f
  write(f, "Hello World")
end

# Read
content = read("input.txt", String)

Построчное чтение

eachline перебирает файл построчно

julia
for line in eachline("data.txt")
  println(line)
end

# Or
lines = readlines("data.txt")

Файлы CSV

CSV.jl работает с CSV-файлами

julia
using CSV, DataFrames

df = CSV.read("data.csv", DataFrame)
CSV.write("output.csv", df)

Файлы JSON

JSON.jl работает с JSON

julia
using JSON

data = JSON.parsefile("data.json")
JSON.print("output.json", data)
17

Модули

Определение модуля

export объявляет публичный интерфейс

julia
module MyModule

export greet, add

greet(name) = println("Hello $name")
add(a, b) = a + b

end  # module

Импорт модуля

Разница между using и import

julia
using MyModule     # imports exported names
using MyModule: greet  # selective import
import MyModule        # needs MyModule.greet
import MyModule: add    # selective import

Стандартные модули

Модули стандартной библиотеки

julia
using Dates        # date and time
using LinearAlgebra # linear algebra
using Statistics     # statistics
using Random         # random numbers
18

Макросы

Определение макроса

Макросы работают с AST на этапе компиляции

julia
macro sayhi(name)
  return :(println("Hi, $name"))
end

@sayhi "Alice"  # Hi, Alice

Цитирование выражений

:() создаёт объект выражения

julia
ex = :(1 + 2)
# :(1 + 2)

dump(ex)
# Expr
#   head: Symbol call
#   args: Array[...]

Часто используемые макросы

Встроенные распространённые макросы

julia
@time sleep(1)      # timing
@assert 1 == 1      # assertion
@show x              # print variable name and value
@elapsed sleep(0.1)  # return only time
@which sin(1)        # view method location
19

Метапрограммирование

Построение выражений

Expr конструирует AST

julia
ex = Expr(:call, :+, 1, 2)
eval(ex)  # 3

# Equivalent to
eval(:(1 + 2))  # 3

Генерация кода

Цикл для генерации кода

julia
for op in (:+, :-, :*, :/)
  eval(:(f($op, a, b) = $op(a, b)))
end

f(+, 1, 2)  # 3

Гигиена макросов

Гигиена макросов предотвращает конфликты переменных

julia
macro setx(val)
  return :(x = $val)
end

# Variables in macros are hygienic and won't pollute the caller's scope
20

Параллельные вычисления

Многопоточность

Макрос @threads для параллельных циклов

julia
# Start: julia --threads=4
Threads.nthreads()  # 4

Threads.@threads for i in 1:100
  results[i] = compute(i)
end

Распределённые вычисления

Стандартная библиотека Distributed

julia
using Distributed
addprocs(4)  # add 4 worker processes

@everywhere function work(x)
  x ^ 2
end

pmap(work, 1:100)  # parallel map

Удалённый вызов

Асинхронный удалённый вызов

julia
using Distributed

ref = @spawnat :any sqrt(16)
fetch(ref)  # 4.0

# @spawnat executes on a specified process
21

Сопрограммы

Задачи (Task)

Task — сопрограмма (coroutine) в Julia

julia
t = Task(() -> begin
  println("running")
  return 42
end)

schedule(t)
wait(t)

Каналы (Channel)

Channel для обмена данными между сопрограммами

julia
ch = Channel(32)

put!(ch, 1)
put!(ch, 2)
take!(ch)  # 1
take!(ch)  # 2

Производитель-потребитель

Сопрограммы реализуют шаблон «производитель–потребитель»

julia
function producer(ch)
  for i in 1:5
    put!(ch, i)
  end
end

task = @task producer(Channel(10))
for val in task
  println(val)
end
22

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

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

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

julia
try
  risky()
catch e
  println("Error: $e")
finally
  cleanup()
end

Выброс исключения

throw выбрасывает объект исключения

julia
throw(ErrorException("something wrong"))
throw(DomainError(-1, "negative"))
error("generic error")

Пользовательские исключения

Наследуйте свой тип от Exception

julia
struct MyError <: Exception
  msg::String
end

throw(MyError("custom error"))

Утверждения

Макрос @assert

julia
@assert x > 0 "x must be positive"
# Throws AssertionError when condition is false
23

Регулярные выражения

Регулярные выражения

r"" создаёт регулярное выражение

julia
re = r"\d+"
occursin(re, "abc123")  # true
match(re, "abc123")     # RegexMatch

Поиск совпадений

match возвращает результат совпадения

julia
m = match(r"(\w+)@(\w+)", "user@host")
m.match   # "user@host"
m.captures  # ["user", "host"]
m[1]      # "user"

Поиск всех совпадений

eachmatch перебирает все совпадения

julia
for m in eachmatch(r"\d+", "a1b2c3")
  println(m.match)
end
# 1, 2, 3

Замена

replace поддерживает регулярные выражения

julia
replace("a1b2c3", r"\d" => "#")
# "a#b#c#"

replace("hello", r"l" => "L" => count=1)
# "heLlo"
24

Работа с датой и временем (DateTime)

Создание даты

Стандартная библиотека Dates

julia
using Dates

now()                    # current time
Date(2024, 1, 15)       # date
DateTime(2024, 1, 15, 10, 30)  # datetime

Форматирование

Форматирование и разбор дат

julia
using Dates

dt = now()
Dates.format(dt, "yyyy-mm-dd HH:MM:SS")
Date("2024-01-15", "yyyy-mm-dd")

Арифметика дат

Типы временных интервалов

julia
using Dates

d1 = Date(2024, 1, 1)
d2 = d1 + Day(30)     # add 30 days
diff = d2 - d1        # 30 days
Day(1) + Hour(12)     # datetime arithmetic
25

Пакеты

Установка пакетов

Pkg.add устанавливает пакеты

julia
using Pkg
Pkg.add("Plots")
Pkg.add(["DataFrames", "CSV"])
Pkg.rm("Plots")  # remove

Управление пакетами

Частые команды Pkg

julia
Pkg.status()    # view installed
Pkg.update()    # update all
Pkg.instantiate()  # install per Project.toml
Pkg.activate("env")  # activate environment

Окружения

Управление проектными окружениями

julia
# Project.toml defines dependencies
# Manifest.toml locks versions

Pkg.activate("myproject")  # activate environment
Pkg.resolve()  # resolve dependencies
26

Менеджер Pkg

Режим Pkg в REPL

] переключает в Pkg-режим REPL

julia
julia> ]
pkg> add Plots
pkg> rm Plots
pkg> status
pkg> update
pkg> test Plots

Создание пакета

generate создаёт скелет пакета

julia
pkg> generate MyPackage

# Directory structure
# MyPackage/
#   Project.toml
#   src/MyPackage.jl

Режим разработки

dev устанавливает пакет в режиме разработки

julia
pkg> dev ./MyPackage  # local development
pkg> dev MyPackage    # dev version from GitHub
pkg> free MyPackage   # exit development mode
27

Взаимодействие с другими языками

Вызов C

ccall вызывает функции C

julia
ccall((:sqrt, "libm"), Float64, (Float64,), 16.0)
# 4.0

Вызов Python

PyCall.jl вызывает Python

julia
using PyCall
np = pyimport("numpy")
np.array([1, 2, 3])
np.mean([1, 2, 3])

Вызов R

RCall.jl вызывает R

julia
using RCall
R"sd(c(1,2,3,4,5))"  # call R code
28

Вычисления на GPU

CUDA-массивы

CUDA.jl поддерживает GPU NVIDIA

julia
using CUDA

a = CUDA.ones(1000)
b = CUDA.zeros(1000)
c = a .+ b  # operations on GPU

GPU-ядро (kernel)

@cuda запускает GPU-ядро

julia
using CUDA

function kernel!(a)
  i = threadIdx().x
  if i <= length(a)
    @inbounds a[i] *= 2
  end
  return
end

@cuda threads=256 kernel!(a)

GPU AMD

AMDGPU.jl поддерживает GPU AMD

julia
using AMDGPU

a = ROCArray(ones(100))
b = a .* 2  # operations on AMD GPU

Связанные сниппеты Julia

Copy-paste ready code for common tasks.

Широковещание и векторизация

Поэлементное применение функции к массивам через точечный синтаксис и @.

Множественная диспетчеризация

Выбор метода по типам всех аргументов во время выполнения, а не только получателя.

Параметрические типы и производительность

Обобщённые, типо-стабильные контейнеры, компилируемые в специализированный код.

Макросы и выражения

Управление деревьями синтаксиса Julia как данными первого класса через :expr и macro.

Многопоточность и распределённые вычисления

Параллелизация циклов через @threads и разгрузка задач через @spawn / pmap.

Операции с DataFrame (DataFrames.jl)

Фильтрация, преобразование, группировка и соединение табличных данных с DataFrames.jl.

Советы по производительности: @inbounds, @fastmath, views

Julia на скорости C за счёт отключения проверок границ, избегания аллокаций и использования views.

Решение ОДУ с DifferentialEquations.jl

Определение и численное решение задачи Коши с адаптивным шагом.

Was this helpful?