Podstawowe operacje w R - część 2.

Operatory i funkcje

Artur Lisowski

2022-11-02

Operatory

Operatory arytmetyczne

x <- 4
y <- 2

# dodawanie
x + y

## [1] 6

# odejmowanie
x - y

## [1] 2

# mnożenie
x * y

## [1] 8

# dzielenie 
x / y

## [1] 2

# modulus 
x %% y

## [1] 0

# power
x ^ y

## [1] 16

Operatory logiczne

# równe?
x == y

## [1] FALSE

# nie równe?
x != y

## [1] TRUE

# większe od?
x > y

## [1] TRUE

# mniejsze od?
x < y

## [1] FALSE

# większe lub równe od?
x >= y

## [1] TRUE

# mniejsze lub równe od?
x <= y

## [1] FALSE

Operator OR | i operator AND & są przydatne, gdy mamy do czynienia z twierdzeniami logicznymi.

(x > y) | (y < x)

## [1] TRUE

(x > y) & (y < x)

## [1] TRUE

i & są wektoryzowane, co oznacza, że można je zastosować do dwóch wektorów logicznych. Każda para jest porównywana i dla każdego elementu powstaje wynik. Wynikiem jest wektor.

c(F,F,F,T,F,F) | c(F,F,F,F,F,F)

## [1] FALSE FALSE FALSE  TRUE FALSE FALSE

Teraz istnieją również dwa warianty || i &&. Operatory te porównują elementy od lewej do prawej i zatrzymują się po pierwszym elemencie. Rozważmy ten sam przykład powyżej, zastępując | przez ||. Wynikiem jest jeden element, a nie wektor.

c(F,F,F,T,F,F) || c(F,F,F,F,F,F)

## Warning in c(F, F, F, T, F, F) || c(F, F, F, F, F, F): 'length(x) = 6 > 1' in
## coercion to 'logical(1)'

## Warning in c(F, F, F, T, F, F) || c(F, F, F, F, F, F): 'length(x) = 6 > 1' in
## coercion to 'logical(1)'

## [1] FALSE

Lepszą praktyką jest używanie any() i all() do oceny wektorów logicznych na pojedynczy logiczny.

# Czy któreś z nich jest TRUE?
any(c(F,F,F,T,F,F))

## [1] TRUE

# Czy wszystkie z nich są TRUE?
all(c(F,F,F,T,F,F))

## [1] FALSE

Znaki/łańcuchy mogą być przypisane do zmiennych w podobny sposób.

z <- "to"
z1 <- "tamto"
paste(z,z1)

## [1] "to tamto"

Funkcja paste() łączy ciągi znaków.

Nazwy zmiennych muszą być tak dobrane, aby nie kolidowały z istniejącymi zmiennymi/funkcjami. Na przykład należy unikać nazwy zmiennej c, ponieważ jest to istniejąca funkcja do konkatenacji obiektów R. Należy unikać nazwy zmiennej t, ponieważ jest to funkcja do transpozycji macierzy. Nazwy zmiennych nie mogą zaczynać się od liczby.

Operator fajki

Możesz użyć operatora pipe (%>%) w R, aby “spiąć” razem sekwencję operacji.

Operator ten jest najczęściej używany z pakietem dplyr w R do wykonywania sekwencji operacji na ramce danych.

Podstawowa składnia operatora fajki to:

dane %>% 
  zrób coś %>% 
  a potem zrób jeszcze coś %>%
  a potem wylicz/narysuj...

Operator fajki po prostu przekazuje wyniki jednej operacji do następnej operacji pod nią.

Zaletą stosowania operatora fajki jest to, że czyni on kod niezwykle łatwym do odczytania.

Fajka podstawowa

Podstawową funkcją dostarczaną przez pakiet magrittr jest %>%, lub tak zwany operator “pipe”. Operator ten przekazuje wartość, lub wynik wyrażenia, do następnego wywołania funkcji/wyrażenia. Na przykład funkcja filtrująca dane może być zapisana jako:

  filter(data, variable == numeric_value)

