Analiza danych to proces przetwarzania, czyszczenia i interpretowania danych w celu wyciągnięcia użytecznych informacji. Python jest jednym z najpopularniejszych języków do analizy danych.

Format CSV

CSV (Comma-Separated Values) to prosty format przechowywania danych tabelarycznych w pliku tekstowym.

Imie,Nazwisko,Wiek,Miasto
Jan,Kowalski,25,Warszawa
Anna,Nowak,30,Kraków
Piotr,Wiśniewski,28,Gdańsk

Struktura:

Pierwszy wiersz = nagłówki kolumn
Kolejne wiersze = dane
Separator (najczęściej przecinek)

Python ma wbudowany moduł csv do czytania i zapisywania plików CSV.

Odczyt pliku CSV

import csv

# Odczyt CSV jako lista list
with open('dane.csv', 'r', encoding='utf-8') as plik:
    czytnik = csv.reader(plik)
    
    # Pierwszy wiersz - nagłówki
    naglowki = next(czytnik)
    print(naglowki)  # ['Imie', 'Nazwisko', 'Wiek', 'Miasto']
    
    # Pozostałe wiersze - dane
    for wiersz in czytnik:
        print(wiersz)
        # ['Jan', 'Kowalski', '25', 'Warszawa']
        # ['Anna', 'Nowak', '30', 'Kraków']

Odczyt jako słownik

import csv

# DictReader - każdy wiersz jako słownik
with open('dane.csv', 'r', encoding='utf-8') as plik:
    czytnik = csv.DictReader(plik)
    
    for wiersz in czytnik:
        print(wiersz)
        # {'Imie': 'Jan', 'Nazwisko': 'Kowalski', 'Wiek': '25', 'Miasto': 'Warszawa'}
        
        # Dostęp po kluczu
        print(f"{wiersz['Imie']} {wiersz['Nazwisko']}, {wiersz['Wiek']} lat")

Zapis do CSV

import csv

dane = [
    ['Imie', 'Nazwisko', 'Wiek', 'Miasto'],
    ['Jan', 'Kowalski', 25, 'Warszawa'],
    ['Anna', 'Nowak', 30, 'Kraków'],
    ['Piotr', 'Wiśniewski', 28, 'Gdańsk']
]

# Zapis do CSV
with open('nowe_dane.csv', 'w', newline='', encoding='utf-8') as plik:
    writer = csv.writer(plik)
    writer.writerows(dane)

print("Plik zapisany!")

Ważne: newline='' zapobiega pustym liniom w Windows

Zapis słowników

import csv

dane = [
    {'Imie': 'Jan', 'Nazwisko': 'Kowalski', 'Wiek': 25},
    {'Imie': 'Anna', 'Nazwisko': 'Nowak', 'Wiek': 30},
    {'Imie': 'Piotr', 'Nazwisko': 'Wiśniewski', 'Wiek': 28}
]

with open('slowniki.csv', 'w', newline='', encoding='utf-8') as plik:
    naglowki = ['Imie', 'Nazwisko', 'Wiek']
    writer = csv.DictWriter(plik, fieldnames=naglowki)
    
    writer.writeheader()  # Zapisz nagłówki
    writer.writerows(dane)  # Zapisz dane

print("Plik zapisany!")

Różne separatory

import csv

# CSV z średnikiem jako separator
with open('dane_sredniki.csv', 'r', encoding='utf-8') as plik:
    czytnik = csv.reader(plik, delimiter=';')
    for wiersz in czytnik:
        print(wiersz)

# Zapis z tabulatorem
with open('dane_tab.csv', 'w', newline='', encoding='utf-8') as plik:
    writer = csv.writer(plik, delimiter='\t')
    writer.writerow(['Kolumna1', 'Kolumna2', 'Kolumna3'])

Pandas – profesjonalna analiza danych

Pandas to najpopularniejsza biblioteka do analizy danych w Pythonie.

Instalacja

pip install pandas

Podstawowe struktury danych

Pandas ma dwie główne struktury:

Series – jednowymiarowa (jak lista z indeksami)
DataFrame – dwuwymiarowa (tabela)

Series – jednowymiarowa seria

import pandas as pd

# Tworzenie Series
s = pd.Series([10, 20, 30, 40, 50])
print(s)
# 0    10
# 1    20
# 2    30
# 3    40
# 4    50
# dtype: int64

