Samouczek Python pandas: Kompletny przewodnik dla początkujących

Zainstaluj pandas

Zainstaluj pandas poleceniem pip install w terminalu. pandas 3 wymaga Pythona 3.11 lub nowszego; na starszym Pythonie pip zainstaluje najnowsze wydanie pandas 2.x zgodne z twoją wersją Pythona.

pip install pandasObsługiwane przez

Alternatywnie możesz zainstalować je przez conda:

conda install pandasObsługiwane przez

Po instalacji pandas dobrze jest sprawdzić zainstalowaną wersję, aby upewnić się, że wszystko działa poprawnie:

import pandas as pd
print(pd.__version__)  # Prints the pandas versionObsługiwane przez

To potwierdza poprawną instalację pandas i pozwala zweryfikować kompatybilność z innymi pakietami.

Co zmieniło się w pandas 3.0 i 3.1

pandas 3.0, wydane w styczniu 2026, zmieniło sposób działania kopii, łańcuchów znaków i przypisania, a pandas 3.1 (październik 2026) oznaczyło jako przestarzałe większość użyć inplace=True. Kod ze starszych tutoriali w większości nadal działa, ale cztery zmiany często zaskakują:

• Copy-on-Write jest domyślne. Każdy podzbiór lub wynik metody zachowuje się jak kopia, więc jego modyfikacja nigdy nie zmienia oryginalnego DataFrame'a. SettingWithCopyWarning zniknęło, podobnie jak potrzeba defensywnych wywołań .copy().
• Łańcuchowe przypisanie już nie działa. df["Age"][0] = 35 aktualizuje tymczasową kopię i pozostawia df bez zmian, a pandas ostrzega błędem ChainedAssignmentError. Zamiast tego użyj jednego wywołania .loc[].
• Łańcuchy znaków mają własny typ danych. Kolumny tekstowe są teraz rozpoznawane jako str zamiast object, oparte na PyArrow, gdy jest zainstalowany.
• inplace=True jest przestarzałe dla sort_values(), reset_index(), dropna(), drop_duplicates(), rename() i kilku innych metod. Zamiast tego przypisz wynik: df = df.dropna().

Oto zmiana dotycząca łańcuchowego przypisania na małym DataFrame:

import pandas as pd

patients = pd.DataFrame({"name": ["Ana", "Ben", "Chloe"], "age": [34, 51, 28]})

patients["age"][0] = 35      # chained assignment: patients is not changed
patients.loc[0, "age"] = 35  # a single .loc[] call: patients is updated
print(patients.dtypes)Obsługiwane przez

name      str
age     int64
dtype: objectObsługiwane przez

Każdy przykład w tym samouczku stosuje się do zasad pandas 3. Pełną listę zmian znajdziesz w oficjalnych informacjach o wydaniu dla pandas 3.0 i pandas 3.1. Jeśli utrzymujesz starszy kod, nasz przewodnik po SettingWithCopyWarning wyjaśnia zachowanie, które zastąpiło Copy-on-Write.

Importowanie danych w pandas

Aby zacząć pracę z pandas, zaimportuj pakiet Pythona pandas jak poniżej. Najczęściej używany alias to pd.

import pandas as pdObsługiwane przez

Importowanie plików CSV

Użyj read_csv() ze ścieżką do pliku CSV, aby wczytać plik wartości rozdzielanych przecinkami (szczegóły znajdziesz w naszym tutorialu o imporcie danych read_csv()).

df = pd.read_csv("diabetes.csv")Obsługiwane przez

Ta operacja wczytuje plik CSV diabetes.csv do DataFrame'a pandas o nazwie df. W całym samouczku używamy zbioru Pima Indians Diabetes: 768 pacjentów, osiem pomiarów zdrowotnych, takich jak Glucose, BMI i Age, oraz kolumna Outcome, gdzie 1 oznacza rozpoznanie cukrzycy.

Importowanie plików tekstowych

Wczytywanie plików tekstowych jest podobne do CSV. Jedyna różnica to konieczność podania separatora argumentem sep, jak poniżej. Separator to znak oddzielający wartości (kolumny) w każdym wierszu. Najczęstsze to przecinek (sep=","), tabulator (sep="\t"), dwukropek (sep=":") i białe znaki (sep=r"\s+"). r"\s+" to wyrażenie regularne dopasowujące jeden lub więcej białych znaków; prefiks r tworzy surowy łańcuch, więc Python nie traktuje \s jako nieprawidłowej sekwencji ucieczki.

df = pd.read_csv("diabetes.txt", sep=r"\s+")Obsługiwane przez

Importowanie plików Excel (pojedynczy arkusz)

Wczytuj pliki Excela funkcją read_excel(), podając ścieżkę do pliku. pandas potrzebuje dodatkowego pakietu silnika dla Excela: zainstaluj openpyxl dla plików .xlsx lub xlrd dla starszych plików .xls.

df = pd.read_excel('diabetes.xlsx')Obsługiwane przez

Możesz też wskazać inne argumenty, np. header, aby określić, który wiersz staje się nagłówkiem DataFrame'a. Domyślnie to 0, czyli pierwszy wiersz to nagłówki/nazwy kolumn. Nazwy kolumn możesz też podać listą w argumencie names. Argument index_col (domyślnie None) przydaje się, jeśli plik zawiera indeks wierszy.

Uwaga: W DataFrame lub Series w pandas indeks to identyfikator wskazujący położenie wiersza lub kolumny w DataFrame. W skrócie: indeks etykietuje wiersz lub kolumnę DataFrame'a i pozwala odwołać się do konkretnego wiersza lub kolumny po jego indeksie (zobaczysz to później). Indeks wierszy DataFrame'a może być zakresem (np. 0–303), szeregiem czasowym (daty lub timestampy), unikalnym identyfikatorem (np. employee_ID w tabeli employees) lub innego typu. Dla kolumn to zwykle łańcuch znaków (nazwa kolumny).

