A ciência de dados é uma área do conhecimento que envolve o estudo e a análise de dados dos mais variados tipos, incluindo financeiros, científicos, sociais e econômicos. Seu intuito é a extração de conhecimento, descoberta de informações ocultas e detecção de padrões em conjuntos de dados para auxiliar na tomada de decisões e gerar valor para o negócio.

Por conta disso, uma das profissões / carreiras mais em alta na atualidade é o cargo de Cientista de Dados. 

Um cientista de dados precisa ter um leque de conhecimentos diverso, combinando expertise em várias áreas do conhecimento, como matemática (principalmente estatística e probabilidade), conhecimentos específicos da área do negócio e, naturalmente, linguagens de programação para a criação de algoritmos e aplicações de software que são empregados no dia-a-dia.

E aqui surge a dúvida mais comum entre os aspirantes à ciência de dados: que linguagem de programação aprender? Dada a quantidade de opções existentes, incluindo linguagens de uso geral e linguagens de nicho, quais linguagens de programação seriam mais apropriadas para uso em ciência de dados?

Para ajudar a responder a essas perguntar e dar um direcionamento aos interessados na área, listo a seguir sete linguagens de programação muito importantes e úteis para o trabalho de um cientista de dados atualmente (e para outras áreas, como Big Data, Machine Learning, Inteligência Artificial, e outras).

Vamos lá!

1. Python

Python é, sem sombra de dúvida, a linguagem ideal para iniciantes em ciência de dados e muitas outras áreas da computação). Com Python é possível trabalhar em nichos diversos como aprendizado de máquina, inteligência artificial, análise de dados, visualização de dados, automação de tarefas e como linguagem de propósito geral, tudo graças ao seu extenso conjunto de poderosas bibliotecas, que inclui ferramentas como NumPy, Matplotlib, Pandas, SciPy e muitas outras.

É, atualmente, uma das linguagens mais utilizadas no mundo, e com perspectivas de crescimento ainda maior nos próximos anos.
Além de tudo isso, é uma linguagem ideal para iniciantes em computação, por sua facilidade de uso e curva de aprendizado muito suave.

É uma linguagem de código aberto, orientada a objetos, muito flexível e com uma comunidade de desenvolvedores gigantesca, que facilita enormemente a troca de informações e orientações sobre ouso da linguagem em si e suas bibliotecas.

2. Linguagem R

Outra linguagem de peso no mundo da ciência de dados, é uma das ferramentas open source para análise estatística mais poderosas disponívis, e que pode ser empregada em tarefas como processamento de grandes volumes de dados, modelagem matemática, mineração de dados, cálculos estatísticos (claro!), e ainda por cima possui bibliotecas gráficas de alta qualidade para visualização de dados.

Com R é possível criar aplicações como sistemas de detecção de fraudes financeiras, modelagem de análise de sentimentos e sistemas de recomendação, além de aplicações para áreas tão diversas quanto engenharia, medicina e biologia.

Tarefas como análise de séries temporais, clustering e modelagem linear são algumas dos exemplos de processos que a linguagem R suporta com simplicidade.

Além disso, existem várias interfaces que podem ser usadas com o R para facilitar o trabalho de desenvolvimento de algoritmos e aplicações, tais como o RStudio e Jupyter Notebooks, entre outras.

Comumente usamos Python e R combinados, unindo suas funcionalidades em um par excelente para praticamente qualquer aplicação.

Como contras da linguagem, podemos citar a velocidade de execução e a quantidade de recursos de hardware que scripts escritos em R consomem, especialmente memória RAM.

3. SQL

Linguagem de Consulta Estruturada para Bancos de Dados, é uma das linguagens mais importantes para trabalho com dados e principalmente Big Data, ao combinar capacidades analíticas e de consultas com transacionais. SQL é um conhecimento básico para praticamente qualquer interessado em trabalhar com desenvolvimento de sistemas de todos os tipos, e em ciência de dados é imprescindível.

Em que usamos SQL exatamente? Bem, trata-se de uma linguagem de domínio específico, sendo empregada no gerenciamento de dados armazenados, local ou remotamente.

Note que existem diversos “sabores” de SQL, dependendo da implementação do fabricante – mas todos seguem um mesmo padrão, o ANSI SQL. E um ponto muito favorável do SQL é que essa linguagem se integra com muita facilidade às outras linguagens de programação, sendo extremamente comum desenvolver aplicações que mesclem códigos escritos, por exemplo, em Python ou Java com SQL.

4. Java

Linguagem de propósito geral e alta performance, o Java é empregado no desenvolvimento de algoritmos para machine learning, além de encontrar aplicações em nichos como Big Data e IoT (Internet das Coisas). É vastamente empregada no desenvolvimento de aplicações móveis e para Web.

Muitos frameworks e ferramentas empregadas em Big Data são escritos ou rodam em Java, como por exemplo Apache Spark, Hive e o Hadoop.

Uma das grandes vantagens do Java é a disponibilidade de IDEs de qualidade para o desenvolvimento de aplicações com eficiência e rapidez, incluindo softwares de alta complexidade. Alguns dos IDEs mais comuns incluem o Eclipse, Netbeans e IntelliJ, entre outros menos usados.

Alguns dos nichos onde o Java é mais empregado na área de ciência de dados incluem Aprendizado Profundo (Deep Learning), Processamento de Linguagem Natural (NLP – Natural Language Processing) e Mineração de Dados (Data Mining), entre outras.

Um ponto no qual a linguagem peca é a falta de ferramentas altamente especializadas para trabalho com estatística e cálculos matemáticos avançados, o que pode ser contornado combinando a linguagem Java com outras linguagens mais especializadas como a linguagem R, por exemplo.

5. C/C++