lub:

  data %>% filter(variable == numeric_value)

Obie funkcje wykonują to samo zadanie i korzyść z użycia %>% może nie być od razu oczywista; jednakże, gdy chcemy wykonać wiele funkcji, jej zaleta staje się oczywista.

Na przykład, jeśli chcemy przefiltrować pewne dane, pogrupować je według kategorii, podsumować je, a następnie uporządkować podsumowane wyniki, możemy wypisać to na trzy różne sposoby.

Możemy na przykład zmienić kolumny w bazowym zbiorze danych “mtcars”:

# zmieniamy nazwy kolumn
mtcars %>%
        head %>%
        set_colnames(paste("Col", 1:11, sep = ""))

##                   Col1 Col2 Col3 Col4 Col5 Col6 Col7 Col8 Col9 Col10 Col11
## Mazda RX4         21.0    6  160  110 3.90 2.62 16.5    0    1     4     4
## Mazda RX4 Wag     21.0    6  160  110 3.90 2.88 17.0    0    1     4     4
## Datsun 710        22.8    4  108   93 3.85 2.32 18.6    1    1     4     1
## Hornet 4 Drive    21.4    6  258  110 3.08 3.21 19.4    1    0     3     1
## Hornet Sportabout 18.7    8  360  175 3.15 3.44 17.0    0    0     3     2
## Valiant           18.1    6  225  105 2.76 3.46 20.2    1    0     3     1

Fajki dodatkowe

magrittr oferuje również kilka alternatywnych operatorów pipe. Niektóre funkcje, jak np. funkcje wykreślania, powodują zakończenie łańcucha argumentów przesyłanych rurociągiem.

Operator tee (%T>%) pozwala kontynuować piping funkcji, które normalnie powodują zakończenie.

mtcars %>%
        filter(carb > 1) %>%
        extract(, 1:4) %>%
        plot() %>%
        summary()

## Length  Class   Mode 
##      0   NULL   NULL

W powyższym przykładzie normalna fajka kończy się funkcją plot() dając w efekcie NULL jako wyniki dla funkcji summary()

Wstawienie %T>% pozwala na wykreślanie i wykonywanie funkcji, które podążają za funkcją plotowania:

mtcars %>%
        filter(carb > 1) %>%
        extract(, 1:4) %T>%
        plot() %>%
        summary()

##       mpg            cyl            disp           hp     
##  Min.   :10.4   Min.   :4.00   Min.   : 76   Min.   : 52  
##  1st Qu.:15.2   1st Qu.:6.00   1st Qu.:147   1st Qu.:110  
##  Median :17.8   Median :8.00   Median :276   Median :175  
##  Mean   :18.6   Mean   :6.64   Mean   :258   Mean   :164  
##  3rd Qu.:21.0   3rd Qu.:8.00   3rd Qu.:351   3rd Qu.:205  
##  Max.   :30.4   Max.   :8.00   Max.   :472   Max.   :335

Operator przypisania złożonego %<>% jest używany do aktualizowania wartości poprzez najpierw wprowadzenie jej do jednego lub więcej wyrażeń, a następnie przypisanie wyniku.

Na przykład, powiedzmy, że chcesz przekształcić zmienną mpg w ramce danych mtcars na pomiar pierwiastka kwadratowego. Użycie %<>% spowoduje wykonanie funkcji po prawej stronie %<>% i zapisanie zmian, jakie te funkcje wykonują, do zmiennej lub ramki danych wywołanej po lewej stronie %<>%.

mtcars$mpg %<>% sqrt

head(mtcars)

##                    mpg cyl disp  hp drat   wt qsec vs am gear carb
## Mazda RX4         4.58   6  160 110 3.90 2.62 16.5  0  1    4    4
## Mazda RX4 Wag     4.58   6  160 110 3.90 2.88 17.0  0  1    4    4
## Datsun 710        4.77   4  108  93 3.85 2.32 18.6  1  1    4    1
## Hornet 4 Drive    4.63   6  258 110 3.08 3.21 19.4  1  0    3    1
## Hornet Sportabout 4.32   8  360 175 3.15 3.44 17.0  0  0    3    2
## Valiant           4.25   6  225 105 2.76 3.46 20.2  1  0    3    1