Importowanie plików Excel (wiele arkuszy)

Wczytywanie plików Excela z wieloma arkuszami niewiele się różni. Trzeba tylko podać dodatkowy argument sheet_name, gdzie można przekazać nazwę arkusza jako łańcuch lub jego pozycję jako liczbę całkowitą (pamiętaj, że Python używa indeksowania od 0, więc pierwszy arkusz to sheet_name = 0)

# Pobranie drugiego arkusza, bo Python indeksuje od 0
df = pd.read_excel('diabetes_multi.xlsx', sheet_name=1)Obsługiwane przez

Importowanie pliku JSON

Podobnie jak read_csv(), możesz użyć read_json() dla plików JSON, przekazując nazwę pliku JSON (więcej szczegółów w tym tutorialu o imporcie danych JSON i HTML do pandas). Poniższy kod czyta plik JSON z dysku i tworzy obiekt DataFrame df.

df = pd.read_json("diabetes.json")Obsługiwane przez

Jeśli chcesz dowiedzieć się więcej o imporcie danych z pandas, sprawdź ten ściąg o imporcie różnych typów plików w Pythonie. 

Importowanie danych z baz SQL

Aby wczytać dane z relacyjnej bazy danych, użyj pd.read_sql() wraz z połączeniem do bazy.

import sqlite3

# Nawiąż połączenie z bazą SQLite
conn = sqlite3.connect("my_database.db")

# Wczytaj dane z tabeli
df = pd.read_sql("SELECT * FROM my_table", conn)Obsługiwane przez

Dla innych baz, takich jak PostgreSQL czy MySQL, przekaż silnik SQLAlchemy jako połączenie zamiast połączenia sqlite3. Dla dużych tabel ustaw argument chunksize, aby czytać wynik partiami.

Importowanie danych z API (format JSON)

Jeśli twoje dane pochodzą z webowego API, pandas może wczytać je bezpośrednio, używając pd.read_json():

df = pd.read_json("https://api.example.com/data.json")Obsługiwane przez

Jeśli odpowiedź API to zagnieżdżony JSON, spłaszcz go funkcją pd.json_normalize(), która zamienia zagnieżdżone klucze na kolumny rozdzielone kropkami:

records = [
    {"id": 1, "vitals": {"glucose": 148, "bmi": 33.6}},
    {"id": 2, "vitals": {"glucose": 85, "bmi": 26.6}},
]
pd.json_normalize(records)Obsługiwane przez

   id  vitals.glucose  vitals.bmi
0   1             148        33.6
1   2              85        26.6Obsługiwane przez

Eksportowanie danych w pandas

Tak jak pandas potrafi importować dane z różnych typów plików, pozwala też eksportować je do różnych formatów. Przydaje się to zwłaszcza wtedy, gdy dane zostały przekształcone przy użyciu pandas i trzeba je zapisać lokalnie. Poniżej pokazujemy, jak zapisywać DataFrame'y pandas do różnych formatów.

Zapisywanie DataFrame'a do pliku CSV

DataFrame pandas (tu używamy df) zapiszesz jako plik CSV metodą .to_csv(). Przekaż ścieżkę do pliku i ustaw index=False, chyba że potrzebujesz indeksu wierszy w pliku (domyślnie index=True zapisze go jako dodatkową nienazwaną kolumnę). Nasz samouczek o zapisywaniu DataFrame do CSV omawia pozostałe argumenty.

df.to_csv("diabetes_out.csv", index=False)Obsługiwane przez

Zapisywanie DataFrame'a do pliku JSON

Wyeksportuj obiekt DataFrame do pliku JSON, wywołując metodę .to_json().

df.to_json("diabetes_out.json")Obsługiwane przez

Uwaga: Plik JSON przechowuje obiekt tabelaryczny, taki jak DataFrame, jako pary klucz–wartość. Dlatego w pliku JSON zauważysz powtarzające się nagłówki kolumn.

Zapisywanie DataFrame'a do pliku tekstowego

Podobnie jak przy zapisie DataFrame'ów do CSV, możesz użyć .to_csv(). Różnice są dwie: format wyjściowy to .txt i musisz podać separator argumentem sep.

df.to_csv('diabetes_out.txt', header=df.columns, index=None, sep=' ')Obsługiwane przez

Zapisywanie DataFrame'a do pliku Excel

Wywołaj .to_excel() na DataFrame, aby zapisać go jako plik .xlsx (wymaga to openpyxl). pandas nie zapisuje już starszych plików .xls.

df.to_excel("diabetes_out.xlsx", index=False)Obsługiwane przez

Przeglądanie i rozumienie DataFrame'ów w pandas

Po wczytaniu danych tabelarycznych do DataFrame'a warto rzucić okiem na dane. Możesz podejrzeć małą próbkę zbioru lub podsumowanie w postaci statystyk opisowych.

Jak przeglądać dane za pomocą .head() i .tail()

Możesz zobaczyć kilka pierwszych lub ostatnich wierszy DataFrame'a metodami .head() i .tail(). Liczbę wierszy określasz argumentem n (domyślnie 5).

df.head()Obsługiwane przez

Pierwszych pięć wierszy DataFrame'a 

df.tail(n = 10)Obsługiwane przez

Ostatnich 10 wierszy DataFrame'a

Rozumienie danych za pomocą .describe()

