2 Typy danych i wektory

Zanim przejdziemy do tabel, poznajmy cegiełki, z których są zbudowane — podstawowe typy danych i wektory. To odpowiednik pojedynczej komórki i pojedynczej kolumny arkusza kalkulacyjnego.

2.1 Podstawowe typy danych

Każda wartość w R i Pythonie ma swój typ. Typ decyduje o tym, jakie operacje można na wartości wykonać.

# Liczby całkowite i rzeczywiste
wiek <- 25L          # integer (L oznacza "całkowity")
wzrost <- 175.5      # numeric (domyślny typ liczbowy)

# Tekst (łańcuch znaków)
imie <- "Anna"

# Wartości logiczne
czy_student <- TRUE
czy_pracuje <- FALSE

# Brak danych
wynik <- NA          # odpowiednik pustej komórki w Excelu

# Sprawdzenie typu
class(wiek)

#> [1] "integer"

class(imie)

#> [1] "character"

class(czy_student)

#> [1] "logical"

# Konwersja typów
as.numeric("3.14")   # tekst → liczba

#> [1] 3.14

as.character(42)     # liczba → tekst

#> [1] "42"

as.logical(1)        # liczba → logiczna (1 = TRUE, 0 = FALSE)

#> [1] TRUE

# Liczby całkowite i rzeczywiste
wiek = 25            # int
wzrost = 175.5       # float

# Tekst (łańcuch znaków)
imie = "Anna"        # str

# Wartości logiczne
czy_student = True   # bool (uwaga: wielka litera T!)
czy_pracuje = False

# Brak danych
import numpy as np
wynik = None         # ogólny brak wartości w Pythonie
wynik_num = np.nan   # brak wartości numerycznej (używany w pandas)

# Sprawdzenie typu
print(type(wiek))
print(type(imie))
print(type(czy_student))

# Konwersja typów
float("3.14")        # tekst → liczba
str(42)              # liczba → tekst
bool(1)              # liczba → logiczna (1 = True, 0 = False)

2.2 Wektory — kolumna danych

Czym jest wektor?

Wyobraź sobie jedną kolumnę Excela. W R taka kolumna to wektor — sekwencja wartości tego samego typu. W Pythonie (pandas) to Series, a w NumPy — array. To fundamentalna jednostka danych, z której buduje się tabele.

# Tworzenie wektora — funkcja c() (od "combine")
pensje <- c(4500, 5200, 4800, 6100, 5500)
miasta <- c("Warszawa", "Kraków", "Gdańsk", "Poznań", "Wrocław")

# Długość wektora
length(pensje)

#> [1] 5

# Podstawowe statystyki — operacje na CAŁYM wektorze jednocześnie
mean(pensje)      # średnia

#> [1] 5220

median(pensje)    # mediana

#> [1] 5200

sum(pensje)       # suma

#> [1] 26100

max(pensje)       # maksimum

#> [1] 6100

min(pensje)       # minimum

#> [1] 4500

# Operacje wektorowe — R działa na całym wektorze, nie na elementach!
# To jak wpisanie formuły w Excelu do całej kolumny naraz.
pensje_po_podwyzce <- pensje * 1.10    # każda pensja +10%
pensje_w_tys <- pensje / 1000          # przeliczenie na tysiące

pensje_po_podwyzce

#> [1] 4950 5720 5280 6710 6050

pensje_w_tys

#> [1] 4.5 5.2 4.8 6.1 5.5

import numpy as np

# Tworzenie tablicy NumPy (odpowiednik wektora R)
pensje = np.array([4500, 5200, 4800, 6100, 5500])
miasta = np.array(["Warszawa", "Kraków", "Gdańsk", "Poznań", "Wrocław"])

# Długość
len(pensje)

# Podstawowe statystyki
np.mean(pensje)      # średnia
np.median(pensje)    # mediana
np.sum(pensje)       # suma
np.max(pensje)       # maksimum
np.min(pensje)       # minimum

# Operacje wektorowe — tak samo jak R, działa na całej tablicy naraz
pensje_po_podwyzce = pensje * 1.10    # każda pensja +10%
pensje_w_tys = pensje / 1000          # przeliczenie na tysiące

print(pensje_po_podwyzce)
print(pensje_w_tys)

2.3 Indeksowanie — wybieranie elementów

Kluczowa różnica: od której liczby zaczynamy?

R liczy elementy od 1 — tak jak Excel i większość języków statystycznych.

Python liczy elementy od 0 — tak jak większość języków programowania ogólnego.

To jedna z najczęstszych przyczyn błędów przy przełączaniu się między językami!

pensje <- c(4500, 5200, 4800, 6100, 5500)

# Wybieranie po indeksie — R liczy od 1
pensje[1]          # pierwsza pensja → 4500

#> [1] 4500

pensje[3]          # trzecia pensja  → 4800

#> [1] 4800

pensje[c(1, 3, 5)] # pierwsza, trzecia i piąta

#> [1] 4500 4800 5500

pensje[2:4]        # od drugiej do czwartej (włącznie)

#> [1] 5200 4800 6100

pensje[-1]         # bez pierwszego

#> [1] 5200 4800 6100 5500

pensje[length(pensje)]  # ostatnia (jak Ctrl+End w Excelu)

#> [1] 5500

# Indeksowanie logiczne — wybieranie po warunku
pensje[pensje > 5000]          # tylko pensje powyżej 5000

#> [1] 5200 6100 5500

pensje[pensje > mean(pensje)]  # powyżej średniej

#> [1] 6100 5500

pensje = np.array([4500, 5200, 4800, 6100, 5500])