Niektóre funkcje (np. lm, aggregate, cor) posiadają argument data, który pozwala na bezpośrednie użycie nazw wewnątrz danych jako części wywołania.

Operator ekspozycji (%$%) jest przydatny, gdy chcemy przekazać ramkę danych, która może zawierać wiele kolumn, do funkcji, która jest stosowana tylko do niektórych kolumn.

Na przykład, funkcja korelacji (cor) wymaga tylko argumentu x i y, więc jeśli przesyłasz dane mtcars do funkcji cor używając %>%, otrzymasz błąd, ponieważ cor nie wie, jak obsługiwać mtcars. Jednak użycie %$% pozwala ci powiedzieć “weź tę ramkę danych, a następnie wykonaj cor() na tych określonych kolumnach w mtcars.”

Błąd no nie? Użycie %$% pozwala na wybranie zmiennych:

mtcars %>%
        subset(vs == 0) %$%
        cor(mpg, wt)

## [1] -0.831

Inne operatory

Oto kilka innych powszechnie używanych operatorów.: jest używany do generowania sekwencji.

1:10

##  [1]  1  2  3  4  5  6  7  8  9 10

%in% jest operatorem zbioru.

“a” %in% c(“x”, “p”, “a”, “c”) sprawdza, czy a jest członkiem zbioru x,p,a,c.

"a" %in% c("x","p","a","c")

## [1] TRUE

Odwrotność również by działała, ale liczba zwróconych elemntów jest teraz inna.

c("x","p","a","c") %in% "a"

## [1] FALSE FALSE  TRUE FALSE

:: jest używany do bezpośredniego dostępu do funkcji z określonego pakietu. Kiedy normalnie wywołujesz funkcję, powiedzmy sum(), R przeszukuje przestrzeń nazw i znajduje ją. W przypadku, gdy istnieje funkcja sum() z innego pakietu, ostatnio załadowany pakiet zastępuje poprzednią funkcję. W takich przypadkach lub aby być całkowicie pewnym, że używasz właściwej funkcji z właściwego pakietu, możesz użyć package::function() do wywołania funkcji. Na przykład; base::sum(). ::: jest używane do wywoływania funkcji z pakietu, które nie są “eksportowane”. Jest to rzadko używane.

%*% jest używane do mnożenia macierzy.

matrix(c(2,2,3,3),nrow=2) %*% matrix(c(4,2,5,3),nrow=2)

##      [,1] [,2]
## [1,]   14   19
## [2,]   14   19

matrix(c(2,2,3,3),nrow=2) %*% c(6,6)

##      [,1]
## [1,]   30
## [2,]   30

Operacje na datach

Operacje na datach i format daty nie są takie proste i oczywiste jak by się wydawało.

Proszę prześledź kilka poniższych przykładów operacji z datami.

x <- "2013-04-03"
# Jaka jest struktura x?
str(x)

##  chr "2013-04-03"

# Użyj as.Date() aby zmienić format na datę
x_date <- as.Date(x)
str(x_date)

##  Date[1:1], format: "2013-04-03"

# Zamień April 10 2014 jako datę
april_10_2014 <- as.Date("2014-04-10")

Użyjmy pakietu readr. Co wykonują poniższe czynności?

as.POSIXct("2010-10-01 12:12:00")

## [1] "2010-10-01 12:12:00 CEST"

as.POSIXct("2010-10-01 12:12:00", tz = "America/Los_Angeles")

## [1] "2010-10-01 12:12:00 PDT"

Bardzo przydatny jest pakiet “lubridate” dla operacji z datami.

library(lubridate)
x <- "2010 September 20th" # 2010-09-20
ymd(x)

## [1] "2010-09-20"

y <- "02.01.2010"  # 2010-01-02
dmy(y)

## [1] "2010-01-02"