Metoda .describe() wypisuje statystyki podsumowujące wszystkich kolumn numerycznych, takie jak liczność, średnia, odchylenie standardowe, zakres i kwartyle kolumn liczbowych.

df.describe()Obsługiwane przez

Uzyskaj statystyki podsumowujące za pomocą .describe()

To daje szybki wgląd w skalę, skośność i zakres danych numerycznych.

Możesz też zmienić kwartyle, używając argumentu percentiles. Tutaj na przykład patrzymy na 30%, 50% i 70% percentyle kolumn numerycznych w DataFrame df.

df.describe(percentiles=[0.3, 0.5, 0.7])Obsługiwane przez

Uzyskaj statystyki podsumowujące z określonymi percentylami 

Możesz też ograniczyć podsumowanie do konkretnych typów danych, używając argumentu include. Tutaj na przykład podsumowujemy tylko kolumny o typie integer. 

df.describe(include=[int])Obsługiwane przez

Uzyskaj statystyki podsumowujące tylko kolumn całkowitoliczbowych 

Podobnie możesz wykluczyć pewne typy danych, używając argumentu exclude.

df.describe(exclude=[int])Obsługiwane przez

              BMI  DiabetesPedigreeFunction
count  768.000000                768.000000
mean    31.992578                  0.471876
std      7.884160                  0.331329
min      0.000000                  0.078000
25%     27.300000                  0.243750
50%     32.000000                  0.372500
75%     36.600000                  0.626250
max     67.100000                  2.420000Obsługiwane przez

Często praktycy wolą oglądać takie statystyki po transpozycji atrybutem .T.

df.describe().TObsługiwane przez

Transponuj statystyki podsumowujące za pomocą .T

Więcej o opisywaniu DataFrame'ów znajdziesz w tym ściągu.

Poznawanie danych za pomocą .info()

Metoda .info() to szybki sposób, by sprawdzić typy danych, brakujące wartości i rozmiar danych w DataFrame. Tutaj ustawiamy argument show_counts na True, co pokazuje liczbę niebrakujących wartości w każdej kolumnie. Ustawiamy też memory_usage na True, aby wyświetlić całkowite zużycie pamięci przez elementy DataFrame. Gdy verbose ma wartość True, wypisywane jest pełne podsumowanie z .info(). 

df.info(show_counts=True, memory_usage=True, verbose=True)Obsługiwane przez

<class 'pandas.DataFrame'>
RangeIndex: 768 entries, 0 to 767
Data columns (total 9 columns):
 #   Column                    Non-Null Count  Dtype  
---  ------                    --------------  -----  
 0   Pregnancies               768 non-null    int64  
 1   Glucose                   768 non-null    int64  
 2   BloodPressure             768 non-null    int64  
 3   SkinThickness             768 non-null    int64  
 4   Insulin                   768 non-null    int64  
 5   BMI                       768 non-null    float64
 6   DiabetesPedigreeFunction  768 non-null    float64
 7   Age                       768 non-null    int64  
 8   Outcome                   768 non-null    int64  
dtypes: float64(2), int64(7)
memory usage: 54.1 KBObsługiwane przez

Poznawanie danych za pomocą .shape

Liczbę wierszy i kolumn w DataFrame możesz sprawdzić atrybutem .shape. Zwraca on krotkę (wiersze, kolumny) i można ją indeksować, aby otrzymać tylko liczbę wierszy lub tylko liczbę kolumn.

df.shape # Get the number of rows and columns
df.shape[0] # Get the number of rows only
df.shape[1] # Get the number of columns onlyObsługiwane przez

(768,9)
768
9Obsługiwane przez

Pobieranie wszystkich kolumn i nazw kolumn

Wywołanie atrybutu .columns obiektu DataFrame zwraca nazwy kolumn w postaci obiektu Index. Przypomnienie: indeks pandas to adres/etykieta wiersza lub kolumny.

df.columnsObsługiwane przez

Index(['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI',
       'DiabetesPedigreeFunction', 'Age', 'Outcome'],
      dtype='str')Obsługiwane przez

Można go zamienić na listę za pomocą funkcji list().

list(df.columns)Obsługiwane przez

['Pregnancies',
 'Glucose',
 'BloodPressure',
 'SkinThickness',
 'Insulin',
 'BMI',
 'DiabetesPedigreeFunction',
 'Age',
 'Outcome']Obsługiwane przez

Sprawdzanie brakujących wartości w pandas za pomocą .isnull()

Przykładowy DataFrame nie ma braków. Dodajmy kilka, żeby było ciekawiej. Metoda .copy() tworzy kopię oryginalnego DataFrame. Praca na kopii pozostawia pierwotny df nienaruszony na potrzeby kolejnych przykładów. Używając .loc (omówione później), możesz ustawić wiersze o etykietach od 2 do 5 w kolumnie Pregnancies jako brakujące. Ponieważ braki są przechowywane jako NaN, czyli liczby zmiennoprzecinkowe, pandas konwertuje kolumnę z int64 na float64.

df2 = df.copy()
df2.loc[2:5,'Pregnancies'] = None
df2.head(7)Obsługiwane przez

Widzisz, że teraz wiersze od 2 do 5 to NaN

Możesz sprawdzić, czy każdy element w DataFrame jest brakiem, używając metody .isnull().

df2.isnull().head(7)Obsługiwane przez

Ponieważ często bardziej przydatne jest wiedzieć, ile masz braków, możesz połączyć .isnull() z .sum(), aby policzyć liczbę braków w każdej kolumnie.

df2.isnull().sum()Obsługiwane przez

Pregnancies                 4
Glucose                     0
BloodPressure               0
SkinThickness               0
Insulin                     0
BMI                         0
DiabetesPedigreeFunction    0
Age                         0
Outcome                     0
dtype: int64Obsługiwane przez

