Pierwsze kroki ze środowiskami wirtualnymi w Pythonie

W tym artykule zgłębimy tajniki tworzenia i wykorzystywania środowisk wirtualnych w Pythonie, obejmując instrukcje dla systemów Windows i Linux.

Podczas pracy nad różnorodnymi projektami w lokalnym środowisku programistycznym, napotkanie problemów z zależnościami jest niemal pewne. Właśnie w tym miejscu środowiska wirtualne wchodzą do gry, umożliwiając efektywniejsze zarządzanie zależnościami i specyfikacjami każdego projektu.

Aby w pełni wykorzystać potencjał środowisk wirtualnych w Pythonie, nauczmy się, jak je tworzyć i aktywować. 👩🏽‍💻

Co to są środowiska wirtualne?

Środowiska wirtualne to odizolowane przestrzenie, w których przechowywany jest kod projektu oraz jego specyficzne zależności.

Ale dlaczego właściwie warto z nich korzystać?

Środowiska wirtualne pozwalają na swobodne instalowanie i używanie różnych wersji tych samych bibliotek dla różnych przedsięwzięć. Co więcej, eliminują ryzyko nieprzewidzianych zmian, które mogłyby pojawić się, gdyby kilka projektów używało różnych wersji tych samych pakietów. Przyjrzyjmy się temu bliżej.

Instalowanie pakietów w Pythonie

Podstawowa biblioteka Pythona oferuje szeroki wachlarz przydatnych modułów do testowania jednostkowego, interakcji z systemem operacyjnym czy obsługi dat i czasu.

Jednakże, pracując nad złożonymi projektami, często konieczne jest zainstalowanie dodatkowych pakietów, stworzonych przez społeczność Pythona. Jest to szczególnie widoczne w przypadku aplikacji takich jak web scraping, uczenie maszynowe czy aplikacje internetowe.

Do instalacji i zarządzania tymi pakietami można wykorzystać narzędzia takie jak conda czy pip.

Każdy projekt wymaga unikalnego zestawu pakietów. Jeśli jednak zainstalujemy wszystkie potrzebne pakiety bezpośrednio w naszym środowisku programistycznym, wszystkie projekty będą współdzieliły te same globalnie zainstalowane pakiety.

Dlaczego to stanowi problem?

Wyobraźmy sobie, że w naszym środowisku programistycznym mamy zainstalowanych wiele pakietów. Projekt, nad którym aktualnie pracujemy, może wymagać tylko kilku z nich. W sytuacji, gdy wszystkie projekty dzielą te same instalacje, niezwykle trudno jest określić, które pakiety są niezbędne dla którego z projektów – identyfikacja zależności staje się prawdziwym wyzwaniem.

Istnieje jeszcze jedno istotne ograniczenie. Załóżmy, że posiadamy projekt korzystający z Django 2.2. Chcąc rozpocząć nowy projekt, który wymaga Django 4, instalujemy nowszą wersję w tym samym środowisku.

Co się dzieje z poprzednią instalacją?

Zostaje ona usunięta i zastąpiona nowszą wersją Django. W najnowszych wydaniach bibliotek często pojawiają się zmiany, w tym usunięcie starszych funkcji. Może to spowodować, że nasze wcześniejsze projekty przestaną działać zgodnie z oczekiwaniami.

Podsumowując, zarządzanie zależnościami staje się niezwykle trudne, gdy wszystkie pakiety są instalowane we wspólnym środowisku. Każdy projekt potrzebuje dedykowanego zestawu bibliotek, by działać poprawnie.

Jak działają środowiska wirtualne

Zrozumieliśmy już wyzwania związane z instalowaniem pakietów w globalnym środowisku programistycznym. Teraz przekonajmy się, jak środowiska wirtualne rozwiązują ten problem.

Tworząc i aktywując środowisko wirtualne dla projektów Python, instalujemy wyłącznie pakiety niezbędne dla danego projektu.

Wracając do przykładu projektów Django, dzięki środowiskom wirtualnym możemy jednocześnie pracować nad projektami opartymi o Django 2.2 i Django 4 bez żadnych konfliktów. Dzieje się tak, ponieważ instalacje Django nie są już instalacjami ogólnosystemowymi, a jedynie ograniczone do odpowiednich środowisk wirtualnych.

