Obsługa bibliotek w Pythonie

Obsługa bibliotek w Pythonie dzieli się na kilka etapów – najmniejszym elementem struktury są funkcje i klasy. Dalej w kolejce mamy moduły (czyli poszczególne pliki .py), by wreszcie zająć się pakietami jak numpy czy pandas. Struktura jest dość prosta, ale na każdym etapie można natknąć się na problemy i w dzisiejszym tutorialu pokażemy, jak je rozwiązać.

Moduły – tworzenie i import

Moduły w Pythonie to teoretycznie prosty temat. Jeśli masz plik .py z funkcjami, klasami lub zmiennymi – gratuluję, to Twój moduł. Chociaż Python nie ma jakichkolwiek wymogów dotyczących obiektowości, warto podzielić kod logicznie, zamiast trzymać wszystko w jednym wielkim pliku.

# plik-z-kalkulatorem.py
def dodaj(a, b):
    return a + b

# inny-plik.py:
import plik-z-kalkulatorem
print(kalkulator.dodaj(2, 3))

!Rada!
Wśród programistów Pythona popularna jest zasada: najpierw funkcja, potem moduł, a dopiero potem klasa – jeśli naprawdę trzeba. To oznacza z grubsza, że warto dwa razy się zastanowić, zanim zaczniesz komplikować sobie kod.

Importowanie

Python daje kilka opcji importu:

#importowanie całego modułu:
import math

#importowanie wybranej funkcji z modułu:
from math import sqrt

#importowanie modułu z aliasem:
import math as m

Dobre praktyki:

• Nie importuj za pomocą gwiazdki, np. from math import * – w ten sposób importujesz WSZYSTKO! Nawet to, czego nie potrzebujesz.
• Używaj aliasów tylko wtedy, gdy nazwa jest długa, np. import pandas as pd – przy czym “za długa” to pojęcie baaaardzo względne. Popularne jest skracanie pandasa do pd, numpaja to np itp.
• Importuj tylko to, czego naprawdę potrzebujesz – biblioteki związane z AI bywają ogromne. Na przykład TensorFlow po zainstalowaniu i załadowaniu do pamięci może zajmować nawet ponad 1 GB.

Wywoływanie własnych modułów

Tworzenie własnego modułu to po prostu zapisanie funkcji w osobnym pliku .py. Wywołanie go też jest bardzo proste – choć trzeba czasem upewnić się co do ścieżki. Zwłaszcza jeśli importowany plik znajduje się w innym pakiecie (o tym w kolejnym podrozdziale).

#struktura projektu:
projekt/
├── main.py
└── narzedzia.py

#narzedzia.py:
def powiedz_czesc(imie):
    print(f"Cześć, {imie}!")\

#main.py:
import narzedzia
narzedzia.powiedz_czesc("Ania")

Obsługa bibliotek – Pakiety

Gdy projekt się rozrasta, zazwyczaj grupujemy pliki w foldery. W Pythonie to pakiety. Każdy pakiet powinien mieć plik __init__.py. Utwórz go, nawet jeśli będzie zupełnie pusty. Dzięki temu starsze wersje Pythona odczytają folder jako pakiet, który można zaimportować.

!Uwaga!
Jeśli plik .py znajduje się w subfolderze, to zarówno folder, jak i subfolder powinny mieć pliki __init__.py.

#struktura projektu
main.py
utils/
├── __init__.py
└── tekstowe/
    ├── __init__.py
    └── komunikaty.py

#komunikaty.py:
def przywitaj(imie):
    return f"Witaj, {imie}!"

#main.py:
from utils.tekstowe.komunikaty import przywitaj
print(przywitaj("Kasia"))

Od Pythona 3.3 można zaimportować plik .py z katalogu, który nie zawiera pliku __init__.py. To zasługa tzw. namespace packages, które umożliwiają traktowanie katalogów jako pakietów, nawet bez __init__.py.

Main.py w pakiecie

