Moduł to plik Pythona (.py) zawierający funkcje, klasy i zmienne, które można wykorzystać w innych programach. Biblioteka to zbiór modułów pogrupowanych tematycznie. Pakiet to katalog zawierający moduły i plik __init__.py.

Dlaczego są ważne?

• Unikamy duplikowania kodu
• Korzystamy z gotowych rozwiązań
• Oszczędzamy czas
• Zwiększamy niezawodność programów

Analogia: Wyobraź sobie biblioteki jak skrzynkę z narzędziami. Zamiast tworzyć młotek od zera, bierzesz gotowy z skrzynki.

Biblioteka Standardowa Pythona

Biblioteka Standardowa (The Python Standard Library) to zestaw modułów instalowanych automatycznie z Pythonem. Nie trzeba ich pobierać – są zawsze dostępne.

Najważniejsze moduły Biblioteki Standardowej

Funkcje wbudowane Pythona

Python ma wbudowane funkcje dostępne zawsze, bez importowania. Poznałeś już wiele z nich:

Najczęściej używane:

print()      # Wyświetlanie
input()      # Pobieranie danych
len()        # Długość kolekcji
type()       # Typ zmiennej
int()        # Konwersja na int
str()        # Konwersja na string
range()      # Sekwencja liczb
sum()        # Suma elementów
max()        # Maksimum
min()        # Minimum
abs()        # Wartość bezwzględna
round()      # Zaokrąglanie
sorted()     # Sortowanie
enumerate()  # Indeks + element
zip()        # Łączenie kolekcji

Przykłady użycia:

# Funkcje agregujące
liczby = [5, 2, 8, 1, 9]
print(sum(liczby))     # 25
print(max(liczby))     # 9
print(min(liczby))     # 1
print(len(liczby))     # 5

# Wartość bezwzględna
print(abs(-10))        # 10

# Zaokrąglanie
print(round(3.14159, 2))  # 3.14

# Sortowanie
print(sorted(liczby))  # [1, 2, 5, 8, 9]

Pełna lista: https://docs.python.org/3/library/functions.html

Importowanie modułów

Sposób 1: Import całego modułu

import math

# Używanie funkcji z modułu
wynik = math.sqrt(16)
print(wynik)  # 4.0

pi = math.pi
print(pi)     # 3.141592653589793

Składnia: moduł.funkcja()

Sposób 2: Import konkretnej funkcji

from math import sqrt, pi

# Używanie bez nazwy modułu
wynik = sqrt(16)
print(wynik)  # 4.0
print(pi)     # 3.141592653589793

Zaleta: Krótszy zapis
Wada: Ryzyko konfliktu nazw

Sposób 3: Import wszystkiego (NIE ZALECANE)

from math import *

# Wszystkie funkcje dostępne bezpośrednio
print(sqrt(16))
print(pi)

Dlaczego unikać?

• Nie wiesz co dokładnie zaimportowałeś
• Ryzyko nadpisania funkcji
• Trudniejsze debugowanie

Sposób 4: Import z aliasem

import math as m

wynik = m.sqrt(16)
print(wynik)

# Przydatne dla długich nazw
import datetime as dt
dzisiaj = dt.date.today()

Gdzie umieszczać importy?

Zasada: Zawsze na początku pliku, przed resztą kodu.

# DOBRZE - importy na górze
import math
import random
from datetime import date

def funkcja():
    return math.sqrt(16)

# ŹLE - importy w środku kodu
def funkcja():
    import math  # Nie rób tego!
    return math.sqrt(16)

Kolejność importów (PEP 8):

1. Biblioteka standardowa
2. Biblioteki third-party (zainstalowane przez pip)
3. Własne moduły

# 1. Biblioteka standardowa
import math
import os
from datetime import datetime

# 2. Third-party
import numpy as np
import pandas as pd

# 3. Własne moduły
from my_module import my_function

Biblioteka math – funkcje matematyczne

Moduł math zawiera zaawansowane funkcje matematyczne.

Podstawowe funkcje

import math

# Pierwiastek kwadratowy
print(math.sqrt(25))      # 5.0

# Potęgowanie
print(math.pow(2, 3))     # 8.0

# Wartość bezwzględna (lepiej użyć wbudowanej abs())
print(math.fabs(-5))      # 5.0

# Zaokrąglanie
print(math.ceil(3.2))     # 4 (w górę)
print(math.floor(3.8))    # 3 (w dół)

# Silnia
print(math.factorial(5))  # 120 (5!)

Funkcje trygonometryczne

import math

# Sinus, cosinus, tangens (w radianach)
print(math.sin(math.pi / 2))   # 1.0
print(math.cos(0))             # 1.0
print(math.tan(math.pi / 4))   # 1.0