W skrócie, środowiska wirtualne to odizolowane przestrzenie, w których przechowywany jest zarówno kod projektu, jak i jego zależności.

Zalety środowisk wirtualnych

Skoro już wiemy, jak działają środowiska wirtualne w Pythonie, przyjrzyjmy się zaletom ich używania:

• Środowiska wirtualne zapewniają odseparowane środowisko programistyczne dla każdego projektu, co umożliwia instalację tylko tych pakietów, które są niezbędne.
• Dzięki izolacji i niezależności środowisk wirtualnych różne projekty mogą korzystać z różnych wersji tej samej biblioteki – w zależności od indywidualnych wymagań. Dodatkowo, w środowiskach wirtualnych nie musimy martwić się o uprawnienia systemowe podczas instalacji bibliotek czy konfiguracji środowiska.
• Po zainstalowaniu pakietów w środowisku wirtualnym można zapisać zależności projektu w pliku `requirements.txt`. Dzięki temu inni programiści mogą łatwo odtworzyć środowisko projektu i zainstalować niezbędne pakiety za pomocą jednego polecenia.

Do tej pory dowiedzieliśmy się, jak działają środowiska wirtualne i jakie korzyści płyną z ich używania. Teraz przyjrzyjmy się najpopularniejszym narzędziom, które można wykorzystać do tworzenia i zarządzania środowiskami wirtualnymi w Pythonie.

#1. Virtualenv

Virtualenv to popularne narzędzie do tworzenia i zarządzania środowiskami wirtualnymi dla projektów Python. Pewien podzbiór funkcjonalności virtualenv jest dostępny w pakiecie venv. Jednak virtualenv jest szybszy i bardziej rozbudowany w porównaniu do venv.

#2. Pipenv

Pipenv łączy funkcjonalność virtualenv ze zdolnością do zarządzania pakietami pip. Wykorzystuje pliki `Pipfile` do zarządzania zależnościami projektu w środowisku wirtualnym.

Można przetestować pipenv bezpośrednio w przeglądarce za pomocą tego placu zabaw Pipenv.

#3. Conda

Jeśli korzystamy z dystrybucji Pythona Anaconda, do zarządzania pakietami i środowiskami wirtualnymi możemy użyć Conda.

Więcej informacji na ten temat można znaleźć w tym wyczerpującym przewodniku dotyczącym zarządzania środowiskami za pomocą Conda.

#4. Poetry

Poetry to narzędzie do zarządzania pakietami, które ułatwia zarządzanie zależnościami we wszystkich projektach Python. Aby zacząć korzystać z Poetry, konieczne jest zainstalowanie Pythona w wersji 3.7 lub nowszej.

#5. Venv

Jak wspomniano wcześniej, venv oferuje podzbiór funkcjonalności virtualenv, ale ma tą zaletę, że jest wbudowane w standardową bibliotekę Pythona, począwszy od wersji 3.3.

Jest ono dostępne z każdą instalacją Pythona i nie wymaga dodatkowej instalacji zewnętrznych pakietów. W tym przewodniku użyjemy venv do tworzenia i pracy ze środowiskami wirtualnymi.

Jak stworzyć środowisko wirtualne Pythona w Ubuntu?

💬 Aby w pełni wykorzystać ten przewodnik, upewnij się, że masz zainstalowaną lokalnie wersję Pythona 3. Najlepiej, aby była to wersja 3.5 lub nowsza.

W tej części pokażemy, jak tworzyć i aktywować środowiska wirtualne na komputerze z systemem Ubuntu Linux. Te same kroki można zastosować również w innych dystrybucjach Linuxa.

Aby uprościć zarządzanie, stwórzmy nowy katalog projektu i przejdźmy do niego. Następnie utworzymy venv w tym katalogu.

$ mkdir my_project
$ cd my_project

Ogólna składnia do utworzenia środowiska wirtualnego to `python3 -m venv <nazwa-lub-ścieżka-venv>`. Po uruchomieniu tego polecenia, w bieżącym katalogu roboczym utworzone zostanie środowisko wirtualne o nazwie `my_env`:

$ python3 -m venv my_env

Jak aktywować i instalować pakiety w środowisku wirtualnym?

Po utworzeniu środowiska wirtualnego, możemy je aktywować i zainstalować w nim potrzebne pakiety. Do aktywacji środowiska wirtualnego, użyjemy następującego polecenia:

$ source my_env/bin/activate

Po aktywowaniu środowiska wirtualnego, możemy użyć polecenia `pip list`, by wyświetlić listę zainstalowanych pakietów:

$ pip list

Ponieważ nie zainstalowaliśmy jeszcze żadnych pakietów, na liście powinny pojawić się jedynie `setuptools` i `pip`, które są instalowane domyślnie.

Instalacja pip w środowisku wirtualnym pozwala na instalowanie pakietów potrzebnych do konkretnego projektu. W ten sposób uzyskujemy niezależne środowisko programistyczne dla każdego projektu.

Po aktywowaniu środowiska wirtualnego, możemy zainstalować w nim pakiety specyficzne dla danego projektu, używając pip. Przykładowo zainstalujmy pakiet `requests`, jeden z najczęściej pobieranych pakietów w Pythonie, który umożliwia wykonywanie zapytań HTTP w celu pracy z internetowymi interfejsami API.

$ pip install requests

Po zainstalowaniu biblioteki `requests`, zobaczymy, że zostaje ona zainstalowana wraz z wszystkimi pakietami, od których zależy.

$ pip list

Możemy użyć polecenia `pip freeze` i przekierować dane wyjściowe do pliku `requirements.txt`, w następujący sposób:

$ pip freeze > requirements.txt

Jeśli sprawdzimy zawartość bieżącego katalogu projektu, zobaczymy, że został utworzony plik `requirements.txt`.

$ ls
# my_env requirements.txt

Środowisko wirtualne można dezaktywować po zakończeniu pracy nad projektem, używając następującego polecenia:

$ deactivate

Jak stworzyć środowisko wirtualne Pythona w systemie Windows

W środowisku programistycznym preferowanym wyborem jest Linux. Jeśli korzystasz z komputera z systemem Windows, możesz rozważyć użycie Podsystemu Windows dla Systemu Linux (WSL) do skonfigurowania środowiska terminala Ubuntu na potrzeby programowania lokalnego.

Jeśli jednak korzystasz z komputera z systemem Windows, możesz użyć programu Windows PowerShell lub wiersza polecenia, aby utworzyć środowisko wirtualne za pomocą następującego polecenia:

> python -m venv <ścieżka-do-venv>

Jak aktywować środowisko wirtualne

Aktywacja środowiska wirtualnego w systemie Windows różni się w zależności od tego, czy pracujemy w wierszu polecenia, czy w programie Windows PowerShell.

Jeśli pracujemy w wierszu polecenia, użyjemy poniższego polecenia, by aktywować środowisko wirtualne:

> <ścieżka-do-venv>Scriptsactivate.bat

Natomiast w przypadku korzystania z programu Windows PowerShell, środowisko wirtualne aktywujemy za pomocą polecenia:

> <ścieżka-do-venv>ScriptsActivate.ps1

Następnie możemy zainstalować wszystkie potrzebne pakiety w środowisku wirtualnym.

Do dezaktywacji środowiska wirtualnego możemy użyć polecenia `deactivate`, zarówno w wierszu polecenia, jak i w programie Windows PowerShell.

Podsumowanie

W tym artykule omówiliśmy ograniczenia wynikające z instalacji ogólnosystemowych i w jaki sposób utrudniają one zarządzanie zależnościami w projektach Python. Środowiska wirtualne w Pythonie oferują znacznie lepsze możliwości zarządzania zależnościami, zapewniając odseparowane środowisko programistyczne dla każdego z projektów.

Spośród dostępnych narzędzi do tworzenia i zarządzania środowiskami wirtualnymi w Pythonie, nauczyliśmy się korzystać z `venv` – pakietu wbudowanego w standardową bibliotekę Pythona, służącego do tworzenia i aktywacji środowisk wirtualnych.

W ramach środowiska wirtualnego możemy zainstalować wersje bibliotek dopasowane do konkretnego projektu. Wymagania te można następnie zapisać w pliku `requirements.txt`, co umożliwia innym programistom łatwe odtworzenie środowiska.

Pamiętaj, aby podczas rozpoczynania kolejnego projektu w Pythonie korzystać ze środowisk wirtualnych, co znacznie ułatwi zarządzanie zależnościami. Udanej pracy! 🎉