2. Konfiguracja środowiska pracy

2.1. Python 3.8.1

Przykłady zawarte w niniejszym dokumencie zostały przetestowane przy użyciu interpretera języka Python w wersji 3.8.1, dostępnego pod adresem URL |https://www.python.org/downloads/| (luty 2020 r.) na komputerze z systemem Windows 10:

Instalacja Pythona powoduje utworzenie drzewa katalogów [1] oraz menu [2] na liście programów:

[3-4]: dwa interaktywne interpretery języka Python;
[5]: dokumentacja języka Python;
[6]: dokumentacja modułów języka Python;

Nie będziemy korzystać z interaktywnego interpretera języka Python. Wystarczy wiedzieć, że skrypty zawarte w tym dokumencie można uruchomić za pomocą tego interpretera. Jest to przydatne do testowania działania funkcji języka Python, ale mało praktyczne w przypadku skryptów, które mają być ponownie wykorzystane. Oto przykład z wykorzystaniem powyższej opcji [4]:

W wierszu poleceń >>> można wprowadzić instrukcję w języku Python, która zostanie natychmiast wykonana. Kod wpisany powyżej ma następujące znaczenie:

>>> nom="tintin"
>>> print("nom=%s" % nom)
nom=tintin
>>> print("type=%s" % type(nom))
type=<class 'str'>
>>>

Wiersze:

1: inicjalizacja zmiennej. W języku Python nie deklaruje się typu zmiennych. Przyjmują one automatycznie typ wartości, która jest im przypisana. Typ ten może ulec zmianie w trakcie działania programu;
2: wyświetlenie nazwy. „nom=%s” to format wyświetlania, w którym %s jest parametrem formalnym oznaczającym ciąg znaków. nom to rzeczywisty parametr, który zostanie wyświetlony w miejsce %s;
3: wynik wyświetlenia;
4: wyświetlenie typu zmiennej „nom”;
5: zmienna „nom” jest tutaj typu class. W Pythonie 2.7 miałaby wartość <type 'str'>;

Teraz otwórzmy konsolę systemu Windows:

Fakt, że mogliśmy wpisać [python] zamiast [1] oraz że znaleziono plik wykonywalny [python.exe], wskazuje, że znajduje się on w katalogu PATH na komputerze z systemem Windows. Jest to istotne, ponieważ oznacza to, że narzędzia programistyczne języka Python będą w stanie znaleźć interpreter języka Python. Można to sprawdzić w następujący sposób:

w pliku [2] zamykamy interpreter języka Python;
w [3] polecenie wyświetlające PATH plików wykonywalnych na komputerze z systemem Windows;
po wpisaniu [4] widać, że folder interpretera Pythona 3.8 jest częścią PATH;

2.2. IDE PyCharm Community

2.2.1. Wprowadzenie

Aby skompilować i uruchomić skrypty zawarte w niniejszym dokumencie, wykorzystaliśmy edytor [PyCharm] w wersji Community, dostępny (luty 2020 r.) na stronie URL |https://www.jetbrains.com/fr-fr/pycharm/download/#section=windows|:

Pobierz wersję Community IDE, PyCharm oraz [1-3] i zainstaluj ją.

Uruchommy IDE PyCharm, a następnie utwórzmy pierwszy projekt w języku Python:

w [2-4] utwórz nowy projekt;

IDE PyCharm przedstawia utworzony projekt w następującej postaci:

w pliku [2-3] przyjrzyjmy się właściwościom pliku IDE;

w [4] – interpreter języka Python, który będzie używany w projekcie;
w [5] – rozwijana lista dostępnych interpreterów;
w [6] wybieramy interpreter pobrany w punkcie |Python 3.8.1|;

w [7] – wybrany interpreter;
w [8] znajduje się lista pakietów dostępnych dla tego interpretera. Pakiety zawierają moduły, z których mogą korzystać skrypty w języku Python. Dostępnych jest setki modułów;

Zacznijmy od utworzenia folderu, w którym umieścimy nasz pierwszy skrypt w języku Python:

kliknij prawym przyciskiem myszy na projekt, a następnie wybierz [1-2], aby utworzyć folder;
w polu [3] wpisz nazwę folderu: zostanie on utworzony w folderze projektu;

Następnie utwórzmy skrypt w języku Python:

