Básico
Hello World
println adiciona uma quebra de linha, print não
println("Hello, World!")
print("No newline")Comentários
#= =# para comentários multilinha
# Single-line comment
#=
Multi-line
comment
=#
# Docstring
"""docstring"""REPL
ans guarda o resultado anterior
$ julia
julia> 1 + 1
2
julia> ans # previous result
2Interpolação de strings
$ para variáveis, $(expression) para expressões
name = "Alice"
age = 30
println("$name is $age")
println("$(age * 2)")Comparações encadeadas
Julia suporta comparações encadeadas
x = 5
1 < x < 10 # true
1 <= x <= 10 # trueVariáveis
Atribuição de variáveis
Suporta nomes de variáveis Unicode
x = 10
name = "Alice"
π = 3.14159 # supports Unicode
δ = 0.001Constantes
const declara uma constante global
const PI = 3.14159
const MAX_SIZE = 100
# const declares a constantAnotações de tipo
:: para anotações de tipo
x::Int = 10
y::Float64 = 3.14
function f(x::Int)::String
string(x)
endAtribuição múltipla
Suporta atribuição múltipla
a, b, c = 1, 2, 3
x, y = y, x # swap
(a, b) = (1, 2)Tipos
Tipos básicos
typeof obtém o tipo
typeof(42) # Int64
typeof(3.14) # Float64
typeof("hi") # String
typeof(true) # Bool
typeof('a') # CharConversão de tipos
Use o nome do tipo como função de conversão
Int(3.14) # 3
Float64(3) # 3.0
String(42) # "42"
Char(65) # 'A'Tipos abstratos
abstract type define um tipo abstrato
abstract type Animal end
abstract type Dog <: Animal end
# <: denotes subtype relationshipStructs
struct é imutável
struct Point
x::Float64
y::Float64
end
p = Point(1.0, 2.0)
p.x # 1.0Structs mutáveis
mutable struct permite modificação de campos
mutable struct Counter
count::Int
end
c = Counter(0)
c.count += 1Tipos paramétricos
T é um parâmetro de tipo
struct Point{T}
x::T
y::T
end
p = Point{Float64}(1.0, 2.0)
q = Point{Int}(1, 2)Multiple dispatch
Sobrecarga de funções
Recurso central de Julia: multiple dispatch
function describe(x::Int)
"integer: $x"
end
function describe(x::String)
"string: $x"
end
describe(42) # "integer: 42"
describe("hi") # "string: hi"Funções paramétricas
where especifica parâmetros de tipo
function norm(p::Point{T}) where T
sqrt(p.x^2 + p.y^2)
end
# Works for all types TFunções de fallback
Função sem anotações de tipo age como padrão
function describe(x)
"unknown: $x"
end
# No type annotation, matches all argumentsAmbiguidade de funções
Cuidado para evitar ambiguidade de funções
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) = 3Funções
Definição de função
return é opcional, retorna a última expressão
function add(a, b)
return a + b
end
# Shorthand
add(a, b) = a + bFunções anônimas
-> define uma função anônima
f = x -> x^2
f(5) # 25
map(x -> x * 2, [1, 2, 3])Múltiplos valores de retorno
Retorna uma tuple para múltiplos valores
function divrem2(a, b)
return a ÷ b, a % b
end
q, r = divrem2(10, 3)Argumentos nomeados
Depois de ; vêm os argumentos nomeados
function plot(x, y; style="line", color="blue")
# style and color are keyword arguments
end
plot(1:10, 1:10, color="red")Argumentos variádicos
... coleta argumentos variádicos
function sumall(args...)
sum(args)
end
sumall(1, 2, 3, 4) # 10Bloco do
O bloco do passa uma função anônima
map([1, 2, 3]) do x
x ^ 2
end
# Equivalent to map(x -> x^2, [1,2,3])Fluxo de controle
if-elseif-else
Expressão condicional
if x > 0
println("positive")
elseif x < 0
println("negative")
else
println("zero")
endOperador ternário
condição ? valor_se_verdadeiro : valor_se_falso
result = x > 0 ? "pos" : "neg"
# Chained
result = x > 0 ? "pos" : x < 0 ? "neg" : "zero"Loop for
for para iteração com in
for i in 1:5
println(i)
end
for (i, v) in enumerate(arr)
println(i, v)
endLoop while
loop while
i = 1
while i <= 5
println(i)
i += 1
endbreak e continue
&& avaliação de curto-circuito para condições
for i in 1:10
i == 5 && break
i % 2 == 0 && continue
println(i)
endArrays
Criando arrays
Arrays são column-major
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)Indexação de arrays
Os índices começam em 1
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]Operações de array
O sufixo ! significa modificação in-place
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 sortArray comprehension
Parecido com list comprehension
[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
O operador . para broadcasting
a = [1, 2, 3]
a .^ 2 # [1, 4, 9]
f.(a) # apply f to each element
a .+ 10 # [11, 12, 13]Tuples
Tuples
Tuples são imutáveis
t = (1, 2, 3)
t[1] # 1
t[2] # 2
# Named tuple
nt = (name="Alice", age=30)
nt.name # "Alice"Destructuring
Atribuição por destructuring de tuple
a, b, c = (1, 2, 3)
(first, second) = (10, 20)
# Ignore
_, y = (1, 2)Dicionários
Criando dicionários
Dict cria um dicionário
d = Dict("a" => 1, "b" => 2)
d2 = Dict(:name => "Alice", :age => 30)
d["c"] = 3 # addAcesso e modificação
[] para acesso e modificação
d = Dict("a" => 1, "b" => 2)
d["a"] # 1
d["a"] = 10 # modify
delete!(d, "b") # deleteIteração
Iterar sobre pares chave-valor
for (k, v) in d
println(k, " => ", v)
end
keys(d) # all keys
values(d) # all valuesOperações de dicionário
Funções comuns de dicionário
haskey(d, "a") # true
get(d, "x", 0) # default value 0
get!(d, "x", 0) # add if missing
merge(d1, d2) # mergeStrings
Básico de strings
Os índices de string podem não ser contíguos (UTF-8)
s = "Hello World"
length(s) # 11
s[1] # 'H'
s[1:5] # "Hello"
lastindex(s) # 11Operações de string
Funções comuns de string
uppercase("hi") # "HI"
lowercase("HI") # "hi"
reverse("hello") # "olleh"
strip(" hi ") # "hi"Buscar e substituir
Buscar e substituir
s = "Hello World"
findfirst("World", s) # 7:11
occursin("World", s) # true
replace(s, "World" => "Julia") # "Hello Julia"Split e join
split e join
split("a,b,c", ",") # ["a", "b", "c"]
join(["a", "b"], "-") # "a-b"
split("hello", "") # ['h','e','l','l','o']Funções matemáticas
Matemática básica
Funções matemáticas embutidas
abs(-5) # 5
sqrt(16) # 4.0
cbrt(27) # 3.0
sign(-5) # -1
floor(3.7) # 3.0
ceil(3.2) # 4.0Funções trigonométricas
Em radianos
sin(π/2) # 1.0
cos(0) # 1.0
tan(π/4) # 1.0
asin(1) # 1.5707... (π/2)Logaritmo e exponencial
log é o logaritmo natural
log(ℯ) # 1.0 (natural log)
log2(8) # 3.0
log10(100) # 2.0
exp(1) # 2.718... (ℯ)Valores especiais
Constantes matemáticas e valores especiais
π # 3.14159...
ℯ # 2.71828...
Inf # positive infinity
NaN # not a number
im # imaginary unitÁlgebra linear
Operações de matriz
Biblioteca padrão LinearAlgebra
using LinearAlgebra
A = [1 2; 3 4]
A' # transpose
inv(A) # inverse matrix
det(A) # determinant
rank(A) # rankDecomposição de matrizes
Várias decomposições de matriz
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) # eigendecompositionOperações de vetores
Operações com vetores
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)Estatística
Estatística básica
Biblioteca padrão Statistics
using Statistics
data = [1, 2, 3, 4, 5]
mean(data) # 3.0
median(data) # 3.0
std(data) # standard deviation
var(data) # varianceQuantiles
Cálculo de quantis
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.75Correlação e covariância
Coeficiente de correlação e covariância
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
cor(x, y) # 1.0 (correlation coefficient)
cov(x, y) # covarianceGráficos
Gráficos básicos
Plots.jl é a principal biblioteca de gráficos
using Plots
x = 1:10
y = x .^ 2
plot(x, y, title="Quadratic", label="x^2")Gráfico de dispersão
scatter desenha um gráfico de dispersão
using Plots
x = rand(50)
y = rand(50)
scatter(x, y, markersize=5, color=:red)Subplots
layout controla o layout dos subplots
using Plots
p1 = plot(1:10, 1:10)
p2 = plot(1:10, (1:10).^2)
plot(p1, p2, layout=(2, 1))Salvar imagem
savefig salva a imagem
using Plots
p = plot(sin, 0, 2π)
savefig(p, "sine.png")DataFrames
Criar DataFrame
DataFrames.jl é parecido com pandas
using DataFrames
df = DataFrame(
name = ["Alice", "Bob", "Carol"],
age = [25, 30, 35],
city = ["NYC", "LA", "SF"]
)Acessar dados
Acesso por linha e coluna
df.name # column
df[1, :] # first row
df[:, :age] # age column
df[1:2, :] # first two rowsFiltrar e ordenar
Filtragem e ordenação
using DataFrames
filter(:age => >(28), df) # age > 28
sort(df, :age) # sort by age
sort(df, :age, rev=true) # descendingAgrupar e agregar
groupby + combine para agregação agrupada
using DataFrames, Statistics
combine(groupby(df, :city), :age => mean => :avg_age)I/O de arquivos
Ler e escrever texto
O bloco open do fecha o arquivo automaticamente
# Write
open("output.txt", "w") do f
write(f, "Hello World")
end
# Read
content = read("input.txt", String)Ler linha por linha
eachline itera linha por linha
for line in eachline("data.txt")
println(line)
end
# Or
lines = readlines("data.txt")Arquivos CSV
CSV.jl lida com arquivos CSV
using CSV, DataFrames
df = CSV.read("data.csv", DataFrame)
CSV.write("output.csv", df)Arquivos JSON
JSON.jl lida com JSON
using JSON
data = JSON.parsefile("data.json")
JSON.print("output.json", data)Módulos
Definir módulo
export declara a interface pública
module MyModule
export greet, add
greet(name) = println("Hello $name")
add(a, b) = a + b
end # moduleImportar módulo
Diferença entre using e import
using MyModule # imports exported names
using MyModule: greet # selective import
import MyModule # needs MyModule.greet
import MyModule: add # selective importMódulos padrão
Módulos da biblioteca padrão
using Dates # date and time
using LinearAlgebra # linear algebra
using Statistics # statistics
using Random # random numbersMacros
Definir macro
Macros operam sobre o AST em tempo de compilação
macro sayhi(name)
return :(println("Hi, $name"))
end
@sayhi "Alice" # Hi, AliceQuoting de expressões
:() cria um objeto de expressão
ex = :(1 + 2)
# :(1 + 2)
dump(ex)
# Expr
# head: Symbol call
# args: Array[...]Macros comuns
Macros comuns embutidas
@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 locationMetaprogramação
Construção de expressões
Expr constrói um AST
ex = Expr(:call, :+, 1, 2)
eval(ex) # 3
# Equivalent to
eval(:(1 + 2)) # 3Geração de código
Loop para gerar código
for op in (:+, :-, :*, :/)
eval(:(f($op, a, b) = $op(a, b)))
end
f(+, 1, 2) # 3Higiene de macros
A higiene de macros evita conflitos de variáveis
macro setx(val)
return :(x = $val)
end
# Variables in macros are hygienic and won't pollute the caller's scopeComputação paralela
Multi-threading
A macro @threads para loops paralelos
# Start: julia --threads=4
Threads.nthreads() # 4
Threads.@threads for i in 1:100
results[i] = compute(i)
endComputação distribuída
Biblioteca padrão Distributed
using Distributed
addprocs(4) # add 4 worker processes
@everywhere function work(x)
x ^ 2
end
pmap(work, 1:100) # parallel mapChamada remota
Chamada remota assíncrona
using Distributed
ref = @spawnat :any sqrt(16)
fetch(ref) # 4.0
# @spawnat executes on a specified processCorrotinas
Task
Task é a corrotina de Julia
t = Task(() -> begin
println("running")
return 42
end)
schedule(t)
wait(t)Channel
Channel para comunicação entre corrotinas
ch = Channel(32)
put!(ch, 1)
put!(ch, 2)
take!(ch) # 1
take!(ch) # 2Produtor-consumidor
Corrotinas implementam produtor-consumidor
function producer(ch)
for i in 1:5
put!(ch, i)
end
end
task = @task producer(Channel(10))
for val in task
println(val)
endTratamento de exceções
try-catch
O construto try-catch-finally
try
risky()
catch e
println("Error: $e")
finally
cleanup()
endLançar exceção
throw lança um objeto de exceção
throw(ErrorException("something wrong"))
throw(DomainError(-1, "negative"))
error("generic error")Exceção personalizada
Herde do tipo Exception
struct MyError <: Exception
msg::String
end
throw(MyError("custom error"))Asserção
A macro @assert
@assert x > 0 "x must be positive"
# Throws AssertionError when condition is falseRegex
Expressões regulares
r"" cria uma regex
re = r"\d+"
occursin(re, "abc123") # true
match(re, "abc123") # RegexMatchMatch
match retorna o resultado da correspondência
m = match(r"(\w+)@(\w+)", "user@host")
m.match # "user@host"
m.captures # ["user", "host"]
m[1] # "user"Encontrar todas
eachmatch itera sobre todas as correspondências
for m in eachmatch(r"\d+", "a1b2c3")
println(m.match)
end
# 1, 2, 3Substituir
replace suporta regex
replace("a1b2c3", r"\d" => "#")
# "a#b#c#"
replace("hello", r"l" => "L" => count=1)
# "heLlo"DateTime
Criar data
Biblioteca padrão Dates
using Dates
now() # current time
Date(2024, 1, 15) # date
DateTime(2024, 1, 15, 10, 30) # datetimeFormatação
Formatação e interpretação
using Dates
dt = now()
Dates.format(dt, "yyyy-mm-dd HH:MM:SS")
Date("2024-01-15", "yyyy-mm-dd")Aritmética de datas
Tipos de intervalo de tempo
using Dates
d1 = Date(2024, 1, 1)
d2 = d1 + Day(30) # add 30 days
diff = d2 - d1 # 30 days
Day(1) + Hour(12) # datetime arithmeticPacotes
Instalar pacotes
Pkg.add instala pacotes
using Pkg
Pkg.add("Plots")
Pkg.add(["DataFrames", "CSV"])
Pkg.rm("Plots") # removeGerenciamento de pacotes
Comandos comuns do Pkg
Pkg.status() # view installed
Pkg.update() # update all
Pkg.instantiate() # install per Project.toml
Pkg.activate("env") # activate environmentAmbientes
Gerenciamento de ambiente de projeto
# Project.toml defines dependencies
# Manifest.toml locks versions
Pkg.activate("myproject") # activate environment
Pkg.resolve() # resolve dependenciesGerenciador Pkg
Modo Pkg do REPL
] entra no modo Pkg do REPL
julia> ]
pkg> add Plots
pkg> rm Plots
pkg> status
pkg> update
pkg> test PlotsCriar pacote
generate cria um esqueleto de pacote
pkg> generate MyPackage
# Directory structure
# MyPackage/
# Project.toml
# src/MyPackage.jlModo de desenvolvimento
dev instala em modo de desenvolvimento
pkg> dev ./MyPackage # local development
pkg> dev MyPackage # dev version from GitHub
pkg> free MyPackage # exit development modeInteroperabilidade
Chamar C
ccall chama funções C
ccall((:sqrt, "libm"), Float64, (Float64,), 16.0)
# 4.0Chamar Python
PyCall.jl chama Python
using PyCall
np = pyimport("numpy")
np.array([1, 2, 3])
np.mean([1, 2, 3])Chamar R
RCall.jl chama R
using RCall
R"sd(c(1,2,3,4,5))" # call R codeComputação em GPU
Arrays CUDA
CUDA.jl suporta GPUs NVIDIA
using CUDA
a = CUDA.ones(1000)
b = CUDA.zeros(1000)
c = a .+ b # operations on GPUKernel de GPU
@cuda lança um kernel de GPU
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 suporta GPUs AMD
using AMDGPU
a = ROCArray(ones(100))
b = a .* 2 # operations on AMD GPUSnippets de Julia relacionados
Copy-paste ready code for common tasks.
Broadcasting e vetorização
Aplica uma função elemento a elemento sobre arrays com sintaxe de ponto e @.
Despacho múltiplo
Seleciona métodos pelos tipos em tempo de execução de todos os argumentos, não apenas o receptor.
Tipos paramétricos e desempenho
Define contêineres genéricos e estáveis quanto ao tipo que compilam para código especializado.
Macros e expressões
Manipula árvores de sintaxe do Julia como dados de primeira classe via :expr e macro.
Multithreading e computação distribuída
Paraleliza laços com @threads e descarrega tarefas com @spawn / pmap.
Operações com DataFrame (DataFrames.jl)
Filtra, transforma, agrupa e junta dados tabulares com DataFrames.jl.
Dicas de desempenho: @inbounds, @fastmath, views
Escreve Julia na velocidade do C removendo checagens de limites, evitando alocações e usando views.
Resolver EDOs com DifferentialEquations.jl
Define e resolve numericamente uma EDO de valor inicial com passo adaptativo.
Was this helpful?