São as linguagens mais antigas listadas neste artigo, e provavelmente as mais difíceis de aprender, mas nem por isso com importância menor: C/C++ (principalmente C++) constitui a principal ferramenta em muitos tipos de sistemas de alta performance, sendo empregada em áreas como Inteligência Artificial, Aprendizado de Máquina e Robótica, onde o processamento de dados analíticos precisa ser feito com muita rapidez e alta performance.

Uma das aplicações mais modernas do C++ é no desenvolvimento de aplicações para veículos autônomos, que necessitam de algoritmos de análise de dados altamente complexos e performáticos, e em muitas aplicações de tempo real onde conjuntos de dados precisam ser tratados praticamente no momento em que são utilizados.

É interessante notar que muitas das linguagens citadas neste artigo são elas próprias escritas em C ou C++, com Python, R e Julia, assim como muitas bibliotecas e frameworks usados em data science, como o TensorFlow, por exemplo.

6. Julia

Inicialmente concebida como uma linguagem para programação científica, é uma linguagem de alto nível extremamente rápida que pode ser usada para o desenvolvimento de diversos tipos de aplicações, sozinha ou em conjunto com bibliotecas C/C++ ou Python.

Sua grande força está nas tarefas de análise numérica, apesar de também poder ser usada como linguagem de programação de propósito geral. É uma linguagem intuitiva, bastante acessível, além de ser de código aberto.

Uma de suas principais aplicações é na área financeira, onde existe a necessidade de realizar cálculos de forma massiva e com muita rapidez, com cálculos de análise de risco ou análise de séries temporais.

Um de seus problemas é o fato de ser uma linguagem relativamente nova e, que por isso, ainda possui uma comunidade de usuários pequena, com menos documentação disponível para consulta.

Porém, permite o interfaceamento (direto ou por pacotes específicos) com bibliotecas de outras linguagens, como Python, R, C++, Matlab e até mesmo Fortran, a´lem de possuir suporta a computação distribuída e computação paralela, o que significa aplicações de elevada performance!

Suas ferramentas de visualização de dados ainda não estão no mesmo nível das ferramentas disponíveis outras linguagens, mas vem melhorando a cada dia.

7. Matlab / Octave

Matlab é um ambiente de computação matemática e uma linguagem proprietária amplamente utilizada em cenários que demandam operações de cálculos avançados.

Encontra aplicações em análise de dados, processamento de imagens, processamento de sinais e, evidentemente, criação de modelos matemáticos por meio da manipulação de matrizes, álgebra linear, análise numérica e outras técnicas, facilitando enormemente a resolução dos problemas matemáticos mais complicados.

É uma linguagem recomendada para trabalho com Big Data e também na Indústria, principalmente de Engenharia. O Matlab traz suporte nativo a diversos formatos de dados empregados em telemetria, sensores, processamento de imagem e vídeo, e muitos outros.

Como ponto talvez negativo do Matlab posso citar o fato de não ser uma linguagem muito rápida, e necessitar de uma licença, de custo relativamente elevado, para ser usada.

O Octave é a principal alternativa ao Matlab, podendo substitui-la no geral em quase todas as tarefas necessárias para análise de dados, com algumas diferenças funcionais. Além disso, é gratuito.

Extra: Matemática

Como citado no início do artigo, conhecimentos em matemática são muito importantes – até mesmo cruciais – para o trabalho na área de data science. Alguns dos tópicos mais relevantes em matemática que é necessário dominar – ou ao menos revisar – incluem:

• Estatística (essencial)
• Probabilidade (essencial)
• Cálculo Integral e Diferencial
• Cálculo Numérico (Álgebra Linear)

Entre outros. Claro que conhecer matemática é benéfico para qualquer área de atuação, principalmente nos domínios da tecnologia, independente do trabalho ser voltado para ciência de dados ou não.

Além disso, tão importante quanto conhecer as linguagens de programação é saber como usar as diversas bibliotecas e frameworks disponíveis para data science, pois, no dia-a-dia do trabalho, é o que você irá usar com mais frequência, e por isso vale a pena investir seu tempo nesse aprendizado.

Conclusão

Neste artigo procurei trazer algumas das linguagens de programação mais indicadas para quem deseja trabalhar com ciência de dados. Note que essas sete linguagens não são as únicas que se prestam a essa tarefa, existindo outras linguagens também interessantes para a área, como Haskell e Lisp, por exemplo. Ciência de Dados é uma área muito vasta, se ramificando em inúmeros caminhos possíveis, e a verdade é que provavelmente você precisará aprender mais do que uma das linguagens citadas – talvez várias delas ao longo de sua carreira e estudos.

Finalmente, tudo o que foi exposto aqui é, basicamente, minha opinião pessoal e minha visão, baseada em meus estudos e experiência de mercado e acadêmica.

Evidentemente vocês podem pensar de forma diferente – talvez achando que uma linguagem deveria ter sido incluída na lista, ou que uma das linguagens que citei não deveria estar aqui – e por isso os convido a postarem seus pensamentos nos comentários logo abaixo, para trocarmos ideias sobre esse assunto tão importante e interessante na atualidade – e certamente pelos anos vindouros.

Até!

O post 7 Linguagens de programação para Ciência de Dados – 2021 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Damos o nome de tokens às palavras individuais e marcas de pontuação (pontos, vírgulas, etc) que compõem e dão sentido a uma frase ou parágrafo de texto. Quando lemos um texto qualquer, nosso cérebro efetua a separação dessas palavras automaticamente, de modo a entendermos o significado do conteúdo lido.

Não só nós realizamos esse processo – compiladores, por exemplo, também realizam a separação de sentença e comandos em partes individuais, como palavras-chave, operadores, nomes de objetos e outros elementos que compõem o código-fonte.
Em outras palavras, os compiladores tokenizam o código para analisá-lo, antes de tentar executá-lo.

Em Java, é possível realizar essa separação de elementos em uma string – ou seja, tokenizar – por meio do emprego do método split, pertencente à classe String.

