Tutorial de programação em Julia para iniciantes

Como instalar e executar Julia? 

Instalar Julia é simples. Baixe o instalador específico para o seu sistema operacional nesta página do site de Julia e marque a opção para adicionar Julia ao PATH do sistema. Se você digitar julia no terminal e receber a seguinte saída, está tudo certo.

Instalando e executando a linguagem Julia

Tanto o PyCharm quanto o VSCode oferecem plugins de Julia com realce de código e depuração. Porém, como cientistas de dados costumam usar o JupyterLab, também é fácil adicionar um kernel de Julia ao JupyterLab. Depois de entrar no prompt julia no terminal, basta executar estas duas linhas:

using Pkg
add("IJulia")

O código adiciona o pacote IJulia à instalação de Julia no sistema. Reinicie qualquer sessão ativa do JupyterLab e você verá a opção de Julia no Launcher.

Julia em execução no JupyterLab

Sintaxe básica de Julia

Esta seção cobre os fundamentos da sintaxe de Julia, incluindo variáveis, tipos de dados, operadores, vetores e mais.

Operadores  

Em programação, há caracteres especiais chamados operadores, que representam processos matemáticos ou lógicos específicos. Abaixo você vê os operadores mais comuns, como adição, subtração, multiplicação, divisão e outros. 

Observação: em Julia, comentários são escritos com # único. Tudo que vem após # é ignorado pelo programa (até o fim da linha).

# Addition in Julia
37 + 73

110

# Subtraction in Julia
17 - 19

-2

# Multiplication in Julia
29 * 33

957

# Division in Julia
22 / 7

3.142857142857143

# Backwards division in Julia, the above is equal to 0 / 5.
5 \ 0

0

# The remainder operator in Julia 
98456 % 23

16

# Raising to the power 2 (squaring)
(22 / 7) ^ 2

9.877551020408163

# Raising to the power 3 (cubing)
-7 ^ 3

-343

# Raising to the power 0.5 (square-rooting)
(355 / 133) ^ 0.5

1.633760365638372

Variáveis

Em programação, usamos variáveis para armazenar informações. Elas facilitam referenciar um dado por um nome. Por exemplo, aqui estamos guardando o número 73 na variável a e a string “Hello world!” na variável “word” (vamos ver os diferentes tipos de dados de Julia na próxima seção). Digitar o nome da variável no console imprime seu valor.

# Storing the number 73 in a variable a
a = 73
a

73

# Storing "Hello world!" in word
word = "Hello world!"
word

Hello world!

Todos os operadores e funções de Julia funcionam da mesma forma com variáveis.

# Multiplying two numeric variables
a = 73
b = 37
a * b

2701

Você pode usar qualquer caractere alfanumérico em nomes de variáveis, incluindo sublinhado. No entanto, há convenções em Julia. Nomes de variáveis:

• usam lower_snake_case (letras minúsculas e palavras separadas por sublinhado)
• não podem começar com número.

Introdução aos tipos de dados em Julia 

Tipos de dados dizem ao programa quais valores uma variável pode receber e quais operadores matemáticos ou lógicos podem ser usados sem gerar erro. Existem vários tipos em Julia; abaixo estão os mais básicos.

Você pode imprimir o tipo de uma variável com a função typeof():

# Getting the type of 3.14
typeof(3.14)

Float64

Ao realizar operações em Julia, é importante considerar as consequências dos diferentes tipos. Por exemplo, multiplicar um float por um inteiro retorna um float.

# Bank balance as an integer
balance = 100

# Interest rate as a float
interest_rate = 1.05

# Interest rate as a float
new_balance = balance * interest_rate

typeof(new_balance)

Float64

Por outro lado, operar strings com tipos numéricos geralmente gera erro. Como no exemplo a seguir.

# Bank balance as an integer
balance = 100

# Interest rate as a string
interest_rate = “5%”

# Interest rate as a float
new_balance = balance * interest_rate

ERROR: MethodError:
no method matching *(::Int64, ::String)

Convertendo tipos de dados em Julia 

É possível converter tipos de dados em Julia com funções nativas. Abaixo está uma tabela com conversões comuns. 

Trabalhando com caracteres e strings em Julia 

Vimos os tipos de dados caractere e string na seção anterior; agora vamos nos aprofundar nas operações mais comuns. Lembrete: uma string é uma sequência ordenada de caracteres (texto) entre aspas duplas. 

# A string is a series of characters
word = "Hello world!"
word

"Hello world!"

Para escrever uma string multilinha, use aspas triplas:

multi_line = """
   This is a
   multi-line string.
"""
print(multi_line)

This is a
multi-line string.