Możesz też zsumować jeszcze raz, żeby dostać łączną liczbę braków w DataFrame.

df2.isnull().sum().sum()Obsługiwane przez

4Obsługiwane przez

Sortowanie, krojenie i wyodrębnianie danych w pandas

Pakiet pandas oferuje kilka sposobów sortowania, pobierania podzbiorów, filtrowania i izolowania danych w DataFrame. Poniżej zobaczysz najczęstsze metody.

Sortowanie danych

Aby posortować DataFrame według konkretnej kolumny, użyj .sort_values(). Zwraca on nowy, posortowany DataFrame i nie zmienia df, więc przypisz wynik do zmiennej, jeśli chcesz go zachować:

df.sort_values(by="Age", ascending=False)  # Sort by Age in descending orderObsługiwane przez

Możesz sortować po wielu kolumnach:

df.sort_values(by=["Age", "Glucose"], ascending=[False, True])Obsługiwane przez

Resetowanie indeksu

Sortowanie lub filtrowanie zachowuje oryginalne etykiety wierszy, więc indeks może być nie po kolei. Użyj .reset_index(), aby dostać świeży indeks od 0 (zobacz nasz samouczek o resetowaniu indeksu w pandas po więcej opcji):

df_sorted = df.sort_values(by="Age", ascending=False).reset_index(drop=True)  # drop=True discards the old index
df_sorted[["Age", "Glucose", "Outcome"]].head(3)Obsługiwane przez

   Age  Glucose  Outcome
0   81      134        0
1   72      119        0
2   70      145        1Obsługiwane przez

Izolowanie jednej kolumny za pomocą [ ] 

Możesz wyodrębnić pojedynczą kolumnę, używając nawiasów kwadratowych [ ] z nazwą kolumny w środku. Wynikiem jest obiekt Series pandas. Series to jednowymiarowa tablica zawierająca dane dowolnego typu: int, float, string, boolean, obiekty Pythona itd. DataFrame składa się z wielu serii pełniących rolę kolumn.

df['Outcome']Obsługiwane przez

0      1
1      0
2      1
3      0
4      1
      ..
763    0
764    0
765    0
766    1
767    0
Name: Outcome, Length: 768, dtype: int64Obsługiwane przez

Izolowanie dwóch lub więcej kolumn za pomocą [[ ]] 

Możesz też podać listę nazw kolumn w nawiasach kwadratowych, aby pobrać więcej niż jedną kolumnę. Tutaj nawiasy kwadratowe użyte są na dwa sposoby. Zewnętrzne oznaczają podzbiór DataFrame, a wewnętrzne służą do utworzenia listy.

df[['Pregnancies', 'Outcome']]Obsługiwane przez

     Pregnancies  Outcome
0              6        1
1              1        0
2              8        1
3              1        0
4              0        1
..           ...      ...
763           10        0
764            2        0
765            5        0
766            1        1
767            1        0

[768 rows x 2 columns]Obsługiwane przez

Izolowanie jednego wiersza za pomocą [ ] 

Pojedynczy wiersz można pobrać, przekazując serię logiczną z jedną wartością True. W poniższym przykładzie zwracany jest drugi wiersz z index = 1. Tutaj .index zwraca etykiety wierszy DataFrame, a porównanie zamienia je w jednowymiarową tablicę boolowską.

df[df.index==1]Obsługiwane przez

Izolowanie jednego wiersza w pandas

Izolowanie dwóch lub więcej wierszy za pomocą [ ] 

Podobnie dwa lub więcej wierszy można zwrócić, używając metody .isin() zamiast operatora ==.

df[df.index.isin(range(2,10))]Obsługiwane przez

Izolowanie wybranych wierszy w pandas

Używanie .loc[] i .iloc[] do pobierania wierszy

Możesz pobierać konkretne wiersze według etykiet lub warunków, używając .loc[] i .iloc[] ("location" i "integer location"). .loc[] używa etykiety, by wskazać wiersz, kolumnę lub komórkę, natomiast .iloc[] korzysta z pozycji numerycznej. Nasz przewodnik loc vs iloc omawia wszystkie różnice; żeby zobaczyć najważniejszą, zmieńmy indeks w wcześniej utworzonym df2, tak aby etykiety i pozycje nie pokrywały się.

df2.index = range(1,769)Obsługiwane przez

Poniższy przykład zwraca Series pandas zamiast DataFrame. W .loc[1] 1 to etykieta, więc zwracany jest wiersz o etykiecie 1 (pierwszy wiersz po zmianie indeksu). W .iloc[1] 1 to pozycja od 0, więc zwracany jest drugi wiersz, który ma etykietę 2.

df2.loc[1]Obsługiwane przez

Pregnancies                   6.000
Glucose                     148.000
BloodPressure                72.000
SkinThickness                35.000
Insulin                       0.000
BMI                          33.600
DiabetesPedigreeFunction      0.627
Age                          50.000
Outcome                       1.000
Name: 1, dtype: float64Obsługiwane przez

df2.iloc[1]Obsługiwane przez

Pregnancies                  1.000
Glucose                     85.000
BloodPressure               66.000
SkinThickness               29.000
Insulin                      0.000
BMI                         26.600
DiabetesPedigreeFunction     0.351
Age                         31.000
Outcome                      0.000
Name: 2, dtype: float64Obsługiwane przez

Możesz też pobrać wiele wierszy, podając zakres w nawiasach kwadratowych. Oba akcesory inaczej traktują koniec zakresu: .loc[100:110] zawiera etykietę 110 i zwraca 11 wierszy, natomiast .iloc[100:110] zatrzymuje się przed pozycją 110 i zwraca 10 wierszy.

