Szybki quiz – przypomnienie poprzedniej lekcji

Temat: SQLite3 w Pythonie

Pytanie 1. Do czego służy kursor (cursor) i dlaczego nie wystarczy samo połączenie (conn)?

Pytanie 2. Co jest nie tak w tym kodzie?

cursor.execute('INSERT INTO produkty (nazwa, cena) VALUES (?, ?)', 'Laptop', 3500)

Pytanie 3. Co zostanie zapisane w bazie po wykonaniu tego kodu?

conn = sqlite3.connect('test.db')
cursor = conn.cursor()
cursor.execute('INSERT INTO produkty (nazwa, cena) VALUES (?, ?)', ('Mysz', 50))
conn.close()

Pytanie 4. Dlaczego w zapytaniu jest przecinek po 30?

cursor.execute('SELECT * FROM pracownicy WHERE wiek > ?', (30,))

Pytanie 5. Wstaw brakującą metodę, aby dodać wszystkie rekordy z listy dane jednym poleceniem:

cursor.______('INSERT INTO pracownicy (imie, wiek) VALUES (?, ?)', dane)

Pytanie 6. Tabela users ma kolumnę email TEXT UNIQUE NOT NULL. Co się stanie, gdy dwa razy wstawisz ten sam e-mail, a kod jest w bloku try z except sqlite3.IntegrityError?

Pytanie 7. Po ustawieniu conn.row_factory = sqlite3.Row jak odwołasz się do wartości z kolumny nazwa w wierszu row?

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

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

Pandas – podstawy

11. Stwórz DataFrame z danymi 3 osób (słownik).
12. Stwórz DataFrame z listy list.
13. Wyświetl pierwsze 3 wiersze DataFrame.
14. Wyświetl ostatnie 2 wiersze DataFrame.
15. Wyświetl informacje o DataFrame (info()).
16. Wyświetl statystyki opisowe (describe()).
17. Wyświetl nazwy kolumn DataFrame.
18. Wyświetl wymiary DataFrame (shape).
19. Wyświetl typy danych kolumn (dtypes).
20. Stwórz Series z listy liczb.

Wczytywanie danych

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

Dostęp do danych

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

Filtrowanie

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

Dodawanie i usuwanie

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

Sortowanie

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

Grupowanie i agregacja

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

Brakujące dane

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

Zapisywanie

66. Zapisz DataFrame do CSV bez indeksu.
67. Zapisz DataFrame do Excel.
68. Zapisz DataFrame do JSON.
69. Zapisz tylko wybrane kolumny do CSV.
70. Zapisz DataFrame z innym separatorem.

Operacje na tekście

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

Unikalne wartości

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

Apply i transform

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

Łączenie danych

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

Zadania analityczne

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

Zadania kompleksowe

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

PODSUMOWANIE

Dwa sposoby pracy z danymi tabelarycznymi w tej lekcji:

• moduł csv (wbudowany) – dane wiersz po wierszu, bez instalacji,
• biblioteka pandas (trzeba zainstalować: pip install pandas) – dane jako tabela (DataFrame) z gotowymi operacjami.

CSV:

• To plik tekstowy: pierwszy wiersz to zwykle nagłówki, dalej dane rozdzielone separatorem (najczęściej przecinkiem).
• csv.reader zwraca każdy wiersz jako listę, csv.DictReader jako słownik (klucze = nagłówki).
• Wartości odczytane z CSV są tekstem ('25', nie 25). Do obliczeń trzeba je przekonwertować.
• Przy zapisie używaj newline='' (bez tego w Windows mogą pojawić się puste linie) oraz encoding='utf-8'.
• csv.DictWriter wymaga fieldnames, a nagłówki zapisuje dopiero writeheader().
• Gdy plik używa innego separatora (np. ;), podaj delimiter=';'.

Pandas – struktury:

• Series – jednowymiarowa (kolumna z indeksem), DataFrame – dwuwymiarowa tabela.
• DataFrame można utworzyć ze słownika (klucz = nazwa kolumny), z listy list (z columns=) lub z listy słowników.

Dostęp do danych:

• df['Imie'] → jedna kolumna (Series), df[['Imie', 'Wiek']] → kilka kolumn (DataFrame, podwójne nawiasy).
• iloc – po pozycji (numerze), loc – po etykiecie indeksu.

Filtrowanie:

• df[df['Wiek'] > 25] – warunek zwraca maskę True/False, a df[maska] zostawia wiersze z True.
• Wiele warunków: & (i), | (lub), każdy warunek w osobnych nawiasach. Nie używamy tu and / or.
• isin([...]) – czy wartość jest na liście.

Modyfikacje:

• Nowa kolumna: df['Nowa'] = .... Usuwanie: df.drop('Kol', axis=1) (axis=1 = kolumna).
• Wiele metod (drop, sort_values, fillna, dropna) zwraca nowy DataFrame. Zmiana oryginału wymaga przypisania wyniku (df = ...) albo inplace=True.

Grupowanie i braki danych:

• groupby('Miasto')['Pensja'].mean() – najpierw grupa, potem kolumna, potem funkcja agregująca.
• Braki to NaN: isnull() (gdzie), isnull().sum() (ile w kolumnie), dropna() (usuń wiersze), fillna(...) (uzupełnij).

Typowe źródła błędów:

• brak nawiasów przy warunkach z & / |,
• df['A', 'B'] zamiast df[['A', 'B']],
• zapomniane index=False przy to_csv / to_excel (do pliku trafia dodatkowa kolumna z numerami wierszy),
• brak przypisania wyniku (df.fillna(0) samo nie zmienia df),
• zły separator lub kodowanie przy read_csv (dane „w jednej kolumnie”, krzaczki zamiast polskich znaków).