Método split – Divide um objeto String em seus tokens componentes, separados entre si por delimitadores especificados. Comumente, os delimitadores empregados são caracteres de espaço, tabulação, newline (quebra de linha), entre outros. Mas também é possível usar outros caracteres como delimitadores – por exemplo, é comum usar vírgulas em arquivos do tipo CSV (comma-separated values / valores separados por vírgulas).

O método split toma como argumento um caractere a ser considerado como delimitador.

Exemplo

Vejamos um exemplo de tokenização de uma String em Java.

Scanner entrada = new Scanner(System.in);
System.out.println("Digite um texto para ser dividido em seus tonkens constituintes, e pressione enter:");
String texto = entrada.nextLine();
// Realizar o processamento da frase, separando seus tokens
String[] tokens = texto.split(" ");
//Informar quantos tokens há na frase:
System.out.printf("%nA frase informada possui %d tokens.%n", tokens.length);
//Mostrar os tokens obtidos
System.out.println("Os tokens da frase são:\n");
for (String item : tokens) {
  System.out.println(item);
}

Neste exemplo, a frase informada é tokenizada pelo método split, que recebeu como argumento o delimitador espaço (” “), e os tokens individuais são armazenados em um array de String que chamamos de tokens. Assim, podemos acessar qualquer um dos tokens simplesmente lendo uma posição no array, ou imprimir todos eles, como fizemos no programa.

O post Como tokenizar strings em Java com o método split apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Nesta lição abordaremos dois tipos de operadores em linguagem R: Operadores Lógicos e Operadores de Comparação.

Esse operadores trabalham sempre com dois valores de retorno possíveis: TRUE (verdadeiro) ou FALSE (falso), também denotados pelas letras maiúsculas T e F, respectivamente.

Operadores de Comparação em R

Também conhecidos como operadores relacionais, permitem estabelecer a relação entre dois valores de entrada, e retornar um valor lógico verdadeiro ou falso dependendo da relação.

Por exemplo, um operador de comparação pode comparar dois números e dizer se eles são iguais ou não.

Os operadores  de comparação em R são os seguintes:

Os operadores de comparação sempre retornam um valor lógico TRUE ou FALSE.

Operadores Lógicos em R

Também conhecidos como operadores booleanos, permitem trabalhar com múltiplas condições relacionais na mesma expressão, e retornam valores lógicos verdadeiro ou falso.

Os operadores lógicos disponíveis em R são:

Além desses operadores lógicos, também temos disponível em R a função isTRUE(x), que verifica se o valor lógico armazenado na variável x é verdadeiro ou não.

Exemplo de Operadores de Comparação

# Comparando valores numéricos

5 < 8
50 > 100

Podemos armazenar os valores lógicos em variáveis:

resultado <- 4 == 9
print(resultado)

E verificar o tipo da variável:

typeof(resultado)

Exemplos de Operadores Lógicos

# Operador not:

res <- !TRUE
print(res)
res2 <- !(6 != 6)
print(res2)

# Operador or

print(res | res2)

# Operador and

print(res & res2)

# Usando a função isTRUE()

isTRUE(res)

# Operador lógico XOR

xor(res, res2)

É isso aí! Continuaremos a estudar operadores em R na próxima lição. Até!

O post Operadores Lógicos e Operadores de Comparação em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Na lição anterior definimos o que é uma matriz em R, quais suas aplicações e como endereçar seus elementos. Agora iremos mostrar como é possível criar matrizes utilizando três funções bastante comuns em linguagem R: matrix(), rbind() e cbind().

Função matrix()

Toma um vetor e o transforma em matriz, dividindo os dados presentes no vetor em várias linhas da matriz.

Sintaxe:

matrix(data = NA, nrow = x, ncol = y, byrow = TRUE | T | F | FALSE)

Onde:

• data é a fonte dos dados (por exemplo, um vetor)
• nrow é o número de linhas desejadas
• ncol é o número de colunas desejadas
• byrow indica se a matriz será preenchida por linhas ou colunas. O padrão é F ou FALSE (por colunas).

Função rbind()

Conecta vetores formando linhas de uma matriz com cada vetor (r = row)

Sintaxe:

rbind(vetor1, vetor2, ..., vetorN)

Função cbind()

Conecta vetores formando colunas de uma matriz com cada vetor (c = column)

Sintaxe:

cbind(vetor1, vetor2, ..., vetorN)

Exemplos

1 – Criar um vetor com a função matrix()

Iniciamos criando um vetor com, digamos, 20 posições preenchidas com números:

> vetor <- 1:20

Agora vamos transformar esse vetor em uma matriz A 4×5 (quatro linhas por cinco colunas) da seguinte forma:

> A <- matrix(vetor, 4, 5)

E então verificamos o conteúdo da matriz criada:

> A

Note os índices indicados para as linhas e colunas da matriz criada.

É importante que o produto do número de linhas pelo número de colunas seja igual ao número total de itens do vetor, para que a matriz possa ser corretamente criada e preenchida. Em nosso caso, 4 linhas x 5 colunas = 20 itens, que é o tamanho do vetor.

E como acessamos o valor armazenado em uma posição da matriz? É simples: basta usar o nome da matriz, seguida de colchetes contendo o número da linha e da coluna separados por vírgulas, nessa ordem. Por exemplo, vamos acessar o elemento que está na linha 3, coluna 4 (número 15):

> A[3,4]
[1] 15

2 – Vamos agora criar uma matriz usando a função rbind()

Começamos criando, por exemplo, três vetores de caracteres, como segue:

> v1 <- c("SP","RJ","MG")
> v2 <- c("RN","MT","AM")
> v3 <- c("PE","RS","SC")

E então criamos uma matriz B unindo os três vetores criados coma função rbind():