# Series z własnymi indeksami
s2 = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
print(s2)
# a    10
# b    20
# c    30

# Dostęp do elementów
print(s2['a'])  # 10
print(s2[0])    # 10

DataFrame – tabela danych

DataFrame to główna struktura w Pandas – dwuwymiarowa tabela z kolumnami.

Tworzenie DataFrame

import pandas as pd

# Ze słownika
dane = {
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28],
    'Miasto': ['Warszawa', 'Kraków', 'Gdańsk']
}

df = pd.DataFrame(dane)
print(df)
#     Imie  Wiek    Miasto
# 0    Jan    25  Warszawa
# 1   Anna    30    Kraków
# 2  Piotr    28    Gdańsk

Z listy list – zagnieżdżone listy

import pandas as pd

dane = [
    ['Jan', 25, 'Warszawa'],
    ['Anna', 30, 'Kraków'],
    ['Piotr', 28, 'Gdańsk']
]

df = pd.DataFrame(dane, columns=['Imie', 'Wiek', 'Miasto'])
print(df)

Z listy słowników

import pandas as pd

dane = [
    {'Imie': 'Jan', 'Wiek': 25, 'Miasto': 'Warszawa'},
    {'Imie': 'Anna', 'Wiek': 30, 'Miasto': 'Kraków'},
    {'Imie': 'Piotr', 'Wiek': 28, 'Miasto': 'Gdańsk'}
]

df = pd.DataFrame(dane)
print(df)

Wczytywanie danych z plików

CSV

import pandas as pd

# Wczytaj CSV
df = pd.read_csv('dane.csv')
print(df)

# Z różnymi opcjami
df = pd.read_csv('dane.csv', 
                 encoding='utf-8',      # Kodowanie
                 sep=';',               # Separator
                 decimal=',',           # Separator dziesiętny
                 thousands=' ')         # Separator tysięcy

# Bez nagłówków
df = pd.read_csv('dane.csv', header=None)

# Własne nazwy kolumn
df = pd.read_csv('dane.csv', names=['Col1', 'Col2', 'Col3'])

Excel

import pandas as pd

# Wymaga: pip install openpyxl

# Wczytaj Excel
df = pd.read_excel('dane.xlsx')

# Konkretny arkusz
df = pd.read_excel('dane.xlsx', sheet_name='Arkusz1')

JSON

import pandas as pd

# Wczytaj JSON
df = pd.read_json('dane.json')

# Z różnymi orientacjami
df = pd.read_json('dane.json', orient='records')

Podstawowe operacje na DataFrame

Podgląd danych

import pandas as pd

df = pd.read_csv('dane.csv')

# Pierwsze 5 wierszy
print(df.head())

# Pierwsze n wierszy
print(df.head(10))

# Ostatnie 5 wierszy
print(df.tail())

# Informacje o DataFrame
print(df.info())
# Wyświetli: typy kolumn, liczbę niepustych wartości

# Statystyki opisowe (dla kolumn numerycznych)
print(df.describe())
# Wyświetli: count, mean, std, min, max, quartiles

# Wymiary (wiersze, kolumny)
print(df.shape)  # (100, 5)

# Nazwy kolumn
print(df.columns)  # Index(['Imie', 'Wiek', 'Miasto'])

# Typy danych
print(df.dtypes)

Dostęp do kolumn

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28],
    'Miasto': ['Warszawa', 'Kraków', 'Gdańsk']
})

# Jedna kolumna (Series)
print(df['Imie'])
# 0      Jan
# 1     Anna
# 2    Piotr

# Lub jako atrybut
print(df.Imie)

# Wiele kolumn (DataFrame)
print(df[['Imie', 'Wiek']])
#     Imie  Wiek
# 0    Jan    25
# 1   Anna    30
# 2  Piotr    28

Dostęp do wierszy

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28],
    'Miasto': ['Warszawa', 'Kraków', 'Gdańsk']
})

# Po indeksie liczbowym - iloc
print(df.iloc[0])  # Pierwszy wiersz
# Imie          Jan
# Wiek           25
# Miasto    Warszawa

print(df.iloc[0:2])  # Pierwsze dwa wiersze

# Po etykiecie indeksu - loc
df_indexed = df.set_index('Imie')
print(df_indexed.loc['Anna'])
# Wiek          30
# Miasto    Kraków

