02_tutoriais:tutorial1:start

Diferenças

Aqui você vê as diferenças entre duas revisões dessa página.

Link para esta página de comparações

Ambos lados da revisão anterior Revisão anterior
Próxima revisão		 Revisão anterior
02_tutoriais:tutorial1:start [2022/05/17 14:19] – adalardo02_tutoriais:tutorial1:start [2025/10/24 18:42] (atual) – [A classe 'factor'] adalardo
Linha 1: Linha 1:
 +<WRAP tabs>
 +  * [[02_tutoriais:tutorial1:start|Tutorial]]
 +  * [[01_curso_atual:exercicios1| Exercícios]]
 +  * [[03_apostila:01-intro| Apostila]]
 +
 +/*
 + [[02_tutoriais:tutorial1_teste:start|TesteTutorial]]
 +*/
 +</WRAP>
 +
 +====== 1a. Introdução ao R: bases da linguagem ======
 +
 +<WRAP center round important 90%>
 +Antes de iniciar essa primeira aulas veja a vídeo-aula sobre o esquema do curso em [[01_curso_atual:start|]]
 +
 +<WRAP center round box 80%>
 +
 +Meu nome é Alexandre e costumo falar devagar nas vídeo-aulas. Como elas estão em um canal do Youtube é possível acelerar clicando em ''Settings'' (símbolo de engrenagem que aparece na barra inferior do vídeo) e em seguida em ''Playback speed''. Procure a sua velocidade!
 +
 +</WRAP>
 +
 +
 +</WRAP>
 +<WRAP center round box 60%>
 +
 +{{ youtube>YjYfChQpMQw?large |}}
 +
 +</WRAP>
 +
 +Entre as várias características que definem uma linguagem computacional está a forma como o código é implementado pelo sistema operacional, ou seja, como a linguagem do programa é transformada em linguagem de máquina. Há dois tipos básicos de implementação: compilação e interpretação. O R faz parte do segundo grupo,  por isso podemos conversar com o programa a cada linha de comando. Além disso, nossa conversa com o R é definida como uma linguagem de alto nível, significando que a sintaxe é similar à linguagem humana e se distancia da linguagem da máquina que é binária, só contendo  zeros e uns. 
 + [[https://www.freecodecamp.org/news/coding-explained-in-25-profound-comics-8847ea03819c/|{{  :02_tutoriais:tutorial1:computerPrograming.jpeg?250}}]]
 +
 +
 +/*
 +<html> <img src="https://quintal7cores.com/wp-content/uploads/2019/02/MarcenariaMob.jpg" alt="maRcenaRia" width="200" style="float:left"></html>
 +*/
 +
 +Outra característica do R é que ele é uma linguagem orientada a objetos, ou seja, manipulamos objetos com procedimentos inerentes à classe a que eles pertencem. Essas características do R fazem com que esse ambiente de programação seja similar a uma oficina onde matéria-prima (objetos) e ferramentas ((funções também são uma classe de objetos)) são manipuladas para efetuar uma tarefa que normalmente se resume na construção de outros objetos, ou //'obras de arte virtuais'//. Vamos entrar nessa oficina! 
 +
 +===== ateliêR =====
 +
 +Vamos usar uma interface web para rodar o R.  Nos quadros  **rdrr.io** é possível submeter linhas de código a um servidor que interpreta o código do R e retorna o resultado da operação em uma outra janela. Caso o servidor não esteja disponível, ou a conexão da internet não seja boa, é possível rodar as linhas de código em uma sessão do R no seu computador, apenas copiando e colando as linhas de código apresentadas antes dos quadros do **rdd.io**.
 +
 +
 +O comando que vamos executar é:
 +
 +<code rsplus| Hello, world!>
 +
 +print("Hello, world")
 +
 +</code>
 +
 +
 +
 +Clique no botão RUN abaixo!
 +
 +
 +
 +{{url>https://rdrr.io/snippets/embed/?code=print(%22Hello%2C%20world!%22)}}
 +
 +
 +
 +Os computeiros dizem que a primeira coisa que devemos fazer quando aprendemos uma linguagem computacional é fazê-la dizer [[https://en.wikipedia.org/wiki/%22Hello,_World!%22_program| Hello, world!]].
 +Pronto, já fizemos nossa primeira tarefa na linguagem R!
 +
 +
 +
 +No código acima, ao clicar em **RUN** enviamos o comando ''print("Hello, world!")'' para o interpretador do R e recebemos o resultado dessa operação. Apesar da simplicidade desse exemplo, temos alguns conceitos básicos da sintaxe do R que são importantes.
 +
 +Note que temos no comando acima caracteres (letras, símbolos e espaços em branco) que estão agrupados entre aspas ''"Hello, world!"''. Esse é o primeiro conceito importante: **O que está entre aspas o R interpreta como sendo caracteres**.  Parece óbvio, mas veja o que acontece ao rodar o código abaixo:
 +
 +
 +<code rsplus>
 +print(Hello)
 +</code>
 +
 +
 +
 +{{url>https://rdrr.io/snippets/embed/?code=print(Hello)}}
 +
 +
 +A mensagem  ''Error in print(Hello) : object 'Hello' not found'', significa que o R não encontrou o objeto com o nome ''Hello''. Nossa segunda definição: **caracteres que não estão entre aspas o R interpreta como sendo o nome de objetos**. No caso, o objeto com o nome ''Hello'' não foi encontrado!
 +
 +===== Atribuição =====
 +
 +Ok! E como fazemos para criar um objeto no R? Para isso usamos as funções de atribuição. Na linguagem temos 3 tipos de atribuições utilizando símbolos diferentes: 
 +
 +
 +<WRAP center round box 90%>
 +
 +__**ATRIBUIÇÃO NO R**__
 +
 +
 +
 +  * junção dos caracteres <wrap hi> < </wrap> e <wrap hi> - </wrap> : atribuição à esquerda;
 +  * caracter <wrap hi> = </wrap>  : o mesmo que acima, atribuição à esquerda;
 +  * junção de <wrap hi> - </wrap> e  <wrap hi> > </wrap> : atribuição à direita;
 +    
 +</WRAP>
 +
 +Nas regras de boas práticas de estilo da linguagem, em geral, se diz que deve-se usar a primeira forma, que a segunda é aceitável, mas que não devemos usar a terceira!
 +
 +Outra boa prática de estilo da linguagem é, uma vez escolhida a forma a ser usada, usar sempre a mesma forma ao longo de seus **//scripts//**. Iremos definir o que é um **//script//** no item [[http://ecor.ib.usp.br/doku.php?id=02_tutoriais:tutorial1:start#o_codigo|'O Código']] desse tutorial.
 +
 +Vamos criar nosso primeiro objeto no R:
 +
 +
 +<code rsplus>
 +
 +Hello <- "Hello, world!"
 +
 +</code>
 +
 +{{url>https://rdrr.io/snippets/embed/?code=Hello%20<-%20%22Hello%2C%20world!%22}}
 +
 +**Parece que nada aconteceu**, mas atribuímos ao objeto chamado ''Hello'' os caracteres que compõem a frase ''Hello, world!''. Após criar o objeto podemos manipulá-lo ou apenas chamá-lo para exibir o que foi atribuído a ele.
 +
 +
 +<code rsplus>
 +
 +Hello
 +
 +</code>
 +
 +
 +{{url>https://rdrr.io/snippets/embed/?code=Hello%20%3C-%20%22Hello%2C%20world!%22%0AHello}}
 +
 +
 +Agora temos novamente o retorno de ''"Hello, world!"'', mas dessa vez a frase vem do objeto ''Hello''. Quando chamamos um objeto que existe no R ele nos retorna o que está armazenado nele.
 +
 +===== Classes de objetos =====
 +
 +
 +Todo o objeto criado em uma sessão do R é atribuído a uma classe. Isso é feito automaticamente pelo R, caso o usuário não explicite a classe do objeto na sua criação. Para acessar a classe do objeto que criamos, utilizamos a função ''class'':
 +
 +<code rsplus>
 +Hello <- "Hello, world!"
 +Hello
 +class(Hello)
 +</code>
 +
 +
 +{{url>https://rdrr.io/snippets/embed/?code=Hello%20%3C-%20%22Hello%2C%20world!%22%0AHello%0Aclass(Hello)}}
 +
 +
 +==== A classe 'function'  ====
 +
 +No nosso primeiro código do R, havia um objeto chamado ''print''. Vamos visualizar a classe a que pertence esse objeto:
 +
 +<code rsplus>
 +class(print)
 +</code>
 +
 +
 +{{url>https://rdrr.io/snippets/embed/?code=class(print)}}
 +
 +
 +O R nos diz que esse objeto é da classe função. Os objetos da classe ''function'' em geral estão associados a uma documentação que nos ajudam a entender como usar essa ferramenta. Para acessar a documentação no R, utilizamos outra ferramenta que é a função ''help''((O caracter ''?'' funciona como um atalho para essa função)).
 +
 +
 +
 +<code rsplus>
 +
 +help(print)
 +
 +</code>
 +/*
 +
 +<html>
 +<iframe width='100%' height='400' src='https://rdrr.io/snippets/embed/?code=help(print)' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=help(print)}}
 +
 +Uma questão interessante aqui é que estamos usando uma ferramenta, a função ''help'', para manipular o objeto ''print'', que por sua vez também é uma função. O que acontece se chamarmos o objeto ''help'' sem os parênteses?
 +
 +
 +<code rsplus>
 +
 +help
 +
 +</code>
 +
 +
 +{{url>https://rdrr.io/snippets/embed/?code=help}}
 +
 +
 +É muito importante diferenciar o objeto que contém o código da função do procedimento ao executar essa função. A diferença entre um e outro está em um detalhe pequeno que são os parênteses <wrap hi>(...)</wrap> que acompanham o nome da função. O nome da função acompanhado dos parênteses faz com que o procedimento associado a esse objeto seja executado. Caso não seja acompanhada dos parênteses, o objeto da classe função irá retornar aquilo que está atribuído a ele: __o texto de código que a função contém__. 
 +
 +
 +==== Argumentos das funções ====
 +
 +
 +Na documentação da função ''print'' há a descrição de argumentos que, entre outras coisas, flexibilizam o procedimento da função. O primeiro argumento, chamado ''x'' é o objeto que será manipulado, um outro argumento dessa função é o ''digits''.  Vamos usá-lo:
 +
 +<code rsplus>
 +
 +print(x= 1.23456789, digits = 3)
 +
 +</code>
 +
 +
 +
 +{{url>https://rdrr.io/snippets/embed/?code=print(x= 1.23456789, digits = 3)}}
 +
 +
 +Para explicitar que estamos manipulando objetos, podemos fazer o procedimento em duas etapas, primeiro atribuindo o valor ''1,23456789'' a um objeto e depois solicitando para que ele seja mostrado na tela com apenas 3 dígitos.
 +
 +
 +<code rsplus>
 +
 +numero <- 1.23456789
 +print(x= numero, digits = 3)
 +
 +</code>
 +
 +
 +{{url>https://rdrr.io/snippets/embed/?code=numero%20%3C-%201.23456789%20%20%0Aprint(x%20%3D%20numero%2C%20digits%20%3D%203)%0A%20}}
 +
 +
 +<WRAP center round important 90%>
 +**O padrão decimal do R**
 +\\
 +Note que o R utiliza o símbolo de ''.'' para indicar o decimal no padrão de números em Inglês. O padrão em Português, que é o uso de '','' como indicador, não funciona no R! 
 +</WRAP>
 +
 +Agora vamos ver a diferença na manipulação que o ''print'' faz, dependendo da classe do objeto:
 +
 +
 +<code rsplus>
 +
 +palavra <- "1.23456789"
 +print(x= palavra, digits = 3)
 +
 +</code>
 +
 +/*
 +
 +<html>
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=numero%20%3C-%201.23456789%20%20%0Apalavra%20%3C-%20%221.23456789%22%0Aprint(x%20%3D%20numero%2C%20digits%20%3D%203)%0Aprint(x%20%3D%20palavra%2C%20digits%20%3D%203)%20' frameborder='0'></iframe>
 +
 +</html>
 +
 +*/
 +
 +{{url> https://rdrr.io/snippets/embed/?code=numero%20%3C-%201.23456789%20%20%0Apalavra%20%3C-%20%221.23456789%22%0Aprint(x%20%3D%20numero%2C%20digits%20%3D%203)%0Aprint(x%20%3D%20palavra%2C%20digits%20%3D%203)%20}}
 +
 +==== As classes 'numeric' e 'character' ====
 +
 +
 +Porque o objeto ''numero'' é manipulado diferentemente do objeto ''palavra''? Por que são objetos de classes diferentes e a função ''print'' reconhece essa diferença e trata eles de forma diferente. Quanto a função manipula números (i.e. classe ''numeric'') o argumento ''digits'' faz sentido. Quando o objeto é da classe ''character'' esse argumento é desprezado. Aqui tem um conceito avançado da linguagem: a função ''print'' executa diferentes procedimentos dependendo da classe do objeto que ela manipula.
 +
 +Já vimos anteriormente que para acessar a classe a que um objeto pertence podemos usar a função ''class'':
 +
 +<code rsplus>
 +
 +class(numero)
 +class(palavra)
 +
 +</code>
 +
 +
 +/*
 +<html>
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=numero%20%3C-%201.23456789%20%20%0Apalavra%20%3C-%20%221.23456789%22%0Aclass(numero)%0Aclass(palavra)' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +{{url> https://rdrr.io/snippets/embed/?code=numero%20%3C-%201.23456789%20%20%0Apalavra%20%3C-%20%221.23456789%22%0Aclass(numero)%0Aclass(palavra)}}
 +
 +Vamos agora usar uma outra função para exemplificar a sintaxe básica do R. A função em questão é ''round'', que arredonda um valor numérico até a casa decimal solicitada. Diferentemente do ''print'', que não modifica o valor, apenas imprime ele com o número de casa decimais solicitado, o ''round'', por sua vez, faz a transformação arredondando o valor ((arredondamentos podem ser danosos, principalmente para cálculos sequenciais e números pequenos)). 
 +
 +A primeira ação que deve ter ao utilizar uma função no R é: **__SEMPRE LER A DOCUMENTAÇÃO__**. 
 +A documentação do ''round'' descreve que ele também tem um argumento chamado ''digits''.
 +
 +
 +<code rsplus>
 +
 +outro <- round(numero, 4)
 +
 +</code>
 +
 +<WRAP center round important 90%>
 +**__Cadê o nome do argumento?__**
 +
 +Note que o código acima não tem o nome dos argumentos. Estamos usando uma das regras dos argumentos no R que é a posição. Caso o nome não seja dado, o R usa a posição para atribuir o valor ao argumento. É possível usar ambas regras, posição e nome, o que é bastante comum. Uma outra regra é a do padrão único do nome simplificado. Por exemplo, o ''dig =  3'' será reconhecido como ''digits = 3 '' desde que não haja nenhum outro argumento que comece com ''dig'' no nome.  Como sabemos a posição e nome dos argumentos? No ''help''. Consulte sempre a documentação! Quase todas as funções que aparecem nos códigos do wiki estão conectadas a sua documentação por um hiperlink. Portanto, use e abuse! 
 +
 +</WRAP>
 +
 +/*
 +
 +<html>
 +
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=numero%20%3C-%201.23456789%20%20%0Aoutro%20%3C-%20round(numero%2C%20digits%20%3D%204)%0Aoutro' frameborder='0'></iframe>
 +
 +</html>
 +
 +*/
 +
 +{{url>ttps://rdrr.io/snippets/embed/?code=numero%20%3C-%201.23456789%20%20%0Aoutro%20%3C-%20round(numero%2C%20digits%20%3D%204)%0Aoutro' frameborder='0}}
 +
 +==== Sintaxe básica ====
 +
 +A sintaxe básica do R pode ser definida como:
 +
 +<code rsplus>
 +
 +object <- tool(x, arg2 = y, arg3 = z)
 +
 +</code>
 +
 +Podemos ler o comando acima como sendo: "utilize a ferramenta ''tool'' para manipular o objeto '' x '' tendo  o argumento  ''arg2'' com o atributo  ''y'' e a opção ''arg3'' como ''z''. O resultado dessa manipulação é armazenado no objeto de nome ''object''. Note que o R, nesse caso, não devolveria nada na tela, pois o resultado da manipulação é atribuído a um objeto ((para atribuir o resultado a um objeto e ao mesmo tempo mostrar na tela, utilize parênteses iniciando e fechando a linha de comando)).
 +
 +
 +
 +=====  Estrutura e tipos de dados =====
 +
 +Até aqui vimos dois tipos de informação que podem ser manipuladas no R: caracteres e números. 
 +Os números, por sua vez, podem ser de dois tipos: números com decimais (''numeric'') e inteiros (''integer''). Essa distinção é importante para a maneira como o R armazena essa informação na memória do computador, de resto elas funcionam como números racionais na matemática clássica.
 +No capítulo seguinte vamos tratar das funções matemáticas mais a fundo. Aqui vamos apenas ver as bases conceituais dos tipos de dados básicos e qual a estrutura básica de armazenamento em objetos. As operações da álgebra básicas no R usam os mesmos símbolos que na matemática tradicional: ''+'', ''-'', ''/'' e ''*''. 
 +
 +
 +
 +<code rsplus>
 +
 +10 + 10
 +10 - 10
 +10 / 10
 +10 * 10
 +
 +</code>
 +
 +/*
 +
 +<html>
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=10%20%2B%2010%0A10%20-%2010%0A10%20%2F%2010%0A10%20*%2010' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=10%20%2B%2010%0A10%20-%2010%0A10%20%2F%2010%0A10%20*%2010}}
 +
 +Como vimos na seção anterior podemos atribuir valores numéricos a um objeto. Depois disso, podemos manipular os valores indiretamente por intermédio do objeto.  
 +
 +<code rsplus>
 +
 +dez <- 10 
 +dez + dez
 +dez - dez
 +dez / dez
 +dez * dez
 +
 +</code>
 +
 +/*
 +
 +<html>
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=dez%20%3C-%2010%20%0Adez%20%2B%20dez%0Adez%20-%20dez%0Adez%20%2F%20dez%0Adez%20*%20dez' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url> https://rdrr.io/snippets/embed/?code=dez%20%3C-%2010%20%0Adez%20%2B%20dez%0Adez%20-%20dez%0Adez%20%2F%20dez%0Adez%20*%20dez}}
 +
 +Atribuímos o valor ''10'' ao objeto ''dez'' e depois manipulamos o objeto ''dez''. Isso não parece ser uma vantagem. Estamos trocando dois dígitos, o valor ''10'', por um objeto que contém 3 letras, o ''dez''. A vantagem começa quando atribuímos o resultado de operações a um outro objeto.
 +
 +<code rsplus>
 +
 +cem <- dez * dez
 +dezmil <- cem * cem
 +cem 
 +dezmil
 +
 +</code>
 +
 +/*
 +
 +<html>
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=dez%20%3C-%2010%20%0Acem%20%3C-%20dez%20*%20dez%0Adezmil%20%3C-%20cem%20*%20cem%0Acem%20%0Adezmil' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=dez%20%3C-%2010%20%0Acem%20%3C-%20dez%20*%20dez%0Adezmil%20%3C-%20cem%20*%20cem%0Acem%20%0Adezmil}}
 +==== Vetores ====
 +
 +
 +Ficaria ainda melhor se pudéssemos operar mais de um valor de uma vez. Como armazenar mais de um valor em um objeto? Usamos a função ''c'' que significa ''c''oncatenar ou ''c''ombinar. Os elementos combinados são a estrutura básica de dados no R, que é o objeto da classe ''vector''. Esse é o elemento básico dos objetos no R. Mesmo que o objeto só tenha um elemento, trata-se de um vetor com comprimento igual a um. 
 +
 +
 +<code rsplus>
 +
 +contadez <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 +contadez
 +
 +</code>
 +
 +/*
 +
 +<html>
 +
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=contadez%20%3C-%20c(1%2C%202%2C%203%2C%204%2C%205%2C%206%2C%207%2C%208%2C%209%2C%2010)%0Acontadez' frameborder='0'></iframe>
 +
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=contadez%20%3C-%20c(1%2C%202%2C%203%2C%204%2C%205%2C%206%2C%207%2C%208%2C%209%2C%2010)%0Acontadez}}
 +
 +=== Indexação de Vetores ===
 +
 +Note que, antes de iniciar a apresentação dos valores que estão no vetor ''contadez'' o R apresenta o valor 1 entre colchetes ''[1]''. Caso o nosso vetor fosse longo e tivesse que ser apresentado em várias linhas, outros valores em colchetes iriam iniciar essa outras linhas de apresentação dos dados. Esses valores representam a indexação do elemento que inicia a linha de apresentação do conteúdo do vetor. Ou seja, o elemento na posição 1, no nosso caso é o valor ''1''.  
 +Vamos inverter esse vetor, em seguida combiná-lo com o vetor anterior!
 +
 +
 +
 +
 +<code rsplus>
 +
 +invertedez <- rev(contadez)
 +descontadez <- c(invertedez, contadez)
 +descontadez
 +
 +</code>
 +
 +
 +/*
 +
 +<html>
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=contadez%20%3C-%20c(1%2C%202%2C%203%2C%204%2C%205%2C%206%2C%207%2C%208%2C%209%2C%2010)%0Ainvertedez%20%3C-%20rev(contadez)%0Adescontadez%20%3C-%20c(invertedez%2C%20contadez)%0Adescontadez' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=contadez%20%3C-%20c(1%2C%202%2C%203%2C%204%2C%205%2C%206%2C%207%2C%208%2C%209%2C%2010)%0Ainvertedez%20%3C-%20rev(contadez)%0Adescontadez%20%3C-%20c(invertedez%2C%20contadez)%0Adescontadez}}
 +
 +Agora, como fazemos para acessar elementos específicos dentro desse vetor? Para isso usamos a indexação de posição. 
 +
 +**//Por padrão no R o primeiro elemento de um vetor está na posição 1//**.
 +
 +Essa frase pouco informativa é um detalhe importante. Em muitas linguagens computacionais, diria até que a maioria das linguagens mais populares, a indexação começa pela posição definida como ''0'' (zero)!  Mais a frente vamos usar outras indexações de vetores e de outras classes de objetos de dados. Abaixo temos alguns exemplos, simples para vetores:
 +
 +
 +<code rsplus>
 +descontadez
 +descontadez[7]
 +descontadez[c(1, 5, 10, 20)]
 +</code>
 +
 +/*
 +
 +<html>
 + <iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=contadez%20%3C-%20c(1%2C%202%2C%203%2C%204%2C%205%2C%206%2C%207%2C%208%2C%209%2C%2010)%0Ainvertedez%20%3C-%20rev(contadez)%0Adescontadez%20%3C-%20c(invertedez%2C%20contadez)%0Adescontadez%0Adescontadez%5B7%5D%0Adescontadez%5Bc(1%2C%205%2C%2010%2C%2020)%5D' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=contadez%20%3C-%20c(1%2C%202%2C%203%2C%204%2C%205%2C%206%2C%207%2C%208%2C%209%2C%2010)%0Ainvertedez%20%3C-%20rev(contadez)%0Adescontadez%20%3C-%20c(invertedez%2C%20contadez)%0Adescontadez%0Adescontadez%5B7%5D%0Adescontadez%5Bc(1%2C%205%2C%2010%2C%2020)%5D}}
 +
 +==== A classe 'Date' ====
 +
 +Crie objetos com as datas do tri e tetracampeonatos mundiais do Brasil((fonte: [[http://pt.fifa.com/worldcup/archive/|FIFA]] )):
 +<code rsplus>
 +copa70 <- "21/06/70"
 +copa94 <- "17/07/94" 
 +</code>
 +Qual a diferença em dias entre essas datas? A subtração retorna um erro (verifique):
 +<code rsplus>
 +copa94 - copa70
 +</code>
 +
 +/*
 +
 +<html>
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=copa70%20%3C-%20%2221%2F06%2F70%22%0Acopa94%20%3C-%20%2217%2F07%2F94%22%20%0Acopa94%20-%20copa70' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=copa70%20%3C-%20%2221%2F06%2F70%22%0Acopa94%20%3C-%20%2217%2F07%2F94%22%20%0Acopa94%20-%20copa70}}
 +
 +Esse erro acontece porque os objetos são caracteres, uma classe que obviamente não permite operações aritméticas. Já sabemos verificar a classe de um objeto, digitando o código:
 +
 +<code rsplus>
 +class(copa70)
 +class(copa94)
 +</code>
 +
 +
 +O resultado seria ''character'' para ambos!
 +
 +
 +Mas o R tem uma classe para datas, que é ''Date''. Vamos fazer a coerção ((procedimento de transformar uma classe em outra)) dos objetos para esta classe, verificar se a coerção foi bem sucedida, e repetir a subtração. O código para isso está descrito abaixo: 
 +
 +<code rsplus>
 +copa70 <- as.Date(copa70, format = "%d/%m/%y")
 +copa94 <- as.Date(copa94, format = "%d/%m/%y")
 +class(copa70)
 +class(copa94)
 +copa94 - copa70
 +</code>
 +
 +<WRAP center round important 80%>
 +**NOTA:** o argumento ''format'' da função ''as.Date'' informa o formato em que está o conjunto de caracteres que deve ser transformado em data, no caso dia/mês/ano (''%d/%m/%y''), todos com dois algarismos. Veja a ajuda da função para outros formatos.
 +
 +</WRAP>
 +
 +
 +
 +Inclua na janela do R online abaixo o código que gera os objetos ''copa70'' e ''cop94'', em seguida verifique a classe a que pertencem,  e depois faça a transformação para a classe ''Date'' e a subtração entre eles.  
 +
 +<WRAP center round tip 80%>
 +__**Comentando meu código**__
 +
 +Ao submeter uma linha de comando ao R é possível incluir comentários usando  o símbolo de '' # ''. O hashtag ou sustenido indica ao R que a partir daquele ponto até o final da linha o código não deve ser interpretado.
 +
 +</WRAP>
 +
 +/*
 +
 +<html>
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0A%23%23%20Digite%20seu%20c%C3%B3digo%20abaixo%20desse%20coment%C3%A1rio!%0A%23%23%20O%20R%20n%C3%A3o%20interpreta%20linhas%20come%C3%A7ando%20com%20%23%0A%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0A' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0A%23%23%20Digite%20seu%20c%C3%B3digo%20abaixo%20desse%20coment%C3%A1rio!%0A%23%23%20O%20R%20n%C3%A3o%20interpreta%20linhas%20come%C3%A7ando%20com%20%23%0A%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0A}}
 +==== A classe 'logical' ====
 +
 +Até o momento, vimos algumas naturezas de informação que podemos armazenar e manipular no R: caracteres, datas e números.  Uma outra natureza importante de dado básico no R é chamada de lógica.
 +As palavras ''TRUE'' e ''FALSE'' e também as abreviações ''T'' e ''F'' são reservadas para esse fim.  Uma questão importante dos dados lógicos é que a eles também são associadas os valores 0 e 1, para ''FALSE'' e ''TRUE'', respectivamente. Veja abaixo como podemos operá-los algebricamente:
 +
 +<code rsplus>
 +
 +TRUE + TRUE
 +TRUE / FALSE
 +TRUE * FALSE
 +
 +</code>
 + 
 +/* 
 +  
 +<html>
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=TRUE%20%2B%20TRUE%0ATRUE%20%2F%20FALSE%0ATRUE%20*%20FALSE' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=TRUE%20%2B%20TRUE%0ATRUE%20%2F%20FALSE%0ATRUE%20*%20FALSE}}
 +
 +Além disso, o R retorna ''TRUE'' ou ''FALSE'' quando fazemos algum procedimento utilizando operadores lógicos. 
 +
 +<WRAP center round box 60%>
 +**__Operadores Lógicos__**
 +
 +  *  ''=='' : igual
 +  *  ''!='' : diferente
 +  *  '' >'' : maior que
 +  *  '' <'' : menor que
 +  *  ''>='' : maior ou igual
 +  *  ''<nowiki><=</nowiki>'': menor ou igual
 +  * '' | '' : uma das condições
 +  * '' & '' : ambas as condições
 + 
 +
 +</WRAP>
 +
 +
 +Alguns exemplos de operações lógicas no R:
 +
 +<code rsplus>
 +numero <- 1.23456789
 +numero < 1
 +numero > 1
 +## abaixo primeiro imprime o valor e depois faz o teste lógico
 +print(numero, digits = 4) == numero  
 +round(numero, digits = 4) == numero
 +numero > 1 & log(numero) > 1
 +numero > 1 | log(numero) > 1
 +
 +</code>
 +
 +
 +<WRAP center round important 80%>
 +**NOTA:** Note que a igualdade é definida por dois caracteres de igualdade: "==". Se usarmos apenas um carácter de igualdade no R isso será interpretado como uma atribuição, como o sinal "<-".  
 +</WRAP>
 +
 +/*
 +
 +<html>
 +<iframe width='100%' height='600' src='https://rdrr.io/snippets/embed/?code=numero%20%3C-%201.23456789%0Anumero%20%3C%201%0Anumero%20%3E%201%0A%23%23%20abaixo%20primeiro%20imprime%20o%20valor%20e%20depois%20faz%20o%20teste%20logico%0Aprint(numero%2C%20digits%20%3D%204)%20%3D%3D%20numero%20%20%0Around(numero%2C%20digits%20%3D%204)%20%3D%3D%20numero%0Anumero%20%3E%201%20%26%20log(numero)%20%3E%201%0Anumero%20%3E%201%20%7C%20log(numero)%20%3E%201' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=numero%20%3C-%201.23456789%0Anumero%20%3C%201%0Anumero%20%3E%201%0A%23%23%20abaixo%20primeiro%20imprime%20o%20valor%20e%20depois%20faz%20o%20teste%20logico%0Aprint(numero%2C%20digits%20%3D%204)%20%3D%3D%20numero%20%20%0Around(numero%2C%20digits%20%3D%204)%20%3D%3D%20numero%0Anumero%20%3E%201%20%26%20log(numero)%20%3E%201%0Anumero%20%3E%201%20%7C%20log(numero)%20%3E%201}}
 +
 +A operação lógica também funciona com vetores, obedecendo a posição dos elementos:
 +
 +<code rsplus>
 +contadez <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 +invertedez <- rev(contadez)
 +invertedez
 +invertedez > contadez
 +</code>
 +
 +
 +/*
 +
 +<html>
 +
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=contadez%20%3C-%20c(1%2C%202%2C%203%2C%204%2C%205%2C%206%2C%207%2C%208%2C%209%2C%2010)%0Ainvertedez%20%3C-%20rev(contadez)%0Ainvertedez%0Ainvertedez%20%3E%20contadez' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=contadez%20%3C-%20c(1%2C%202%2C%203%2C%204%2C%205%2C%206%2C%207%2C%208%2C%209%2C%2010)%0Ainvertedez%20%3C-%20rev(contadez)%0Ainvertedez%0Ainvertedez%20%3E%20contadez}}
 +
 +
 +==== A classe 'factor' ====
 +
 +Para a melhor compreender essa classe de objetos no R, o Prof. Alexandre preparou uma vídeo-aula específica, disponível abaixo.
 +
 +<WRAP center round box 60%>
 +
 +{{ youtube>6cLtNwBE7Fs?large |}}
 +
 +</WRAP>
 +
 +Imagine um experimento em que classificamos as plantas em uma escala de herbivoria com os níveis: "alto", "médio", "baixo" e "nulo". Vamos criar um objeto que representa o valor desta medida de herbivoria em uma amostra de 14 plantas:
 +<code rsplus>
 +herb <- c("A", "M", "M", "A", "A", "M", "M", "B", "A", "A", "A", "A", "B", "A")
 +</code>
 +E então criar um objeto da classe fator com estes valores:
 +<code rsplus>
 +herbFactor <- factor(herb)
 +</code>
 +Usamos a função ''table'' para contar o número de observações em cada nível do fator, cujo resultado atribuímos a um outro objeto. Os valores são exibidos se digitamos o nome do objeto.
 +<code rsplus>
 +herbTable <- table(herbFactor)
 +herbTable
 +</code>
 +A função para gerar gráficos ''plot'' pode ser aplicada diretamente ao objeto desta tabela:
 +<code rsplus>
 +plot(herbTable)
 +</code>
 +
 +** Rode o código abaixo e avalie o que está sendo produzido em cada linha de comando **. Caso fique com dúvidas a primeira coisa a fazer é consultar o ''help()'' da função. O quadro onde temos o código abaixo, pode ser editado e pode rodar novamente com outro código. Fique à vontade para explorar a documentação das funções que estamos apresentando.
 +
 +
 +/*
 +
 +<html>
 +<iframe width='100%' height='300' src='https://rdrr.io/snippets/embed/?code=herb%20%3C-%20c(%22A%22%2C%20%22M%22%2C%20%22M%22%2C%20%22A%22%2C%20%22A%22%2C%20%22M%22%2C%20%22M%22%2C%20%22B%22%2C%20%22A%22%2C%20%22A%22%2C%20%22A%22%2C%20%22A%22%2C%20%22B%22%2C%20%22A%22)%0AherbFactor%20%3C-%20factor(herb)%0AherbTable%20%3C-%20table(herbFactor)%0AherbTable%0Aplot(herbTable)' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=herb%20%3C-%20c(%22A%22%2C%20%22M%22%2C%20%22M%22%2C%20%22A%22%2C%20%22A%22%2C%20%22M%22%2C%20%22M%22%2C%20%22B%22%2C%20%22A%22%2C%20%22A%22%2C%20%22A%22%2C%20%22A%22%2C%20%22B%22%2C%20%22A%22)%0AherbFactor%20%3C-%20factor(herb)%0AherbTable%20%3C-%20table(herbFactor)%0AherbTable%0Aplot(herbTable)}}
 +
 +Note que na tabela e na figura os níveis não estão ordenados da forma como deveriam e falta o nível de herbivoria nula. Isto acontece porque, ao criar uma variável de fator a partir de um vetor de valores, o R cria níveis apenas para os valores presentes, e ordena estes níveis alfabeticamente. Caso um nível não tenha sido observado nos dados, ele fica de fora da variável, mas o correto seria ele ter a contagem como ''0 ''.
 +
 +Para ordenar o fator e incluir um nível que não foi representado na amostra usamos o argumento ''levels'' da função ''fator'':
 +
 +<code rsplus>
 +herbFactor <- factor(herb, levels = c("N", "B", "M", "A"))
 +</code>
 +
 +Modifique o código da janela acima, incluindo o argumento ''levels'' na função ''factor'' e rode novamente o código todo na janela abaixo.
 +
 +/*
 +
 +<html>
 +<iframe width='100%' height='500' src='https://rdrr.io/snippets/embed/?code=%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0A%23%23%20Digite%20seu%20c%C3%B3digo%20abaixo%20desse%20coment%C3%A1rio!%0A%23%23%20O%20R%20n%C3%A3o%20interpreta%20linhas%20come%C3%A7ando%20com%20%23%0A%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0A' frameborder='0'></iframe>
 +</html>
 +
 +*/
 +
 +{{url>https://rdrr.io/snippets/embed/?code=%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0A%23%23%20Digite%20seu%20c%C3%B3digo%20abaixo%20desse%20coment%C3%A1rio!%0A%23%23%20O%20R%20n%C3%A3o%20interpreta%20linhas%20come%C3%A7ando%20com%20%23%0A%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0A}}
 +
 +<WRAP center round important 60%>
 +
 +**NOTA:** há uma classe para fatores ordenados que poderia se aplicar aqui, mas seu uso tem implicações importantes nos resultados de algumas análises, que no momento não vêm ao caso. Mais informações a respeito na ajuda da função: ''help(factor)''.
 +</WRAP>
 +
 +
 +===== O Código =====
 +
 +Antes de continuar a introdução aos conceitos básicos do R, vamos entender uma conduta importante em programação. Um dos primeiros hábitos que você deve adquirir para trabalhar com o R é **não digitar os comandos diretamente no console do R((Console é a interface de interação com o interpretador da linguagem: recebe o comando,  envia ao interpretador e retorna a resposta. O que vínhamos usando no início desse tutorial é um interpretador online do R))**, e sim em um arquivo texto, que chamamos de **//script//** ou **//código//**. Essa intermediação entre o texto do comando e o interpretador, feita pelo script, é importante pois garante que o que está sendo direcionado ao R é armazenado no arquivo texto. Esse arquivo pode ser salvo, como um registro do procedimento executado, mas principalmente para que ele possa ser utilizado e melhorado sempre que necessário. 
 +
 +<WRAP center round box 90%>
 +
 +**__Reprodutibilidade do procedimento__**
 +
 +Quando trabalhamos em uma planilha eletrônica, a partir de dados brutos, podemos salvar os gráficos ou os dados modificados após manipulados. Entretanto, o procedimento não é salvo. Se precisar fazer o mesmo procedimento para outro conjunto de dados precisará lembrar todas as etapas e a ordem em que foram executadas. Em programação, o script é nosso roteiro do procedimento que foi executado. Para repetir um procedimento é só executar novamente o script. Isso incrementa muito a reprodutibilidade do nosso procedimento, uma qualidade muito importante para a ciência de um modo geral. Por isso, deste ponto do curso em diante, iremos abandonar a interface do R online que estávamos usando até então, para trabalhar através de scripts ou códigos!
 +
 +</WRAP>
 +
 +==== Editor de Código ====
 +[[https://www.freecodecamp.org/news/coding-explained-in-25-profound-comics-8847ea03819c/|{{:02_tutoriais:tutorial1:codeDeadline.png?400  |}}]]
 +
 +Um editor de código nada mais é do que um editor de texto puro como o bloco de notas do Windows. Algumas funcionalidades são bem vindas, como por exemplo, enviar a linha de código diretamente para o console do R sem a necessidade de copiar e colar. 
 +
 +A instalação básica do R contém uma interface gráfica de usuário (R-GUI) simples, tanto no Windows como no IOS/Mac, que acompanha um editor de códigos.
 +
 +<WRAP center round box 80%>
 +
 +O editor de códigos do R-GUI no Windows ou Mac é bastante simples e costuma ser uma boa opção para usuários iniciantes do R. Para esta disciplina esse editor é suficiente. 
 +
 +No Linux não há uma [[http://en.wikipedia.org/wiki/GUI|GUI]] padrão para o R, e esta escolha deve ser feita logo no início. 
 +
 +Na página de material de apoio há uma seção com várias [[http://ecologia.ib.usp.br/bie5782/doku.php?id=01_curso_atual:material:start#interfaces_para_o_r|dicas sobre interfaces para o R]] para lhe ajudar.
 +
 +</WRAP>
 +
 +
 +A figura abaixo é uma captura de tela do R-GUI do Windows, mas no MAC o editor é similar, e você pode manter a mesma lógica.  Deixe sempre uma janela de código aberta acima da janela do R, como na imagem abaixo:
 +<WRAP center round box 80%>
 +
 +{{  :02_tutoriais:script_e_r-windows.png  |Janelas do r e do script}}
 +
 +</WRAP>
 +
 +
 +
 +<WRAP center round important 80%>
 +
 +**__Interface de usuário R-GUI__**
 +
 +
 +Na figura acima há duas janelas com funcionamentos e objetivos muito distintos.
 +  - a janela da parte superior apresenta um arquivo de texto puro que pode ser editado e salvo como texto. Por padrão salvamos esses arquivos com a extensão ''.r'' ou ''.R'' para reconhecermos que é um script da linguagem R. O sistema operacional deve reconhecer a extensão com sendo do R automaticamente.
 +  - a janela na parte inferior é o console do R, ou seja o programa propriamente dito. Essa janela recebe os comandos de código e envia ao interpretador do R, que por sua vez, retorna o resultado final do processamento((quando a tarefa solicitada é a representação de um gráfico, uma nova janela é aberta, um dispositivo gráfico. )). 
 +
 +Para evitar confusão e perda de trabalho é importante digitar as informações que serão transmitidas ao R (linhas de código) no arquivo texto e ir enviando esses comandos ao console R. Uma boa prática também é comentar as linhas de código para que outras pessoas, ou mesmo a pessoa que criou o código, possam entender ou lembrar o que cada parte ou linha do código executa.
 +
 +É imprescindível aprender a se organizar dentro do ambiente de programação, para evitar o risco de perder trabalho ou ficar perdido entre as tarefas executadas.
 +  
 +</WRAP>
 +
 +==== O primeiro Script ====
 +
 +O exercício final deste tutorial é produzir um script que você terá de salvar e submeter para avaliação. Assim, siga atentamente as instruções nos pontos abaixo. 
 +
 +
 +  * Copie todas as linhas de códigos que foram processados nesse tutorial até o momento em arquivo texto simples no bloco de nota do Windows ou algum outro programa simples de texto (TextEdit no macOS);
 +  * Salve o arquivo em uma pasta ((diretório de trabalho é o nome técnico desta pasta para o R)) conhecida do seu computador, associada a essa disciplina, com o nome e extensão ''tutorial01.r'' ((quando o sistema operacional não mostra a extensão dos arquivos é preciso configura-lo para que seja apresentado));
 +  *Execute o R e abra o //script// que salvou, utilizando a opção do menu "Arquivo/Abrir script":
 +<WRAP center round box 60%>
 +
 +{{  :02_tutoriais:abrir_script.png  |abra o arquivo de código}}
 +
 +</WRAP>
 +
 +
 +  * Vá para a janela do //script//, coloque o cursor na primeira linha e tecle ''Ctrl-r''. Faça o mesmo com as linhas seguintes;
 +
 +
 +<WRAP center round box 80%>
 + //**__Para Usuários de MAC__**//
 +
 +Para enviar comandos do editor de código do R-GUI para o R utilize //Command+Enter// ou //Command+Return//.
 +
 +<WRAP center round tip 80%>
 +Veja o material [[https://cran.r-project.org/bin/macosx/RMacOSX-FAQ.html| RMacOSX]]
 +</WRAP>
 +
 +</WRAP>
 +
 +  * Coloque o título no arquivo como sendo ''## Tutorial Introducao ao R ''
 +  * Na linha seguinte coloque a data como comentário: ''## Data: ....'';
 +  * Comente cada bloco de código com o nome do tópico que o código está associado no roteiro
 +  * Comente ou retire qualquer linha de código que tenha gerado erros durante o processamento;
 +  * Retire a redundância na atribuição dos abjetos, mas cuidado com objetos que são sobrescritos, veja o ''copa70'', por exemplo;  
 +  * Ao final selecione todas as linhas do script, inclusive comentários e e tecle ''Ctrl-r'' para submeter tudo ao interpretador do R;
 +  * Garanta que não há mensagens de erro ao longo do processamento do script.
 +
 +<WRAP center round box 80%>
 +
 +{{:02_tutoriais:envia_comando_do_script.png|CTRL-R envia comandos do script}}
 +
 +
 +<WRAP center round tip 90%>
 +**__Comentários no código__**
 +
 +Para fazer comentários no código, usamos o símbolo de ''#''. 
 +Qualquer conteúdo na linha de comando depois do  ''#'' não é interpretado pelo R. Utilizamos os comentários, em geral, para tornar o código autoexplicativo. 
 +
 +</WRAP>
 +
 +</WRAP>
 +
 +  * Salve o //script// com estas modificações. 
 +
 +Você terá que submeter o //script// salvo no nosso sistema de correção automática de código, chamado **notaR**. Portanto, que o arquivo foi salvo corretamente.
 +
 +<WRAP center round todo 80%>
 +Siga para a aba de [[01_curso_atual:exercicios1|exercícios]] para seguir os exercícios desse tópico. Os exercícios ficarão embutidos nesse wiki, mas deixaremos sempre o link para o notaR caso prefiram abrir a plataforma diretamente. **Lembre-se de logar no sistema notaR** antes de fazer os exercícios e não deixe de passar pela aba da apostila, pois ela é complementar aos [[03_apostila:01-intro|tutoriais]], apesar de possuir alguma redundância desejável para melhor fixar o conteúdo das atividades.
 +
 +</WRAP>
 +
 +
 +
 +