# Konwersja stopnie ↔ radiany
stopnie = 90
radiany = math.radians(stopnie)
print(radiany)                 # 1.5707... (π/2)

radiany = math.pi
stopnie = math.degrees(radiany)
print(stopnie)                 # 180.0

Logarytmy i wykładnicze

import math

# Logarytm naturalny (ln)
print(math.log(math.e))    # 1.0

# Logarytm o podstawie 10
print(math.log10(100))     # 2.0

# Logarytm o dowolnej podstawie
print(math.log(8, 2))      # 3.0 (log₂8)

# e^x
print(math.exp(1))         # 2.718... (e)

Stałe matematyczne

import math

print(math.pi)    # 3.141592653589793
print(math.e)     # 2.718281828459045
print(math.tau)   # 6.283185307179586 (2π)
print(math.inf)   # Nieskończoność
print(math.nan)   # Not a Number

Przykład praktyczny – odległość między punktami

import math

def odleglosc(x1, y1, x2, y2):
    """
    Oblicza odległość między dwoma punktami.
    Wzór: √[(x₂-x₁)² + (y₂-y₁)²]
    """
    return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)

# Test
dist = odleglosc(0, 0, 3, 4)
print(f"Odległość: {dist}")  # 5.0

Przykład – funkcja sigmoid

import math

def sigmoid(x):
    """
    Funkcja sigmoidalna: σ(x) = 1 / (1 + e^(-x))
    Używana w uczeniu maszynowym.
    """
    return 1 / (1 + math.exp(-x))

# Test
print(sigmoid(0))      # 0.5
print(sigmoid(5))      # 0.993...
print(sigmoid(-5))     # 0.006...

Biblioteka random – liczby losowe

Moduł random służy do generowania liczb pseudolosowych.

Podstawowe funkcje

import random

# Losowa liczba zmiennoprzecinkowa [0.0, 1.0)
print(random.random())  # np. 0.7234...

# Losowa liczba całkowita z zakresu
print(random.randint(1, 10))  # np. 7 (włącznie z 1 i 10)

# Losowa liczba zmiennoprzecinkowa z zakresu
print(random.uniform(1.5, 5.5))  # np. 3.7...

Losowanie z sekwencji

import random

# Losowy element z listy
kolory = ["czerwony", "zielony", "niebieski"]
print(random.choice(kolory))  # np. "zielony"

# Losowe elementy (z powtórzeniami)
print(random.choices(kolory, k=3))  # np. ['czerwony', 'czerwony', 'niebieski']

# Losowe elementy (bez powtórzeń)
print(random.sample(kolory, k=2))  # np. ['niebieski', 'czerwony']

# Przetasowanie listy
random.shuffle(kolory)
print(kolory)  # Zmieniona kolejność

Ziarno losowe (seed)

Ustawienie ziarna zapewnia powtarzalność losowania.

import random

# Ustawienie ziarna
random.seed(12)

# Zawsze te same "losowe" liczby
print(random.randint(1, 100))  # Zawsze ta sama wartość
print(random.randint(1, 100))  # Zawsze ta sama wartość

# Resetowanie do prawdziwej losowości
random.seed()

Zastosowanie: Debugging, reprodukowalne eksperymenty, testy.

Przykłady praktyczne

Rzut kostką:

import random

def rzut_kostka():
    return random.randint(1, 6)

print(f"Wyrzuciłeś: {rzut_kostka()}")

Losowe hasło:

import random
import string

def generuj_haslo(dlugosc=8):
    znaki = string.ascii_letters + string.digits
    return ''.join(random.choice(znaki) for _ in range(dlugosc))

print(generuj_haslo(12))  # np. "aB3dK9mQ1pR7"

Symulacja rzutu monetą:

import random

def rzut_moneta():
    return random.choice(["Orzeł", "Reszka"])

# 10 rzutów
for i in range(10):
    print(f"Rzut {i+1}: {rzut_moneta()}")

Biblioteka datetime – data i czas

Moduł datetime służy do pracy z datami i czasem.

Aktualna data i czas

from datetime import datetime, date, time

# Aktualna data i czas
teraz = datetime.now()
print(teraz)  # 2024-01-15 14:30:45.123456

# Tylko data
dzisiaj = date.today()
print(dzisiaj)  # 2024-01-15

# Części daty
print(dzisiaj.year)   # 2024
print(dzisiaj.month)  # 1
print(dzisiaj.day)    # 15

Tworzenie własnych dat

from datetime import date, datetime

# Konkretna data
urodziny = date(1990, 5, 15)
print(urodziny)  # 1990-05-15