df2.loc[100:110]Obsługiwane przez

Izolowanie wierszy w pandas za pomocą .loc[]

df2.iloc[100:110]Obsługiwane przez

Izolowanie wierszy w pandas za pomocą .iloc[]

Możesz też pobierać podzbiory za pomocą .loc[] i .iloc[], używając listy zamiast zakresu.

df2.loc[[100, 200, 300]]Obsługiwane przez

Izolowanie wierszy za pomocą listy w pandas z .loc[]

df2.iloc[[100, 200, 300]]Obsługiwane przez

Izolowanie wierszy za pomocą listy w pandas z .iloc[]

Możesz też wybierać konkretne kolumny wraz z wierszami. Tu .iloc[] różni się od .loc[] – wymaga pozycji kolumn, a nie ich etykiet.

df2.loc[100:110, ['Pregnancies', 'Glucose', 'BloodPressure']]Obsługiwane przez

     Pregnancies  Glucose  BloodPressure
100          1.0      122             90
101          1.0      163             72
102          1.0      151             60
103          0.0      125             96
104          1.0       81             72
105          2.0       85             65
106          1.0      126             56
107          1.0       96            122
108          4.0      144             58
109          3.0       83             58
110          0.0       95             85Obsługiwane przez

df2.iloc[100:110, :3]Obsługiwane przez

     Pregnancies  Glucose  BloodPressure
101          1.0      163             72
102          1.0      151             60
103          0.0      125             96
104          1.0       81             72
105          2.0       85             65
106          1.0      126             56
107          1.0       96            122
108          4.0      144             58
109          3.0       83             58
110          0.0       95             85Obsługiwane przez

Dla szybszej pracy możesz przekazać początkowy indeks wiersza jako zakres.

df2.loc[760:, ['Pregnancies', 'Glucose', 'BloodPressure']]Obsługiwane przez

     Pregnancies  Glucose  BloodPressure
760          6.0      190             92
761          2.0       88             58
762          9.0      170             74
763          9.0       89             62
764         10.0      101             76
765          2.0      122             70
766          5.0      121             72
767          1.0      126             60
768          1.0       93             70Obsługiwane przez

df2.iloc[760:, :3]Obsługiwane przez

     Pregnancies  Glucose  BloodPressure
761          2.0       88             58
762          9.0      170             74
763          9.0       89             62
764         10.0      101             76
765          2.0      122             70
766          5.0      121             72
767          1.0      126             60
768          1.0       93             70Obsługiwane przez

Możesz aktualizować wartości, łącząc .loc[] z operatorem przypisania =. Buduj warunek z tego samego DataFrame, który aktualizujesz: warunek zbudowany z df nie będzie już zgodny z nowym indeksem df2 i pandas zgłosi błąd.

df2.loc[df2["Age"] == 81, "Age"] = 80Obsługiwane przez

Filtrowanie wierszy warunkami

pandas pozwala filtrować dane warunkami na wartościach wierszy/kolumn. Na przykład poniższy kod wybiera wiersz, w którym ciśnienie krwi (Blood Pressure) wynosi dokładnie 122. Tutaj izolujemy wiersze za pomocą nawiasów [ ], jak w poprzednich sekcjach. Zamiast przekazywać indeksy wierszy czy nazwy kolumn, podajemy warunek, że kolumna BloodPressure równa się 122. Ten warunek zapisujemy jako df.BloodPressure == 122.

df[df.BloodPressure == 122]Obsługiwane przez

Izolowanie wierszy na podstawie warunku w pandas 

Poniższy przykład pobiera wszystkie wiersze, w których Outcome wynosi 1. Tutaj df.Outcome wybiera tę kolumnę, df.Outcome == 1 zwraca serię wartości bool określających, które Outcome są równe 1, a następnie [] pobiera podzbiór df, gdzie ta seria ma wartość True.

df[df.Outcome == 1]Obsługiwane przez

Izolowanie wierszy na podstawie warunku w pandas 

Możesz użyć operatora >, aby porównywać wartości. Poniższy kod pobiera Pregnancies, Glucose i BloodPressure dla wszystkich rekordów, w których BloodPressure jest większe niż 100.

df.loc[df['BloodPressure'] > 100, ['Pregnancies', 'Glucose', 'BloodPressure']]Obsługiwane przez

     Pregnancies  Glucose  BloodPressure
43             9      171            110
84             5      137            108
106            1       96            122
177            0      129            110
207            5      162            104
362            5      103            108
369            1      133            102
440            0      189            104
549            4      189            110
658           11      127            106
662            8      167            106
672           10       68            106
691           13      158            114Obsługiwane przez

Czyszczenie danych w pandas

Czyszczenie danych to jedno z najczęstszych zadań w data science. pandas pozwala wstępnie przetwarzać dane do różnych zastosowań, m.in. trenowania modeli uczenia maszynowego i głębokiego. Skorzystajmy z DataFrame df2 z wcześniejszego przykładu, który ma cztery braki, by pokazać kilka technik czyszczenia. Przypomnienie: tak sprawdzisz liczbę braków w DataFrame.

df2.isnull().sum()Obsługiwane przez

Pregnancies                 4
Glucose                     0
BloodPressure               0
SkinThickness               0
Insulin                     0
BMI                         0
DiabetesPedigreeFunction    0
Age                         0
Outcome                     0
dtype: int64Obsługiwane przez

Radzenie sobie z brakami #1: usuwanie brakujących wartości

Jednym ze sposobów obchodzenia się z brakami jest ich usunięcie. Jest to szczególnie przydatne, gdy masz dużo danych i utrata niewielkiej części nie wpłynie na dalszą analizę. Możesz użyć metody .dropna(), jak poniżej. Tutaj zapisujemy wyniki .dropna() do DataFrame df3.