# Konkretna komórka
print(df.iloc[0, 1])  # Wiersz 0, kolumna 1 → 25
print(df.loc[0, 'Wiek'])  # Wiersz 0, kolumna 'Wiek' → 25

Filtrowanie danych

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr', 'Ewa'],
    'Wiek': [25, 30, 28, 22],
    'Miasto': ['Warszawa', 'Kraków', 'Gdańsk', 'Warszawa']
})

# Filtruj wiek > 25
starsi = df[df['Wiek'] > 25]
print(starsi)
#     Imie  Wiek   Miasto
# 1   Anna    30   Kraków
# 2  Piotr    28   Gdańsk

# Filtruj miasto
warszawiacy = df[df['Miasto'] == 'Warszawa']
print(warszawiacy)

# Wiele warunków (& = and, | = or)
mlodzi_z_warszawy = df[(df['Wiek'] < 30) & (df['Miasto'] == 'Warszawa')]
print(mlodzi_z_warszawy)

# isin() - czy wartość w liście
krakowskie = df[df['Miasto'].isin(['Kraków', 'Gdańsk'])]
print(krakowskie)

Dodawanie i usuwanie kolumn

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28]
})

# Dodaj nową kolumnę
df['Pensja'] = [5000, 6000, 5500]
print(df)
#     Imie  Wiek  Pensja
# 0    Jan    25    5000
# 1   Anna    30    6000
# 2  Piotr    28    5500

# Oblicz nową kolumnę z istniejącej
df['Wiek_za_10_lat'] = df['Wiek'] + 10
print(df)

# Usuń kolumnę
df = df.drop('Wiek_za_10_lat', axis=1)
# Lub in-place
df.drop('Pensja', axis=1, inplace=True)
print(df)

Sortowanie

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28],
    'Pensja': [5000, 6000, 5500]
})

# Sortuj po wieku (rosnąco)
df_sorted = df.sort_values('Wiek')
print(df_sorted)

# Sortuj malejąco
df_sorted = df.sort_values('Wiek', ascending=False)
print(df_sorted)

# Sortuj po wielu kolumnach
df_sorted = df.sort_values(['Wiek', 'Pensja'], ascending=[True, False])
print(df_sorted)

# In-place
df.sort_values('Wiek', inplace=True)

Grupowanie i agregacja

import pandas as pd

df = pd.DataFrame({
    'Miasto': ['Warszawa', 'Kraków', 'Warszawa', 'Gdańsk', 'Kraków'],
    'Wiek': [25, 30, 28, 22, 35],
    'Pensja': [5000, 6000, 5500, 4500, 6500]
})

# Grupuj po mieście i oblicz średnią
srednie = df.groupby('Miasto')['Pensja'].mean()
print(srednie)
# Miasto
# Gdańsk       4500.0
# Kraków       6250.0
# Warszawa     5250.0

# Wiele agregacji
agregacja = df.groupby('Miasto').agg({
    'Wiek': 'mean',
    'Pensja': ['min', 'max', 'mean']
})
print(agregacja)

# Policz wystąpienia
liczebnosc = df.groupby('Miasto').size()
print(liczebnosc)

Brakujące dane

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, 7, 8],
    'C': [9, 10, 11, 12]
})

# Sprawdź brakujące wartości
print(df.isnull())
#        A      B      C
# 0  False  False  False
# 1  False   True  False
# 2   True  False  False
# 3  False  False  False

# Zlicz brakujące
print(df.isnull().sum())
# A    1
# B    1
# C    0

# Usuń wiersze z brakującymi
df_clean = df.dropna()
print(df_clean)

# Wypełnij brakujące wartością
df_filled = df.fillna(0)
print(df_filled)

# Wypełnij średnią
df['A'] = df['A'].fillna(df['A'].mean())
print(df)

Zapisywanie danych

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28]
})

# Do CSV
df.to_csv('wynik.csv', index=False)  # index=False = bez numeru wiersza

# Do Excel
df.to_excel('wynik.xlsx', index=False, sheet_name='Dane')

# Do JSON
df.to_json('wynik.json', orient='records', indent=2)

print("Pliki zapisane!")

Praktyczne przykłady

Przykład 1: Analiza sprzedaży

import pandas as pd

# Dane sprzedażowe
sprzedaz = pd.DataFrame({
    'Produkt': ['Laptop', 'Mysz', 'Klawiatura', 'Laptop', 'Mysz'],
    'Cena': [3000, 50, 200, 3000, 50],
    'Ilosc': [2, 10, 5, 1, 15],
    'Miasto': ['Warszawa', 'Kraków', 'Warszawa', 'Gdańsk', 'Kraków']
})