Minimum, które powinno wejść w pamięć

Jeżeli masz zapamiętać tylko kilka rzeczy z tej lekcji, zapamiętaj te:

1. CSV to tekst. csv.reader daje listy, csv.DictReader daje słowniki, a wszystkie wartości są napisami.
2. Zapis CSV: open(..., 'w', newline='', encoding='utf-8'). DictWriter potrzebuje fieldnames i writeheader().
3. import pandas as pd. Series = kolumna, DataFrame = tabela.
4. Jedna kolumna: df['A']. Kilka kolumn: df[['A', 'B']] (podwójne nawiasy).
5. iloc – pozycja, loc – etykieta.
6. Filtrowanie: df[df['Wiek'] > 25]. Kilka warunków: & / | i nawiasy wokół każdego warunku.
7. groupby('kol')['inna'].mean() – grupuj, wybierz kolumnę, policz.
8. Braki danych: isnull().sum(), dropna(), fillna().
9. Zapis: to_csv('plik.csv', index=False).
10. Metody Pandas zwykle nie zmieniają oryginału. Przypisz wynik albo użyj inplace=True.

Ściągawka – najważniejsze polecenia i składnia

Moduł csv

python

import csv
with open('dane.csv', 'r', encoding='utf-8') as plik:
    for wiersz in csv.DictReader(plik):
        print(wiersz['Imie'])

with open('wynik.csv', 'w', newline='', encoding='utf-8') as plik:
    writer = csv.writer(plik)

Tworzenie i wczytywanie

Podgląd

Dostęp

Filtrowanie

df[df['Wiek'] > 25]
df[df['Miasto'] == 'Warszawa']
df[(df['Wiek'] < 30) & (df['Miasto'] == 'Warszawa')]   # i
df[(df['Wiek'] > 25) | (df['Miasto'] == 'Kraków')]     # lub
df[df['Miasto'].isin(['Kraków', 'Gdańsk'])]

Kolumny, sortowanie, grupowanie

Braki danych i zapis

Quiz – sprawdź się

Pytanie 1. (teoria) Czym różni się Series od DataFrame? Którą strukturę zwraca df['Imie'], a którą df[['Imie', 'Wiek']]?

Pytanie 2. (analiza kodu) Plik dane.csv zawiera:

Imie,Wiek
Jan,25

Co się stanie po uruchomieniu kodu?

import csv
with open('dane.csv', 'r', encoding='utf-8') as plik:
    czytnik = csv.reader(plik)
    next(czytnik)
    for wiersz in czytnik:
        print(wiersz[1] + 1)

Pytanie 3. (znajdź błąd) Kod zapisuje plik, ale w pliku brakuje wiersza z nagłówkami. Co należy dodać i gdzie?

import csv
dane = [{'Imie': 'Jan', 'Wiek': 25}, {'Imie': 'Anna', 'Wiek': 30}]
with open('o.csv', 'w', newline='', encoding='utf-8') as plik:
    writer = csv.DictWriter(plik, fieldnames=['Imie', 'Wiek'])
    writer.writerows(dane)

Pytanie 4. (co zostanie wyświetlone) Jaki będzie wynik?

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

Pytanie 5. (znajdź błąd) Ten kod ma wypisać osoby starsze niż 25 lat z Warszawy, ale nie działa poprawnie. Popraw go i wyjaśnij przyczynę.

print(df[df['Wiek'] > 25 & df['Miasto'] == 'Warszawa'])

Pytanie 6. (co zostanie wyświetlone) Dla df z pytania 4:

print(df.iloc[1, 0])
print(df.loc[2, 'Wiek'])

Pytanie 7. (wybór poprawnej składni) Która instrukcja wyświetli dwie kolumny: Imie i Wiek?

• a) print(df['Imie', 'Wiek'])
• b) print(df[['Imie', 'Wiek']])
• c) print(df('Imie', 'Wiek'))
• d) print(df.Imie, Wiek)

Pytanie 8. (co zostanie wyświetlone)

g = pd.DataFrame({'M': ['a', 'b', 'a'], 'P': [10, 20, 30]})
print(g.groupby('M')['P'].mean())

Pytanie 9. (przewidywanie działania)

import numpy as np
d = pd.DataFrame({'A': [1, np.nan, 3]})
d['A'].fillna(0)
print(d['A'].tolist())
d['A'] = d['A'].fillna(d['A'].mean())
print(d['A'].tolist())

Pytanie 10. (uzupełnij kod) Wstaw brakujące argumenty:

# plik używa średników jako separatora, a liczby mają przecinek dziesiętny (np. 12,5)
df = pd.read_csv('dane.csv', ______, ______)

# zapis bez dodatkowej kolumny z numerami wierszy
df.to_csv('wynik.csv', ______)

Pytanie 11. (teoria) Do jakiego polecenia SQL z poprzedniej lekcji jest podobna funkcja pd.merge()?

Pytanie 12. (zadanie praktyczne) Dany jest DataFrame o nazwie sprzedaz z kolumnami Produkt, Cena, Ilosc. Napisz kod, który:

1. doda kolumnę Wartosc (cena razy ilość),
2. wypisze łączną wartość sprzedaży,
3. wypisze wartość sprzedaży dla każdego produktu.

  Imie  Wiek    Miasto
0  Jan    25  Warszawa
3  Ewa    22  Warszawa

M
a    20.0
b    20.0
Name: P, dtype: float64

sprzedaz['Wartosc'] = sprzedaz['Cena'] * sprzedaz['Ilosc']
print(sprzedaz['Wartosc'].sum())
print(sprzedaz.groupby('Produkt')['Wartosc'].sum())