z <- "Sep, 12th 2010 14:00"  # 2010-09-12T14:00
mdy_hm(z)

## [1] "2010-09-12 14:00:00 UTC"

Możemy także w dowolny sposób manipulować formatem wyświetlania dat.

# Kolejność:
x <- "Monday June 1st 2010 at 4pm"
parse_date_time(x, orders = "amdyIp")

## Warning: All formats failed to parse. No formats found.

## [1] NA

two_orders <- c("October 7, 2001", "October 13, 2002", "April 13, 2003",  "17 April 2005", "23 April 2017")
parse_date_time(two_orders, orders = c("mdy","dmy"))

## [1] "2001-10-07 UTC" "2002-10-13 UTC" "2003-04-13 UTC" "2005-04-17 UTC"
## [5] "2017-04-23 UTC"

short_dates <- c("11 December 1282", "May 1372", "1253")
myorders <- c("dOmY", "OmY", "Y")
parse_date_time(short_dates, orders = myorders)

## [1] "1282-12-11 UTC" "1372-05-01 UTC" "1253-01-01 UTC"

Funkcje pakietu lubridate pozwalają nam również zaokrąglać formaty dat.

r_3_4_1 <- ymd_hms("2016-05-03 07:13:28 UTC")
# Zaokrąglij w dół do dni
floor_date(r_3_4_1, unit = "day")

## [1] "2016-05-03 UTC"

# Zaokrąglij do 5 minut
round_date(r_3_4_1, unit = "5 minutes")

## [1] "2016-05-03 07:15:00 UTC"

# Zaokrąglij do tygodni 
ceiling_date(r_3_4_1, unit = "week")

## [1] "2016-05-08 UTC"

# Odejmij od r_3_4_1 ją samą i zaokrąglij do dni
r_3_4_1 - floor_date(r_3_4_1, unit = "day")

## Time difference of 7.22 hours

Rozpatrzmy funkcje obliczeniowe dat:

# Lądowanie na księżycu :)
date_landing <- mdy("July 20, 1969")
moment_step <- mdy_hms("July 20, 1969, 02:56:15", tz = "UTC")
# Ile dni już upłynęło??
difftime(today(), date_landing, units = "days")

## Time difference of 19463 days

# Ile sekund?
difftime(now(),moment_step, units = "secs")

## Time difference of 1681620548 secs

Możemy łatwo obliczać różnice między datami:

# 3 daty
mar_11 <- ymd_hms("2017-03-11 12:00:00", 
  tz = "America/Los_Angeles")
mar_12 <- ymd_hms("2017-03-12 12:00:00", 
  tz = "America/Los_Angeles")
mar_13 <- ymd_hms("2017-03-13 12:00:00", 
  tz = "America/Los_Angeles")
# Różnica pomiędzy mar_13 oraz mar_12 w sekundach
difftime(mar_13, mar_12, units = "secs")

## Time difference of 86400 secs

Możemy również manipulować datami, dodawać lub odejmować okresy:

# Dodaj jeden tydzień do mon_2pm
mon_2pm <- dmy_hm("27 Aug 2018 14:00")
mon_2pm + weeks(1)

## [1] "2018-09-03 14:00:00 UTC"

# Dodaj 81 godzin do tue_9am
tue_9am <- dmy_hm("28 Aug 2018 9:00")
tue_9am + dhours(81)

## [1] "2018-08-31 18:00:00 UTC"

# Odejmij 5 lat od today()
today() - years(5)

## [1] "2017-11-02"

# Odejmij 5 lat od today()
today() - dyears(5)

## [1] "2017-11-01 18:00:00 UTC"

Możemy również manipulować sekwencjami:

# Dodaj 8 godzin:
today_8am <- today() + hours(8)
# Sekwencja 1 do 26:
every_two_weeks <- 1:26 * weeks(2)
# Utwórz sekwencję dat co 2 tygodnie przez rok:
every_two_weeks  + today_8am