# Konkretna data i czas
wydarzenie = datetime(2024, 12, 31, 23, 59, 59)
print(wydarzenie)  # 2024-12-31 23:59:59

Formatowanie dat

from datetime import datetime

teraz = datetime.now()

# Różne formaty
print(teraz.strftime("%Y-%m-%d"))           # 2024-01-15
print(teraz.strftime("%d/%m/%Y"))           # 15/01/2024
print(teraz.strftime("%d %B %Y"))           # 15 January 2024
print(teraz.strftime("%A, %d %B %Y"))       # Monday, 15 January 2024
print(teraz.strftime("%H:%M:%S"))           # 14:30:45
print(teraz.strftime("%d.%m.%Y %H:%M"))     # 15.01.2024 14:30

Kody formatowania:

• %Y – rok (4 cyfry)
• %m – miesiąc (01-12)
• %d – dzień (01-31)
• %H – godzina (00-23)
• %M – minuta (00-59)
• %S – sekunda (00-59)
• %A – dzień tygodnia (pełna nazwa)
• %B – miesiąc (pełna nazwa)

Parsowanie dat ze stringów

from datetime import datetime

# String → datetime
data_str = "2024-01-15"
data = datetime.strptime(data_str, "%Y-%m-%d")
print(data)
print(type(data))  # <class 'datetime.datetime'>

Różnica między datami (timedelta)

from datetime import date, timedelta

data1 = date(2024, 1, 1)
data2 = date(2024, 7, 18)

# Różnica
roznica = data2 - data1
print(roznica)        # 199 days, 0:00:00
print(roznica.days)   # 199

# Dodawanie czasu
za_tydzien = date.today() + timedelta(days=7)
print(za_tydzien)

# Odejmowanie czasu
tydzien_temu = date.today() - timedelta(days=7)
print(tydzien_temu)

# Różne jednostki
za_30_dni = date.today() + timedelta(days=30)
za_2_tygodnie = date.today() + timedelta(weeks=2)
za_godzine = datetime.now() + timedelta(hours=1)

Przykład – obliczanie wieku

from datetime import date

def oblicz_wiek(data_urodzenia):
    dzisiaj = date.today()
    wiek = dzisiaj.year - data_urodzenia.year
    
    # Sprawdź czy już były urodziny w tym roku
    if (dzisiaj.month, dzisiaj.day) < (data_urodzenia.month, data_urodzenia.day):
        wiek -= 1
    
    return wiek

# Test
urodziny = date(1990, 5, 15)
print(f"Wiek: {oblicz_wiek(urodziny)} lat")

Biblioteka calendar – kalendarz

Moduł calendar do pracy z kalendarzami.

Wyświetlanie kalendarza

import calendar

# Cały rok
print(calendar.calendar(2024))

# Konkretny miesiąc
print(calendar.month(2024, 6))

Wynik dla czerwca 2024:

     June 2024
Mo Tu We Th Fr Sa Su
                1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30

Przydatne funkcje

import calendar

# Czy rok przestępny?
print(calendar.isleap(2024))  # True
print(calendar.isleap(2023))  # False

# Ile dni w miesiącu?
print(calendar.monthrange(2024, 2))  # (3, 29) - luty zaczyna się w czwartek, ma 29 dni

# Dzień tygodnia (0=poniedziałek, 6=niedziela)
print(calendar.weekday(2024, 1, 15))  # 0 (poniedziałek)

# Nazwa dnia tygodnia
dni = ['Poniedziałek', 'Wtorek', 'Środa', 'Czwartek', 'Piątek', 'Sobota', 'Niedziela']
dzien_index = calendar.weekday(2024, 1, 15)
print(dni[dzien_index])  # Poniedziałek

Biblioteka string – operacje na stringach

Moduł string zawiera stałe i funkcje do pracy ze stringami.

Stałe stringów

import string

# Wszystkie litery
print(string.ascii_lowercase)  # 'abcdefghijklmnopqrstuvwxyz'
print(string.ascii_uppercase)  # 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
print(string.ascii_letters)    # 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

# Cyfry
print(string.digits)           # '0123456789'

# Znaki przestankowe
print(string.punctuation)      # '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

# Białe znaki
print(string.whitespace)       # ' \t\n\r\x0b\x0c'

Praktyczne zastosowanie – generator haseł:

import string
import random

def generuj_haslo(dlugosc=12):
    znaki = string.ascii_letters + string.digits + string.punctuation
    return ''.join(random.choice(znaki) for _ in range(dlugosc))

print(generuj_haslo(16))

Biblioteka collections – zaawansowane kolekcje

Moduł collections zawiera specjalne typy kolekcji.

Counter – licznik elementów