Plik main.py zazwyczaj znajduje się w katalogu głównym programu, a nie w pakiecie. W dużych projektach czasem zdarza się jednak umieszczanie pliku main.py wewnątrz pakiecie, zwłaszcza jeśli projekt ma być instalowalną paczką. Może to powodować problemy z importami, jeśli program nie jest poprawnie uruchomiony.

#struktura projektu:
projekt/
└── pakiet/
    ├── __init__.py
    ├── main.py
    └── narzedzia.py

#main.py:
from . import narzedzia

#niepoprawne
python pakiet/main.py       # ❌ ImportError

#poprawne
cd projekt
python -m pakiet.main       # ✅ Działa!

Kolejność importów wg PEP 8

Aby kod był czytelny, trzymaj się kolejności zalecanej przez PEP 8:

→ Biblioteki standardowe (os, math)
→ Biblioteki zewnętrzne (numpy, pandas)
→ Twoje moduły lokalne (mojmodul, projekt.utils)

Między każdą z tych grup zostaw pustą linię, na końcu również.

Importy a pamięć RAM

Importując moduł, Python wczytuje jego kod do pamięci. Dla prostych modułów to niezauważone, ale ciężkie pakiety (np. tensorflow, opencv) potrafią zjeść setki MB. Rozwiązanie? „Lazy import” wewnątrz funkcji:

def analiza():
    import pandas as pd
    # tu dopiero używamy pandas

Pandas zostanie zaimportowany dopiero po wywołaniu funkcji analiza. I nie – nie zniknie po zakończeniu funkcji i nie będzie importowany wielokrotnie przy każdym wywołaniu funkcji. Po pierwszym wywołaniu będzie już dostępny globalnie.

Obsługa bibliotek – niezgodność wersji

Niestety Python nie zainspirował się Javową zasadą: „Backwards Compatibility” i kolejne wersje bibliotek w Pythonie często nie współgrają ze sobą.

Każdy, komu wysypał się projekt, bo wersja numpaja była w konflikcie z pandasem, wie, że niezgodność bibliotek to ZŁO i potrafi skutecznie spowolnić prace nad projektem.

Możesz sprawdzać wersje bibliotek, możesz wymuszać instalacje konkretnych wersji i zapisywać wszystko w requirements.txt. Ale zawsze to jest dużo dodatkowej roboty, na którą nikt nie ma ochoty. Na szczęście są sposoby, by radzić sobie z niezgodnością bibliotek.

Środowiska wirtualne

Jeśli pracujesz nad kilkoma projektami jednocześnie i każdy potrzebuje innej wersji danej biblioteki, możesz stworzyć wirtualne środowiska dla każdego z tych projektów. Każdy projekt ma wtedy własne, odseparowane biblioteki.

#Idź do katalogu źródłowego swojego projektu:
cd /ścieżka/do/twojego/projektu

#Stwórz katalog env/:
python -m venv env

#Aktywuj go:
source env/bin/activate  # macOS/Linux

.\env\Scripts\activate # Windows

#Zainstaluj wszystko, czego potrzebujesz:
pip install numpy pandas scikit-learn tensorflow

# zapisz wszystkie importy wraz z wersjami do pliku requirements, żeby bez problemu odtworzyć srodowisko:
pip freeze > requirements.txt

#Zalecane – po zakończeniu pracy ze środowiskiem, zdezaktywuj je:
deactivate

Menedżery Pakietów

Menedżer pakietów to narzędzie, które pozwala Ci instalować i zarządzać bibliotekami zewnętrznymi w Twoim projekcie Pythonowym. W praktyce: nie musisz szukać kodu na GitHubie, ściągać ZIP-ów ani martwić się, czy wszystko do siebie pasuje. Wystarczy jedno polecenie i gotowe. 

Najpopularniejsze menedżery to pip i conda (choć są inne). Choć oba narzędzia służą do zarządzania bibliotekami w Pythonie, pip i conda mają swoje smaczki i warto, je znać, by wiedzieć, kiedy którego używać.

PIP