df3 = df2.copy()
df3 = df3.dropna()
df3.shapeObsługiwane przez

(764, 9) # this is 4 rows less than df2Obsługiwane przez

Argument axis pozwala wskazać, czy usuwasz wiersze, czy kolumny z brakami. Domyślny axis usuwa wiersze zawierające NaN. Użyj axis = 1, aby usunąć kolumny z co najmniej jednym NaN. Jak w każdym przykładzie w tym poradniku, przypisujemy wynik zamiast przekazywać inplace=True, które pandas 3.1 deprecjonuje dla .dropna().

df3 = df2.dropna(axis=1)
list(df3.columns)Obsługiwane przez

['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DiabetesPedigreeFunction', 'Age', 'Outcome']Obsługiwane przez

Domyślnie .dropna() usuwa wiersz, jeśli którakolwiek z jego wartości jest pusta. Ustaw argument how na 'all', aby usuwać tylko wiersze, w których wszystkie wartości są puste. W df2 nie ma całkowicie pustych wierszy, więc nic nie zostaje usunięte:

df3 = df2.dropna(how="all")
df3.shapeObsługiwane przez

(768, 9)Obsługiwane przez

Radzenie sobie z brakami #2: zastępowanie braków

Zamiast usuwać braki, możesz je zastąpić statystyką podsumowującą lub stałą wartością. Na przykład jeśli brakuje jednego dnia w tygodniu odczytów temperatury, wypełnienie go średnią z tego tygodnia zachowuje wiersz i traci niewiele informacji. Poniższy kod wypełnia brakujące wartości w Pregnancies średnią dla tej kolumny.

df3 = df2.copy()
# Get the mean of Pregnancies
mean_value = df3["Pregnancies"].mean()
# Fill only that column's missing values
df3["Pregnancies"] = df3["Pregnancies"].fillna(mean_value)
df3["Pregnancies"].head(7)Obsługiwane przez

1    6.000000
2    1.000000
3    3.846859
4    3.846859
5    3.846859
6    3.846859
7    3.000000
Name: Pregnancies, dtype: float64Obsługiwane przez

Radzenie sobie z duplikatami

Dodajmy duplikaty do oryginalnych danych, aby nauczyć się usuwać powtórzenia w DataFrame. Używamy funkcji pd.concat(), by skleić wiersze DataFrame df2 z samym df2, dodając idealne duplikaty każdego wiersza z df2. 

df3 = pd.concat([df2, df2])
df3.shapeObsługiwane przez

(1536, 9)Obsługiwane przez

Możesz usunąć wszystkie zduplikowane wiersze (domyślnie) z DataFrame, używając metody .drop_duplicates().

df3 = df3.drop_duplicates()
df3.shapeObsługiwane przez

(768, 9)Obsługiwane przez

Zmiana nazw kolumn

Częstym zadaniem przy czyszczeniu danych jest zmiana nazw kolumn. Przekaż metodzie .rename() słownik columns, który mapuje stare nazwy na nowe:

df3 = df3.rename(columns={"DiabetesPedigreeFunction": "DPF"})
df3[["Glucose", "BMI", "DPF", "Age"]].head()Obsługiwane przez

   Glucose   BMI    DPF  Age
1      148  33.6  0.627   50
2       85  26.6  0.351   31
3      183  23.3  0.672   32
4       89  28.1  0.167   21
5      137  43.1  2.288   33Obsługiwane przez

Możesz też przypisać pełną listę nazw do .columns. Lista musi zawierać nazwy wszystkich kolumn w ich aktualnej kolejności: pandas przypisuje nazwy po pozycji, więc lista w złej kolejności po cichu pomyli etykiety danych.

df3.columns = ["Pregnancies", "Glucose", "BloodPressure", "SkinThickness", "Insulin", "BMI", "DPF", "Age", "Outcome"]
list(df3.columns)Obsługiwane przez

['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DPF', 'Age', 'Outcome']Obsługiwane przez

Więcej o czyszczeniu danych oraz o łatwiejszych i bardziej przewidywalnych przepływach pracy znajdziesz w poniższej liście kontrolnej, która zawiera kompleksowy zestaw typowych zadań czyszczenia danych. 

Łączenie DataFrame’ów w pandas

pandas łączy DataFrame’y na dwa sposoby: .merge() łączy tabele po wspólnych kolumnach kluczowych, jak w SQL, a pd.concat() układa tabele jedną nad drugą lub obok siebie.

Łączenie DataFrame’ów za pomocą .merge()

Użyj .merge(), gdy dwie tabele współdzielą kolumnę kluczową. Załóżmy, że druga tabela mapuje każdy kod Outcome na czytelną etykietę. Lewe złączenie po Outcome doda tę etykietę do każdego wiersza pacjenta:

outcome_labels = pd.DataFrame({"Outcome": [0, 1], "Diagnosis": ["Non-diabetic", "Diabetic"]})

df_labeled = df.merge(outcome_labels, on="Outcome", how="left")
df_labeled[["Glucose", "Outcome", "Diagnosis"]].head(3)Obsługiwane przez

   Glucose  Outcome     Diagnosis
0      148        1      Diabetic
1       85        0  Non-diabetic
2      183        1      DiabeticObsługiwane przez

Argument how ustawia typ złączenia: "left" zachowuje każdy wiersz z df, "inner" zachowuje tylko wiersze z dopasowaniem w obu tabelach, a "outer" zachowuje wszystkie wiersze z obu. Nasz poradnik o łączeniu DataFrame’ów w pandas omawia .join() i każdy typ złączenia szczegółowo.