from collections import Counter

# Zliczanie elementów
items = ['YES', 'NO', 'NO', 'YES', 'EMPTY', 'YES', 'NO']
licznik = Counter(items)

print(licznik)  # Counter({'YES': 3, 'NO': 3, 'EMPTY': 1})

# Dostęp do liczby wystąpień
print(licznik['YES'])  # 3
print(licznik['EMPTY'])  # 1

# Najczęstsze elementy
print(licznik.most_common(2))  # [('YES', 3), ('NO', 3)]

Praktyczne zastosowanie – analiza tekstu:

from collections import Counter

tekst = "ala ma kota a kot ma ale"
slowa = tekst.split()
licznik = Counter(slowa)

print(licznik)
print(f"Najczęstsze słowo: {licznik.most_common(1)}")

defaultdict – słownik z wartością domyślną

from collections import defaultdict

# Zwykły słownik
slownik = {}
# slownik['klucz'] += 1  # KeyError!

# defaultdict z wartością domyślną 0
licznik = defaultdict(int)
licznik['a'] += 1  # Działa! Domyślnie 0
licznik['a'] += 1
print(licznik)  # defaultdict(<class 'int'>, {'a': 2})

deque – kolejka dwustronna

from collections import deque

kolejka = deque([1, 2, 3])

# Dodawanie
kolejka.append(4)       # Dodaj na końcu
kolejka.appendleft(0)   # Dodaj na początku
print(kolejka)          # deque([0, 1, 2, 3, 4])

# Usuwanie
kolejka.pop()           # Usuń z końca
kolejka.popleft()       # Usuń z początku
print(kolejka)          # deque([1, 2, 3])

Biblioteka json – praca z formatem JSON

JSON (JavaScript Object Notation) to popularny format wymiany danych.

Konwersja Python ↔ JSON

import json

# Python → JSON (serializacja)
dane_python = {
    "imie": "Jan",
    "wiek": 25,
    "miasto": "Warszawa",
    "hobby": ["programowanie", "sport"]
}

json_string = json.dumps(dane_python, indent=4, ensure_ascii=False)
print(json_string)

Wynik:

{
    "imie": "Jan",
    "wiek": 25,
    "miasto": "Warszawa",
    "hobby": [
        "programowanie",
        "sport"
    ]
}

Parametry dumps()

import json

dane = {"PLW": 360.0, "TEN": 320.0, "CDR": 329.0}

# Sortowanie po kluczach + wcięcie
json_str = json.dumps(dane, sort_keys=True, indent=4)
print(json_str)

Wynik:

{
    "CDR": 329.0,
    "PLW": 360.0,
    "TEN": 320.0
}

JSON → Python (deserializacja)

import json

json_string = '{"imie": "Jan", "wiek": 25}'

# JSON → Python
dane = json.loads(json_string)
print(dane)        # {'imie': 'Jan', 'wiek': 25}
print(type(dane))  # <class 'dict'>
print(dane['imie'])  # Jan

Zapis i odczyt plików JSON

import json

# Zapis do pliku
dane = {"imie": "Jan", "wiek": 25}
with open('dane.json', 'w', encoding='utf-8') as f:
    json.dump(dane, f, indent=4, ensure_ascii=False)

# Odczyt z pliku
with open('dane.json', 'r', encoding='utf-8') as f:
    wczytane = json.load(f)
    print(wczytane)

Biblioteka pickle – serializacja obiektów

pickle służy do zapisywania obiektów Pythona do plików binarnych.

Zapis i odczyt

import pickle

# Dane do zapisania
ids = ['001', '003', '011']

# Zapis do pliku
with open('data.pickle', 'wb') as f:  # 'wb' = write binary
    pickle.dump(ids, f)

# Odczyt z pliku
with open('data.pickle', 'rb') as f:  # 'rb' = read binary
    wczytane = pickle.load(f)
    print(wczytane)  # ['001', '003', '011']

Pickle vs JSON:

• pickle – tylko Python, pliki binarne, wszystkie typy Pythona
• json – uniwersalny, tekstowy, tylko podstawowe typy

Biblioteka re – wyrażenia regularne

Moduł re służy do pracy z wyrażeniami regularnymi (regex) – wzorcami tekstowymi.

Podstawowe funkcje

findall() – znajdź wszystkie wystąpienia:

import re

# Znajdź wszystkie cyfry
string = 'Python 3.8'
cyfry = re.findall(r'\d', string)
print(cyfry)  # ['3', '8']

# Znajdź wszystkie znaki alfanumeryczne
string = '!@#$%^&45wc'
alfanum = re.findall(r'\w', string)
print(alfanum)  # ['4', '5', 'w', 'c']