pip to domyślny menedżer pakietów Pythona, który korzysta z PyPI — centralnego repozytorium paczek Pythonowych. Instaluje tylko biblioteki napisane w Pythonie (lub opakowania do C/C++), ale nie zarządza zależnościami systemowymi ani wersją Pythona.

Zalety:

• wbudowany w Pythona,
• prosty i szybki,
• działa wszędzie.

Wady:

• może mieć problemy z bibliotekami zależnymi od kompilacji (np. tensorflow, opencv),
• nie radzi sobie dobrze z konfliktami wersji.

Conda

Conda to menedżer pakietów i środowisk, który działa niezależnie od pip. Instaluje nie tylko pakiety Pythonowe, ale też biblioteki systemowe, zależności C/C++, CUDA, narzędzia linuksowe itd.
Używa własnego repozytorium (conda-forge lub defaults) i potrafi rozwiązywać złożone zależności automatycznie.

Zalety:

• idealny do ML, AI, obliczeń naukowych,
• instaluje kompletne środowiska (Python + pakiety),
• radzi sobie z trudnymi zależnościami.

Wady:

• większy, cięższy,
• potrzebujesz osobnej instalacji (np. Anaconda, Miniconda),
• wolniejsze instalacje niż pip.

Rada!
Wiele osób używa obu menedżerów naraz: condę do tworzenia środowiska dla ml, a pipa do instalacji mniej problematycznych paczek z PyPI. Ważne tylko, by nie mieszać ich bez świadomości skutków.

Podstawowe komendy pipa i condy

Zadanie	pip	conda
Instalacja biblioteki	pip install pandas	conda install pandas
Aktualizacja paczki	pip install –upgrade scikit-learn	conda update scikit-learn
Odinstalowanie paczki	pip uninstall matplotlib	conda remove matplotlib
Instalacja konkretnej wersji	pip install tensorflow==2.13	conda install tensorflow=2.13
Spis wszystkich zależności	pip freeze > requirements.txt	conda list –export > environment.txt
Instalacja z pliku	pip install -r requirements.txt	conda create –name myenv –file environment.txt

Trendy wśród pythonowców

W społeczności Pythona wyraźnie widać kilka dominujących trendów związanych z organizacją kodu — szczególnie w obszarze funkcji, modułów, pakietów i importów:

1. Funkcje i moduły są podstawowym sposobem tworzenia kodu — klasy pojawiają się tylko tam, gdzie rzeczywiście mają sens.
2. Modułowa struktura pomaga w utrzymaniu i ponownym użyciu kodu — moduły zawierają powiązane funkcje, klasy lub zmienne.
3. Pakiety i jasne importy ułatwiają skalowanie projektów — ustrukturyzowane foldery z __init__.py nadają porządek, a PEP‑8 zaleca wyraźne rozróżnienie między importami standardowymi, zewnętrznymi i lokalnymi. To potwierdza „Hitchhiker’s Guide to Python”, który stwierdza, że system modułów i importów to centralne elementy, które wymuszają strukturę w projekcie.
4. Dbanie o czytelność importów i prosty kod (PEP‑20: Zen of Python) — moduły jako niezależne przestrzenie nazw walczą z nadmiarowym kodem.

Podsumowanie

Dobrze zorganizowane moduły + kontrola wersji + osobne środowiska = spokojna głowa i mniejsze ryzyko, że coś położy Ci projekt, kiedy najmniej tego oczekujesz. Znajdź swój sposób na tworzenie środowiska, na korzystanie z modułów i importów i trzymaj się go. Konsekwencja jest bardzo ważna i zapewnia spójność kodu.

Dzisiejszy tutek jest ostatnim (chyba że coś się jeszcze urodzi) w mini kursie o podstawach Pythona (polecam cały – wszystkie artykuły to perełki, w których zawarliśmy wiele dobrych praktyk, jak i mniej znanych trików.)

Jeśli cały kurs już za Tobą, czas podjąć ostateczną decyzję — którą ścieżkę kariery programisty AI wybierasz? Sprawdź w naszym quizie i rozpocznij naukę.