Konkatenacja DataFrame’ów za pomocą pd.concat()

Używaj pd.concat(), gdy tabele mają te same kolumny i chcesz ułożyć ich wiersze, na przykład gdy rekordy pacjentów przychodzą w dwóch partiach. Ustaw ignore_index=True, aby dostać świeży indeks od 0 zamiast zachowywać etykiety z każdej partii:

batch_1 = df.iloc[:500]
batch_2 = df.iloc[500:]

df_combined = pd.concat([batch_1, batch_2], ignore_index=True)
df_combined.shapeObsługiwane przez

(768, 9)Obsługiwane przez

Przy axis=1 pd.concat() układa tabele obok siebie, dopasowując wiersze po etykietach indeksu:

measurements = df[["Glucose", "BMI"]]
outcomes = df[["Outcome"]]

pd.concat([measurements, outcomes], axis=1).head(3)Obsługiwane przez

   Glucose   BMI  Outcome
0      148  33.6        1
1       85  26.6        0
2      183  23.3        1Obsługiwane przez

Aby poćwiczyć obie metody w praktyce, wypróbuj nasz kurs Joining Data with pandas.

Analiza danych w pandas

Główna zaleta pandas to szybkie funkcje analizy danych. W tej sekcji skupimy się na zestawie technik analitycznych, których możesz używać w pandas.

Operatory podsumowujące (średnia, dominanta, mediana)

Jak widziałeś wcześniej, możesz obliczyć średnią wartości w każdej kolumnie metodą .mean().

df.mean()Obsługiwane przez

Pregnancies                   3.845052
Glucose                     120.894531
BloodPressure                69.105469
SkinThickness                20.536458
Insulin                      79.799479
BMI                          31.992578
DiabetesPedigreeFunction      0.471876
Age                          33.240885
Outcome                       0.348958
dtype: float64Obsługiwane przez

Modę (dominantę) można policzyć podobnie metodą .mode(). 

df.mode()Obsługiwane przez

Wypisywanie dominanty kolumn w pandas

Podobnie medianę każdej kolumny obliczysz metodą .median()

df.median()Obsługiwane przez

Pregnancies                   3.0000
Glucose                     117.0000
BloodPressure                72.0000
SkinThickness                23.0000
Insulin                      30.5000
BMI                          32.0000
DiabetesPedigreeFunction      0.3725
Age                          29.0000
Outcome                       0.0000
dtype: float64Obsługiwane przez

Tworzenie nowych kolumn na podstawie istniejących 

pandas umożliwia szybkie i wydajne obliczenia, łącząc dwie lub więcej kolumn jak zmienne skalarne. Poniższy kod dzieli każdą wartość w kolumnie Glucose przez odpowiadającą jej wartość w kolumnie Insulin, tworząc nową kolumnę Glucose_Insulin_Ratio.

df2['Glucose_Insulin_Ratio'] = df2['Glucose']/df2['Insulin']
df2.head()Obsługiwane przez

Tworzenie nowej kolumny z istniejących kolumn w pandas

Wiersze, w których Insulin wynosi 0, pokazują inf, bo dzielenie przez zero daje nieskończoność. W tym zbiorze danych 0 w kolumnie Insulin oznacza brak pomiaru (374 z 768 wierszy), więc potraktuj te zera jako braki przed dzieleniem:

df2["Glucose_Insulin_Ratio"] = df2["Glucose"] / df2["Insulin"].where(df2["Insulin"] > 0)
df2["Glucose_Insulin_Ratio"].head()Obsługiwane przez

1         NaN
2         NaN
3         NaN
4    0.946809
5    0.815476
Name: Glucose_Insulin_Ratio, dtype: float64Obsługiwane przez

.where() zachowuje wartości spełniające warunek, a pozostałe zastępuje NaN, więc dla tych wierszy iloraz jest brakujący zamiast nieskończonego. Nasz poradnik o dodawaniu kolumn w pandas pokazuje więcej sposobów wyprowadzania nowych kolumn.

Zliczanie za pomocą .value_counts()

Gdy kolumna zawiera kategorie, często chcesz policzyć, ile obserwacji przypada na każdą z nich. Służy do tego metoda .value_counts(). Tutaj na przykład liczymy, ile obserwacji ma Outcome równe 1 (cukrzyca), a ile ma Outcome równe 0 (bez cukrzycy).

df['Outcome'].value_counts()Obsługiwane przez

Outcome
0    500
1    268
Name: count, dtype: int64Obsługiwane przez

Dodanie argumentu normalize zwraca udziały zamiast bezwzględnych zliczeń.

df['Outcome'].value_counts(normalize=True)Obsługiwane przez

Outcome
0    0.651042
1    0.348958
Name: proportion, dtype: float64Obsługiwane przez

Wyłącz automatyczne sortowanie wyników, używając argumentu sort (domyślnie True). Domyślnie sortowanie odbywa się według liczebności malejąco.

df['Outcome'].value_counts(sort=False)Obsługiwane przez

Outcome
1    268
0    500
Name: count, dtype: int64Obsługiwane przez

Możesz też zastosować .value_counts() do obiektu DataFrame i wskazanych kolumn w nim, a nie tylko do pojedynczej kolumny. Tutaj na przykład stosujemy value_counts() do df z argumentem subset, który przyjmuje listę kolumn. 

df.value_counts(subset=['Pregnancies', 'Outcome'])Obsługiwane przez

Pregnancies  Outcome
1            0          106
2            0           84
0            0           73
3            0           48
4            0           45
0            1           38
5            0           36
6            0           34
1            1           29
3            1           27
7            1           25
4            1           23
8            1           22
5            1           21
7            0           20
2            1           19
9            1           18
6            1           16
8            0           16
10           0           14
             1           10