Znajdowanie adresów email:

import re

raw_text = "Wyślij email na adres: info@template.com lub sales-info@template.it"
emails = re.findall(r'[\w\.-]+@[\w\.-]+', raw_text)
print(emails)
# ['info@template.com', 'sales-info@template.it']

split() – dzielenie tekstu:

import re

text = 'Programowanie w języku Python – od A do Z'

# Podział po białych znakach
slowa = re.split(r'\s+', text)
print(slowa)
# ['Programowanie', 'w', 'języku', 'Python', '–', 'od', 'A', 'do', 'Z']

Podstawowe wzorce regex

Instalowanie pakietów zewnętrznych

Biblioteka standardowa nie zawiera wszystkiego. Można instalować pakiety zewnętrzne za pomocą pip.

Czym jest pip?

pip to menedżer pakietów dla Pythona. Pobiera pakiety z repozytorium PyPI (Python Package Index): https://pypi.org/

Podstawowe komendy pip

W terminalu wpisujemy:

# Instalacja pakietu:
pip install numpy

# Instalacja konkretnej wersji:
pip install numpy==1.24.0

# Aktualizacja pakietu:
pip install --upgrade numpy

# Odinstalowanie pakietu:
pip uninstall numpy

# Lista zainstalowanych pakietów:
pip list

# Informacje o pakiecie:
pip show numpy

# Zapisanie zainstalowanych pakietów:
pip freeze > requirements.txt

# Instalacja z pliku requirements.txt:
pip install -r requirements.txt

Popularne biblioteki zewnętrzne

NumPy – operacje numeryczne

Biblioteka do obliczeń numerycznych, praca z tablicami wielowymiarowymi.

import numpy as np

# Tworzenie tablicy
arr = np.array([1, 2, 3, 4, 5])
print(arr)

# Operacje na całej tablicy
print(arr * 2)      # [2, 4, 6, 8, 10]
print(arr + 10)     # [11, 12, 13, 14, 15]

# Statystyki
print(np.mean(arr))  # Średnia
print(np.std(arr))   # Odchylenie standardowe
print(np.max(arr))   # Maksimum

Dokumentacja: https://numpy.org/

Pandas – analiza danych

Biblioteka do analizy i przetwarzania danych tabelarycznych.

import pandas as pd

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

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

Dokumentacja: https://pandas.pydata.org/

Matplotlib – wykresy

Biblioteka do tworzenia wykresów i wizualizacji danych.

import matplotlib.pyplot as plt

# Prosty wykres
x = [1, 2, 3, 4, 5]
y = [1, 4, 9, 16, 25]

plt.plot(x, y)
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Wykres y = x²')
plt.show()

Dokumentacja: https://matplotlib.org/

Requests – zapytania HTTP

Biblioteka do wysyłania zapytań HTTP.

import requests

# Pobranie danych z API
response = requests.get('https://api.github.com')
print(response.status_code)  # 200
print(response.json())        # Dane w formacie JSON

Dokumentacja: https://requests.readthedocs.io/

Tworzenie własnych modułów

Możesz tworzyć własne moduły – pliki .py z funkcjami do wielokrotnego użytku.

Przykład – moduł matematyczny

Plik moj_modul.py:

"""
Mój własny moduł matematyczny.
"""

def dodaj(a, b):
    """Dodaje dwie liczby."""
    return a + b

def odejmij(a, b):
    """Odejmuje dwie liczby."""
    return a - b

def pomnoz(a, b):
    """Mnoży dwie liczby."""
    return a * b

PI = 3.14159

Użycie w innym pliku:

import moj_modul

wynik = moj_modul.dodaj(5, 3)
print(wynik)  # 8

print(moj_modul.PI)  # 3.14159

Lub:

from moj_modul import dodaj, PI

wynik = dodaj(5, 3)
print(wynik)  # 8
print(PI)     # 3.14159

Dobre praktyki

1. Importuj tylko to czego potrzebujesz

# DOBRZE - konkretne funkcje
from math import sqrt, pi

# ŹLE - wszystko niepotrzebnie
from math import *

2. Używaj aliasów dla długich nazw

# DOBRZE
import datetime as dt
dzisiaj = dt.date.today()

# ŹLE - za długie
import datetime
dzisiaj = datetime.date.today()

3. Grupuj importy

# DOBRZE - pogrupowane
import os
import sys

import numpy as np
import pandas as pd

from my_module import funkcja

# ŹLE - chaotyczne
from my_module import funkcja
import numpy as np
import os
import pandas as pd
import sys

4. Dokumentuj własne moduły

"""
Moduł do obliczeń geometrycznych.

Zawiera funkcje do obliczania:
- pola figur
- objętości brył
- obwodów
"""

