3  Funcionamento básico

3.1 Operadores

  • Aritmetica basica
2+5         #Adicao                     
5-2         #Subtracao
2*5         #Multiplicacao
8/2         #Divisao
2^5         #Exponenciacao
5%%2        #Resto da divisão
  • Relacionais
3==5          #Igual
3!=5          #Diferente
3>5         #Maior que
3<5         #Menor que
3>=5          #Maior ou igual
3<=5          #Menor ou igual    
  • Operações podem ser concatenadas:
((2+5-3)*10)^4/7^4

3.2 Variáveis

A seta “<-” representa o simbolo de atribuição e ao escrever o nome do objeto, seu valor sera impresso. Veja o exemplo:

x <- 1
x
[1] 1

Caso algum valor seja atribuído ao mesmo objeto, ele será sobrescrito:

x <- "gol do gremio!"
x
[1] "gol do gremio!"

Os resultados de operações podem ser salvos em objetos:

x<-2+5
y=5-2
2*5->w
z<-8/2

resultado <- (((x-y)*w)^z)/(x^z)
resultado
[1] 1066.222

3.3 Funções

Chamando funções:

sum(1,3,5)
[1] 9
a <- rep("Aluno",times=3)
a
[1] "Aluno" "Aluno" "Aluno"

3.4 Acessando a documentação

Estas funções buscam e exibem a documentação de funções:

help(sum)
?sd
??plot

3.5 Vetores

funcao c() : concatenate

number <- c(1, 2, 3, 4, 5)
letter <- c("x", "y", "z", "w", "j")
logical <- c(TRUE, FALSE, FALSE, TRUE, FALSE)
seq <- 1:10

Hierarquia de classes

x <- c(1, 2, 3)                   # Numeric
y <- c("1", "2", "3")             # Character
x <- c(TRUE, FALSE, FALSE)        # Logical
y <- c("TRUE", "FALSE", "FALSE")  # Character

Podemos somar vetores logicos

sum(logical) 
[1] 2

Vetores comportam somente uma classe de elementos

Coerção de objetos usando funções do tipo as.algumacoisa()

x <- 0:10
x
 [1]  0  1  2  3  4  5  6  7  8  9 10
class(x)
[1] "integer"
a <- as.numeric(x)
a
 [1]  0  1  2  3  4  5  6  7  8  9 10
class(a)
[1] "numeric"
b <- as.character(x)
b
 [1] "0"  "1"  "2"  "3"  "4"  "5"  "6"  "7"  "8"  "9"  "10"
class(b)
[1] "character"
c <- as.logical(x)
c
 [1] FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE
class(c)
[1] "logical"

Vetores de NA

x <- c(1, 2, 3, NA)
y <- c("a", "b", "c", NA)

is.na(x)
[1] FALSE FALSE FALSE  TRUE
a <- c(1, 3, NA, 7, 9)
sum(a)
[1] NA
sum(a, na.rm=TRUE)
[1] 20

Objetos possuem atributos: classe, tamanho, dimensoes, nomes, etc

x <- 1:5
x
[1] 1 2 3 4 5
length(x)
[1] 5
dim(x)
NULL
attributes(x)
NULL
names(x) <- c("a", "b", "c", "d", "e")
x
a b c d e 
1 2 3 4 5 
attributes(x)
$names
[1] "a" "b" "c" "d" "e"

3.6 Factor

Fatores sao vetores categóricos, possuem o atributo level

x <- factor(c("s", "n", "n", "s", "s"))
z <- factor(c("alto", "baixo", "medio"))

3.7 Matrix

Matrizes são vetores com o atributo dimensão

x <- 1:20
x
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
attributes(x)
NULL
m <- matrix(x, 4, 5)
m
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20
attributes(m)          
$dim
[1] 4 5
dim(x) <- c(4,5)
x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20
identical(x, m)
[1] TRUE

Como são vetores, matrizes comportam somente uma classe de elementos

Manipulação de matrizes

a <- 1:5
b <- -1:-5
c <- c(3, 6, 4, 9, 1)

m <- cbind(a, b, c)       #funcao cbind() concatena colunas
m1 <- rbind(a, b, c)      #funcao rbind() concatena linhas

3.8 Array