9            0           10
11           1            7
13           0            5
             1            5
12           0            5
11           0            4
12           1            4
14           1            2
15           1            1
17           1            1
Name: count, dtype: int64Obsługiwane przez

Agregacja danych z .groupby() w pandas

pandas pozwala agregować wartości, grupując je według konkretnych wartości kolumn. Możesz to zrobić, łącząc metodę .groupby() z wybraną funkcją podsumowującą. Poniższy kod wyświetla średnią każdej kolumny numerycznej pogrupowaną według Outcome.

df.groupby('Outcome').mean()Obsługiwane przez

Agregowanie danych według jednej kolumny w pandas

.groupby() umożliwia grupowanie po więcej niż jednej kolumnie, przekazując listę nazw kolumn, jak poniżej.

df.groupby(['Pregnancies', 'Outcome']).mean()Obsługiwane przez

Agregowanie danych według dwóch kolumn w pandas

Każdą metodę podsumowującą można używać razem z .groupby(), w tym .min(), .max(), .mean(), .median(), .sum() i inne. Nasz poradnik o GroupBy w pandas omawia wielokrotne agregacje z .agg() i inne wzorce.

Tabele przestawne 

pandas umożliwia także obliczanie statystyk podsumowujących w formie tabel przestawnych. To ułatwia wyciąganie wniosków na podstawie kombinacji zmiennych. Poniższy kod wybiera wiersze jako unikalne wartości Pregnancies, kolumny jako unikalne wartości Outcome, a w komórkach umieszcza średnie wartości BMI w odpowiadającej grupie.

Na przykład dla Pregnancies = 5 i Outcome = 0 średnie BMI wynosi 31,1.

pd.pivot_table(df, values="BMI", index='Pregnancies', 
               columns=['Outcome'], aggfunc='mean')Obsługiwane przez

Outcome              0          1
Pregnancies                      
0            31.727397  39.213158
1            29.616038  37.793103
2            29.679762  34.578947
3            29.231250  32.548148
4            31.255556  33.873913
5            31.100000  36.780952
6            29.591176  31.775000
7            29.975000  34.756000
8            30.693750  32.204545
9            28.840000  33.300000
10           30.114286  31.380000
11           37.125000  39.385714
12           30.560000  34.575000
13           33.280000  36.720000
14                 NaN  35.100000
15                 NaN  37.100000
17                 NaN  40.900000Obsługiwane przez

Wizualizacja danych w pandas

pandas udostępnia wygodne nakładki na funkcje rysujące Matplotlib, które ułatwiają wizualizację DataFrame’ów. Poniżej zobaczysz, jak wykonywać typowe wizualizacje danych w pandas.

Wykresy liniowe w pandas

pandas pozwala zobrazować zależności między zmiennymi za pomocą wykresów liniowych. Poniżej znajduje się wykres liniowy BMI i Glucose względem indeksu wierszy.

df[['BMI', 'Glucose']].plot.line()Obsługiwane przez

Podstawowy wykres liniowy w pandas

Możesz wybrać kolory, korzystając z argumentu color.

df[['BMI', 'Glucose']].plot.line(color={"BMI": "red", "Glucose": "blue"})Obsługiwane przez

Podstawowy wykres liniowy w pandas, z własnymi kolorami

Wszystkie kolumny df można też narysować w osobnych skalach i na osobnych osiach, używając argumentu subplots.

df.plot.line(subplots=True)Obsługiwane przez

Podwykresy dla wykresów liniowych w pandas

Wykresy słupkowe w pandas

Dla kolumn dyskretnych możesz użyć wykresu słupkowego po liczebnościach kategorii, aby zwizualizować ich rozkład. Poniżej zwizualizowano zmienną Outcome o wartościach binarnych.

df['Outcome'].value_counts().plot.bar()Obsługiwane przez

Wykresy słupkowe w pandas

Wykresy pudełkowe w pandas

Rozkład kwartylowy zmiennych ciągłych można zobrazować wykresem pudełkowym. Poniższy kod pozwala utworzyć wykres pudełkowy w pandas.

df.boxplot(column=['BMI'], by='Outcome')Obsługiwane przez

Wykresy pudełkowe w pandas

Na koniec

Masz już rdzeniowy workflow w pandas: wczytaj plik do DataFrame’a, obejrzyj go metodami .head(), .info() i .describe(), wybieraj wiersze za pomocą .loc[] i .iloc[], czyść brakujące wartości i duplikaty, łącz tabele oraz podsumowuj z użyciem .groupby() i tabel przestawnych.

Jeśli uczyłeś się pandas przed 2026 r., warto zmienić jeden nawyk: przypisuj wyniki zamiast przekazywać inplace=True i wykonuj każdą aktualizację pojedynczym wywołaniem .loc[]. Najszybciej utrwalisz resztę, powtarzając workflow na zbiorze danych, na którym ci zależy. Te materiały pomogą ci pójść dalej:

• [Cheat sheets] Mnóstwo ściągawek do Pythona i pandas, do pod ręką w trakcie nauki 
• [Szkolenia na żywo] Nasze darmowe sesje live code-along, z których wiele korzysta z pandas
• [Kursy] Data Manipulation with pandas i Joining Data with pandas do interaktywnej praktyki
• [Przygotowanie do rozmów] Nasze topowe pytania rekrutacyjne z pandas, by sprawdzić, co już umiesz
• [Więcej tutoriali] Sprawdź pozostałe poradniki o pandas i ekosystemie PyData, w tym jak zaimplementować średnie kroczące w pandas oraz używanie metody .apply() w pandas