def pole_kola(promien):
    """
    Oblicza pole koła.
    
    Args:
        promien (float): Promień koła
    
    Returns:
        float: Pole koła
    """
    from math import pi
    return pi * promien ** 2

Przykłady kompleksowe

Przykład 1: Program do analizy tekstu

import string
from collections import Counter

def analizuj_tekst(tekst):
    """Analizuje podany tekst."""
    
    # Usuwanie znaków przestankowych
    tekst_czysty = tekst.translate(str.maketrans('', '', string.punctuation))
    
    # Lista słów
    slowa = tekst_czysty.lower().split()
    
    # Statystyki
    liczba_slow = len(slowa)
    liczba_znakow = len(tekst)
    
    # Najczęstsze słowa
    licznik = Counter(slowa)
    najczestsze = licznik.most_common(5)
    
    # Wyniki
    print(f"Liczba słów: {liczba_slow}")
    print(f"Liczba znaków: {liczba_znakow}")
    print(f"Średnia długość słowa: {liczba_znakow / liczba_slow:.2f}")
    print(f"\nNajczęstsze słowa:")
    for slowo, ilosc in najczestsze:
        print(f"  {slowo}: {ilosc}")

# Test
tekst = """Python to język programowania wysokiego poziomu.
Python jest łatwy w nauce. Python jest wszędzie."""

analizuj_tekst(tekst)

Przykład 2: Generator raportów z datą

from datetime import datetime
import json

def generuj_raport(dane):
    """Generuje raport z bieżącą datą."""
    
    raport = {
        "data_utworzenia": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        "autor": "System",
        "dane": dane,
        "liczba_rekordow": len(dane)
    }
    
    # Zapis do pliku JSON
    nazwa_pliku = f"raport_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
    
    with open(nazwa_pliku, 'w', encoding='utf-8') as f:
        json.dump(raport, f, indent=4, ensure_ascii=False)
    
    print(f"Raport zapisany: {nazwa_pliku}")
    return nazwa_pliku

# Test
dane_sprzedazy = [
    {"produkt": "Laptop", "cena": 3000},
    {"produkt": "Mysz", "cena": 50},
    {"produkt": "Klawiatura", "cena": 200}
]

generuj_raport(dane_sprzedazy)

Przykład 3: Walidator danych

import re
from datetime import datetime

class Walidator:
    """Klasa do walidacji różnych typów danych."""
    
    @staticmethod
    def email(adres):
        """Sprawdza poprawność adresu email."""
        wzorzec = r'^[\w\.-]+@[\w\.-]+\.\w+$'
        return bool(re.match(wzorzec, adres))
    
    @staticmethod
    def telefon(numer):
        """Sprawdza poprawność numeru telefonu (9 cyfr)."""
        return bool(re.match(r'^\d{9}$', numer))
    
    @staticmethod
    def data(data_str):
        """Sprawdza poprawność daty (YYYY-MM-DD)."""
        try:
            datetime.strptime(data_str, "%Y-%m-%d")
            return True
        except ValueError:
            return False

# Test
print(Walidator.email("jan@example.com"))   # True
print(Walidator.email("niepoprawny"))        # False
print(Walidator.telefon("123456789"))        # True
print(Walidator.telefon("12345"))            # False
print(Walidator.data("2024-01-15"))          # True
print(Walidator.data("15-01-2024"))          # False

Podsumowanie

Biblioteka Standardowa:

• math – funkcje matematyczne
• random – liczby losowe
• datetime – data i czas
• calendar – operacje kalendarzowe
• string – stałe i operacje na stringach
• collections – zaawansowane kolekcje
• json – format JSON
• pickle – serializacja
• re – wyrażenia regularne

Instalowanie pakietów:

• pip install nazwa_pakietu
• PyPI: https://pypi.org/

Importowanie:

• import moduł
• from moduł import funkcja
• import moduł as alias

Własne moduły:

• Twórz pliki .py z funkcjami
• Importuj jak standardowe moduły
• Dokumentuj funkcje

Dobre praktyki:

• Importy na początku pliku
• Importuj tylko to czego potrzebujesz
• Używaj aliasów dla długich nazw
• Grupuj importy tematycznie

Ćwiczenia – Biblioteki, moduły, pakiety

Biblioteka math