# Wartość sprzedaży
sprzedaz['Wartosc'] = sprzedaz['Cena'] * sprzedaz['Ilosc']

# Całkowita sprzedaż
print(f"Całkowita sprzedaż: {sprzedaz['Wartosc'].sum()} zł")

# Sprzedaż po produktach
po_produktach = sprzedaz.groupby('Produkt')['Wartosc'].sum()
print("\nSprzedaż po produktach:")
print(po_produktach)

# Najlepiej sprzedający się produkt
najlepszy = po_produktach.idxmax()
print(f"\nNajlepszy produkt: {najlepszy}")

Przykład 2: Czyszczenie danych

import pandas as pd
import numpy as np

# Dane z błędami
df = pd.DataFrame({
    'Imie': ['Jan', 'ANNA', 'piotr', '  Ewa  '],
    'Wiek': [25, 200, -5, 30],  # Błędne wartości
    'Email': ['jan@test.com', 'invalid', 'piotr@test.com', 'ewa@test.com']
})

print("PRZED czyszczeniem:")
print(df)

# Normalizuj imiona
df['Imie'] = df['Imie'].str.strip().str.title()

# Popraw wiek (ustal realistyczne granice)
df.loc[(df['Wiek'] < 0) | (df['Wiek'] > 120), 'Wiek'] = np.nan
df['Wiek'] = df['Wiek'].fillna(df['Wiek'].median())

# Waliduj email (prosty sposób)
df['Email_OK'] = df['Email'].str.contains('@')

print("\nPO czyszczeniu:")
print(df)

Przykład 3: Analiza ocen uczniów

import pandas as pd

oceny = pd.DataFrame({
    'Uczen': ['Jan', 'Anna', 'Piotr', 'Jan', 'Anna', 'Piotr'],
    'Przedmiot': ['Matematyka', 'Matematyka', 'Matematyka', 
                  'Polski', 'Polski', 'Polski'],
    'Ocena': [4, 5, 3, 5, 4, 4]
})

# Średnia po uczniach
srednie_uczniow = oceny.groupby('Uczen')['Ocena'].mean()
print("Średnie uczniów:")
print(srednie_uczniow)

# Średnia po przedmiotach
srednie_przedmiotow = oceny.groupby('Przedmiot')['Ocena'].mean()
print("\nŚrednie przedmiotów:")
print(srednie_przedmiotow)

# Najlepszy uczeń
najlepszy = srednie_uczniow.idxmax()
print(f"\nNajlepszy uczeń: {najlepszy} (średnia: {srednie_uczniow.max():.2f})")

# Tabela przestawna
pivot = oceny.pivot_table(
    values='Ocena',
    index='Uczen',
    columns='Przedmiot',
    aggfunc='mean'
)
print("\nTabela przestawna:")
print(pivot)

Przykład 4: Łączenie danych

import pandas as pd

# Dane uczniów
uczniowie = pd.DataFrame({
    'ID': [1, 2, 3],
    'Imie': ['Jan', 'Anna', 'Piotr']
})

# Dane ocen
oceny = pd.DataFrame({
    'ID_ucznia': [1, 1, 2, 3],
    'Przedmiot': ['Matematyka', 'Polski', 'Matematyka', 'Polski'],
    'Ocena': [4, 5, 5, 3]
})

# Połącz (merge) - jak JOIN w SQL
polaczone = pd.merge(uczniowie, oceny, 
                      left_on='ID', 
                      right_on='ID_ucznia')

print(polaczone)
#    ID  Imie  ID_ucznia   Przedmiot  Ocena
# 0   1   Jan          1  Matematyka      4
# 1   1   Jan          1      Polski      5
# 2   2  Anna          2  Matematyka      5
# 3   3 Piotr          3      Polski      3

Pandas – przydatne metody

Unikalne wartości

import pandas as pd

df = pd.DataFrame({
    'Miasto': ['Warszawa', 'Kraków', 'Warszawa', 'Gdańsk', 'Kraków']
})

# Unikalne wartości
print(df['Miasto'].unique())
# ['Warszawa' 'Kraków' 'Gdańsk']

# Liczba unikalnych
print(df['Miasto'].nunique())  # 3