# Wybieranie po indeksie — Python liczy od 0!
pensje[0]           # pierwsza pensja → 4500 (indeks 0!)
pensje[2]           # trzecia pensja  → 4800 (indeks 2!)
pensje[[0, 2, 4]]   # pierwsza, trzecia i piąta
pensje[1:4]         # od drugiej do czwartej (koniec WYŁĄCZONY!)
pensje[-1]          # ostatnia (ujemny indeks)

# Indeksowanie logiczne — wybieranie po warunku
pensje[pensje > 5000]           # tylko pensje powyżej 5000
pensje[pensje > np.mean(pensje)] # powyżej średniej

2.4 Zmienne jakościowe — factor i categorical

Czym jest factor?

Wyobraź sobie kolumnę w Excelu z wartościami “niskie”, “średnie”, “wysokie”. Excel traktuje je jako zwykły tekst i sortuje alfabetycznie: “niskie”, “średnie”, “wysokie” — co akurat tutaj działa, ale “styczeń”, “luty”, “marzec” posortuje już błędnie: “luty”, “marzec”, “styczeń”.

Factor (R) i Categorical (Python) to typy danych które “wiedzą” jaka jest właściwa kolejność kategorii — niezależnie od alfabetu.

# Zwykły wektor tekstowy — sortuje alfabetycznie
miesiace_text <- c("marzec", "styczeń", "luty", "marzec", "styczeń")
sort(miesiace_text)   # błędna kolejność: luty, marzec, styczeń

#> [1] "luty"    "marzec"  "marzec"  "styczeń" "styczeń"

# Factor — definiujemy właściwą kolejność
miesiace_factor <- factor(
  miesiace_text,
  levels = c("styczeń", "luty", "marzec")
)

sort(miesiace_factor)   # poprawna kolejność: styczeń, styczeń, luty, marzec, marzec

#> [1] styczeń styczeń luty    marzec  marzec 
#> Levels: styczeń luty marzec

# Factor "pamięta" wszystkie możliwe kategorie (levels)
levels(miesiace_factor)

#> [1] "styczeń" "luty"    "marzec"

# Zliczanie — pokazuje też kategorie z zerową liczebnością
table(miesiace_factor)

#> miesiace_factor
#> styczeń    luty  marzec 
#>       2       1       2

# Factor uporządkowany (ordered) — gdy kategorie mają naturalną hierarchię
wyksztalcenie <- factor(
  c("wyższe", "średnie", "podstawowe", "wyższe", "średnie"),
  levels  = c("podstawowe", "średnie", "wyższe"),
  ordered = TRUE
)

# Można porównywać kategorie
wyksztalcenie[1] > wyksztalcenie[2]   # wyższe > średnie → TRUE

#> [1] TRUE

min(wyksztalcenie)                     # podstawowe

#> [1] podstawowe
#> Levels: podstawowe < średnie < wyższe

# Praktyczny przykład — factor na wykresie
library(ggplot2)

sprzedaz <- data.frame(
  miesiac = factor(
    c("sty", "lut", "mar", "kwi", "maj", "cze"),
    levels = c("sty", "lut", "mar", "kwi", "maj", "cze")
  ),
  wartosc = c(120, 95, 140, 160, 175, 155)
)

# Bez factora miesiące byłyby posortowane alfabetycznie!
ggplot(sprzedaz, aes(x = miesiac, y = wartosc)) +
  geom_col(fill = "steelblue") +
  labs(title = "Sprzedaż według miesiąca",
       x = NULL, y = "Wartość (tys. PLN)") +
  theme_minimal()

import pandas as pd

# Zwykła seria tekstowa — sortuje alfabetycznie
miesiace_text = pd.Series(["marzec", "styczeń", "luty", "marzec", "styczeń"])
miesiace_text.sort_values()   # błędna kolejność: luty, marzec, styczeń

# Categorical — definiujemy właściwą kolejność
miesiace_cat = pd.Categorical(
    miesiace_text,
    categories=["styczeń", "luty", "marzec"],
    ordered=True
)

pd.Series(miesiace_cat).sort_values()  # poprawna kolejność

# Dostępne kategorie
miesiace_cat.categories

# Zliczanie
pd.Series(miesiace_cat).value_counts().sort_index()

# Categorical w kolumnie DataFrame
df = pd.DataFrame({
    "wyksztalcenie": pd.Categorical(
        ["wyższe", "średnie", "podstawowe", "wyższe", "średnie"],
        categories=["podstawowe", "średnie", "wyższe"],
        ordered=True
    ),
    "pensja": [6500, 4800, 3200, 7100, 4200]
})

# Sortowanie respektuje kolejność kategorii
df.sort_values("wyksztalcenie")

# Porównania
df["wyksztalcenie"] > "średnie"

# Praktyczny przykład — Categorical na wykresie
import matplotlib.pyplot as plt

sprzedaz = pd.DataFrame({
    "miesiac": pd.Categorical(
        ["sty", "lut", "mar", "kwi", "maj", "cze"],
        categories=["sty", "lut", "mar", "kwi", "maj", "cze"],
        ordered=True
    ),
    "wartosc": [120, 95, 140, 160, 175, 155]
}).sort_values("miesiac")

fig, ax = plt.subplots(figsize=(8, 4))
ax.bar(sprzedaz["miesiac"], sprzedaz["wartosc"], color="steelblue")
ax.set_title("Sprzedaż według miesiąca")
ax.set_ylabel("Wartość (tys. PLN)")
ax.grid(axis="y", alpha=0.3)
plt.tight_layout()
plt.show()

Kiedy używać factora / Categorical?

Miesiące, dni tygodnia, kwartały — zawsze, gdy kolejność ma znaczenie
Skale ocen: “niedostateczny” → “celujący”
Poziomy wykształcenia, grupy wiekowe, kategorie dochodowe
Wszędzie tam gdzie chcesz kontrolować kolejność na wykresie lub w tabeli