1. Użyj modułu math do obliczenia pierwiastka kwadratowego z liczby 144.
2. Oblicz pole koła o promieniu 5 używając stałej pi z modułu math.
3. Oblicz sinus kąta 30 stopni (najpierw skonwertuj na radiany).
4. Użyj funkcji math.ceil() i math.floor() do zaokrąglenia liczby 7.8 w górę i w dół.
5. Oblicz 2 do potęgi 10 używając funkcji z modułu math.
6. Oblicz silnię liczby 7 używając funkcji z modułu math.
7. Oblicz logarytm naturalny (ln) liczby e.
8. Oblicz logarytm dziesiętny (log₁₀) liczby 1000.
9. Oblicz odległość między punktami (0, 0) i (6, 8) używając twierdzenia Pitagorasa i funkcji z math.
10. Stwórz funkcję która sprawdza czy liczba jest liczbą pierwszą używając funkcji math.sqrt() do optymalizacji.

1. Wygeneruj losową liczbę całkowitą z zakresu 1-100.
2. Wylosuj losowy element z listy [„kamień”, „papier”, „nożyce”].
3. Wygeneruj 5 losowych liczb z zakresu 1-50 (z powtórzeniami).
4. Wylosuj 3 różne liczby z zakresu 1-10 (bez powtórzeń).
5. Przetasuj listę [1, 2, 3, 4, 5] i wyświetl wynik.
6. Ustaw ziarno losowe na 42 i wygeneruj 3 losowe liczby. Sprawdź czy za każdym uruchomieniem są takie same.
7. Symuluj 100 rzutów kostką (liczby 1-6) i policz ile razy wypadła każda liczba.
8. Napisz funkcję która generuje losowe hasło składające się z 12 znaków (litery i cyfry).
9. Wylosuj 10 liczb z zakresu 1-100 i znajdź ich średnią.
10. Symuluj grę „Orzeł czy Reszka” – 50 rzutów, policz ile razy wypadł orzeł.

Biblioteka datetime

1. Wyświetl aktualną datę i czas.
2. Wyświetl tylko aktualną datę (bez czasu).
3. Stwórz datę swojego urodzenia i wyświetl ją.
4. Oblicz ile dni minęło od 1 stycznia 2024 do dzisiaj.
5. Oblicz jaka będzie data za 100 dni od dzisiaj.
6. Sformatuj aktualną datę w formacie „DD.MM.YYYY”.
7. Sformatuj aktualny czas w formacie „HH:MM:SS”.
8. Wyświetl pełną nazwę dnia tygodnia dla dzisiejszej daty.
9. Oblicz swój wiek w latach na podstawie daty urodzenia.
10. Sprawdź czy data „2024-02-29” jest poprawna (luty 2024 ma 29 dni?).

Biblioteka calendar

1. Wyświetl kalendarz dla roku 2024.
2. Wyświetl kalendarz dla czerwca 2024.
3. Sprawdź czy rok 2024 jest rokiem przestępnym.
4. Sprawdź ile dni ma luty 2024.
5. Sprawdź jaki dzień tygodnia to 1 stycznia 2024.

Biblioteka string

1. Wyświetl wszystkie małe litery alfabetu używając modułu string.
2. Wyświetl wszystkie cyfry używając modułu string.
3. Wyświetl wszystkie znaki przestankowe dostępne w module string.
4. Stwórz string zawierający wszystkie litery (małe i wielkie) oraz cyfry.
5. Wygeneruj losowe hasło używając string.ascii_letters i string.digits (10 znaków).

Biblioteka collections

1. Zlicz wystąpienia każdej litery w słowie „mississippi” używając Counter.
2. Znajdź 3 najczęstsze słowa w zdaniu używając Counter.
3. Stwórz Counter z listy [„a”, „b”, „a”, „c”, „b”, „a”] i wyświetl wynik.
4. Użyj Counter do znalezienia najczęstszej cyfry w liczbie 11223344556.
5. Zlicz wystąpienia każdego znaku w swoim imieniu i nazwisku.

Biblioteka json

1. Stwórz słownik z danymi osoby (imię, wiek, miasto) i skonwertuj go na string JSON.
2. Skonwertuj string JSON '{„name”: „Jan”, „age”: 25}’ na słownik Pythona.
3. Zapisz listę produktów ze słownika do pliku JSON z wcięciami (indent=4).
4. Odczytaj dane z pliku JSON i wyświetl je.
5. Stwórz słownik z cenami produktów, posortuj po kluczach i zapisz do JSON.

Biblioteka pickle

1. Zapisz listę [„Python”, „Java”, „C++”] do pliku używając pickle.
2. Odczytaj dane zapisane w poprzednim zadaniu z pliku pickle.
3. Zapisz słownik użytkowników do pliku pickle.
4. Zapisz krotkę z 5 liczbami do pliku pickle i odczytaj ją.
5. Porównaj rozmiar pliku JSON i pickle dla tych samych danych.

Biblioteka re (wyrażenia regularne)