São vetores multidimensionais

ar <- array(1:200, c(5, 10, 4))    
ar
, , 1

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,]    1    6   11   16   21   26   31   36   41    46
[2,]    2    7   12   17   22   27   32   37   42    47
[3,]    3    8   13   18   23   28   33   38   43    48
[4,]    4    9   14   19   24   29   34   39   44    49
[5,]    5   10   15   20   25   30   35   40   45    50

, , 2

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,]   51   56   61   66   71   76   81   86   91    96
[2,]   52   57   62   67   72   77   82   87   92    97
[3,]   53   58   63   68   73   78   83   88   93    98
[4,]   54   59   64   69   74   79   84   89   94    99
[5,]   55   60   65   70   75   80   85   90   95   100

, , 3

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,]  101  106  111  116  121  126  131  136  141   146
[2,]  102  107  112  117  122  127  132  137  142   147
[3,]  103  108  113  118  123  128  133  138  143   148
[4,]  104  109  114  119  124  129  134  139  144   149
[5,]  105  110  115  120  125  130  135  140  145   150

, , 4

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,]  151  156  161  166  171  176  181  186  191   196
[2,]  152  157  162  167  172  177  182  187  192   197
[3,]  153  158  163  168  173  178  183  188  193   198
[4,]  154  159  164  169  174  179  184  189  194   199
[5,]  155  160  165  170  175  180  185  190  195   200
ar[,,1]                            #[linha, coluna, matrix]
     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,]    1    6   11   16   21   26   31   36   41    46
[2,]    2    7   12   17   22   27   32   37   42    47
[3,]    3    8   13   18   23   28   33   38   43    48
[4,]    4    9   14   19   24   29   34   39   44    49
[5,]    5   10   15   20   25   30   35   40   45    50

3.9 List

Listas são tipos especiais de vetores, que comportam elementos de deferentes classes. cada elemento da lista aparece com [[]]

a <- c(1, 3, NA, 7, 9)
b<-matrix(1:200, 20,10)
c<-"Gol do Gremio"
z<-factor(c("alto", "baixo", "medio"))

ls<-list(a, b, c, z)
ls                       
[[1]]
[1]  1  3 NA  7  9

[[2]]
      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
 [1,]    1   21   41   61   81  101  121  141  161   181
 [2,]    2   22   42   62   82  102  122  142  162   182
 [3,]    3   23   43   63   83  103  123  143  163   183
 [4,]    4   24   44   64   84  104  124  144  164   184
 [5,]    5   25   45   65   85  105  125  145  165   185
 [6,]    6   26   46   66   86  106  126  146  166   186
 [7,]    7   27   47   67   87  107  127  147  167   187
 [8,]    8   28   48   68   88  108  128  148  168   188
 [9,]    9   29   49   69   89  109  129  149  169   189
[10,]   10   30   50   70   90  110  130  150  170   190
[11,]   11   31   51   71   91  111  131  151  171   191
[12,]   12   32   52   72   92  112  132  152  172   192
[13,]   13   33   53   73   93  113  133  153  173   193
[14,]   14   34   54   74   94  114  134  154  174   194
[15,]   15   35   55   75   95  115  135  155  175   195
[16,]   16   36   56   76   96  116  136  156  176   196
[17,]   17   37   57   77   97  117  137  157  177   197
[18,]   18   38   58   78   98  118  138  158  178   198
[19,]   19   39   59   79   99  119  139  159  179   199
[20,]   20   40   60   80  100  120  140  160  180   200

[[3]]
[1] "Gol do Gremio"

[[4]]
[1] alto  baixo medio
Levels: alto baixo medio

A função vector pode criar listas vazias

ls1<-vector("list", 5)  
ls1
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
NULL

[[5]]
NULL

3.10 Data Frame

Formado por vetores de mesmo tamanho, organizados como colunas

number<-c(1, 2, 3, 4, 5)
letter<-c("x", "y", "z", "w", "j")
logical<- c(TRUE, FALSE, FALSE, TRUE, FALSE)
seq<-1:10

