Hlavní navigace

Názory k článku Programovací jazyk R: práce s datovými rámci, jednoduché grafy

  • 24. 9. 2020 12:46

    bez přezdívky

    Hezka serie, diky.
    Jen par doplneni:
    Z datoveho ramce clovek snadno vybere jeden sloupec pomoci "$". To se hodi zejmena v typickem pouziti Rka k pocitani nejake statistiky. Cili napr.:

    > languages <- data.frame(
    + id = c (1:9),
    + name = c("C", "Java", "Python", "C++", "C#", "Visual Basic", "JavaScript", "PHP", "R"),
    + usage = c(15.95, 13.48, 10.47, 7.11, 4.58, 4.12, 2.54, 2.49, 2.37),
    + change = c(0.74, -3.18, 0.59, 1.48, 1.18, 0.83, 0.41, 0.62, 1.33),
    + stringsAsFactors = FALSE
    + )
    > mean(languages$u­sage)
    [1] 7.012222

    Souvisi to s tim, ze datovy ramec jako typ objektu vychazi z typu seznam.

    Taky:
    Pri vyberech je potreba davat pozor na to, ze R defaultne zahazuje "prebytecne dimenze" a pak meni typ. Pokud vybereme radek datoveho ramce, je vysledkem datovy ramec. Pokud ale vybereme sloupec, je pri vychozim nastaveni vysledkem vector (omlouvam se, nepamatuji si, jak to P. T. prelozil). Funguje to i u matic, u datovych ramcu je to zradnejsi v tom, ze pri vyberu radku tohle neprobehne. (Nemuze, protoze radek datoveho ramce muze obsahovat hodnoty ruznych typu - cili bez konverze typu z nich nejde udelat vector, leda seznam, a protoze je datovy ramec taky seznam, zustane datovy ramec)

    > # situace u matic:
    > a <- matrix(1:6, 2, 3)
    > a
    [,1] [,2] [,3]
    [1,] 1 3 5
    [2,] 2 4 6
    > class(a)
    [1] "matrix"
    > b <- a[1, ]
    > b
    [1] 1 3 5
    > class(b)
    [1] "integer"
    >
    > d <- a[ ,1]
    > d
    [1] 1 2
    > class(d)
    [1] "integer"
    > e <- a[ , 1, drop= FALSE]
    > e
    [,1]
    [1,] 1
    [2,] 2
    > class(e)
    [1] "matrix"
    > #situace u datoveho ramce:
    > df <- as.data.frame(a)
    > df
    V1 V2 V3
    1 1 3 5
    2 2 4 6
    > class(df)
    [1] "data.frame"
    > # u sloupcu konverze probehne:
    > f <- df[ ,2]
    > f
    [1] 3 4
    > class(f)
    [1] "integer"
    > # lze ji zamezit:
    > g <- df[ , 2, drop= FALSE]
    > g
    V2
    1 3
    2 4
    > class(g)
    [1] "data.frame"
    > # u radku konverze neprobehne:
    > h <- df[1, ]
    > h
    V1 V2 V3
    1 1 3 5
    > class(h)
    [1] "data.frame"
    > #lze ji vynutit:
    > i <- unlist(h)
    > i
    V1 V2 V3
    1 3 5
    > class(i)
    [1] "integer"
    > #kdyz o tom clovek nevi, muze se mu stat tohle:
    > mean(h)
    [1] NA
    Warning message:
    In mean.default(h) : argument is not numeric or logical: returning NA

    Posledni vec, jen kosmeticka:
    T sice funguje jako TRUE a F jako FALSE, ale rozhodnete si, co je pro prehlednost kodu lepsi.

  • 25. 9. 2020 14:51

    Nuphar

    Já ho prásknu, on také učí erko. :-)

    S tím výběrem z datového rámce bych ukázal příklad s testovacími daty:

    > languages <- data.frame(
    +    id = c (1:9),
    +    name = c("C", "Java", "Python", "C++", "C#", "Visual Basic", "JavaScript", "PHP", "R"),
    +    usage = c(15.95, 13.48, 10.47, 7.11, 4.58, 4.12, 2.54, 2.49, 2.37),
    +    change = c(0.74, -3.18, 0.59, 1.48, 1.18, 0.83, 0.41, 0.62, 1.33),
    +    stringsAsFactors = FALSE
    + )
    > languages # Všimněte si, že to neobaluji do print(...) :-)
      id         name usage change
    1  1            C 15.95   0.74
    2  2         Java 13.48  -3.18
    3  3       Python 10.47   0.59
    4  4          C++  7.11   1.48
    5  5           C#  4.58   1.18
    6  6 Visual Basic  4.12   0.83
    7  7   JavaScript  2.54   0.41
    8  8          PHP  2.49   0.62
    9  9            R  2.37   1.33
    > class(languages["name"])
    [1] "data.frame" # datový rámec jako původní zdroj
    > class(languages$name)
    [1] "character" # vektor
    > class(languages[2])
    [1] "data.frame" # datový rámec jako původní zdroj
    > languages[3]
      usage
    1 15.95
    2 13.48
    3 10.47
    4  7.11
    5  4.58
    6  4.12
    7  2.54
    8  2.49
    9  2.37
    > languages["name"]
              name
    1            C
    2         Java
    3       Python
    4          C++
    5           C#
    6 Visual Basic
    7   JavaScript
    8          PHP
    9            R
    > languages$name
    [1] "C"            "Java"         "Python"       "C++"          "C#"
    [6] "Visual Basic" "JavaScript"   "PHP"          "R"
    > languages[2]
              name
    1            C
    2         Java
    3       Python
    4          C++
    5           C#
    6 Visual Basic
    7   JavaScript
    8          PHP
    9            R

    Možná bych ještě zdůraznil, že ty faktory jsou děsně užitečné, protože se dají snadno použít na třídění, třeba pro krabicové grafy:

    langs <- data.frame(languages["name"], languages["usage"])
    > langs <- rbind(data.frame(langs$name, jitter(langs$usage)),
    data.frame(langs$name, jitter(langs$usage)),
    data.frame(langs$name, jitter(langs$usage)),
    data.frame(langs$name, jitter(langs$usage)),
    data.frame(langs$name, jitter(langs$usage)))
    > langs
         langs.name jitter.langs.usage.
    1             C           15.948595
    2          Java           13.487646
    3        Python           10.473382
    4           C++            7.117757
    5            C#            4.574903
    6  Visual Basic            4.119771
    7    JavaScript            2.533762
    8           PHP            2.481331
    9             R            2.378226
    10            C           15.955915
    11         Java           13.484478
    12       Python           10.472911
    13          C++            7.103522
    14           C#            4.583332
    15 Visual Basic            4.129590
    16   JavaScript            2.530045
    17          PHP            2.496101
    18            R            2.366824
    19            C           15.955425
    20         Java           13.488209
    21       Python           10.477087
    22          C++            7.112658
    23           C#            4.583441
    24 Visual Basic            4.119844
    25   JavaScript            2.531923
    26          PHP            2.491034
    27            R            2.362223
    28            C           15.943325
    29         Java           13.488028
    30       Python           10.461460
    31          C++            7.110751
    32           C#            4.578946
    33 Visual Basic            4.121060
    34   JavaScript            2.534422
    35          PHP            2.486563
    36            R            2.379705
    37            C           15.949777
    38         Java           13.484966
    39       Python           10.461877
    40          C++            7.110917
    41           C#            4.574754
    42 Visual Basic            4.113257
    43   JavaScript            2.540743
    44          PHP            2.494350
    45            R            2.366082
    boxplot(langs$jitter.langs.usage.~langs$langs.name)

    Je to poněkud humpolácké, ale jako ukázka to snad stačí. :-)