##  [1] "2022-11-16 08:00:00 UTC" "2022-11-30 08:00:00 UTC"
##  [3] "2022-12-14 08:00:00 UTC" "2022-12-28 08:00:00 UTC"
##  [5] "2023-01-11 08:00:00 UTC" "2023-01-25 08:00:00 UTC"
##  [7] "2023-02-08 08:00:00 UTC" "2023-02-22 08:00:00 UTC"
##  [9] "2023-03-08 08:00:00 UTC" "2023-03-22 08:00:00 UTC"
## [11] "2023-04-05 08:00:00 UTC" "2023-04-19 08:00:00 UTC"
## [13] "2023-05-03 08:00:00 UTC" "2023-05-17 08:00:00 UTC"
## [15] "2023-05-31 08:00:00 UTC" "2023-06-14 08:00:00 UTC"
## [17] "2023-06-28 08:00:00 UTC" "2023-07-12 08:00:00 UTC"
## [19] "2023-07-26 08:00:00 UTC" "2023-08-09 08:00:00 UTC"
## [21] "2023-08-23 08:00:00 UTC" "2023-09-06 08:00:00 UTC"
## [23] "2023-09-20 08:00:00 UTC" "2023-10-04 08:00:00 UTC"
## [25] "2023-10-18 08:00:00 UTC" "2023-11-01 08:00:00 UTC"

Funkcje

Funkcje, które są dostarczane z bazową instalacją R, są określane jako funkcje wbudowane lub funkcje bazowe.

R ma mnóstwo wbudowanych funkcji do różnych zastosowań, takich jak analiza danych, programowanie, matematyka, wykreślanie itp.

Dodatkowe funkcje mogą być udostępnione poprzez zainstalowanie zewnętrznych pakietów.

Funkcje podstawowe

Poniżej przedstawiono kilka funkcji, które można zastosować do danych liczbowych:

# wygeneruj 10 liczb losowych z zakresu od 1 do 200
x <- sample(x=1:200,10)

# długość
length(x)

## [1] 10

# suma
sum(x)

## [1] 922

# średnia
mean(x)

## [1] 92.2

# mediana
median(x)

## [1] 91

# minimum
min(x)

## [1] 26

# logarytm
log(x)

##  [1] 4.78 5.08 5.04 3.26 3.43 5.00 4.90 4.14 3.69 3.81

# exponent
exp(x)

##  [1]                   4797813327299302234462606026664000264424602484482006
##  [2] 8344716494264774957688804000246286066468200084406804686424280244482422
##  [3]   20684484173822473364464408020426602222466086448840082880604288006482
##  [4]                                                           195729609429
##  [5]                                                         29048849665247
##  [6]      18861808084906519176082464404028488288826224804866088626240420620
##  [7]            15684135116819639964262268620424226404266080206062402606846
##  [8]                                           2293783159469609954826688068
##  [9]                                                     235385266837020000
## [10]                                                   34934271057485094912

# pierwiastek
sqrt(x)

##  [1] 10.91 12.69 12.45  5.10  5.57 12.17 11.58  7.94  6.32  6.71

# zaokrąglanie
round(x)

##  [1] 119 161 155  26  31 148 134  63  40  45

# sortowanie
sort(x)

##  [1]  26  31  40  45  63 119 134 148 155 161

Funkcje tekstowe

Kilka przydatnych funkcji związanych z ciągami znaków:

a <- "sunny"
b <- "day"

# połącz
paste(a, b)

## [1] "sunny day"

# odnajdź wzór
grep("sun", a)

## [1] 1

# liczba znaków
nchar("sunny")

## [1] 5

# do dużej litery
toupper("sunny")

## [1] "SUNNY"

# do małej litery
tolower("SUNNY")

## [1] "sunny"

# zamiana wzoru
sub("sun", "fun", "sunny")

## [1] "funny"

# podciąg
substr("sunny", start=1, stop=3)

## [1] "sun"

Funkcje ogólne

Kilka ogólnych funkcji:

print("hello")

## [1] "hello"

print("world")

## [1] "world"

cat("hello")

## hello

cat(" world")

##  world

cat("\nhello\nworld")