Você pode extrair informações e atributos de strings de várias formas. Por exemplo, a indexação com colchetes permite extrair caracteres individuais ou um intervalo de caracteres pela posição. No exemplo, 1:3 denota a sequência de números de 1 a 3, inclusive.

text = "Julia is a high-level, dynamic programming language"
# Extracting the first character in text based on its index
text[1]

'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

# Extracting the first three characters in text based on its index
text[1:3]
"Jul"
Acima usamos 1 dentro dos colchetes e obtivemos o primeiro caractere. Você também pode usar o operador especial begin:
# Extracting the first character in text with the begin operator
text[begin]
'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)
Ao extrair um único caractere de uma string, o tipo retornado será Char.
# Extract the type of the fourth character
typeof(text[4])
Char
# Extract the type of the fourth character
typeof(text[4])
Porém, ao fatiar uma string e extrair mais de um caractere, a saída também é uma string. 
# Extract the type of the first 5 characters
typeof(text[begin:5])
String
No exemplo acima, fatiamos os cinco primeiros caracteres do texto. Lembre-se de que ambos os índices, dos dois lados dos dois-pontos, são inclusivos. Diferente de Python, índices negativos não são suportados. Em vez disso, use o operador end com um número negativo. Por exemplo, para obter o terceiro caractere a partir do fim da string:
# Third from the end of the string
text[end-2]
'a': ASCII/Unicode U+0067 (category Ll: Letter, lowercase)
Operações comuns com strings em Julia 
Você pode usar a função length() para contar o número de caracteres de uma string.
# Count the number of characters in a string
length(text)
51
Uma tarefa comum é combinar duas ou mais strings. Você pode fazer isso com a função string(), passando as strings separadas por vírgulas.
# Creating one string from "Julia", "is", "awesome"
string("Julia ", "is ", "awesome!")
"Julia is awesome!"
Você também pode usar o operador * (multiplicação) para juntar strings.
# Creating one string by multiplying strings
"73 " * "is " * "the " * "best " * "prime."
"73 is the best prime."
Em ambos os casos, lembre-se de incluir espaços entre as palavras. Outra forma de juntar strings é repetir a mesma string várias vezes. Veja como fazer isso com o operador ^ (exponenciação):
# Creating one string with the exponentiation operator
"Three times the fun!" ^ 3
"Three times the fun! Three times the fun! Three times the fun!"
Arrays em Julia 
Outro tipo de dado comum em Julia e em outras linguagens são os arrays. Em Julia, arrays são listas de valores entre colchetes []. Eles recebem nomes diferentes conforme a dimensão. 

Arrays unidimensionais são chamados de vetores.
Arrays bidimensionais são chamados de matrizes.
Arrays tridimensionais (ou mais) são chamados simplesmente de arrays.

Neste tutorial, vamos focar apenas em vetores. Vetores podem ser criados passando itens entre colchetes, como abaixo.
# Define a three-integer vector
x = [1, 2, 3]
3-element Vector{Int64}:
1
2
3
# Get the type of x
typeof(x)
Vector{Int64} (alias for Array{Int64, 1})
O vetor x tem tipo Vector, que é um alias para um array unidimensional (como indicado por alias for Array{In664, 1}). Todos os elementos são do tipo Int64. Mas nem sempre os elementos precisam ter o mesmo tipo. Veja um vetor com elementos de tipos diferentes. 
# Define a vector with various data types
array = [1, "Hello", 22/7]
3-element Vector{Any}:
1
"Hello"
3.142857142857143
Perceba que os elementos do vetor têm o tipo Any entre chaves, indicando múltiplos tipos. Você pode até passar vetores dentro de vetores.
# Define a vector with various data types, including another vector
array = [1, 2, 3, ["Hello", 73]]
4-element Array{Any,1}:
1
2
3
Any["Hello", 73]
A função length() funciona da mesma forma em vetores e strings, contando o número de elementos do array.
# Get the length of a vector
length(array)
3
As regras de indexação são similares — aqui, indexamos o primeiro e o segundo elementos do array.
# Get the first element of a vector
array = [1, "Hello", 22/7]
array[begin]
1
# Get the last element of a vector
array[end-1]
"Hello"
Operadores booleanos e comparações numéricas 
Linguagens de programação usam valores booleanos para implementar lógica. Um booleano só pode ter dois valores: true ou false. Eles são especialmente úteis em comparações numéricas e com operadores lógicos. Vamos começar pelas comparações.
Operadores de comparação numérica em Julia
Na tabela abaixo, você encontra os operadores de comparação numérica mais usados em Julia. Como verá nos exemplos, dá para comparar booleanos, valores numéricos e mais. Repare que você pode usar uma ou duas notações para escrever menor/maior ou igual. Para a versão de um símbolo, digite \le e TAB ou \ge e TAB.




Operador


Nome


Exemplo




==


igualdade