dt<-data.frame(number, letter, logical)
class(dt)
[1] "data.frame"
dt$letter                     #usamos $ para acessar as colunas de um data.frame
[1] "x" "y" "z" "w" "j"
class(dt$letter)              #vetores de caracter sao interpretados como fatores
[1] "character"
dt<-data.frame(number, letter, logical, stringsAsFactors = F) #stringsAsFactors = F
dt$letter
[1] "x" "y" "z" "w" "j"
class(dt$letter)
[1] "character"
attributes(dt)                #data.frames possuem colnames e rownames
$names
[1] "number"  "letter"  "logical"

$class
[1] "data.frame"

$row.names
[1] 1 2 3 4 5
colnames(dt)
[1] "number"  "letter"  "logical"
row.names(dt)
[1] "1" "2" "3" "4" "5"
dt[5,2]                       #acessamos data.frames da mesma forma que matrizes
[1] "j"

3.11 Desafio

Pratique sem IA!

Os desafios a seguir foram criados para ajudá-lo a desenvolver suas habilidades de forma independente.
Evite o uso de Inteligência Artificial e tente resolver os problemas por conta própria.
Aprender com a prática fortalecerá seu raciocínio e aprofundará seu conhecimento! 🚀

Vetores:

Em R, os vetores são um dos tipos mais básicos de objetos. Eles são parecidos com os vetores que vimos na matemática. A diferença é que aqui podemos ter vetores não só de números, mas também de letras (caracteres).

  1. Um vetor de números pode ser construído assim:

    num <- c(1,2,3,4)

    Se você executar essa linha acima terá criado um vetor com o nome de “num” que contém os elementos 1,2,3 e 4.

    Para criarmos um vetor, utilizamos a função “c()”.

  1. Experimente fazer um vetor chamado “num2” e que contenha os seguintes elementos: 1,a,3,b. Depois veja qual a classe dos elementos desse vetor usando a função class(). OBS: Não esqueça que letras e palavras tem de ser colocadas entre aspas.

  2. Agora crie um vetor num3 com os elementos: 1,2,3,4,5. Use a função class() para saber qual a classe dos elementos desse vetor

  3. Por que a classe dos vetores ‘num2’ e ‘num3’ é diferente?

  1. José e Paulo adoram jogar basquete nas suas horas livres. Eles mantém uma competição entre si e por isso decidiram registrar todos os pontos que eles marcam durante as partidas.

Até agora foram 8 partidas:

  • José fez 8, 10, 12, 9, 15, 16, 11, 7 cestas.

  • Paulo fez 5, 11, 13, 14, 23, 14, 9, 10 cestas.

  1. Crie dois objetos que contenham o número de cestas que cada um fez:

  2. Verifique a classe de cada um dos objetos:

  3. Com a utilização da ajuda do R, procure por uma função que possibilite o cálculo de médias. Com ela, calcule as médias de cestas dos dois jogadores e atribua estes valores a objetos diferentes:

  4. Compare os valores das médias calculadas usando os operadores lógicos “>” e “<”. Quem teve um desempenho médio melhor?

Data Frames:

Vetores são muito úteis, mas na medida que trabalhamos com muitos tipos de vetores e com mais valores, fica mais complicado. Para contornar esse problema, nós temos em R um objeto chamado de Dataframe. O Dataframe é uma espécie de matriz: tem linhas e colunas. A diferença é: numa matriz, todos as colunas tem um mesmo tipo, enquanto em um data.frame podemos ter em cada coluna um tipo diferente de dado. Assim, dataframes podem ter uma coluna de um vetor numérico e outra de um vetor de caracteres.

O data.frame ‘contagem’ mostra a quantidade de células contadas por 5 ICs diferentes durante a primeira semana de trabalho no laboratório.

contagem <- data.frame(IC = c('Você','João','Fernanda','Júlio','Larissa'),
                       semana_1 = c(30, 46, 50, 20, 10))

Na segunda semana de experimento, todos os ICs do laboratório repetiram a contagem, e os números de células contadas foram: 10, 39, 55, 11, 20.

  1. Crie uma nova coluna neste mesmo dataframe chamada de ‘semana_2’ com estes números.

  2. O chefe do laboratório pediu para que os ICs mostrassem qual deles contou o maior e o menor número de células em cada semana. Procure por funções no R que mostre qual valor de contagem na semana 1 é maior e qual é o menor.