1. Znajdź wszystkie cyfry w tekście „Python 3.12 został wydany w 2023 roku”.
2. Znajdź wszystkie słowa zaczynające się na literę „P” w tekście.
3. Sprawdź czy string zawiera adres email (prosty wzorzec z @ i kropką).
4. Znajdź wszystkie liczby (także wielocyfrowe) w tekście.
5. Podziel tekst po przecinkach używając re.split().

Tworzenie własnych modułów

1. Stwórz moduł kalkulator.py z funkcjami: dodaj, odejmij, pomnoz, podziel. Zaimportuj go i użyj.
2. Stwórz moduł geometria.py z funkcjami obliczającymi pole koła, kwadratu i prostokąta.
3. Stwórz moduł konwersje.py z funkcjami konwertującymi temperatury (C→F, F→C, C→K).
4. Stwórz moduł walidatory.py ze funkcjami sprawdzającymi email, telefon, PESEL.
5. Stwórz moduł statystyki.py z funkcjami: srednia, mediana, minimum, maksimum.

Instalowanie pakietów (teoretycznie)

1. Napisz komendę która zainstaluje pakiet requests.
2. Napisz komendę która zainstaluje konkretną wersję pakietu numpy (wersja 1.24.0).
3. Napisz komendę która zaktualizuje pakiet pandas do najnowszej wersji.
4. Napisz komendę która odinstaluje pakiet matplotlib.
5. Napisz komendę która wyświetli wszystkie zainstalowane pakiety.

Zadania mieszane

1. Napisz program który generuje 10 losowych dat z roku 2024 i sortuje je chronologicznie.
2. Stwórz program który symuluje 1000 rzutów monetą i oblicza procent orłów i reszek.
3. Napisz funkcję która sprawdza czy podany rok jest rokiem przestępnym (bez calendar.isleap).
4. Stwórz generator losowych kolorów w formacie RGB (3 liczby 0-255).
5. Napisz program który oblicza BMI i zapisuje historię pomiarów do pliku JSON.
6. Stwórz program do generowania losowych pytań matematycznych (dodawanie, odejmowanie).
7. Napisz funkcję która konwertuje datę ze stringa „DD-MM-YYYY” na obiekt datetime.
8. Stwórz prosty system logowania który zapisuje czas logowania do pliku.
9. Napisz program który liczy ile dni pozostało do końca roku.
10. Stwórz funkcję która generuje unikalny identyfikator zawierający datę i losowe znaki.

Zadania algorytmiczne z bibliotekami

1. Używając math.gcd() znajdź NWD trzech liczb.
2. Napisz funkcję która sprawdza czy trzy odcinki mogą utworzyć trójkąt (używaj math).
3. Symuluj grę w kości – rzucaj dwiema kostkami dopóki suma nie będzie równa 12.
4. Napisz program który losuje 6 liczb z 49 (losy loterii).
5. Stwórz kalkulator odsetek składanych używając math.pow().
6. Napisz funkcję która generuje ciąg Fibonacciego do n-tego wyrazu i zapisuje do JSON.
7. Stwórz program który mierzy czas wykonania różnych operacji (użyj time.time()).
8. Napisz walidator kodu pocztowego (format XX-XXX) używając re.
9. Stwórz funkcję która znajduje wszystkie palindromy w tekście.
10. Napisz program który generuje tabelkę sinusów dla kątów 0-90 stopni (co 10°).

Zadania kompleksowe

1. Stwórz system zarządzania zadaniami: dodawanie zadań z datą, zapis do JSON, wyświetlanie nadchodzących zadań.
2. Napisz generator faktur: produkty, ceny, data wystawienia, zapis do pliku z unikalną nazwą (data + losowe ID).
3. Stwórz prosty dziennik treningowy: data, rodzaj ćwiczenia, czas, zapis do JSON, statystyki.
4. Napisz program do analizy haseł: długość, siła (wielkie/małe litery, cyfry, znaki specjalne), sugestie poprawy.
5. Stwórz system rezerwacji: sprawdzanie dostępnych terminów, rezerwacja z datą, zapis do pliku.
6. Napisz kalkulator kredytu hipotecznego: kwota, oprocentowanie, liczba rat, harmonogram spłat do JSON.
7. Stwórz generator quizów: losowe pytania z pliku JSON, punktacja, zapis wyników z datą.
8. Napisz program do śledzenia nawyków: codzienna lista nawyków, checklisty, statystyki za miesiąc.
9. Stwórz prosty system księgowy: przychody, wydatki z datami, kategorie, raport miesięczny do JSON.
10. Napisz generator CV: dane z formularza, szablony, zapis do różnych formatów (txt, JSON), walidacja danych.