> B <- rbind(v1, v2, v3)

E então verificamos o conteúdo da matriz:

> B

Note que são mostrados os nomes dos vetores v1, v2 e v3 nas linhas do vetor criado. Porém, para acessar uma de suas posições, basta referenciá-las normalmente pelos números de linha e coluna, como por exemplo:

> B[3,3]
     v3
[1] "SC"

Também podemos acessar o elemento fornecendo o nome do vetor que originou a linha, em vez do número da linha em si:

> B["v3",3]
      v3
[1] "SC"

3 – E por fim vamos criar uma matriz usando a função cbind().

Primeiramente vamos criar três vetores numéricos, com 6 elementos em cada, como segue:

> n1 <- 1:6
> n2 <- 12:17
> n3 <- 24:29

E então criamos a matriz C unindo os três vetores criados com a função cbind():

> C <- cbind(n1, n2, n3)

Finalmente, verificamos o conteúdo da matriz:

C

Note que os elementos são arranjados em colunas, em vez de linhas, como ocorreu com a função rbind(). E perceba também que, em vez de serem mostrados os números de índice das colunas, são mostrados os nomes dos vetores empregados. Porém, o processo de acesso aos elementos da matriz é o mesmo: basta indicar entre os colchetes os números da linha e da coluna desejados:

C[4,3]
n3
[1] 27

Ou ainda usar o nome da coluna:

C[4,"n3"]
n3
27

É isso aí! Na próxima lição vamos nos aprofundar na manipulação dos elementos de uma matriz, incluindo a atribuição, leitura e alteração dos elementos.

O post Como criar matrizes em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Damos o nome de matriz a um vetor bidimensional, composto por linhas e colunas, como uma espécie de tabela. Na verdade, podemos considerar uma matriz como um conjunto de vetores interligados.

As matrizes encontram inúmeras aplicações em computação, principalmente relacionadas às áreas de física, engenharia e análise de dados, que possuem fórmulas que dependem de quantidades multidimensionais e conjuntos de dados de múltiplas dimensões. Um exemplo bem simples de aplicação de matrizes é a construção de jogos de computadores e em computação gráfica, para realizar transformações 2D e 3D, entre inúmeras outras.

Assim como acontece com os vetores em R, somente é possível armazenar dados de um mesmo tipo nas posições de uma matriz. Assim, teremos matrizes de inteiros, ou de caracteres, ou de valores lógicos, mas não matrizes que misturem valores inteiros com caracteres, por exemplo. Além disso, os números de índice tanto das colunas quanto das linhas se inicia em 1, em vez de 0, com acontece em muitas linguagens de programação. Cuidado com esse detalhe!

Abaixo temos um exemplo de uma matriz A com 4 linhas e 4 colunas:

E, logo a seguir, temos a mesma matriz A com alguns dados inseridos em posições diversas:

Indexando os elementos de uma matriz

Para referenciar um elemento dentro de uma matriz, usamos um par de valores de índice, que representam a linha onde o valor se encontra e a coluna, respectivamente. Esses valores são números separados por uma vírgula, e posicionados dentro de colchetes (lembre-se, a posição em um vetor também é representada por um número dentro de colchetes), seguindo o nome da matriz (em nosso exemplo, matriz A). Ou seja:

NomeMatriz[Linha, Coluna]

Desta forma, na matriz mostrada anteriormente temos os valores armazenados nas seguintes posições:

Valor 22: posição A[1,1]
Valor 32: posição A[2,3]
Valor 15: posição A[2,2]
Valor 96: posição A[4,3]

Em R, podemos fazer referência a todos os elementos de uma linha em particular indicando dentro dos colchetes o números dessa linha, seguido por uma vírgula, e sem indicar o número da coluna. Assim, podemos referenciar, por exemplo, a coluna 3 de nossa matriz da seguinte forma:

> A[3,]

Isso permite selecionar todos os dados da linha 3 da matriz. E, de mesma forma, também é possível referenciar todos os valores de uma dada coluna escrevendo dentro dos colchetes uma vírgula, seguida do número da coluna – por exemplo, a coluna 2:

> A[,2]

Assim, teremos todos os dados presentes na coluna 2 da matriz A.

Na próxima lição vamos explorar as possibilidades existentes para a criação de matrizes em R.

O post Matrizes em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Já sabemos que os vetores possuem um número de índice que identifica cada valor armazenado em suas posições. Assim, para acessar um elemento qualquer, usamos esse número de índice – por exemplo, para acessar o quarto elemento de um vetor usamos o índice [4].

Porém, em R também é possível atribuir nomes às posições de índice em um vetor, de modo a ser possível acessar esses elementos por meio deste nome escolhido, em vez de utilizar apenas o seu valor numérico. Usar um nome de identificação possui inúmeras utilidades em R, como por exemplo, criar tabelas de lookup.

Um exemplo de vetor nomeado é um dataset (conjunto de dados) interno de nome islands, disponível pronto para uso no R, cuja estrutura pode ser analisada usando-se a função str():

> str(islands)
Named num [1:48] 11506 5500 16988 2968 16 ...
- attr(*, "names") = chr [1:48] "Africa" "Antarctica" "Asia" "Australia" ...

Esse vetor armazena a área da superfície das 48 maiores massas de terra do mundo, incluindo continentes e grandes ilhas. Veja que foi retornada a informação de que se trata de um vetor com 48 elementos, com os valores dos primeiros elementos mostrados.
Na segunda linha, é mostrado que esse vetor possui um atributo que contém a palavra “names“, e os primeiros elementos desse atributo são “Africa”, “Antarctica”, “Asia” e “Australia”. Esses são os nomes de cada posição do vetor, e cada posição também possui o valor armazenado e associado a esses nomes.

Desta forma, podemos acessar os elementos do vetor por nome. Por exemplo, para verificarmos os valores atribuídos às posições “Antarctica” e “Australia”, podemos fazer o seguinte:

> islands[c("Antarctica", "Australia")]
Antarctica Australia
      5500      2968

Para saber quais são os nomes existentes em um vetor nomeado empregados a função names():

> names(islands)
[1] "Africa" "Antactica" "Asia" ...
[6] "Baffin" "Banks" "Borneo" ...

(saída truncada)

Como criar um vetor nomeado em R

Criamos um vetor nomeado atribuindo valores a um vetor comum, e então empregado a função names() para associar os nomes às posições de índice do vetor criado. Vejamos alguns exemplos:

1 – Vamos criar um vetor chamado aulas.materia, no qual iremos armazenar o número de aulas existentes em quatro matérias distintas:

> aulas.materia <- c(8, 10, 8, 12)

Mas de quais matérias são essas quantidades de aulas? Vamos agora associar os nomes das matérias ao vetor, usando-os como nomes das posições de índice:

> names(aulas.materia) <- c("Física", "Português", "História", "Matemática")

Note que passamos um vetor com os nomes das matérias para ser utilizado como nomes das posições. Podemos então verificar o conteúdo do vetor nomeado criado:

> aulas.materia
Física Português História Matemática
     8        10        8         12

2 – Queremos criar um vetor que contenha os nomes dos meses do ano, e os dias que cada mês possui. Para isso, começamos criando um vetor com a quantidade de dias de cada mês, em ordem:

> dias.mês <- c(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

Logo após, vamos atribuir os nomes de índice, que são os nomes dos meses. Podemos criar um vetor contendo esses nomes, com fizemos no exemplo anterior; em inglês é possível utilizar o dataset interno chamado de “month.name”:

> names(dias.mês) <- month.name

Com o vetor criado, podemos consultar a quantidade de dias em um mês qualquer, por exemplo, em maio (“May”):

> dias.mês["May"]
May
31

O mesmo resultado será obtido se passarmos o número de índice da posição (5) em vez no nome atribuído. Para visualizar todos os meses com seus respectivos números de dias fazemos simplesmente:

> dias.mês[month.name]

Podemos também buscar itens neste vetor por meio dos valores armazenados, em vez de usar os índices ou nomes. Por exemplo, para saber quantos meses possuem no máximo 30 dias podemos executar:

> names(dias.mês[dias.mês == 30])
[1] "April" "June" "September"
[4] "November"

Neste exemplo verificamos os valores armazenados no vetor dias.mês comparando seus valores (e não os nomes de índice) com o valor 30, utilizando um operador de comparação de igualdade ==.

Nas próximas lições vamos falar sobre vetores compostos – mais precisamente, sobre matrizes em R.

O post Trabalhando com vetores nomeados em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em R, além das operações aritméticas básicas, também existem diversas funções que podem ser aplicadas diretamente a vetores, para realizar as mais variadas tarefas em conjuntos de dados simultaneamente. Um dos grupos de funções mais importantes são as funções de soma, produto e cumulativas. Nesta lição vamos explorar algumas das principais funções aritméticas que podemos aplicar a vetores em linguagem R.

A tabela a seguir mostra algumas funções aritméticas cujo resultado depende da combinação dos valores presentes em um vetor:

Vejamos exemplos de aplicação dessas funções em vetores. Para isso, empregaremos um vetor x de 15 números, criado conforme a instrução a seguir:

x <- c(13, 24, 2, 45, 34, 33, 10, 8, 32, 39, 16, 19, 9, 25, 42)

Exemplos

1 – Queremos saber o valor dos somatórios dos 15 itens no vetor x:

> res <- sum(x)
> print(res)
[1] 351

2 – Queremos descobrir quais são o maior e o menor valores presentes no vetor:

> min(x)
[1] 2
> max(x)
[1] 45

3 – Suponha que tenhamos um outro vetor, y, com os valores a seguir:

y <- c(4, 7, 9, 12, 11)

Podemos calcular o somatório combinado de ambos os vetores, x e y, usando a mesma função sum(), pois essa função aceita múltiplos vetores como entrada, bastando para isso separá-los por vírgulas:

res <- sum(x, y)
print(res)
[1] 394

4 – Vamos retornar a soma cumulativa dos valores em y – ou seja, o resultado de cada soma parcial realizada:

res <- cumsum(y)
print(res)
[1] 4 11 20 32 43

5 – Retornar o maior valor cumulativo no vetor x:

res <- cummax(x)
print(res)
[1] 13 24 24 45 45 45 45 45 45 45 45 45 45 45 45 

6 – Podemos também retornar as diferenças entre cada valor em u vetor, como por exemplo, no vetor y:

res <- diff(y)
print(res)
[1] 3 2 3 -1

Neste exemplo, foram retornados quatro números:

• 3 é a diferença entre o primeiro e o segundo valores do vetor: 7 -4 
• 2 é a diferença entre o segundo e o terceiro valores do vetor: 9 – 7
• 3 é a diferença entre o terceiro e o quarto valores do vetor: 12 – 9 
• -1 é a diferença entre o quarto e o quinto valores do vetor: 11 – 12 

7 – Também podemos aplicar essas funções a partes de um vetor. Por exemplo, suponha que se deseje saber o somatório apenas dos cinco primeiros valores do vetor x. Para tal, basta indicar entre colchetes as posições desejadas na soma:

sum(x[1:5])
[1] 118

8 – E se quisermos saber qual o valor da soma do elementos  de número 1, 2  e 4 do vetor x? Simples – basta criar um vetor com os números de índice desejados, usando a função combine,  e utilizá-lo na soma:

sum(x[c(1, 2, 4)])
[1] 82

É isso aí! Há muitas outras funções matemáticas que podem ser aplicadas a vetores em R. Vamos estudá-las nas próximas lições.

O post Linguagem R – Funções aritméticas em vetores apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Podemos efetuar operações aritméticas simples com vetores em R de forma rápida e muito fácil. Vamos criar os vetores a e b, numéricos, com os valores a seguir:

> a <- c(3, 6, 9, 12)
> b <- c(2, 4, 6, 8)

Suponha que seja precisemos adicionar os valores desses dois vetores, em forma ordenada – primeiro valor de a somado com o primeiro valor de b, e assim sucessivamente até o ultimo valor. Como fazemos isso em R? Simples – somamos os vetores diretamente:

> a + b
[1] 5 10 15 20

Simples não? Em outras linguagens de programação seria necessário criar um loop, usando alguma estrutura de repetição, e inserir a operação aritmética dentro desse loop, retornando cada valor calculado. Em R basta somar os dois vetores, e todo o cálculo é feito automaticamente.

Aplicamos essa mesma técnica para realizar outras operações básicas, como a subtração (-), multiplicação (*), divisão (/) e exponenciação (^). Veja, por exemplo, o produto entre os valores dos dois vetores:

> a * b
[1] 6 24 54 96

Ou ainda os valores do vetor a elevados aos valores do vetor b:

> a ^ b
[1] 9  1296  531441   429981696

Em todos esses exemplos os vetores possuíam o mesmo comprimento (4 elementos). Mas o que acontece se os vetores envolvidos em um cálculo aritmético tiverem tamanhos diferentes? Vejamos um exemplo – vamos criar o vetor f, contendo 6 elementos:

> f <- c(1, 1, 2, 3, 5, 8)

Vamos tentar somar esse vetor com o vetor b:

> b + f
[1] 3 5 8 11 7 12
Warning message:
In b + f: longer object length is not a multiple of shorter object length.

Todos os valores foram somados. Porém, note que os dois últimos valores obtidos, 7 e 12, corresponde à soma de 5 + 2 e 8 + 4, primeiro e segundo valores de b com os dois últimos valores de f. O que ocorreu é que, como o vetor b é menor que o vetor f, seus valores foram reciclados, ou seja, foram reutilizados quando a última posição do vetor foi utilizada no cálculo. O R nos avisou disso com a mensagem que diz que o comprimento do maior objeto (f) não é um múltiplo do comprimento do menor objeto (b).

A reciclagem sempre ocorre quando os vetores envolvidos não possuem o mesmo comprimento, e a mensagem de aviso aparece quando o maior vetor não tem um comprimento múltiplo do menor vetor – mas, ainda assim, os valores do menor vetor são reciclados até a posição necessária.

Um exemplo bem claro da reciclagem de vetores é a multiplicação de todos os valores de um vetor por um valor fixo. Suponha que os valores do vetor a precisem ser multiplicados por 5 – todos eles multiplicados por esse mesmo valor. Como procedemos? Basta multiplicar o vetor por 5:

> a * 5
[1] 15 30 45 60

Além de podermos aplicar operações aritméticas em e entre vetores, podemos também aplicar diversas funções sobre os valores de um vetor, como por exemplo calcular o somatório de seus valores, visualizar valores acumulados ou ainda a diferença entre cada valor de um vetor.

Veremos algumas dessas funções aritméticas na próxima lição.

O post Aritmética simples com vetores em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma das características mais poderosas da linguagem R é o fato de que qualquer pessoa pode criar funções e compartilhá-las com outros usuários do R, de forma organizada.
Desta forma, muitas funções estão disponíveis de forma imediata, o que facilita muito o trabalho do analista de dados – desde que ele saiba como encontrar e instalar essas funções.

A maioria das funções é distribuída na forma de pacotes (“packages”), que são constituídos por código em R, arquivos de ajuda, conjuntos de dados (datasets), e outros elementos importantes para o funcionamento das funções.

Os pacotes são, no geral, encontrados em websites especiais denominados “repositórios”. O repositório mais importante do R é o CRAN – Comprehensive R Archive Network – acessível pelo endereço http://cran.r-project.org, e possui centenas de pacotes prontos para serem adicionados à sua instalação do R.

Veremos neste tutorial como gerenciar pacotes em R utilizando comandos do terminal.

Como instalar um pacote em R

Para instalar um pacote em R usamos a função install.packages(). Sua sintaxe é a seguinte:

> install.packages(nome_pacote)

Vamos instalar um pacote de exemplo, de nome “fortunes”:

> install.packages("fortunes")

Veja a saída gerada durante a instalação do pacote:

Instalação de pacotes em linguagem R

Para usar um pacote instalado, é necessário carregá-lo quando for preciso utilizá-lo. Por padrão, o R não carrega automaticamente na memória todos os pacotes que você instala, para poupar memória do sistema.

Veja o que ocorre ao tentarmos utilizar uma função de um pacote que não foi carregado:

> fortune(1)

Para carregar um pacote instalado usamos a função library(). Sua sintaxe é bem simples:

> library("nome_pacote")

Após carregar o pacote, ele estará disponível para uso na linha de comandos e em seus scripts. Vamos carregar o pacote fortunes e tentar uma de suas funções novamente:

> library("fortunes")
> fortune(1)

Descarregando um pacote

Para descarregar um pacote que não esteja mais em uso, para liberar espaço em memória, usamos a função detach(), como segue:

> detach(package:fortunes, unload=TRUE)

A partir desse momento as funções do pacote não estarão mais disponíveis para uso, porém o pacote continua instalado no sistema, e pode ser utilizado novamente a qualquer momento, bastando para isso carregá-lo novamente.

Desinstalar pacotes em R

Para desinstalar um pacote em R usamos a função remove.packages(). Podemos remover uma ou mais funções de uma vez, fornecendo seus nomes separados por vírgulas. Veja sua sintaxe básica:

> remove.packages("pacote_a_remover")

Ou, para remover vários pacotes de uma vez:

> remove.packages(c("pacote1", "pacote2", "...", "pacoteN")

Criamos um vetor contendo os nomes dos pacotes a remover, e o passamos à função como argumento.

Atualizar pacotes em R

Podemos atualizar os pacotes existentes em uma instalação do R usando a função update.packages():

> update.packages()

Podemos também visualizar uma listagem extensa de todos os pacotes do R que estão instalados em seu sistema por meio da função installed.packages():

> installed.packages()

A imagem a seguir mostra o início da saída deste comando (truncada, pois é muito extensa):

Pacotes instalados no R. Saída truncada.

Se você utiliza o IDE RStudio, é possível realizar essas tarefas de gerenciamento de pacotes por meio da interface gráfica, de forma simplificada. Veremos como fazer isso em outro tutorial.

Até!

O post Como instalar e carregar pacotes em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Nesta lição vamos introduzir um assunto de muita importância em linguagem R: os Vetores.

Os vetores são uma das características mais importantes em R, uma estrutura de dados amplamente empregada em inúmeros cenários diferentes.

Bem, mas o que é exatamente um vetor?

Um vetor é, basicamente, um conjunto unidimensional de valores, todos do mesmo tipo, que funciona como uma espécie de “variável multivalorada”. Em R, os vetores podem ter quantos valores (elementos) forem necessários – mesmo um único valor é um vetor contendo um elemento.

A figura a seguir ilustra um vetor de nome “Vetor1“, com cinco elementos de índices de 1 a 5, preenchido com valores numéricos inteiros:

Vetor de 5 posições (elementos) preenchido com valores numéricos.

Como criar um vetor em R

Podemos criar vetores em R de várias formas. Por exemplo, é possível criar um vetor de números inteiros simplesmente usando o operador : (“até”). Suponha que você queira criar um vetor que contenha os números de 2 a 8, e batizá-lo como “vetor”. Para isso, basta executar o comando a seguir:

vetor <- 2:8

Isso criará um vetor com as posições de 1 até 7 preenchidas com os valores numéricos inteiros de 2 até 8. Para visualizar seu conteúdo, basta usar uma função como print():

print(vetor)
[1] 2 3 4 5 6 7 8

O número 1 entre colchetes no início da linha ([1]) indica que esta linha inicia com a exibição do elemento 1 do vetor (primeira posição). 

Note que o vetor criado possui os números de 2 até 8, em intervalos de valor 1. Esse intervalo é o padrão, mas podemos especificar um intervalo diferente para os números. Para tal, fazemos uso da função seq(). Suponha um conjunto de números de 2 até 18, porém com um intervalo de valor 2 entre eles. Criamos esse vetor assim:

vetor <- seq(from = 2, to = 18, by = 2)
print(vetor)
[1] 2 4 6 8 10 12 14 16 18

A função seq() requer por padrão três parâmetros: 

• from = valor inicial
• to = valo final
• by = incremento

Alternativamente, podemos fornecer esses parâmetros (em ordem) sem a necessidade de especificá-los por nome:

vetor <- seq(2,18,2)
print(vetor)
[1] 2 4 6 8 10 12 14 16 18

Também é possível especificar o comprimento da sequência de valores a ser criada, usando o argumento opcional length.out. Neste caso, o tamanho do intervalo entre os valores será calculado automaticamente. Por exemplo, suponha que precisamos de uma sequência que contenha 10 valores, entre os números 2 e 8:

vetor <- seq(from = 2, to = 8, length.out = 10)
print(vetor)
[1] 2.00 2.66 3.33 4.00 4.66 5.33 6.00 6.66 7.33 8.00

Note que o intervalo entre os números foi calculado automaticamente, e os 10 valores foram gerados para o vetor. Neste caso é obrigatório especificar os nomes dos parâmetros passados à função.

Combinando vetores em R

É possível combinar um ou mais vetores, criando assim um novo vetor em R por meio da aplicação da função combine, representada por c( ). Com ela, podemos combinar vetores de qualquer tamanho, seja contendo um único elemento ou contendo milhares deles.

Vejamos um exemplo.

vetor1 <- 1:5
vetor2 <- 12:16
vetor3 <- c(vetor1, vetor2)
print(vetor3)
[1] 1 2 3 4 5 12 13 14 15 16

Note que a ordem dos valores é mantida – vetor1 foi passado como parâmetro antes de vetor2 à função, e por isso seus valores são mostrados antes também.

Também usamos a função c() para criar vetores que contenham valores especificados, como por exemplo:

vetor1 <- c("Fábio", "Maria", "Ana", "Bruce")

Repetindo vetores em R

Também podemos repetir os valores presentes em um vetor diversas vezes para criar um vetor de tamanho maior (ou para outro propósito qualquer), de forma simples e rápida com o emprego da função rep() – “replicate“. Podemos utilizar essa função de várias formas, passando alguns parâmetros modificadores a ela. Vejamos alguns exemplos:

1 – Repetir o vetor completo um número determinado de vezes – como por exemplo, 5 vezes:

vetor1 <- 1:5
rep(vetor1, times = 5)
[1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5
[21] 1 2 3 4 5

2 – Podemos repetir cada valor dentro do vetor com o argumento each:

vetor1 <- 1:5
rep(vetor1, each = 3)
[1] 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5

3 – Repetir cada valor um número diferente de vezes. Para isso, passamos um vetor como argumento de times, contendo o número de vezes que cada elemento deverá ser repetido em suas respectivas posições:

vetor1 <- 1:5
rep(vetor1, times = c(1,2,1,2,1))
[1] 1  2 2 3  4 4  5

Neste caso mandamos repetir o primeiro valor de vetor1 uma vez, o segundo valor duas vezes, o terceiro valor, uma vez, o quarto, duas vezes, e o quinto valor, uma vez também.

4 – Repetir os valores de um vetor um número determinado de vezes, de forma individual, até que um tamanho máximo seja alcançado (número de itens), mesmo que a última repetição fique incompleta:

vetor1 <- 1:5
rep(vetor1, length.out = 16)
[1] 1  2 3 4 5 1 2 3 4 5 1 2 3 4 5 1

Pedimos para que a função repetisse os valores de vetor um até obtermos 16 valores – note que na última repetição, somente o valor “1” foi utilizado, pois é o 16º valor.

Testando o tipo de um vetor

Podemos empregar diversas funções para verificar o tipo de dado armazenado em um vetor. São elas:

• is.numeric – Verifica se um vetor é de algum tipo numérico
• is.integer – Verifica se o vetor é do tipo numérico inteiro
• is.double – Verifica se o vetor é do tipo double
• is.complex – Verifica se o vetor é do tipo número complexo
• is.character – Verifica se o vetor é do tipo string de caracteres
• is.logical  – Verifica se o vetor é do tipo booleano

Sem nos esquecermos da função typeof(), que retorna o tipo do objeto armazenado.

Vejamos alguns exemplos.

vetor1 <- 1:10
vetor2 <- c(1+2i, 2+3i, 3+5i)
vetor3 <- c("Fábio", "Monica", "Ana")
is.numeric(vetor1)
[1] TRUE
is.double(vetor1)
[1] FALSE
is.character(vetor2)
[1] FALSE
is.complex(vetor2)
[1] TRUE
is.character(vetor3)
[1] TRUE

Verificando as propriedades de um vetor em R

Podemos verificar a estrutura de um vetor – ou seja, seu tipo e conteúdo – por meio da função str(). Vejamos a estrutura dos vetores criados na seção anterior:

str(vetor1)
int [1:10] 1 2 3 4 5 6 7 8 9 10
str(vetor2)
cplx [1:3] 1+2i 2+3i 3+5i
str(vetor3)
chr [1:3] "Fábio" "Monica" "Ana"

A primeira palavra retornada indica o tipo de dados do vetor (inteiro, complexo e caractere, em nosso exemplos). E os números dentro dos colchetes indicam as dimensões do vetor. Por exemplo, o vetor1 possui uma única dimensão, com os índices especificados pelos números 1:10.

Caso você queria apenas saber o tamanho de um vetor, use a função length():

length(vetor2)
[1] 3

Isso nos diz que o vetor2 possui o tamanho de 3 elementos.

Como acessar os elementos de um vetor

Para que os vetores tenham realmente utilidade é necessário que seja possível acessar seus elementos individuais, para que possam ser lidos e manipulados. A maneira mais simples de fazer isso é especificar o número da posição que queremos acessar entre colchetes. Veja um exemplo:

vetor <- c("Fábio", "Monica", "Ana", "Pedro")
print(vetor[2])
[1] "Monica"

Neste exemplo acessamos a posição de índice 2 do vetor, que nos retornou o segundo valor armazenado – no caso a string “Monica”.

Podemos acessar mais de um elemento combinando seus números de índice:

print(vetor[c(1,3)])
[1] "Fábio" "Ana"

Retornar todos os elementos exceto alguns determinados:

print(vetor[c(-1, -4)])
[1] "Monica" "Ana"

Ou ainda retornar apenas um grupo sequencial de elementos, como por exemplo os três primeiros:

print(vetor[1:3))
[1] "Fábio" "Monica" "Ana"

Alterando o conteúdo de um vetor

Podemos alterar os valores dos elementos de um vetor empregando também os colchetes e números de índice. Veja um exemplo:

vetor <- c("Fábio", "Monica", "Ana", "Pedro")
print(vetor[2])
[1] "Monica"
vetor[2] <- "Sofia"
vetor[2]
[1] "Sofia"

Neste exemplo nós alteramos o elemento da segunda posição do vetor de “Monica” para “Sofia”.

Podemos esvaziar um vetor atribuindo a ele o valor NULL:

vetor <- NULL
vetor
NULL

Note que o vetor continua existindo, apesar de não possuir nenhum elemento. Caso seja necessário destrui-lo em definitivo, desalocando o vetor da memória, use a função rm():

rm(vetor)
vetor
Error: object 'vetor' not found

Aritmética com Vetores

É possível realizar operações aritméticas com os valores contidos em um vetor. Essas operações são efetuadas membro a membro, ou seja, em um elemento por vez.

Vejamos um exemplo. Suponha um vetor de 5 números, de 1 a 5. Queremos multiplicar todos os seus elementos por 2:

vetor <- 1:5
vetor * 2
[1] 2 4 6 8 10

Outro exemplo. Suponha que também temos um outro vetor, vetor2, com os números de 20 a 24, e queremos adicionar o dois vetores:

vetor <- 1:5
vetor2 <- 20:24
vetor + vetor2
[1] 21 23 25 27 29

Veja que o primeiro elemento de vetor foi adicionado ao primeiro elemento de vetor2, e assim por diante.

O mesmo ocorrerá com as outras operações básicas – multiplicação, subtração e divisão.

Reciclagem

Se, ao efetuarmos uma operação aritmética entre dois vetores, um deles tiver tamanho diferente – ou seja, of menor – seus valores serão reciclados (repetidos) durante as operações. Veja o exemplo:

vetor <- 1:5
vetor2 <- 6:8
vetor * vetor2
[1] 6 14 24 24 35
Warning message:
In vetor * vetor2 :
longer object length is not a multiple of shorter object length

Note que foi emitida uma mensagem de aviso, dizendo que o comprimento do vetor maior não é um múltiplo do menor. Os valores obtidos são interpretados assim:

1 x 6 = 6
2 x 7 = 14
3 x 8 = 24
4 x 6 = 24 // Aqui começa a reciclagem de valores do vetor2.
5 x 7 = 35

O post Trabalhando com Vetores em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.