## 
## hello
## world

Jeśli widzisz, że kopiujesz fragment kodu R wiele razy, to prawdopodobnie dobrym pomysłem jest stworzenie z niego funkcji.

Załóżmy, że masz dwa wektory, na których chciałbyś wykonać serię operacji, a następnie wyprowadzić wynik.

a <- 1:6
b <- 8:10

d <- a*b
e <- log(d)
f <- sqrt(e)
f

## [1] 1.44 1.70 1.84 1.86 1.95 2.02

Możesz zmodyfikować ten blok kodu w funkcję w następujący sposób:

my_function <- function(a, b){
  d <- a*b
  e <- log(d)
  f <- sqrt(e)
  return(f)
}

Po zdefiniowaniu możesz użyć tego, gdziekolwiek jest to potrzebne:

my_function(a=2:4, b=6:8)

## [1] 1.58 1.74 1.86

Zmienne zdefiniowane wewnątrz funkcji są dostępne tylko wewnątrz tej funkcji i nie są dostępne poza nią, chyba że zostaną zwrócone:

W powyższej funkcji zmienna varz utworzona wewnątrz funkcji nie jest dostępna poza nią.

Możliwa jest jednak sytuacja odwrotna:

my_new_function <- function() {
  varz <- foo + 2
  return(varz)
}

foo <- 55
my_new_function()

## [1] 57

W powyższym przykładzie zmienna foo użyta wewnątrz funkcji nie jest dostarczona do funkcji poprzez argument, a mimo to udaje się ją znaleźć. Gdy funkcja nie znajduje zmiennej wewnątrz funkcji, szuka jej poza nią.

Funkcje warunkowe

Instrukcje warunkowe pisze się za pomocą if().

a <- 2
b <- 5

if(a < b) print(paste(a,"jest mniejsze od",b))

## [1] "2 jest mniejsze od 5"

else służy do dodania alternatywnego wyjścia:

a <- 2
b <- 5

if(a < b) {
  print(paste(a,"jest mniejsze od",b))
}else{
  print(paste(b,"jest mniejsze od",a))
}

## [1] "2 jest mniejsze od 5"

a <- 60
b <- 10

if(a < b) {
  print(paste(a,"jest mniejsze od",b))
}else{
  print(paste(b,"jest mniejsze od",a))
}

## [1] "10 jest mniejsze od 60"

instrukcje if else mogą być łączone w łańcuchy:

grade <- "B"

if(grade == "A"){
  print("Ocena jest bardzo dobra!")
}else if(grade == "B"){
  print("Ocena jest dobra.")
} else if (grade == "C") {
  print("Ocena dostateczna.")
}

## [1] "Ocena jest dobra."

Nie należy tego mylić z funkcją o nazwie ifelse(). Jest ona również używana do wyboru warunkowego i przyjmuje postać ifelse(test, return-if-yes, return-if-no), a to jest wektorowe. Tak więc, na przykład, oto kilka wieków osób. Sklasyfikuj je jako dorosłych lub młodocianych.

x <- c(6,23,12,10,56,44)
ifelse(x>18,"Dorosły", "Młodociany")

## [1] "Młodociany" "Dorosły"    "Młodociany" "Młodociany" "Dorosły"   
## [6] "Dorosły"

Pętla for() jest przydatna do wielokrotnego uruchamiania poleceń przez znaną liczbę iteracji.