kliknij prawym przyciskiem myszy na folderze [bases], a następnie wybierz [1-3];
w polu [4-5] wpisz nazwę skryptu;

Napiszmy nasz pierwszy skrypt:

w pliku [3] wpisujemy następujący skrypt:
- wiersze 1, 3: komentarze zaczynają się od znaku #;
- wiersz 2: inicjalizacja zmiennej. W języku Python nie deklaruje się typu zmiennych;
- wiersz 4: wyświetlanie na ekranie. Użyta tutaj składnia to [format % données] w formacie:
  - format: nazwa=%s, gdzie %s oznacza miejsce na ciąg znaków. Znajdzie się on w części [données] wyrażenia;
  - dane: wartość zmiennej [nom] zastąpi format %s w ciągu formatującym;
- za pomocą [4-5] zmieniamy format kodu zgodnie z zaleceniami organizacji zarządzającej językiem Python;

Skrypt uruchamia się poprzez kliknięcie prawym przyciskiem myszy na kodzie [6]:

w [7] – wykonane polecenie;
w [8] – wynik wykonania;

Aby uruchomić skrypt z dokumentu, pobierz kod z URL |https://tahe.developpez.com/tutoriels-cours/python-flask-2020/documents/python-flask-2020.rar|, a następnie w PyCharm wykonaj następujące czynności:

w [1-2] otwórz istniejący projekt: wskaż folder z pobranym kodem;
w [3] – otwarty projekt;
w [4-5] – uruchomienie jednego ze skryptów projektu;

w [7-8] – wyniki wykonania;

2.2.2. Wirtualne środowisko uruchomieniowe

Nasze środowisko pracy jest już gotowe do działania. Zmodyfikujemy je jednak, aby móc pisać skrypty w ramach tego kursu. Najpierw zmieńmy konfigurację Pycharm:

W prawym oknie:

domyślnie zaznaczone jest pole wyboru [1]. Odznaczamy je, aby Pycharm nie otwierał domyślnie ostatnio otwieranego projektu, ale pozostawił nam możliwość wyboru projektu, który chcemy otworzyć;
w opcji [2] nie potwierdzamy zamknięcia PyCharmu podczas zamykania okna aplikacji;
w opcji [3] nowe projekty otwierają się w osobnym oknie;
w [4], jeśli zamkniemy PyCharm, a program jest w trakcie wykonywania, zostanie on zatrzymany;

Zamknijmy teraz PyCharm, a następnie otwórzmy go ponownie:

w [1] tworzymy nowy projekt;
w [2] należy wskazać folder projektu;
w [3] wybierz środowisko wirtualne. Środowisko wirtualne jest przypisane wyłącznie do tworzonego projektu. Nie miesza się ono ze środowiskami wirtualnymi innych projektów. Projekt Python / Flask korzysta z wielu zewnętrznych bibliotek, które należy zainstalować. Projekt P1 może korzystać z biblioteki B w wersji v1, a projekt P2 z tej samej biblioteki B, ale w wersji v2. Te dwie wersje mogą być mniej lub bardziej kompatybilne. Gdy jednak instaluje się bibliotekę w wersji v2, a wersja v1 jest już zainstalowana, ta ostatnia zostaje nadpisana przez wersję v2. Może to stanowić problem dla projektu, który korzystał z wersji v1, jeśli nowa wersja v2 nie jest w pełni kompatybilna z wersją v1. Aby uniknąć tych problemów, każdy projekt izoluje się w środowisku wirtualnym;
w [4] należy wskazać folder, w którym będą przechowywane biblioteki Pythona pobrane w trakcie realizacji projektu. W tym przypadku wybraliśmy folder [venv] (środowisko wirtualne) znajdujący się wewnątrz folderu projektu. Nie ma jednak obowiązku, aby to robić;
w pliku [5], interpreter języka Python dla tego projektu. Jest to ten sam interpreter, który zainstalowaliśmy w poprzednim kroku;
w [6], utworzyć projekt;

w [7-8] – utworzony projekt;
w [9] – środowisko uruchomieniowe projektu, zwane środowiskiem wirtualnym;
w [10], folder [site-packages] to folder, w którym będą przechowywane biblioteki pobrane w późniejszym terminie;

2.2.3. Git

Następnie uruchamia się oprogramowanie do kontroli kodu źródłowego. W tym przypadku będzie to Git [1-4]:

Oprogramowanie do kontroli kodu źródłowego (VCS: Version Control System) pozwala śledzić zmiany w projekcie. Można tworzyć „migawki” projektu w różnych momentach jego cyklu życia za pomocą operacji zwanej commitem. Jeśli wykonamy dwa commity w momentach T i T+1, system VCS pozwala sprawdzić, co uległo zmianie między tymi dwiema zatwierdzonymi wersjami. Zazwyczaj system VCS jest używany przez zespół programistów. Programiści ci dokonują commitów swojego kodu po jego odpowiednim przetestowaniu. Na podstawie systemu VCS inni programiści mogą pobrać ten zatwierdzony kod i z niego korzystać.

W tym przypadku mamy do czynienia z jednym programistą. Doświadczenie pokazuje, że aplikacja może działać w momencie T, a w momencie T+1 już nie. W takiej sytuacji chcielibyśmy cofnąć się do momentu T, aby zacząć od nowa. VCS to umożliwia i właśnie z tego powodu wykorzystamy go w tym przypadku.

Pokazujemy, jak to zrobić przy użyciu Git.

w [1] należy wybrać zakładkę [Git] (w lewym dolnym rogu);
w [2] widać, że 495 plików projektu nie jest objętych kontrolą wersji przez Git. Oznacza to, że nie zostaną one uwzględnione w commitach projektu;
w [3] znajduje się przycisk z [commit] lub przycisk zatwierdzania projektu. Jak już wspomniano, Git wykonuje wówczas migawkę projektu i zapisuje ją w folderze [.git] w katalogu głównym projektu (nie wyświetlanym przez PyCharm, ale widocznym w Eksploratorze Windows);

Zatwierdźmy projekt w jego obecnym stanie ([3]).

w [4] znajduje się lista plików nieobjętych kontrolą wersji;
w [5] wszystkie te pliki nieobjęte kontrolą wersji należą do środowiska wirtualnego [venv];
w pliku [6] każde zatwierdzenie musi być opatrzone komunikatem. Programista opisuje w nim zmiany wprowadzone w wersji, która ma zostać zatwierdzona, w porównaniu z ostatnią zatwierdzoną wersją;

Niektóre foldery lub pliki mogą zostać pominięte przez Git. W takim przypadku nigdy nie są one uwzględniane w obrazku repozytorium. W powyższym [5] kliknijmy prawym przyciskiem myszy na folder [venv].

W pliku [1-3] określamy, że folder [venv] nie powinien być uwzględniony w kopii zapasowej Gita. Lista folderów i plików pomijanych przez Git jest zapisana w pliku o nazwie [.gitignore] [4];

po wykonaniu poprzedniej operacji wszystkie pliki z folderu [venv] znikają z listy plików nieobjętych kontrolą wersji. Pozostaje tylko plik [.gitignore], który właśnie został utworzony;
w [5] zaznaczamy go, aby został zapisany;
w [6] tworzymy komunikat zatwierdzenia:
w pliku [7] zatwierdzamy zmiany. W tym momencie zostanie wykonane zdjęcie projektu;

w pliku [8-9] znajduje się zawartość pliku [.gitignore]: pojedynczy wiersz z nazwą folderu [/venv], który wskazuje, że jego zawartość ma zostać pominięta na zdjęciach;

Pokażmy teraz, do czego może nam służyć Git. Najpierw tworzymy folder o nazwie [git] (można użyć dowolnej innej nazwy – folder ten zostanie usunięty po zakończeniu demonstracji):

w pliku [1-5] tworzy się folder o nazwie [git];

w pliku [6-10] tworzy się skrypt w języku Python o nazwie [git_01];

w pliku [11-12] skrypt zawiera jedynie komentarz;
w pliku [13-14] tworzymy kopię pliku [git_01]. W tym celu należy zaznaczyć plik [git_01], nacisnąć klawisze Ctrl+C (Kopiuj), a następnie Ctrl+V (Wklej) i jako nazwę pliku podać [git_02];

Teraz zatwierdźmy nasz projekt. Zostanie wykonane zdjęcie z dwoma plikami [git_01, git_02];

w pliku [1-3], zatwierdzamy projekt;
w pliku [4] wybieramy pliki nieobjęte wersjonowaniem, które chcemy zatwierdzić, w tym przypadku wszystkie;
w pliku [5] wpisujemy komunikat identyfikujący zatwierdzenie;
w [6] zatwierdza się;