# Zlicz wystąpienia
print(df['Miasto'].value_counts())
# Warszawa    2
# Kraków      2
# Gdańsk      1

Zastosuj funkcję

import pandas as pd

df = pd.DataFrame({
    'Liczba': [1, 2, 3, 4, 5]
})

# apply() - zastosuj funkcję do każdego elementu
df['Kwadrat'] = df['Liczba'].apply(lambda x: x ** 2)
print(df)

# apply() z własną funkcją
def klasyfikuj(x):
    if x < 3:
        return 'Mała'
    else:
        return 'Duża'

df['Kategoria'] = df['Liczba'].apply(klasyfikuj)
print(df)

Zastąp wartości

import pandas as pd

df = pd.DataFrame({
    'Ocena': ['A', 'B', 'C', 'A', 'B']
})

# Zamień wartości
mapping = {'A': 5, 'B': 4, 'C': 3}
df['Ocena_numeryczna'] = df['Ocena'].replace(mapping)
print(df)

Podsumowanie

Format CSV:

Prosty format tabelaryczny
Moduł csv do odczytu/zapisu
csv.reader(), csv.DictReader()
csv.writer(), csv.DictWriter()

Pandas – podstawy:

Series – jednowymiarowa
DataFrame – dwuwymiarowa tabela
pd.read_csv(), pd.read_excel(), pd.read_json()

Operacje DataFrame:

Podgląd: head(), tail(), info(), describe()
Dostęp: df['kolumna'], df.iloc[], df.loc[]
Filtrowanie: df[df['kolumna'] > wartość]
Sortowanie: sort_values()
Grupowanie: groupby()

Brakujące dane:

isnull(), dropna(), fillna()

Zapis:

to_csv(), to_excel(), to_json()

Zastosowania:

Analiza sprzedaży
Czyszczenie danych
Raporty i statystyki
Przygotowanie danych do wizualizacji

Ćwiczenia – CSV i Pandas

Moduł csv

Stwórz plik CSV z danymi 5 osób (imię, nazwisko, wiek, miasto).
Wczytaj plik CSV i wyświetl wszystkie dane.
Wczytaj CSV jako słowniki (DictReader) i wyświetl.
Dodaj nową osobę do istniejącego pliku CSV.
Policz ile osób jest z konkretnego miasta.
Znajdź najstarszą osobę w pliku CSV.
Wyfiltruj osoby starsze niż 25 lat i zapisz do nowego CSV.
Stwórz CSV z danymi produktów (nazwa, cena, ilość).
Oblicz wartość magazynu (cena × ilość) i zapisz do nowego CSV.
Wczytaj CSV z różnym separatorem (średnik).

Pandas – podstawy

Stwórz DataFrame z danymi 3 osób (słownik).
Stwórz DataFrame z listy list.
Wyświetl pierwsze 3 wiersze DataFrame.
Wyświetl ostatnie 2 wiersze DataFrame.
Wyświetl informacje o DataFrame (info()).
Wyświetl statystyki opisowe (describe()).
Wyświetl nazwy kolumn DataFrame.
Wyświetl wymiary DataFrame (shape).
Wyświetl typy danych kolumn (dtypes).
Stwórz Series z listy liczb.

Wczytywanie danych

Wczytaj plik CSV do DataFrame.
Wczytaj CSV bez nagłówków i dodaj własne.
Wczytaj tylko pierwsze 10 wierszy z CSV.
Wczytaj CSV z separatorem średnikowym.
Wczytaj plik Excel do DataFrame.

Dostęp do danych

Wyświetl pojedynczą kolumnę DataFrame.
Wyświetl dwie wybrane kolumny DataFrame.
Wyświetl pierwszy wiersz DataFrame (iloc).
Wyświetl wiersze od 2 do 5 (iloc).
Wyświetl konkretną komórkę DataFrame.

Filtrowanie

Wyfiltruj osoby starsze niż 25 lat.
Wyfiltruj osoby z konkretnego miasta.
Wyfiltruj osoby młodsze niż 30 AND z Warszawy.
Wyfiltruj osoby starsze niż 25 OR z Krakowa.
Wyfiltruj osoby z listy miast (isin).
Wyfiltruj wiersze gdzie pensja > 5000.
Znajdź osoby których imię zaczyna się na 'A’.
Wyfiltruj produkty droższe niż 100 zł.
Znajdź zamówienia z ostatniego miesiąca.
Wyfiltruj niepuste wartości w kolumnie.