1 == 3 # Retorna false




!=


diferença


1 != 3 # Retorna true




<


menor que


1 < 3 # Retorna true




<=, ≤


menor ou igual a


length("Hello") <= 5 # Retorna true




>


maior que


1 > 1 # Retorna false




>=, ≥


maior ou igual a


true >= true # Retorna true




Operadores booleanos em Julia
Além das comparações numéricas, existem os operadores booleanos — como and/or. Eles servem para combinar duas ou mais expressões booleanas em uma só. Abaixo estão os mais comuns e como usar. 




Operador


Nome


Exemplos




&&


operador and


true && true # Retorna true


5 > 4 && 3^3 == 27 # Retorna true




||


operador or


73 > 45 || 73 % 2 == 0 # Retorna true




Sintaxe intermediária de Julia
Declarações condicionais em Julia
Usando valores e operadores booleanos, você pode escrever condições. Por exemplo, se algo for verdadeiro — execute uma operação. Se for falso, execute outra. Condicionais também são chamadas de estruturas if/else. Veja como escrever:
if true
   print("Do something")
else
   print("Do something else")
end
Quando a condição após if avalia para true, o bloco if é executado; caso contrário, o bloco else é executado. Este exemplo verifica se um número é par ou ímpar.
number = 5

if number % 2 == 0
   print("The number is even")
else
   print("The number is odd")
end
The number is odd
Na expressão após o if, usamos o operador módulo, %, para checar se o resto da divisão por 2 é 0. Avalia para falso porque o resto de 5 dividido por 2 é 1. Logo, o else é executado. Agora, vamos usar operadores booleanos e condicionais para escrever um programa que verifica se um número é positivo, negativo ou zero. 
number = 0

if number > 0
   print("The number is positive.")
elseif number == 0
   print("The number is equal to zero.")
else
   print("The number is negative.")

end
The number is equal to zero.
Adicionamos a nova condição com a cláusula elseif. Usamos elseif quando precisamos checar duas ou mais condições em ordem específica. 
Loops for 
Um loop for é usado para iterar e realizar operações sobre cada elemento de uma sequência (string, vetor, tupla, conjunto etc.) em ordem. A sintaxe é direta em Julia. Por exemplo, vamos imprimir cada elemento de um vetor:
languages = ["Julia", "Python", "R"]

for lang = languages
   println(lang)

end
Julia
Python
R
O loop começa com a palavra-chave for. Em seguida, escolhemos um nome de variável temporária — aqui, lang, cujo valor muda conforme percorremos o vetor languages. Para indicar que estamos iterando languages, escrevemos seu nome após o operador de atribuição =.
Dentro do loop, usamos println() para imprimir cada elemento de languages, representado pela variável lang. lang é temporária porque não fica acessível após o término do loop.
Observação: a diferença entre print() e println() é que println() imprime cada item em uma nova linha.
Você pode usar tudo o que aprendeu até aqui dentro de loops for. Por exemplo, crie um array de 10 inteiros e imprima apenas os ímpares:
integers_vector = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for i = integers_vector
   # Print only odd numbers
   if i % 2 == 1
       println(i)
   end
end
1
3
5
7
9
Não se esqueça de fechar o for e o if com end.
Você também pode iterar sobre strings, já que também são sequências. Aqui, por exemplo, imprimimos cada letra da string "Julia".
for letter = "Julia"
   println(letter)

end
J
u
l
i
a
Instalando pacotes em Julia 
Todos os operadores (+, -, *, ^), funções (print(), println(), typeof()) e palavras-chave (for, if, else) que usamos vêm com a instalação de Julia. Contudo, isso não basta para resolver todos os problemas. Precisamos instalar pacotes para carregar ferramentas e funções adicionais. Pacotes são bibliotecas de código pré-escrito (por outros programadores) que adicionamos à nossa instalação de Julia para resolver problemas específicos.
Por exemplo, vamos instalar dois pacotes, DataFrames e CSV, que ajudam a manipular informações em arquivos CSV. Veja como fazer:
using Pkg
Pkg.add("DataFrames")
Pkg.add("CSV")
A classe Pkg é o gerenciador global de pacotes de Julia. Sua função add() adiciona novos pacotes à instalação. Para importar todos os nomes de funções das bibliotecas, usamos a palavra-chave using no topo dos scripts.
using DataFrames
using CSV
Vamos usar essas funções na próxima seção.
Primeiros passos com DataFrames 
Um DataFrame é um tipo especial em linguagens de ciência de dados como Julia, Python ou R, projetado para trabalhar com tabelas. O formato de arquivo mais popular para armazenar tabelas é o CSV (comma-separated values). A biblioteca DataFrame traz as ferramentas para carregar esses arquivos e manipular as informações.
Importando arquivos CSV
Vamos importar o conjunto de dados diamonds neste tutorial. O arquivo diamonds.csv é assim:

Acesse o dataset diamonds aqui
A primeira linha é o cabeçalho e contém os nomes das colunas. Vamos carregar o arquivo usando os pacotes CSV e DataFrames.
# Load in the diamonds DataFrame
diamonds = DataFrame(CSV.File("data/diamonds.csv"))
typeof(diamonds)
DataFrame
Passamos o caminho do arquivo CSV para CSV.File(), que por sua vez é passado para a função DataFrame(). A saída de typeof() mostra que deu certo.
Manipulação simples de dados 
A primeira coisa a fazer com um novo DataFrame é imprimir algumas linhas para ver sua estrutura. Use a função first().
# Print the first 7 rows of diamond
first(diamonds, 7)
7 × 10 DataFrame

As 7 primeiras linhas do dataset diamonds
A função first() retorna as primeiras n linhas de um DataFrame. Como vemos, há 6 colunas numéricas e 3 categóricas (texto). O índice também é contado como coluna nos DataFrames de Julia. 
Também existe a função last(), análoga a first(). Como o nome indica, ela retorna as últimas n linhas.
Outra função útil é size(). Ela imprime o número de linhas e colunas de um DataFrame.
# Print the dimensions of diamonds
size(diamonds)
(10000, 10)
O nosso tem 10 mil linhas e 10 colunas (incluindo o índice). O olho humano não dá conta de 10k linhas, então usamos estatísticas descritivas para entender a distribuição das colunas do conjunto de dados. Para isso, usamos a função describe()
# Summary statistics of diamonds using describe()
describe(diamonds)
10 × 7 DataFrame

Saída da função describe()
A saída é uma tabela-resumo com 7 colunas. As colunas min, max, mean e median se aplicam apenas às colunas numéricas. Em eltype, você vê os tipos de dados de cada coluna de diamonds. Os números ao lado de String se referem ao tamanho da maior string naquela coluna.
Você também pode usar a seguinte sintaxe para selecionar colunas individuais do DataFrame.
# Extracting the first 10 rows of the cut column
diamonds[:, :cut][begin:10]
10-element PooledArrays.PooledArray{String15,UInt32,1,Array{UInt32,1}}:

"Ideal"
"Ideal"
"Ideal"
"Premium"
"Fair"
"Premium"
"Very Good"
"Ideal"
"Ideal"
"Premium"
O primeiro dois-pontos dentro dos colchetes seleciona todas as linhas. Depois, especificamos o nome da coluna após a vírgula e outro dois-pontos (sem aspas). Em seguida, indexamos o array retornado para selecionar as dez primeiras linhas. Para simplificar, poderíamos selecionar as dez primeiras linhas diretamente nos primeiros colchetes, como abaixo:
# Extracting the first 10 rows of the cut column
diamonds[1:10, :carat]
10-element PooledArrays.PooledArray{String15,UInt32,1,Array{UInt32,1}}:

"Ideal"
"Ideal"
"Ideal"
"Premium"
"Fair"
"Premium"
"Very Good"
"Ideal"
"Ideal"
"Premium"
Para selecionar múltiplas colunas, coloque os nomes (com dois-pontos) dentro de colchetes.
# Extracting the first 5 rows of the cut, carat, price columns
diamonds[1:5, [:carat, :cut, :price]]
5 × 3 DataFrame

As 5 primeiras linhas e 3 colunas do dataset diamonds
Vamos rodar describe() apenas nas colunas numéricas
# Running describe on numeric columns only
describe(diamonds[:, [:carat, :depth, :table, :price, :x, :y]])

Executando describe() apenas nas colunas numéricas
Para ver o DataFrame ordenado em ordem crescente por uma coluna, use sort():
# Sort diamonds and see the first 5 rows
sorted_diamonds = sort(diamonds, :price)
first(sorted_diamonds, 5)

Tabela ordenada
Para ordenar em ordem decrescente, envolva a coluna com a função order().
# Sort diamonds in descending order and see the first 5 rows
sorted_diamonds = sort(diamonds, order(:price, rev=true))
first(sorted_diamonds, 5)



Tabela ordenada, em ordem decrescente

Perfeito! Agora você sabe carregar DataFrames e fazer uma exploração inicial.
Aprenda mais sobre Julia 
Mesmo sendo uma linguagem jovem, Julia já conta com muitos recursos para você dominar o assunto. Confira alguns para turbinar suas habilidades:

A ascensão de Julia — vale a pena aprender em 2022?
Migrando de MATLAB para Julia
Veja nossos cheat sheets, cobrindo todas as ferramentas e tecnologias de dados, incluindo Julia
Confira nosso curso Introduction to Julia