w [1-2] potwierdź zatwierdzenie;
w [3] wybieramy zakładkę [Log];
w [4], widok gałęzi projektu. Tutaj jest tylko jedna gałąź o nazwie [master];
w [5-6] – właśnie wykonany commit;

Teraz w ten sam sposób utwórzmy skrypt [git_03]:

Zmodyfikujmy skrypt [git_02] i usuńmy skrypt [git_01]:

Następnie zatwierdźmy nową wersję:

Teraz w logach mamy dwa zatwierdzenia:

Po wybraniu konkretnego zatwierdzenia po jego prawej stronie pojawia się drzewo plików projektu:

Załóżmy teraz, że ostatni commit doprowadził nas do impasu i chcielibyśmy powrócić do stanu odpowiadającego jednemu z poprzednich commitów:

do [1-2], wybieramy commit, do którego stanu chcemy powrócić;
w [3-5] dostępnych jest kilka trybów resetowania. Wybieramy tryb [hard], który przywraca wybrany stan, tracąc zmiany wprowadzone od tego momentu;

w [6] przywrócono [git_01], który został usunięty;
po zmianie na [7-8] odzyskujemy [git_02] w jego pierwotnym stanie, bez wprowadzonej wcześniej modyfikacji;

Teraz zmodyfikujmy plik [git_02] i dodajmy pliki [git_03] oraz [1-4]:

Teraz ponownie wykonajmy operację przywrócenia do pierwotnego commitu:

na [1-4], co powoduje powrót do zdjęcia z commit nr 1;
W przypadku opcji [5-6] wybieramy opcję [Keep] zamiast [Hard]. Opcje te nie są łatwe do zrozumienia. Należy więc je wypróbować:

w przypadku opcji [1] plik [git_03] nadal istnieje;
po zastosowaniu opcji [2-3] plik [git_02] zachował wprowadzone zmiany;

Trudno powiedzieć, co zrobił ten plik [Revert Commit]. Teraz zatwierdźmy aktualny stan:

w pliku [1-6] – zatwierdzenie;

w [9] widać nowe zatwierdzenie;

Teraz spróbujmy powrócić do commitu nr 1, tak jak to już zrobiono:

w [1-6] powracamy do commitu nr 1 w trybie [Hard];

w [7-8] tym razem faktycznie utracono wszystkie zmiany wprowadzone od pierwszego commit;

W dalszej części nie będziemy już wracać do [Git]. Czytelnik może pracować w następujący sposób:

może śledzić podane przykłady, wpisując je samodzielnie lub pobierając je ze strony internetowej kursu;
za każdym razem, gdy przykład zadziała, będzie mógł zatwierdzić swój projekt;
gdy tworzy własny kod i utknie w martwym punkcie, wie, że może przywrócić stabilny stan, powracając do poprzedniego zatwierdzenia;

2.3. Konwencje pisania kodu w języku Python

Można pisać kod w języku Python bez przestrzegania konwencji pisania i nie przeszkodzi to w jego działaniu. Jednak może on nie spotkać się z uznaniem społeczności Pythona, która ustanowiła konwencje pisania. Zostały one podsumowane w poście pod adresem |https://stackoverflow.com/questions/159720/what-is-the-naming-convention-in-python-for-variable-and-function-names|:

Nazwa modułu (module_name) jest zgodna z konwencją nazywana czasem [snake_case]: pisana małymi literami, z ewentualnym rozdzielaniem słów znakiem podkreślenia. Ta konwencja [snake_case] ma zastosowanie do nazw metod, pakietów, zmiennych i funkcji;
nazwa klasy (ClassName) jest zgodna z konwencją nazywana czasem [PascalCase]: ciąg słów połączonych bez spacji, z wielką literą na początku każdego słowa;
nazwy stałych są zgodne z konwencją [SNAKE_CASE]: ciąg słów pisanych wielkimi literami, oddzielonych znakiem podkreślenia;

Konwencje te zostały ogólnie zastosowane w niniejszym dokumencie. Niemniej jednak w przypadku modułów definiujących klasę nadałem modułowi taką samą nazwę jak klasie, którą zawiera. Zgodnie z tym moduł ten stosuje konwencję [PascalCase] zamiast [snake_case]. Chciałem mieć możliwość szybkiego zidentyfikowania modułów zawierających klasy.