Dodawanie i usuwanie

Dodaj nową kolumnę do DataFrame.
Oblicz nową kolumnę na podstawie istniejącej (np. wiek + 10).
Usuń kolumnę z DataFrame.
Usuń wiersz po indeksie.
Zmień nazwę kolumny (rename).

Sortowanie

Posortuj DataFrame po wieku (rosnąco).
Posortuj DataFrame po imieniu (alfabetycznie).
Posortuj DataFrame po wieku (malejąco).
Posortuj po dwóch kolumnach (wiek, pensja).
Posortuj indeks DataFrame.

Grupowanie i agregacja

Zgrupuj po mieście i oblicz średni wiek.
Zgrupuj po kategorii produktu i oblicz sumę sprzedaży.
Policz ile osób jest w każdym mieście (size).
Zgrupuj i oblicz min, max, mean dla pensji.
Stwórz tabelę przestawną (pivot_table).

Brakujące dane

Stwórz DataFrame z brakującymi wartościami (np.nan).
Sprawdź które wiersze mają brakujące dane (isnull).
Policz brakujące wartości w każdej kolumnie.
Usuń wiersze z brakującymi wartościami (dropna).
Wypełnij brakujące wartości zerem (fillna).
Wypełnij brakujące wartości średnią kolumny.
Usuń kolumny z więcej niż 50% braków.
Wykryj duplikaty wierszy (duplicated).
Usuń duplikaty (drop_duplicates).
Zastąp wartości None średnią.

Zapisywanie

Zapisz DataFrame do CSV bez indeksu.
Zapisz DataFrame do Excel.
Zapisz DataFrame do JSON.
Zapisz tylko wybrane kolumny do CSV.
Zapisz DataFrame z innym separatorem.

Operacje na tekście

Zamień wszystkie imiona na wielkie litery (str.upper).
Usuń spacje z początku i końca (str.strip).
Sprawdź czy email zawiera '@’ (str.contains).
Podziel kolumnę na dwie (str.split).
Wyciągnij pierwsze 3 znaki z tekstu (str[:3]).

Unikalne wartości

Wyświetl unikalne wartości kolumny 'Miasto’.
Policz liczbę unikalnych miast (nunique).
Zlicz wystąpienia każdej wartości (value_counts).
Znajdź najczęściej występującą wartość.
Usuń duplikaty z kolumny.

Apply i transform

Zastosuj funkcję lambda do kolumny (apply).
Stwórz kategorię na podstawie wieku (apply).
Zastosuj własną funkcję do DataFrame.
Oblicz nową kolumnę używając apply.
Zamień wartości używając replace.

Łączenie danych

Połącz dwa DataFrame wertykalnie (concat).
Połącz dwa DataFrame horyzontalnie (concat axis=1).
Wykonaj merge (inner join) dwóch DataFrame.
Wykonaj left join.
Wykonaj outer join.

Zadania analityczne

Wczytaj dane sprzedażowe i oblicz całkowitą wartość sprzedaży.
Znajdź 5 najlepiej sprzedających się produktów.
Oblicz średnią cenę produktów w każdej kategorii.
Stwórz raport miesięczny sprzedaży.
Znajdź klientów którzy wydali najwięcej.
Oblicz procent sprzedaży dla każdego produktu.
Wyfiltruj zamówienia z ostatnich 30 dni.
Znajdź produkty których nie ma na stanie.
Oblicz średnią ocen dla każdego produktu.
Stwórz ranking najlepszych sprzedawców.

Zadania kompleksowe

Wczytaj dane uczniów i ocen, oblicz średnie, znajdź najlepszego.
Analiza danych o pracownikach: średnia pensja, najstarszy, podział po działach.
Dane sprzedażowe: najlepszy miesiąc, najbardziej dochodowy produkt, trend.
Czyszczenie danych: usuń duplikaty, wypełnij braki, normalizuj tekst.
Analiza ankiety: zlicz odpowiedzi, procenty, wykres rozkładu.
Połącz dane z dwóch źródeł (merge) i stwórz raport.
Analiza logów: zlicz błędy, najczęstsze typy, wykres czasowy.
Dane finansowe: oblicz przychody, koszty, zysk netto.
Segmentacja klientów: podziel na grupy wiekowe, oblicz statystyki.
Time series: analiza sprzedaży w czasie, trendy, sezonowość.