for (i in 1:5){
  print(i)
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Pętla while() jest przydatna do wielokrotnego uruchamiania poleceń przez nieznaną liczbę iteracji, aż do spełnienia jakiegoś warunku.

i <- 1
while(i < 5){
  print(i)
  i <- i+1
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4

Struktura tibble

W całej tej książce pracujemy z “tibbles” zamiast tradycyjnego data.frame w R. Tibbles są ramkami danych, ale poprawiają niektóre starsze zachowania, aby ułatwić życie. R jest starym językiem i niektóre rzeczy, które były przydatne 10 lub 20 lat temu, teraz stają na drodze.

Trudno jest zmienić bazę R bez łamania istniejącego kodu, więc większość innowacji pojawia się w pakietach. Tutaj zobaczmy jak działa tibble, który zapewnia opinane ramki danych, które sprawiają, że praca w tidyverse jest nieco łatwiejsza. W większości analiz używa się terminu tibble i data frame zamiennie.

tibble(
  x = 1:5, 
  y = 1, 
  z = x ^ 2 + y
)

## # A tibble: 5 × 3
##       x     y     z
##   <int> <dbl> <dbl>
## 1     1     1     2
## 2     2     1     5
## 3     3     1    10
## 4     4     1    17
## 5     5     1    26

Jeśli jesteś już zaznajomiony z data.frame(), zauważ, że tibble() robi znacznie mniej: nigdy nie zmienia typu danych wejściowych (np. nigdy nie konwertuje ciągów znaków na współczynniki!), nigdy nie zmienia nazw zmiennych i nie tworzy nazw wierszy.

Główne różnice między tibble a ramką danych:

Tibble mają wyrafinowaną metodę drukowania, która pokazuje tylko pierwsze 10 wierszy i wszystkie kolumny, które mieszczą się na ekranie. To znacznie ułatwia pracę z dużymi danymi. Oprócz nazwy, każda kolumna podaje swój typ, co jest miłą cechą zapożyczoną z str()

Tibbles są zaprojektowane tak, abyś przypadkowo nie przytłoczył swojej konsoli, gdy drukujesz duże ramki danych. Ale czasami potrzebujesz więcej danych wyjściowych niż domyślny wyświetlacz. Istnieje kilka opcji, które mogą pomóc.

Zadanie do wykonania

Zadanie wykonaj w kilku etapach: 1. Zapisz “dane” jako obiekt tibble pod inną nazwą, np. dane2. Porównaj je.

dane2<- as.tibble(dane)

## Warning: `as.tibble()` was deprecated in tibble 2.0.0.
## Please use `as_tibble()` instead.
## The signature and semantics have changed, see `?as_tibble`.

Które ze zmiennych przekształcone powinny być w czynnik (factor)?

#Zmiana zmiennych type i state w faktor 
dane2$type <- as.factor(dane2$type)
dane2$state <- as.factor(dane2$state)

#Próba zmiany daty na zmienną data
dane2$rok<-substr(dane2$sale_date, start=25, stop=28)
dane2$dzienNazwa <-substr(dane2$sale_date, start=1, stop=3)
dane2$miesiac <-substr(dane2$sale_date, start=5, stop=7)
dane2$dzien <- substr(dane2$sale_date, start=9, stop=10)
dane2$sale_date<- substr(dane2$sale_date, start=1, stop=10)
dane2$sale_date <-paste(dane2$dzienNazwa,dane2$miesiac,dane2$dzien,dane2$rok)
dane2$sale_date <-gsub(" ", "/", dane2$sale_date)

Cena nieruchomości (price) jest obecnie integer. Czy to odpowiednie?

dane2$price <- as.numeric(dane2$price)

Napisz własną funkcję, która wykonywać będzie standaryzowanie zmiennych.

#Funkcja standaryzująca
Standaryzcja <- function(x)
{ 
  A <- (x - mean(x))/(sd(x))
  return(A)
}

Utwórz nową zmienną “cena” w tibble “dane2”, która będzie zestandaryzowaną ceną, korzystając z własnej funkcji.

dane2$cena <- Standaryzcja(dane2$price)

Wykreśl cenę oraz price na wykresach ramkowych obok siebie na jednym ekranie. Różnice?

par(mfrow=c(1,2))
boxplot(dane2$price, main = "Wykres ramkowy cen", ylab = "cena w USD", xlab = "")
boxplot(dane2$cena , main = "Wykres ramkowy cen po standaryzacji ", ylab = " ", xlab = "")

RÓŻNICE: Dużo obserwacji występuje po śRednia + 2 odchylenia standardowe. Przy dalszej analizie niektóre obserwacji przydałoby się odciąć.