Ten moduł wprowadza kluczowe koncepcje związane z organizacją kodu w Pythonie – od definicji modułu jako pliku .py, przez różne formy importowania (import, from...import, aliasowanie), aż po zaawansowane mechanizmy, takie jak pakiety, plik __init__.py i zmienna __name__. Omówione zostały najważniejsze moduły biblioteki standardowej (math, random, datetime, os, sys, string) oraz praktyczne zasady ich wykorzystania w codziennej pracy programisty. Szczegółowo przeanalizowano mechanizm wyszukiwania modułów przez interpreter (sys.path, PYTHONPATH) oraz proces tworzenia własnych modułów i pakietów. Moduł wprowadza również w tematykę zarządzania zależnościami zewnętrznymi – menedżer pip, repozytorium PyPI, plik requirements.txt oraz izolację środowisk za pomocą venv. Całość uzupełniają praktyczne przykłady kodu oraz wyjaśnienie dobrych praktyk, takich jak unikanie importu gwiazdkowego i stosowanie aliasów branżowych.

• Moduły i importowanie – definicja modułu, składnia import, from...import, as, pułapka importu gwiazdkowego (*)
• Biblioteka standardowa – przegląd modułów math, random, datetime, os, sys, string i ich praktyczne zastosowania
• Własne moduły i pakiety – tworzenie pliku .py, struktura pakietów, plik __init__.py, zmienna __name__ i warunek if __name__ == '__main__'
• Zarządzanie zależnościami – pip, instalacja i usuwanie pakietów, PyPI, plik requirements.txt i precyzyjne wersjonowanie
• Środowiska wirtualne – venv, tworzenie, aktywacja, dezaktywacja, izolacja zależności, workflow z requirements.txt i .gitignore

• Moduł to w najprostszej postaci pojedynczy plik tekstowy z rozszerzeniem .py, zawierający poprawny kod źródłowy w języku Python.
• Stanowi on podstawową jednostkę organizacyjną, która umożliwia logiczne grupowanie powiązanych ze sobą funkcji, klas oraz stałych.
• Dzięki takiemu podziałowi unikamy pisania pojedynczych, gigantycznych plików, które są niezwykle trudne w analizie, utrzymaniu i debugowaniu.
• Moduł tworzy osobną, izolowaną przestrzeń nazw (ang. namespace), co zapobiega konfliktom nazw zmiennych w różnych częściach systemu.
• W ten sposób każdy plik staje się samodzielnym modułem, który można wielokrotnie importować i wykorzystywać ponownie w wielu niezależnych projektach.
• Importowanie modułu polega na załadowaniu jego zawartości do pamięci operacyjnej podczas uruchamiania skryptu.
• Modularność wspiera również wielokrotne wykorzystanie kodu, ponieważ jeden raz zaimplementowany moduł może służyć wielu niezależnym aplikacjom.
• W ten sposób struktura projektu staje się przejrzysta, a sam kod jest znacznie prostszy w testowaniu i utrzymaniu.

• Podział kodu na moduły to jeden z najważniejszych kroków na drodze do tworzenia czystego i profesjonalnego oprogramowania.
• Główną zaletą takiego podejścia jest promowanie zasady DRY (ang. Don't Repeat Yourself) poprzez wielokrotne wykorzystanie kodu w różnych skryptach.
• Wydzielenie konkretnych funkcji, np. operacji matematycznych lub obsługi bazy danych, pozwala na ich modyfikowanie w jednym miejscu bez wpływu na resztę systemu.
• Modularność znacząco poprawia czytelność projektu, ułatwiając nowym programistom zrozumienie jego struktury i sposobu działania.
• Dodatkowo ułatwia to pracę zespołową, ponieważ członkowie zespołu mogą pracować nad niezależnymi modułami bez ryzyka konfliktów w kodzie.
• Podział na moduły skraca również czas kompilacji i analizy kodu przez statyczne narzędzia sprawdzające.
• Upraszcza to także pisanie testów jednostkowych, ponieważ każdy moduł można testować w pełnej izolacji od reszty systemu.
• Ostatecznie modularność to kluczowy element budowania skalowalnych systemów informatycznych o długim cyklu życia.

• Aby uzyskać dostęp do kodu zgromadzonego w innym module, musimy go wczytać do bieżącego pliku za pomocą słowa kluczowego import.
• Najprostsza składnia polega na wpisaniu import nazwa_modulu na samym początku naszego pliku skryptu.
• Spowoduje to jednorazowe wykonanie kodu z zaimportowanego modułu i udostępnienie jego zasobów w programie.
• Wszystkie funkcje i zmienne z tego modułu są wtedy dostępne poprzez tzw. nazwę kwalifikowaną z kropką, np. math.sqrt().
• Taki zapis jest bardzo zalecany, ponieważ jasno informuje czytelnika kodu o pochodzeniu używanych narzędzi i zapobiega kolizjom nazw.
• Dostęp kwalifikowany chroni również przed przypadkowym nadpisaniem wbudowanych funkcji języka Python.
• Jest to najbardziej przejrzysta forma importu, ułatwiająca analizę kodu przez systemy kontroli wersji.
• Dodatkowo ułatwia to pracę z narzędziami typu autouzupełnianie w nowoczesnych edytorach IDE.

import math

liczba = 25
pierwiastek = math.sqrt(liczba)  # Wywołanie kwalifikowane
print(pierwiastek)  # Wyświetli: 5.0
            

• Jeśli w naszym programie planujemy korzystać tylko z kilku konkretnych elementów modułu, możemy użyć instrukcji from ... import ....
• Pozwala ona na zaimportowanie wybranych funkcji, klas lub zmiennych bezpośrednio do bieżącej przestrzeni nazw.
• Dzięki temu możemy wywoływać te elementy bezpośrednio po ich nazwach, z pominięciem przedrostka modułu i kropki (np. samo sqrt()).
• Zwiększa to czytelność kodu i skraca zapis w miejscach, gdzie dane funkcje są wywoływane bardzo często.
• Należy jednak zachować czujność, ponieważ bezpośrednie zaimportowanie funkcji może przesłonić istniejącą funkcję o tej samej nazwie w naszym skrypcie.
• Taki import ładuje do pamięci cały moduł, lecz eksponuje jedynie wybrane, zadeklarowane elementy.
• Pozwala to na pisanie bardziej zwięzłych i eleganckich formuł matematycznych czy logicznych.
• Trzeba jednak kontrolować liczbę importowanych w ten sposób elementów, aby zachować porządek w kodzie.
• Jest to bardzo popularna technika przy importowaniu konkretnych klas wyjątków lub stałych konfiguracyjnych.

from math import sqrt, pi

promien = 5
wynik = sqrt(promien)  # Wywołanie bezpośrednie, bez math.
print(wynik)
print(pi)  # Bezpośredni dostęp do stałej pi
            

• Czasami nazwy importowanych modułów lub funkcji są bardzo długie, skomplikowane lub kolidują z nazwami w naszym własnym programie.
• W takich sytuacjach Python oferuje mechanizm tworzenia aliasów (skróconych nazw) za pomocą słowa kluczowego as.
• Możemy zmienić nazwę całego modułu (np. import numpy as np) lub konkretnej zaimportowanej funkcji (np. from math import sqrt as pierwiastek).
• Użycie aliasów drastycznie poprawia czytelność kodu, zwłaszcza przy pracy z popularnymi bibliotekami do analizy danych.
• Jest to powszechny standard branżowy, który pozwala na pisanie zwięzłego i estetycznego kodu źródłowego.
• Umożliwia to także szybką podmianę implementacji biblioteki bez modyfikowania reszty kodu programu.
• Pomaga to również w unikaniu kolizji nazw przy jednoczesnym importowaniu modułów o takich samych nazwach z różnych pakietów.
• Aliasowanie powinno być jednak stosowane z umiarem i zgodnie z przyjętymi w zespole konwencjami.
• Jest to kluczowy element tworzenia czytelnych skryptów integrujących wiele zewnętrznych interfejsów API.

import datetime as dt
from math import factorial as silnia

teraz = dt.datetime.now()
wynik_silni = silnia(5)  # Użycie polskiego aliasu dla funkcji
print(wynik_silni)  # Wyświetli: 120
            

• Instrukcja from nazwa_modulu import * służy do zaimportowania absolutnie wszystkich publicznych elementów z danego modułu bezpośrednio do naszego kodu.
• Choć na pierwszy rzut oka wydaje się to wygodne, ponieważ nie musimy wpisywać nazw funkcji ani kropki, to w praktyce jest to skrajnie niebezpieczny antywzorzec.
• Taki import (tzw. import gwiazdkowy) doszczętnie 'zaśmieca' naszą lokalną przestrzeń nazw setkami niezidentyfikowanych zmiennych i funkcji.
• Może to doprowadzić do ukrytych błędów, gdy importowane funkcje po cichu nadpiszą nasze własne funkcje o tych samych nazwach.
• Ponadto kod staje się zupełnie nieczytelny dla innych programistów, którzy nie są w stanie określić, skąd pochodzi dana funkcja.
• Utrudnia to również działanie statycznym analizatorom kodu oraz narzędziom autouzupełniania w IDE.
• Import gwiazdkowy drastycznie spowalnia proces debugowania, ponieważ źródło błędnych wartości staje się trudne do wyśledzenia.
• Z tego powodu oficjalny przewodnik stylistyczny PEP 8 kategorycznie odradza stosowanie tej konstrukcji w kodzie produkcyjnym.
• Jedynym akceptowalnym wyjątkiem są specyficzne pliki konfiguracyjne lub inicjalizacyjne pakietów.

# Skrajnie niebezpieczny antywzorzec - unikaj!
from math import *

# Nie wiadomo na pierwszy rzut oka, skąd pochodzą te funkcje:
wynik = sin(pi / 2) + log(10)
            

• Biblioteka standardowa Pythona oferuje bogaty zestaw modułów gotowych do użycia od razu po instalacji, a jednym z najważniejszych jest moduł math.
• Zawiera on zestaw bardzo wydajnych funkcji przeznaczonych do zaawansowanych obliczeń matematycznych, trygonometrycznych i logarytmicznych.
• Znajdziemy w nim funkcje do zaokrąglania liczb w górę (math.ceil()) oraz w dół (math.floor()), a także stałe matematyczne takie jak Pi (math.pi) czy liczba Eulera (math.e).
• Wszystkie te funkcje są zaimplementowane w języku C, co gwarantuje ich błyskawiczne działanie i najwyższą precyzję obliczeń.
• Moduł math eliminuje konieczność ręcznego pisania skomplikowanych algorytmów obliczeniowych.
• Oferuje również zaawansowane funkcje, takie jak obliczanie silni (math.factorial()) czy największego wspólnego dzielnika (math.gcd()).
• Wszystkie operacje są zoptymalizowane pod kątem wydajności procesora i dokładności zmiennoprzecinkowej.
• Jest to niezastąpione narzędzie w pracy każdego inżyniera, analityka danych oraz twórcy gier komputerowych.
• Korzystanie z niego gwarantuje, że obliczenia są zgodne z międzynarodowymi standardami numerycznymi.

import math

print(math.pi)        # Stała Pi: 3.141592653589793
print(math.ceil(4.2))  # Zaokrąglenie w górę: 5
print(math.floor(4.8)) # Zaokrąglenie w dół: 4
            

• Do wprowadzania elementu losowości do naszych programów, gier czy testów jednostkowych służy wbudowany moduł random.
• Umożliwia on generowanie liczb pseudolosowych z różnych rozkładów, losowanie elementów z list oraz tasowanie kolekcji.
• Funkcja random.randint(a, b) pozwala na wylosowanie liczby całkowitej z domkniętego przedziału od a do b.
• Metoda random.choice(lista) w ułamku sekundy wybiera jeden losowy element z przekazanej listy, a random.shuffle(lista) miesza kolejność elementów w miejscu.
• Należy pamiętać, że moduł ten nie powinien być używany do celów kryptograficznych (np. generowania haseł), ponieważ generowane liczby są przewidywalne.
• Do celów związanych z bezpieczeństwem należy zamiast tego stosować wbudowany moduł secrets.
• Moduł random opiera się na algorytmie Mersenne Twister, który charakteryzuje się ogromnym okresem generowania liczb.
• Umożliwia to tworzenie wiarygodnych symulacji statystycznych i modelowania procesów losowych.
• Jest to jedno z najbardziej intuicyjnych i najczęściej używanych narzędzi w codziennej pracy programisty.

import random

liczba = random.randint(1, 10)      # Losowa liczba całkowita od 1 do 10
owoc = random.choice(["jabłko", "banan"]) # Wybór z listy
print(f"Wylosowano: {liczba} oraz {owoc}")
            

• Praca z datami, godzinami oraz strefami czasowymi to jedno z najczęstszych wyzwań w programowaniu, które w Pythonie rozwiązuje wbudowany moduł datetime.
• Udostępnia on trzy główne klasy: date (do samej daty), time (do samej godziny) oraz datetime (łączącą obie te informacje).
• Za pomocą metody datetime.now() pobieramy aktualny czas z systemu operacyjnego z precyzją do mikrosekund.
• Kluczowym elementem modułu jest klasa timedelta, która reprezentuje różnicę czasu i pozwala na proste dodawanie lub odejmowanie dni, godzin i minut od konkretnej daty.
• Moduł oferuje też zaawansowane formatowanie dat na napisy za pomocą metody strftime().
• Umożliwia również parsowanie napisów na obiekty daty przy użyciu metody strptime().
• Wspiera obsługę stref czasowych za pomocą klasy timezone, co jest kluczowe w systemach globalnych.
• Klasy te są w pełni odporne na błędy związane z latami przestępnymi oraz zmianami czasu na letni i zimowy.
• Ułatwia to budowanie stabilnych systemów rezerwacji, logowania zdarzeń czy harmonogramowania zadań.

import datetime

teraz = datetime.datetime.now()
jutro = teraz + datetime.timedelta(days=1)  # Dodanie jednego dnia
print(teraz.strftime("%d-%m-%Y %H:%M"))  # Piękne formatowanie daty
            

• Moduł os (ang. Operating System) to potężne narzędzie biblioteki standardowej, które umożliwia naszemu programowi bezpośrednią interakcję z systemem operacyjnym, na którym jest uruchomiony.
• Pozwala on na wykonywanie operacji na plikach i folderach, takich jak tworzenie katalogów (os.mkdir()), sprawdzanie zawartości folderu (os.listdir()) czy usuwanie plików.
• Za pomocą os.getcwd() możemy sprawdzić bieżący katalog roboczy, z którego uruchomiono skrypt.
• Moduł ten dba o przenośność kodu – automatycznie dopasowuje się do systemu (Windows, Linux, macOS), co pozwala na pisanie kodu niezależnego od platformy.
• Do operowania na ścieżkach udostępnia też kluczowy podmoduł os.path.
• Umożliwia on odczytywanie zmiennych środowiskowych systemu za pomocą słownika os.environ.
• Pozwala również na uruchamianie zewnętrznych programów systemowych przy użyciu funkcji os.system().
• Jest to fundamentalne narzędzie przy tworzeniu skryptów automatyzacyjnych, instalatorów i narzędzi administracyjnych.
• Dzięki niemu aplikacje mogą elastycznie reagować na strukturę dyskową komputera użytkownika.

import os

katalog_roboczy = os.getcwd()  # Pobranie ścieżki bieżącej
pliki = os.listdir(".")       # Lista plików w tym katalogu
print(f"Folder roboczy: {katalog_roboczy}")
print(f"Znaleziono plików: {len(pliki)}")
            

• Moduł sys (ang. System) dostarcza zmienne i funkcje ściśle powiązane z samym interpreterem Pythona oraz środowiskiem uruchomieniowym.
• Jednym z jego najważniejszych zastosowań jest obsługa argumentów wiersza poleceń poprzez listę sys.argv, która przechowuje parametry przekazane do skryptu podczas jego uruchamiania.
• Zmienna sys.path przechowuje listę ścieżek wyszukiwania, w których Python szuka modułów podczas importowania.
• Za pomocą funkcji sys.exit() możemy w dowolnym momencie bezpiecznie przerwać działanie programu i zwrócić kod wyjścia do systemu operacyjnego.
• Moduł ten pozwala również na sprawdzanie wersji interpretera oraz limitów systemowych.
• Umożliwia przekierowywanie standardowego strumienia wejścia, wyjścia oraz strumienia błędów za pomocą sys.stdout i sys.stderr.
• Udostępnia także informacje o rozmiarze obiektów w pamięci RAM za pomocą funkcji sys.getsizeof().
• Pozwala to na precyzyjną optymalizację zużycia zasobów komputera przez nasz program.
• Jest to niezastąpione narzędzie przy pisaniu zaawansowanych narzędzi CLI oraz systemów diagnostycznych.

import sys

print(f"Wersja Pythona: {sys.version}")
print(f"Argumenty startowe: {sys.argv}")  # Lista argumentów CLI
# sys.exit(0)  # Opcjonalne poprawne zakończenie programu
            

• Wbudowany moduł string udostępnia zestaw bardzo przydatnych stałych tekstowych oraz narzędzi pomocnych przy zaawansowanym przetwarzaniu napisów.
• Znajdziemy w nim gotowe zestawy znaków, takie jak wszystkie litery alfabetu łacińskiego (string.ascii_letters), cyfry dziesiętne (string.digits) czy znaki przestankowe.
• Stałe te są nieocenione przy walidacji danych wejściowych, np. sprawdzaniu, czy hasło użytkownika zawiera wymagane znaki specjalne.
• Moduł udostępnia również klasę Template, która pozwala na bezpieczne i czytelne podstawianie zmiennych do szablonów tekstowych.
• Eliminuje to konieczność ręcznego definiowania długich ciągów znaków w kodzie.
• Pozwala to również na bezpieczniejsze generowanie komunikatów, minimalizując ryzyko ataków typu format string.
• Udostępnia także pomocne funkcje do kapitalizacji i formatowania całych bloków tekstu.
• Ułatwia to pisanie parserów danych tekstowych, logów oraz generatorów raportów.
• Jest to bardzo lekkie i wydajne narzędzie, stanowiące doskonałe uzupełnienie wbudowanych metod obiektów typu string.

import string

litery = string.ascii_lowercase  # "abcdefghijklmnopqrstuvwxyz"
cyfry = string.digits            # "0123456789"
print(litery)
print(cyfry)
            

• Tworzenie własnego modułu w Pythonie jest niezwykle proste i intuicyjne – nie wymaga żadnych specjalnych konfiguracji ani instalacji.
• Wystarczy stworzyć nowy plik tekstowy o wybranej nazwie, np. geometria.py, i zapisać w nim funkcje, klasy lub stałe.
• Aby skorzystać z tego modułu w innym pliku, oba pliki muszą znajdować się w tym samym katalogu (lub w ścieżce wyszukiwania Pythona).
• W pliku głównym po prostu wpisujemy import geometria i uzyskujemy dostęp do jego zawartości za pomocą operatora kropki.
• Taki podział pozwala na wygodne separowanie logiki biznesowej od interfejsu użytkownika lub skryptu uruchomieniowego.
• Ułatwia to również późniejszą aktualizację i naprawę błędów w konkretnej części aplikacji.
• Własne moduły mogą bez problemu importować inne wbudowane lub zewnętrzne biblioteki wewnątrz swojej struktury.
• Pozwala to na budowanie warstwowej, profesjonalnej architektury oprogramowania.
• Każdy napisany przez nas moduł staje się pełnoprawnym elementem systemu, gotowym do wielokrotnego wykorzystania w przyszłości.

# plik: geometria.py (nasz własny moduł)
def pole_kola(promien):
    return 3.14159 * promien ** 2

# plik: main.py (program główny)
import geometria
print(geometria.pole_kola(5))  # Wyświetli pole koła dla r=5
            

• Podczas uruchamiania dowolnego skryptu, Python automatycznie tworzy i zarządza kilkoma specjalnymi zmiennymi systemowymi o nazwach otoczonych podwójnymi podkreśleniami (tzw. dunder variables).
• Najważniejszą z nich jest zmienna __name__, która przechowuje informację o kontekście, w jakim aktualnie wykonywany jest dany plik.
• Jeśli plik jest uruchamiany bezpośrednio jako główny program (np. komendą w terminalu), Python przypisuje zmiennej __name__ wartość tekstową '__main__'.
• Jeśli natomiast plik został zaimportowany przez inny skrypt jako moduł pomocniczy, zmienna __name__ przyjmuje wartość będącą faktyczną nazwą tego pliku (np. 'geometria').
• Pozwala to programowi na dynamiczne dostosowanie swojego zachowania w zależności od sposobu uruchomienia.
• Zmienna ta jest widoczna w każdym module i jest tworzona automatycznie przez interpreter przed wykonaniem pierwszej linii kodu.
• Zrozumienie jej działania jest kluczowe dla pisania modułów przeznaczonych do ponownego wykorzystania.
• Stanowi ona podstawę modularnej architektury aplikacji i ułatwia tworzenie pakietów narzędziowych.

# plik: modul.py
print(f"Wartość __name__ to: {__name__}")
# Bezpośrednie uruchomienie wypisze: __main__
# Import modułu wypisze: modul
            

• Konstrukcja if __name__ == '__main__': to jeden z najważniejszych i najbardziej powszechnych wzorców projektowych w języku Python.
• Pozwala ona na wydzielenie fragmentu kodu (np. testów, demonstracji działania lub głównego menu), który ma się wykonać wyłącznie wtedy, gdy plik uruchomimy bezpośrednio.
• Jeśli ten sam plik zostanie zaimportowany przez inny moduł, kod umieszczony pod tym warunkiem zostanie całkowicie zignorowany.
• Zapobiega to przypadkowemu i niechcianemu uruchamianiu procedur testowych lub interaktywnych menu podczas importowania funkcji.
• Jest to klucz do tworzenia modułów hybrydowych, które mogą działać zarówno jako samodzielne skrypty, jak i biblioteki pomocnicze.
• Wzorzec ten ułatwia automatyczne testowanie kodu i integrowanie go z systemami CI/CD.
• Chroni on również przed niekontrolowanymi efektami ubocznymi (np. wysyłaniem zapytań sieciowych) podczas samego importu modułu.
• Jest to powszechnie przyjęta konwencja i standard branżowy w społeczności Pythona.
• Każdy profesjonalny programista Pythona powinien stosować tę konstrukcję w swoich plikach skryptów.

def oblicz(x):
    return x * 2

if __name__ == "__main__":
    print("Testuję funkcję:", oblicz(5))  # Uruchomi się tylko bezpośrednio
            

• W miarę jak nasz projekt programistyczny rośnie, zarządzanie dziesiątkami pojedynczych plików modułów w jednym katalogu staje się uciążliwe.
• Python rozwiązuje ten problem za pomocą pakietów (ang. packages), które są logicznym rozwinięciem idei modułów.
• Pakiet to w uproszczeniu zwykły katalog w systemie operacyjnym, który grupuje powiązane ze sobą moduły (pliki .py) w hierarchiczną strukturę.
• Dzięki temu możemy organizować kod w wielopoziomowe drzewa katalogów, np. pakiet baza_danych zawierający moduły polaczenie.py oraz zapytania.py.
• Pozwala to na zachowanie idealnego porządku w dużych aplikacjach i łatwe zarządzanie ich architekturą.
• Pakiety skutecznie eliminują konflikty nazw między modułami stworzonymi przez różnych deweloperów.
• Umożliwiają logiczne podzielenie odpowiedzialności za poszczególne warstwy aplikacji (np. interfejs, logika, baza danych).
• Ułatwiają dystrybucję kodu oraz publikowanie własnych bibliotek w globalnych repozytoriach.
• Stanowią one kręgosłup każdego zaawansowanego frameworka i aplikacji komercyjnej.

• Aby przekształcić zwykły katalog w systemie operacyjnym w oficjalny pakiet Pythona, katalog ten musi spełniać określone warunki strukturalne.
• Przede wszystkim musi zawierać plik o specjalnej nazwie __init__.py.
• Plik ten może być zupełnie pusty, lecz jego fizyczna obecność jest dla interpretera Pythona sygnałem, że dany folder powinien być traktowany jako importowalny pakiet.
• Oprócz pliku __init__.py, w katalogu umieszczamy standardowe pliki modułów .py, które będą realizować konkretne funkcjonalności.
• Od wersji Pythona 3.3 pliki te nie są bezwzględnie wymagane (tzw. namespace packages), jednak ich tworzenie pozostaje najlepszą praktyką gwarantującą zgodność.
• Plik __init__.py służy również do wykonywania kodu inicjalizacyjnego podczas importu pakietu.
• Można w nim zdefiniować zmienną __all__, która kontroluje elementy importowane przy użyciu gwiazdki.
• Umożliwia on również uproszczenie ścieżek importu dla użytkowników zewnętrznych naszego pakietu.
• Tworzenie pakietów to standardowa procedura przy budowaniu komponentów do ponownego wykorzystania.

• Importowanie kodu zorganizowanego w pakiety odbywa się za pomocą dobrze znanej składni kropkowej, która precyzyjnie odzwierciedla strukturę katalogów na dysku.
• Możemy zaimportować cały moduł należący do pakietu za pomocą instrukcji import pakiet.modul, a następnie wywoływać jego funkcje jako pakiet.modul.funkcja().
• Często wygodniejszym rozwiązaniem jest użycie konstrukcji from pakiet.modul import funkcja, co pozwala na bezpośrednie wywoływanie funkcji w kodzie.
• Jeśli struktura pakietu jest wielopoziomowa (np. pakiet zawiera podkatalogi), kolejne poziomy katalogów oddzielamy kolejnymi kropkami, co daje nam pełną kontrolę nad importami.
• Umożliwia to precyzyjne wczytywanie tylko tych komponentów, które są nam niezbędne w danym momencie.
• Możemy również stosować aliasowanie dla importowanych modułów pakietowych (np. import pakiet.modul as pm).
• Taka elastyczność składni ułatwia pisanie zwięzłego i wysoce czytelnego kodu źródłowego.
• Pomaga to zachować przejrzystość w sekcji importów na samym początku pliku źródłowego.

# Importowanie modułu z pakietu o nazwie "grafika"
from grafika.filtry import rozmycie

obraz = "foto.png"
rozmyty_obraz = rozmycie(obraz)  # Bezpośrednie wywołanie
            

• Kiedy wpisujemy instrukcję import, interpreter Pythona musi zlokalizować wskazany plik modułu na dysku twardym komputera.
• Robi to, przeszukując listę katalogów zapisaną w systemowej zmiennej sys.path w ściśle określonej kolejności.
• Najpierw przeszukiwany jest katalog bieżący (w którym znajduje się aktualnie uruchomiony skrypt), co pozwala na bezproblemowy import własnych modułów.
• Następnie przeszukiwane są ścieżki zdefiniowane w systemowej zmiennej środowiskowej PYTHONPATH, a na samym końcu katalogi biblioteki standardowej oraz zainstalowanych bibliotek zewnętrznych (site-packages).
• Jeśli Python przeszuka wszystkie te miejsca i nie odnajdzie pliku, zgłosi błąd ModuleNotFoundError.
• Zmienna sys.path jest zwykłą listą napisów, którą możemy dynamicznie modyfikować w trakcie działania programu.
• Pozwala to na tymczasowe dodawanie niestandardowych lokalizacji modułów za pomocą metody sys.path.append().
• Zrozumienie tego mechanizmu jest kluczowe dla rozwiązywania problemów z importowaniem bibliotek w środowiskach produkcyjnych.
• Ułatwia to konfigurację zaawansowanych systemów wdrożeniowych i testowych.

import sys

# Wypisanie wszystkich ścieżek, w których Python szuka modułów
for sciezka in sys.path:
    print(sciezka)
            

• Jedną z największych sił języka Python jest jego gigantyczna, globalna społeczność, która tworzy i udostępnia tysiące gotowych bibliotek zewnętrznych.
• Do zarządzania tymi bibliotekami służy oficjalny, wbudowany menedżer pakietów o nazwie pip (ang. Pip Installs Packages).
• Pobiera on biblioteki z centralnego, publicznego repozytorium o nazwie PyPI (ang. Python Package Index), które zawiera setki tysięcy darmowych pakietów do wszelkich możliwych zastosowań – od tworzenia stron internetowych po sztuczną inteligencję.
• Narzędzie pip działa w wierszu poleceń (terminalu) i automatycznie dba o pobranie wskazanej biblioteki, jej instalację oraz rozwiązanie ewentualnych zależności między pakietami.
• Pozwala to na błyskawiczne wdrożenie gotowych rozwiązań do naszego autorskiego projektu.
• Narzędzie to potrafi również aktualizować zainstalowane już pakiety do ich najnowszych wersji.
• Działa na wszystkich wiodących systemach operacyjnych, gwarantując pełną spójność środowiska.
• Jest to absolutnie fundamentalne narzędzie w codziennej pracy programisty Pythona.
• Dzięki niemu ekosystem Pythona rozwija się w niespotykanym dotąd tempie.

# Polecenie wpisywane w terminalu systemowym (nie w Pythonie!)
pip --version  # Sprawdzenie zainstalowanej wersji narzędzia pip
            

• Aby zainstalować dowolną bibliotekę zewnętrzną z repozytorium PyPI na naszym komputerze, korzystamy z podstawowego polecenia pip install nazwa_pakietu.
• Polecenie to należy bezwzględnie wpisywać w terminalu systemowym (np. PowerShell, CMD lub Terminal w macOS/Linux), a nie w interaktywnej konsoli Pythona.
• Narzędzie pip automatycznie łączy się z serwerami PyPI, wyszukuje najnowszą stabilną wersję biblioteki, pobiera ją i instaluje w katalogu site-packages naszej instalacji Pythona.
• Od tego momentu biblioteka jest w pełni dostępna dla każdego skryptu na naszym komputerze i możemy ją wczytywać za pomocą standardowej instrukcji import.
• Narzędzie to automatycznie weryfikuje również sumy kontrolne plików, dbając o bezpieczeństwo instalacji.
• Pozwala także na instalowanie konkretnych wersji bibliotek przy użyciu operatora podwójnego równa się.
• Instalacja może być realizowana w trybie cichym lub z pełnym logowaniem postępu na ekranie.
• Zrozumienie działania tego polecenia to pierwszy krok do budowania nowoczesnych aplikacji internetowych i desktopowych.

# Wywołanie instalacji w terminalu systemowym (CLI)
pip install requests  # Instalacja popularnej biblioteki do zapytań HTTP
            

• Po zainstalowaniu kilku bibliotek zewnętrznych warto mieć pod kontrolą, jakie pakiety i w jakich wersjach znajdują się na naszym komputerze.
• Służy do tego polecenie terminalowe pip list, które wyświetla przejrzystą tabelę wszystkich zainstalowanych bibliotek wraz z ich aktualnymi numerami wersji.
• Jeśli potrzebujemy bardziej szczegółowych informacji o konkretnym pakiecie, możemy użyć polecenia pip show nazwa_pakietu.
• Wyświetli ono m.in. krótki opis biblioteki, nazwisko autora, licencję, na której została wydana, lokalizację na dysku oraz listę innych bibliotek, które są wymagane do jej poprawnego działania.
• Narzędzie pip show pozwala również na szybkie odnalezienie fizycznej ścieżki instalacji biblioteki na naszym dysku twardym.
• Jest to szczególnie przydatne przy debugowaniu problemów z importowaniem różnych wersji tego samego pakietu.
• Możemy także użyć flagi --files, aby zobaczyć dokładną listę wszystkich plików wchodzących w skład danej biblioteki.
• Pozwala to na pełną kontrolę i audyt bezpieczeństwa kodu instalowanego z sieci internetowej.
• Stanowi to podstawę sprawnego administrowania środowiskiem programistycznym.

# Polecenia terminalowe do zarządzania bibliotekami
pip list          # Wyświetla tabelę zainstalowanych pakietów
pip show requests # Wyświetla szczegółowe metadane o pakiecie requests
            

• Gdy dana biblioteka nie jest nam już potrzebna lub chcemy zwolnić miejsce na dysku, możemy ją w prosty sposób usunąć z komputera za pomocą polecenia pip uninstall nazwa_pakietu.
• Narzędzie pip zapyta nas o potwierdzenie decyzji, a po wpisaniu 'y' bezpowrotnie skasuje pliki biblioteki z systemu.
• Innym niezwykle ważnym poleceniem jest pip freeze.
• Wypisuje ono listę zainstalowanych pakietów w formacie nazwa==wersja, co pozwala na precyzyjne zarejestrowanie stanu naszego środowiska.
• Wynik tego polecenia możemy przekierować do pliku tekstowego, co jest standardową praktyką przy tworzeniu projektów zespołowych.
• Zapisanie zależności w ten sposób jest kluczowym elementem profesjonalnego cyklu życia oprogramowania (SDLC).
• Plik ten staje się oficjalnym spisem treści wymaganych do uruchomienia naszej aplikacji w dowolnym innym miejscu.
• Usuwanie pakietów pozwala na zachowanie czystości i oszczędność pamięci na dyskach deweloperskich.
• Narzędzie pip dba o to, by przy deinstalacji usunąć wszystkie powiązane skrypty startowe.
• Gwarantuje to spójność i porządek w całym systemie.

# Usuwanie biblioteki oraz eksportowanie listy zależności
pip uninstall requests         # Usuwa bibliotekę z systemu
pip freeze > requirements.txt  # Zapisuje listę zależności do pliku txt
            

• Plik requirements.txt to absolutny standard branżowy i jeden z najważniejszych plików w każdym profesjonalnym projekcie programistycznym w Pythonie.
• Przechowuje on prostą listę wszystkich bibliotek zewnętrznych wraz z ich dokładnymi wersjami, które są wymagane do poprawnego uruchomienia naszej aplikacji.
• Dzięki temu, zamiast instalować każdą bibliotekę z osobna, nowa osoba pobierająca nasz projekt może zainstalować wszystkie wymagane zależności za pomocą jednego, prostego polecenia: pip install -r requirements.txt.
• Gwarantuje to, że każdy członek zespołu oraz serwer produkcyjny korzysta z dokładnie tych samych wersji bibliotek, co zapobiega powstawaniu trudnych do zdiagnozowania błędów.
• Pozwala to na bezproblemowe uruchamianie aplikacji w kontenerach takich jak Docker lub w usługach chmurowych AWS i Azure.
• Plik ten może być również wersjonowany w repozytorium Git, co pozwala na śledzenie zmian w bibliotekach na przestrzeni czasu.
• Dzięki temu cały zespół deweloperski zawsze pracuje w identycznych warunkach technologicznych.
• Eliminujemy w ten sposób popularny problem 'u mnie działa', który paraliżuje pracę zespołów IT.
• Jest to fundament każdego nowoczesnego potoku CI/CD.

# Przykład zawartości pliku requirements.txt
requests==2.28.1
flask==2.2.2
pandas==1.5.0

# Komenda instalacji wszystkich zależności z pliku na raz:
# pip install -r requirements.txt
            

• Podczas pracy nad wieloma projektami programistycznymi na jednym komputerze szybko napotkamy poważny problem – konflikty wersji bibliotek.
• Na przykład, starszy Projekt A może wymagać biblioteki Django w wersji 2.2, podczas gdy nowoczesny Projekt B potrzebuje Django w wersji 4.1.
• Instalując te biblioteki globalnie w systemie, nowsza wersja nadpisze starszą, uszkadzając Projekt A.
• Rozwiązaniem tego krytycznego problemu są środowiska wirtualne (ang. virtual environments), realizowane za pomocą wbudowanego modułu venv.
• Środowisko wirtualne to w pełni odizolowany, prywatny katalog zawierający własną kopię interpretera Pythona oraz własny, niezależny folder na biblioteki instalowane przez pip.
• Katalog ten zawiera również prywatny plik wykonywalny Pythona, co uniemożliwia wpływ globalnych zmian systemowych na nasz projekt.
• Używanie wirtualnych środowisk pozwala na testowanie aplikacji z różnymi wersjami Pythona bez konieczności przeinstalowywania systemu.
• Jest to sterylna przestrzeń, która chroni nas przed przypadkowym uszkodzeniem innych działających na komputerze programów.
• Korzystanie z venv to powszechny standard we wszystkich projektach komercyjnych na całym świecie.
• Żaden profesjonalny deweloper nie instaluje bibliotek produkcyjnych w środowisku globalnym.

• Tworzenie nowego środowiska wirtualnego w Pythonie jest niezwykle szybkie i odbywa się bezpośrednio z poziomu wiersza poleceń systemowych.
• Aby to zrobić, przechodzimy w terminalu do folderu naszego projektu, a następnie wpisujemy komendę python -m venv venv (zazwyczaj jako nazwę wybiera się po prostu venv lub .venv).
• Polecenie to uruchamia wbudowany moduł venv, który tworzy w naszym projekcie nowy katalog o podanej nazwie.
• Wewnątrz tego katalogu Python tworzy kompletną strukturę podfolderów, kopiuje pliki interpretera Pythona, instaluje menedżer pakietów pip oraz przygotowuje skrypty aktywacyjne niezbędne do uruchomienia środowiska.
• Nazwa venv jest powszechnie akceptowaną konwencją, która ułatwia innym programistom natychmiastowe zidentyfikowanie charakteru tego folderu.
• Tworzenie środowiska trwa zazwyczaj kilka sekund i nie wymaga uprawnień administratora systemowego.
• Narzędzie automatycznie konfiguruje skrypty dla różnych konsol systemowych, takich jak CMD, PowerShell czy Bash.
• Katalog ten jest w pełni niezależny, co oznacza, że możemy go bez konsekwencji skasować i utworzyć na nowo.
• Pozwala to na szybkie i bezproblemowe resetowanie stanu zależności w naszym projekcie.

# Tworzenie środowiska wirtualnego o nazwie "venv" w terminalu
python -m venv venv

# Wygenerowany folder "venv" zawiera własny katalog bin/Scripts, interpreter i pip
            

• Samo utworzenie katalogu środowiska wirtualnego nie oznacza jeszcze, że z niego korzystamy – musimy je najpierw jawnie aktywować w naszym terminalu.
• Pracę tę ułatwiają gotowe skrypty aktywacyjne.
• Proces aktywacji różni się w zależności od używanego systemu operacyjnego oraz powłoki systemowej.
• Na systemie Windows w powłoce PowerShell robimy to za pomocą skryptu .\venv\Scripts\Activate.ps1, natomiast na systemach Linux i macOS używamy polecenia source venv/bin/activate.
• Po pomyślnej aktywacji, na początku wiersza poleceń terminala pojawi się charakterystyczny nawias z nazwą środowiska, np. (venv).
• Nazwa środowiska w nawiasie przypomina nam o tym, że wszystkie wywołania poleceń będą izolowane.
• Po zakończeniu pracy dezaktywacja przywraca pierwotne, globalne ustawienia systemu operacyjnego w ułamku sekundy.
• Aby opuścić środowisko i powrócić do globalnych ustawień systemu, wpisujemy po prostu polecenie deactivate.

# Aktywacja na Windows (PowerShell):
.\venv\Scripts\Activate.ps1

# Aktywacja na Linux / macOS (Bash/Zsh):
source venv/bin/activate

# Dezaktywacja (na każdym systemie):
deactivate
            

• Profesjonalna praca z projektami w języku Python opiera się na ściśle określonym, powtarzalnym cyklu życia środowiska wirtualnego (tzw. workflow).
• Kiedy rozpoczynamy nowy projekt lub pobieramy istniejący z repozytorium (np. GitHub), pierwszym krokiem jest stworzenie lokalnego środowiska za pomocą python -m venv venv.
• Następnie aktywujemy to środowisko i za pomocą pip install -r requirements.txt instalujemy wszystkie wymagane biblioteki.
• Cała nasza praca, pisanie kodu oraz uruchamianie testów odbywa się przy aktywowanej piaskownicy.
• Przed wysłaniem kodu do repozytorium aktualizujemy plik zależności komendą pip freeze > requirements.txt.
• Sam katalog venv dodajemy do pliku .gitignore, aby nie zaśmiecać repozytorium.
• Dodanie folderu venv do pliku .gitignore chroni repozytorium przed niepotrzebnym wysyłaniem megabajtów kodu bibliotek zewnętrznych.
• Dzięki temu repozytorium pozostaje lekkie, a pobranie projektu trwa zaledwie kilka sekund.
• Ostateczna instalacja zależności na maszynie docelowej odbywa się automatycznie na podstawie pliku tekstowego.
• Taki cykl pracy gwarantuje pełną odtwarzalność projektu i minimalizuje ryzyko błędów konfiguracyjnych.
• Jest to podstawowa higiena deweloperska wymagana w każdej nowoczesnej firmie programistycznej.

# Typowy workflow w 4 krokach:
# 1. python -m venv venv            (tworzenie)
# 2. .\venv\Scripts\Activate.ps1   (aktywacja na Windows)
# 3. pip install -r requirements.txt (instalacja zależności)
# 4. pip freeze > requirements.txt  (zapisanie zmian)
            

• Jedno z najważniejszych haseł reklamowych języka Python brzmi: 'Batteries Included' (baterie w zestawie).
• Oznacza to, że wraz z samą instalacją interpretera otrzymujemy potężną, niezwykle bogatą bibliotekę standardową, składającą się z setek gotowych i doskonale przetestowanych modułów.
• Oprócz podstawowych narzędzi, takich jak math, random czy datetime, biblioteka standardowa oferuje moduły do pracy z internetem, obsługi baz danych (np. sqlite3), kompresji plików (np. zipfile) czy parsowania formatów XML i JSON.
• Korzystanie z modułów wbudowanych gwarantuje maksymalną wydajność (wiele z nich napisano w języku C) oraz eliminuje potrzebę instalowania zewnętrznych pakietów.
• Znajdziemy tu również moduły do zaawansowanego szyfrowania, kompresji danych algorytmem gzip, a także obsługi protokołów sieciowych FTP i SMTP.
• Korzystanie z biblioteki standardowej gwarantuje najwyższy poziom bezpieczeństwa, ponieważ kod ten jest audytowany przez kluczowych deweloperów Pythona.
• Pozwala to również na pisanie kodu w pełni przenośnego, który zadziała na dowolnym komputerze z zainstalowanym interpreterem.
• Koncepcja 'Batteries Included' to jeden z głównych powodów tak ogromnej popularności języka Python w biznesie i nauce.
• Umożliwia ona błyskawiczne prototypowanie i wdrażanie stabilnych aplikacji produkcyjnych.

• Klasa timedelta z modułu datetime to jedno z najbardziej eleganckich narzędzi do wykonywania arytmetyki czasu w nowoczesnych językach programowania.
• Reprezentuje ona czysty czas trwania (ang. duration), czyli różnicę między dwiema datami lub godzinami.
• Tworząc obiekt timedelta, możemy określić liczbę dni, sekund, mikrosekund, milisekund, minut, godzin lub tygodni.
• Obiekt ten możemy w naturalny sposób dodawać lub odejmować od standardowych obiektów datetime za pomocą operatorów + i -.
• Umożliwia to bardzo proste realizowanie zadań takich jak wyznaczanie daty ważności konta użytkownika czy obliczanie czasu, jaki pozostał do określonego wydarzenia.
• Obiekt timedelta automatycznie przelicza jednostki czasu, dbając o poprawność obliczeń nawet przy przekraczaniu granic miesięcy i lat.
• Pozwala na porównywanie czasów trwania przy użyciu standardowych operatorów porównania (np. <, >).
• Możemy w ten sposób łatwo realizować zaawansowane filtry czasowe w bazach danych lub logach aplikacji.
• Klasa ta jest kluczowym elementem przy budowaniu systemów rezerwacyjnych, kalendarzy oraz harmonogramów zadań.
• Zapewnia ona najwyższą dokładność i eliminuje ryzyko popełnienia typowych błędów związanych z czasem.

import datetime

start = datetime.date(2026, 5, 18)
okres = datetime.timedelta(weeks=2)  # Czas trwania: 2 tygodnie
koniec = start + okres
print(f"Start: {start}, Koniec: {koniec}")  # Automatycznie doda 14 dni
            

• Oprócz generowania pojedynczych liczb losowych, moduł random oferuje zaawansowane narzędzia do pracy z kolekcjami danych (np. listami).
• Funkcja random.choice(sekwencja) pobiera jeden losowy element, natomiast random.sample(sekwencja, k) pozwala na wylosowanie unikalnej podgrupy o rozmiarze k bez zwracania (doskonale nadaje się do symulacji gier liczbowych typu Lotto).
• Jeżeli dopuszczamy powtórzenia wylosowanych elementów, korzystamy z metody random.choices(), co ułatwia symulowanie rozkładów prawdopodobieństwa.
• Do losowego mieszania elementów bezpośrednio w oryginalnej liście (w miejscu, ang. in-place) służy funkcja random.shuffle(lista).
• Zwraca ona None i modyfikuje kolekcję bezpośrednio, co oszczędza pamięć RAM komputera.
• Funkcja ta przydaje się przy tasowaniu talii kart w grach lub algorytmach optymalizacyjnych.
• Warto pamiętać, że mieszanie działa tylko na obiektach modyfikowalnych (np. listach), a wywołanie go na krotce (tuple) spowoduje błąd typu TypeError.
• Moduł ten pozwala również na ustawienie ziarna losowości za pomocą metody random.seed().
• Gwarantuje to pełną odtwarzalność wyników losowania podczas testów.
• Tasowanie i próbkowanie z random to podstawowe narzędzie w arsenale każdego analityka danych.

import random

talia = ["As", "Król", "Dama", "Walet"]
random.shuffle(talia)  # Tasowanie w miejscu
print(talia)

wybrane = random.sample(talia, 2)  # Pobranie 2 unikalnych
print(wybrane)
            

• Kiedy importujemy zewnętrzny moduł lub tworzymy własny, Python automatycznie przydziela mu całkowicie osobną i niezależną przestrzeń nazw (ang. namespace).
• Przestrzeń nazw działa jak wirtualny mur odgradzający zmienne i funkcje zdefiniowane w jednym pliku od elementów w innym.
• Dzięki temu możemy bez obaw zdefiniować w naszym pliku głównym zmienną o nazwie x, nawet jeśli zaimportowany moduł math również posiada własną zmienną x.
• Dostęp do zmiennej modułu uzyskujemy kwalifikowanie (math.pi), a do własnej bezpośrednio (x).
• Taki mechanizm gwarantuje absolutne bezpieczeństwo przed przypadkowym nadpisywaniem danych w dużych systemach informatycznych.
• Wbudowany słownik __dict__ każdego modułu przechowuje wszystkie zdefiniowane w nim zmienne i funkcje.
• Pozwala to Pythonowi na błyskawiczne odnajdywanie nazw w pamięci operacyjnej komputera.
• Przestrzenie nazw modułów są tworzone dynamicznie w momencie pierwszego importu i pozostają aktywne aż do zakończenia działania programu.
• Taka izolacja umożliwia bezproblemową integrację kodu stworzonego przez setki niezależnych programistów z całego świata.
• Stanowi to fundament współczesnej inżynierii oprogramowania i pozwala na budowanie gigantycznych systemów korporacyjnych.

• Stosowanie skróconych nazw (aliasów) za pomocą instrukcji as to powszechny standard branżowy, bez którego trudno wyobrazić sobie współczesną pracę programisty Python.
• W świecie analizy danych i uczenia maszynowego istnieją niepisane reguły, które wręcz nakazują stosowanie konkretnych, jednolitych aliasów dla popularnych bibliotek.
• Na przykład bibliotekę numpy importuje się zawsze jako np, pandas jako pd, a moduł wykresów matplotlib.pyplot jako plt.
• Taka standaryzacja sprawia, że kod pisany przez różnych deweloperów z całego świata staje się natychmiast czytelny i łatwy w analizie dla każdego członka zespołu, eliminując zbędne zróżnicowanie nazewnictwa.
• Standaryzacja ta obejmuje również biblioteki takie jak seaborn importowaną jako sns czy scipy.
• Ułatwia to czytanie dokumentacji technicznej, tutoriali oraz kodu na portalach takich jak GitHub czy Stack Overflow.
• Pisanie kodu zgodnie z tymi konwencjami jest oznaką dojrzałości i profesjonalizmu programisty.
• Ułatwia to również pracę systemom sztucznej inteligencji wspomagającym pisanie kodu (np. Copilot).
• Stosowanie branżowych aliasów to obowiązkowy element edukacji każdego przyszłego analityka danych i programisty Python.

# Standard branżowy w analizie danych:
import numpy as np
import pandas as pd

tabela = pd.DataFrame()  # Zwięzły, powszechnie czytelny zapis
            

• Aby w pełni zrozumieć działanie zmiennej __name__, należy przyjrzeć się procesowi ładowania kodu przez interpreter Pythona.
• Kiedy Python uruchamia plik, najpierw analizuje jego kontekst wywołania.
• Jeśli plik jest punktem startowym aplikacji (został kliknięty lub wywołany bezpośrednio w konsoli), interpreter przypisuje specjalnemu atrybutowi __name__ unikalną wartość '__main__'.
• W przypadku gdy ten sam plik jest importowany przez instrukcję import z poziomu innego skryptu, Python przypisuje mu nazwę równą nazwie modułu (czyli nazwie pliku bez rozszerzenia .py).
• Pozwala to programiście pisać uniwersalne moduły, które zachowują się elastycznie w zależności od kontekstu.
• Pozwala to również na tworzenie elastycznych skryptów testowych, które mogą być importowane bez uruchamiania ich głównej logiki wykonawczej.
• Wartość __name__ można w każdej chwili sprawdzić w konsoli interaktywnej Pythona.
• Jest to jedna z najpotężniejszych cech dynamicznego ładowania modułów w Pythonie.
• Zrozumienie tego mechanizmu pozwala na pełną kontrolę nad przepływem sterowania w naszej aplikacji.
• Stanowi to podstawę do nauki bardziej zaawansowanych wzorców architektonicznych i metaprogramowania.

# Kod demonstrujący wartość __name__
print(f"Uruchomiono moduł z __name__ = {__name__}")

# W main.py wypisze: __main__
# Po imporcie w innym pliku wypisze nazwę pliku
            

• Plik __init__.py odgrywa fundamentalną rolę w cyklu życia każdego pakietu w języku Python.
• Oprócz tego, że jego obecność informuje interpreter o istnieniu importowalnego folderu, plik ten służy również jako miejsce do konfiguracji startowej pakietu.
• Kod umieszczony wewnątrz __init__.py jest automatycznie wykonywany przy pierwszym imporcie jakiegokolwiek elementu z danego pakietu.
• Możemy w nim zdefiniować zmienną specjalną __all__, która precyzyjnie kontroluje, jakie moduły będą importowane przy użyciu importu gwiazdkowego.
• Pozwala to na ukrycie wewnętrznych szczegółów implementacji pakietu i wystawienie eleganckiego interfejsu API.
• Plik __init__.py umożliwia również definiowanie metadanych pakietu, takich jak wersja (__version__) czy autor (__author__).
• Pozwala na importowanie podmodułów w tle, dzięki czemu użytkownik końcowy może korzystać z uproszczonego interfejsu importu.
• W ten sposób możemy ukryć skomplikowaną strukturę katalogów pod jednym, eleganckim szyldem pakietu.
• Jest to kluczowy element budowania profesjonalnych bibliotek dystrybuowanych za pomocą menedżera pip.
• Zapewnia to najwyższą estetykę i profesjonalizm naszego kodu źródłowego.

# plik: grafika/__init__.py
__all__ = ["filtry", "kolory"]  # Kontrola importu gwiazdkowego
print("Zainicjalizowano pakiet grafika!")
            

• Repozytorium PyPI (ang. Python Package Index) to publiczny skarbiec, w którym deweloperzy z całego świata publikują swoje darmowe biblioteki i narzędzia.
• Jest ono zintegrowane bezpośrednio z menedżerem pakietów pip, co tworzy niezwykle spójny i potężny ekosystem programistyczny.
• Dzięki pip nie musimy ręcznie wchodzić na strony internetowe, pobierać archiwów zip, rozpakowywać ich ani konfigurować ścieżek systemowych.
• Narzędzie pip dba o cały ten proces automatycznie w tle.
• Co ważne, pip sprawdza również zależności instalowanej biblioteki – jeśli wybrany pakiet wymaga do działania trzech innych bibliotek, pip pobierze i zainstaluje je wszystkie.
• Menedżer pip potrafi również instalować pakiety bezpośrednio z repozytoriów Git (np. GitHub) oraz z lokalnych plików instalacyjnych.
• Narzędzie to automatycznie pobiera i kompiluje surowy kod źródłowy do zoptymalizowanych plików binarnych.
• Dba również o bezpieczeństwo, weryfikując certyfikaty SSL serwerów PyPI.
• Dzięki tak spójnemu ekosystemowi, instalacja nawet najbardziej skomplikowanych bibliotek do uczenia maszynowego (np. TensorFlow) sprowadza się do jednej linijki w terminalu.
• Jest to nieocenione ułatwienie w codziennej pracy programistycznej.

• Podczas tworzenia profesjonalnych aplikacji komercyjnych niezwykle ważną praktyką jest unikanie instalowania bibliotek 'w ciemno' bez określania ich wersji.
• Biblioteki zewnętrzne na PyPI nieustannie się rozwijają – ich autorzy dodają nowe funkcje, lecz czasem usuwają stare lub zmieniają sposób ich wywoływania (ang. breaking changes).
• Jeśli w naszym pliku requirements.txt zapiszemy samo requests, pip pobierze najnowszą wersję.
• Może się okazać, że za rok nowa wersja biblioteki uniemożliwi uruchomienie naszego starego kodu.
• Aby temu zapobiec, zawsze precyzyjnie wskazujemy numery wersji za pomocą operatora ==, gwarantując pełne bezpieczeństwo projektu.
• Stosowanie przedziałów wersji (np. requests>=2.0.0,<3.0.0) pozwala na automatyczne pobieranie poprawek bezpieczeństwa przy zachowaniu zgodności wstecznej.
• Pomaga to w automatyzacji procesu aktualizacji bibliotek w dużych projektach biznesowych.
• Precyzyjne wersjonowanie chroni serwery produkcyjne przed nagłymi awariami po automatycznym wdrożeniu nowej wersji kodu.
• Jest to absolutny standard wymagany w każdym profesjonalnym potoku CI/CD.
• Gwarantuje to, że środowisko uruchomieniowe jest w 100% przewidywalne i stabilne.

# Dobre praktyki wersjonowania w requirements.txt:
requests==2.28.1  # Dokładna wersja (zalecana)
flask>=2.0.0,<3.0.0   # Przedział wersji akceptowalnych
            

• Praca nad projektami Pythona bez używania izolowanych środowisk wirtualnych venv to jeden z najczęstszych i najbardziej dotkliwych błędów popełnianych przez początkujących programistów.
• Instalując wszystkie zewnętrzne biblioteki globalnie w systemie operacyjnym, doprowadzamy do powstawania tzw. 'piekła zależności' (ang. dependency hell).
• Różne projekty zaczynają walczyć ze sobą o wersje tych samych pakietów, a każda kolejna instalacja niesie ryzyko uszkodzenia działających już programów.
• Co więcej, globalny folder bibliotek staje się olbrzymi i niemożliwy do wyczyszczenia.
• Środowisko wirtualne venv rozwiązuje te problemy u samej podstawy, tworząc sterylne piaskownice dla każdego projektu osobno.
• Wirtualne środowiska są również bardzo lekkie, ponieważ nie zawierają pełnej kopii bibliotek standardowych, a jedynie linki symboliczne do nich.
• Pozwala to na posiadanie setek niezależnych środowisk dla różnych projektów na jednym dysku twardym bez obaw o brak wolnego miejsca.
• Eliminują one całkowicie potrzebę posiadania uprawnień administratora systemowego do instalowania nowych bibliotek.
• Ułatwia to pracę w chmurze i wdrażanie aplikacji na serwery produkcyjne przy użyciu kontenerów Docker.
• Praca z venv to podstawa profesjonalnej higieny deweloperskiej.

• System Windows posiada specyficzne powłoki systemowe, takie jak PowerShell oraz tradycyjny Wiersz Poleceń (CMD), co wymaga dokładnego zrozumienia komend aktywacyjnych.
• Aby stworzyć i aktywować środowisko wirtualne pod Windows, otwieramy terminal w folderze projektu.
• Tworzymy środowisko standardową komendą python -m venv venv.
• W przypadku powłoki PowerShell, domyślne zabezpieczenia systemu Windows mogą blokować uruchamianie skryptów aktywacyjnych – w takiej sytuacji przed aktywacją należy odblokować uprawnienia komendą Set-ExecutionPolicy -Scope Process Bypass.
• Następnie uruchamiamy skrypt aktywacji, co potwierdzi pojawienie się przedrostka (venv).
• W powłoce PowerShell konieczne może być również wpisanie ścieżki z kropką i ukośnikiem na początku, co wskazuje na katalog bieżący.
• Po pomyślnej aktywacji, interpreter Pythona automatycznie korzysta z bibliotek zainstalowanych wyłącznie w tym folderze venv.
• W tradycyjnym Wierszu Poleceń (CMD) aktywację wykonujemy prostą komendą venv\Scripts\activate.bat.
• Zrozumienie tych różnic systemowych pozwala na bezproblemową pracę w środowiskach typu Windows.
• Ułatwia to również integrację z edytorami kodu takimi jak VS Code czy PyCharm.

# Kompletna procedura dla Windows PowerShell:
Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process
python -m venv venv
.\venv\Scripts\Activate.ps1
            

• Podczas gdy wbudowany moduł os doskonale radzi sobie z podstawowymi operacjami na plikach, do bardziej zaawansowanych zadań Python udostępnia dedykowany moduł o nazwie shutil (ang. Shell Utilities).
• Oferuje on wysokopoziomowe operacje na całych strukturach plików i folderów, które leżą poza możliwościami modułu os.
• Za pomocą shutil.copy() kopiujemy plik wraz z jego uprawnieniami, a shutil.copytree() pozwala na skopiowanie całego drzewa katalogów wraz ze wszystkimi plikami i podfolderami za jednym razem.
• Do przenoszenia plików służy metoda shutil.move(), a do bezpowrotnego usuwania całych struktur folderów – potężna metoda shutil.rmtree().
• Moduł shutil wspiera również tworzenie i rozpakowywanie archiwów zip, tar oraz gztar za pomocą metod make_archive() i unpack_archive().
• Pozwala to na automatyczne tworzenie kopii zapasowych baz danych czy logów systemowych bezpośrednio w naszym skrypcie.
• Metody te działają w sposób zoptymalizowany pod kątem zużycia pamięci RAM, co pozwala na przetwarzanie bardzo dużych plików.
• Narzędzie to dba o zachowanie struktury katalogów i praw dostępu do plików na systemach Linux i macOS.
• Jest to niezastąpione narzędzie w codziennej pracy każdego administratora systemów i programisty.

import shutil

# Skopiowanie całego katalogu z zawartością do nowej lokalizacji
shutil.copytree("projekty", "kopia_zapasowa/projekty")

# Bezpowrotne usunięcie folderu wraz z zawartością
# shutil.rmtree("kopia_zapasowa")
            

• Do nawiązywania połączeń sieciowych, wysyłania zapytań i pobierania danych z internetu bezpośrednio w kodzie, Python udostępnia wbudowany moduł urllib.
• Jest to niskopoziomowa biblioteka sieciowa, która pozwala na bezproblemową komunikację za pomocą protokołu HTTP i HTTPS bez instalowania bibliotek zewnętrznych.
• Za pomocą podmodułu urllib.request i funkcji urlopen() możemy otworzyć dowolną stronę internetową jako strumień danych, a następnie odczytać jej kod źródłowy HTML za pomocą metody .read().
• Zwracane surowe dane w postaci bajtów należy następnie zdekodować na tekst za pomocą standardowego dekodera .decode('utf-8').
• Moduł urllib.parse umożliwia dodatkowo bezpieczne kodowanie i dekodowanie parametrów przekazywanych w adresach URL (np. spacji czy znaków specjalnych).
• Ułatwia to budowanie dynamicznych zapytań do wyszukiwarek internetowych i interfejsów API.
• Do obsługi ciasteczek (cookies) oraz zaawansowanej autoryzacji moduł ten udostępnia podklasy menedżerów połączeń.
• Pozwala to na automatyzację pobierania danych ze stron wymagających prostego uwierzytelnienia.
• Mimo że biblioteka requests jest bardziej popularna w codziennej pracy, znajomość urllib jest kluczowa w środowiskach o ograniczonych uprawnieniach.

import urllib.request

with urllib.request.urlopen("https://www.python.org") as odpowiedz:
    surowe_dane = odpowiedz.read()
    html = surowe_dane.decode("utf-8")  # Dekodowanie bajtów na string
    print(html[:100])  # Wycinek kodu HTML strony
            

• Napiszmy kompletny, użyteczny i w pełni interaktywny program konsolowy, który realizuje klasyczną grę w zgadywanie losowej liczby z przedziału 1-100.
• Program w ułamku sekundy generuje tajną liczbę przy użyciu metody random.randint() z modułu random.
• Następnie gra działa w pętli while True, pobierając od użytkownika kolejne typy za pomocą funkcji input().
• Aplikacja inteligentnie podpowiada graczowi, czy jego strzał jest zbyt mały, czy zbyt duży, oraz zlicza liczbę wykonanych prób.
• Po odgadnięciu liczby program wyświetla gratulacje, podsumowuje liczbę kroków i bezpiecznie kończy działanie.
• Program ten można łatwo rozbudować o zapisywanie najlepszych wyników do pliku tekstowego na dysku.
• Gra doskonale uczy obsługi wyjątków (np. gdy użytkownik zamiast liczby wpisze tekst), co chroni aplikację przed nagłym zawieszeniem.
• Zastosowanie instrukcji break pozwala na natychmiastowe opuszczenie pętli po odgadnięciu sekretu.
• Jest to klasyczny przykład algorytmu wyszukiwania binarnego w praktyce, gdzie gracz optymalizuje swoje strzały.
• Taki projekt stanowi doskonałą bazę do nauki programowania obiektowego i tworzenia interfejsów graficznych.

import random
sekret = random.randint(1, 100)
proby = 0
while True:
    strzal = int(input("Zgadnij liczbę (1-100): "))
    proby += 1
    if strzal == sekret:
        print(f"Brawo! Odgadłeś w {proby} próbach."); break
    elif strzal < sekret: print("Za mało!")
    else: print("Za dużo!")
            

• Przeanalizujmy kompletny i wysoce praktyczny program, który pomaga w wyznaczaniu dokładnych terminów realizacji zadań (np. w zarządzaniu projektami) za pomocą klas datetime oraz timedelta.
• Program pobiera aktualną datę z systemu i pozwala na elastyczne obliczenie, jaki dzień tygodnia oraz jaka data wypadnie po upływie określonej liczby dni (np. po 45 dniach).
• Dodatkowo, program wykorzystuje właściwość weekday() do sprawdzenia, czy wyznaczona data wypada w weekend (sobota lub niedziela).
• W przypadku wykrycia weekendu, aplikacja potrafi automatycznie przesunąć termin na najbliższy poniedziałek, co jest standardową procedurą w biznesie.
• Aplikacja ta doskonale prezentuje przydatność metod weekday() oraz strftime() w codziennej automatyzacji procesów biznesowych.
• Program można rozbudować o listę dni ustawowo wolnych od pracy, co pozwoli na jeszcze bardziej precyzyjne planowanie terminów.
• Obliczenia na datach są w pełni bezpieczne i automatycznie uwzględniają lata przestępne oraz różną długość miesięcy.
• Dzięki temu eliminujemy ryzyko popełnienia kosztownych błędów w harmonogramach finansowych czy logistycznych.
• Jest to klasyczny przykład narzędzia automatyzującego codzienną, rutynową pracę biurową.

import datetime
teraz = datetime.date.today()
termin = teraz + datetime.timedelta(days=45)
if termin.weekday() == 5:  # Sobota
    termin += datetime.timedelta(days=2)
elif termin.weekday() == 6:  # Niedziela
    termin += datetime.timedelta(days=1)
print(f"Ostateczny termin (pon-piąt): {termin}")
            

• Wkraczając w świat profesjonalnego programowania, warto poznać absolutną czołówkę najpopularniejszych bibliotek zewnętrznych, które zrewolucjonizowały świat IT i uczyniły Pythona liderem branży.
• Do komunikacji sieciowej i pobierania danych z API standardem jest biblioteka requests.
• W tworzeniu serwisów internetowych królują frameworki Flask oraz Django.
• Przy pracy z danymi, analizie statystycznej i uczeniu maszynowym nieocenioną rolę odgrywają pakiety pandas (zarządzanie tabelami), numpy (obliczenia macierzowe) oraz scikit-learn.
• Do tworzenia pięknych wykresów i wizualizacji danych stosuje się biblioteki matplotlib oraz seaborn.
• Znajomość tych bibliotek to absolutny fundament przy ubieganiu się o pracę na stanowiskach deweloperskich i analitycznych.
• Biblioteki te są nieustannie rozwijane przez tysiące programistów, co gwarantuje ich bezpieczeństwo i stabilność.
• Ich instalacja za pomocą pip trwa zaledwie kilka sekund i daje nam dostęp do narzędzi używanych przez największe firmy technologiczne (np. Google, Netflix, Spotify).
• Wykorzystanie tych pakietów skraca czas tworzenia aplikacji o miesiące, pozwalając na skupienie się na unikalnej logice biznesowej.
• Ekosystem Pythona jest dzięki temu najbogatszym środowiskiem programistycznym na świecie.

• Czas na praktyczne zadania utrwalające wiedzę z części 12.
• Pierwsze ćwiczenie polega na stworzeniu własnego modułu pomocniczego o nazwie geometria.py.
• W module tym należy zapisać dwie poprawnie zaimplementowane funkcje: pole_kola(promien), która wyliczy pole koła przy użyciu stałej math.pi z modułu wbudowanego math, oraz pole_prostokata(a, b).
• Następnie należy utworzyć plik główny app.py, zaimportować w nim stworzony moduł geometria za pomocą instrukcji import geometria i przetestować działanie obu funkcji w konsoli, wyświetlając wyniki obliczeń.
• Ćwiczenie to uczy programistę poprawnego importowania własnych plików i korzystania z przestrzeni nazw modułów.
• Pozwala zrozumieć, jak wydzielenie funkcji do zewnętrznego pliku upraszcza kod głównej aplikacji.
• Uczy również dbania o przejrzystość struktury katalogów i unikania konfliktów nazw zmiennych.
• Jest to podstawowe ćwiczenie architektoniczne, które stanowi fundament pod późniejszą naukę programowania obiektowego.
• Pomyślne ukończenie tego zadania gwarantuje zrozumienie podstaw modularności oprogramowania.

# plik: geometria.py
import math
def pole_kola(r):
    return math.pi * r ** 2

# plik: app.py
import geometria
print(geometria.pole_kola(5))  # Obliczenie pola dla r=5
            

• Drugie ćwiczenie ma na celu utrwalenie pracy z wbudowanym modułem random.
• Zadaniem programisty jest stworzenie symulatora tradycyjnych gier planszowych.
• Program powinien w pętli while True umożliwiać użytkownikowi symulację rzutu sześcienną kostką do gry (losowanie liczb całkowitych od 1 do 6 za pomocą random.randint).
• Dodatkowo, program powinien na starcie zdefiniować listę graczy (np. cztery imiona), w ułamku sekundy losowo ustalić kolejność ich startu przy użyciu metody random.shuffle(), a następnie na żądanie użytkownika wybierać losowego gracza do wykonania rzutu.
• Program ten uczy dynamicznej modyfikacji list w pamięci operacyjnej oraz interakcji z użytkownikiem w pętli zdarzeń.
• Pozwala zrozumieć różnicę między losowaniem z powtórzeniami a unikalnym tasowaniem całej kolekcji.
• Projekt można łatwo rozbudować o graficzną wizualizację rzutów kostką przy użyciu biblioteki tkinter.
• Stanowi on doskonale przygotowaną bazę pod tworzenie bardziej skomplikowanych gier planszowych i karcianych.
• Ćwiczenie to doskonale rozwija wyobraźnię algorytmiczną młodego programisty.

import random
gracze = ["Anna", "Jan", "Maria", "Piotr"]
random.shuffle(gracze)  # Ustalenie losowej kolejności
rzut = random.randint(1, 6)  # Symulacja kostki do gry
print(f"Startuje: {gracze[0]}, Wynik rzutu: {rzut}")
            

• Trzecie ćwiczenie to kompleksowy test umiejętności zarządzania zależnościami w profesjonalnym projekcie.
• Należy założyć nowy katalog projektu na dysku.
• Następnie w terminalu systemowym należy utworzyć środowisko wirtualne venv, aktywować je, a za pomocą narzędzia pip zainstalować popularną bibliotekę zewnętrzną requests.
• W kolejnym kroku należy napisać krótki skrypt pobierz.py, który zaimportuje bibliotekę i pobierze dowolną stronę HTML (np. python.org).
• Na sam koniec, deweloper musi wyeksportować zainstalowane zależności do oficjalnego pliku konfiguracyjnego requirements.txt za pomocą komendy pip freeze.
• Ćwiczenie to gwarantuje pełną samodzielność dewelopera w konfigurowaniu sterylnych środowisk roboczych.
• Pozwala na praktyczne przetestowanie całego cyklu zarządzania zależnościami (workflow) w realnym scenariuszu projektowym.
• Uczy dbania o to, by instalowane biblioteki nie kolidowały z globalnymi ustawieniami systemu operacyjnego komputera.
• Jest to standardowa procedura wdrożeniowa wymagana w każdej nowoczesnej firmie IT.
• Zrozumienie tego procesu eliminuje większość problemów z uruchamianiem kodu na innych komputerach.

# Procedura testowa w terminalu:
python -m venv venv
.\venv\Scripts\Activate.ps1
pip install requests
pip freeze > requirements.txt
            

• Aby pisany przez nas kod modułów i importów był w pełni profesjonalny i zgodny z oficjalnymi standardami społeczności Pythona, należy przestrzegać rygorystycznych reguł opisanych w dokumencie PEP 8.
• Zgodnie z tymi zaleceniami, wszystkie instrukcje import muszą być bezwzględnie umieszczone na samym początku pliku źródłowego.
• Importy należy grupować w trzy wyraźne bloki przedzielone pustą linią: najpierw moduły biblioteki standardowej (np. math, os), potem moduły bibliotek zewnętrznych (np. requests), a na samym końcu nasze własne, lokalne moduły.
• Każdy pojedynczy import powinien być zapisany w osobnej linijce, co drastycznie podnosi czytelność kodu.
• Zgodnie z PEP 8, w sekcji importów nie należy używać importu gwiazdkowego, a każdy blok importów powinien być wyraźnie oddzielony pustą linią.
• Przestrzeganie tych reguł sprawia, że kod staje się estetyczny, spójny i łatwy w analizie dla każdego programisty na świecie.
• Pokazuje to również wysoki kunszt i profesjonalizm autora oprogramowania.
• Ułatwia to pracę w dużych zespołach deweloperskich, gdzie spójność stylu jest kluczowa dla sukcesu projektu.
• Zbiór tych zasad to elementarz każdego profesjonalnego programisty Pythona.

# Dobre praktyki PEP 8 - uporządkowane importy:
import os       # 1. Biblioteka standardowa
import sys

import requests # 2. Biblioteki zewnętrzne

import geometria # 3. Własne moduły lokalne
            

• W części 12 opanowaliśmy kluczowe fundamenty niezbędne do tworzenia dużych, modularnych i łatwych w utrzymaniu aplikacji w języku Python.
• Nauczyliśmy się dzielić kod na logiczne, niezależne moduły (pliki .py) i pakiety (katalogi z plikiem __init__.py) oraz precyzyjnie kontrolować przestrzenie nazw.
• Poznaliśmy potęgę wbudowanych narzędzi biblioteki standardowej (math, random, datetime, os, sys).
• Opanowaliśmy profesjonalne posługiwanie się menedżerem pakietów pip do instalowania zewnętrznych bibliotek oraz tworzenie plików zależności requirements.txt.
• Na koniec nauczyliśmy się izolować środowiska deweloperskie za pomocą środowisk wirtualnych venv.
• Poznaliśmy mechanizmy wyszukiwania modułów na dysku twardym przy użyciu zmiennej systemowej sys.path.
• Zrozumieliśmy, jak ważne dla stabilności aplikacji jest precyzyjne wersjonowanie bibliotek zewnętrznych.
• Ukończenie tej części wykładu stanowi doskonałe przygotowanie do tworzenia zaawansowanych aplikacji komercyjnych.
• Zdobyta wiedza pozwala na płynne i bezpieczne wdrażanie kodu w chmurze oraz kontenerach testowych.
• Modularność to klucz do stania się samodzielnym i cenionym inżynierem oprogramowania.

• Serdeczne gratulacje! Ukończenie wszystkich 12 części naszego kompleksowego kursu to wspaniałe osiągnięcie, które daje Ci solidne i pewne fundamenty do rozpoczęcia kariery w świecie IT.
• Przeszliśmy niesamowitą drogę – od pierwszego programu 'Hello World' i zmiennych, przez instrukcje warunkowe, zaawansowane pętle, dynamiczne listy, słowniki i krotki.
• Opanowaliśmy czystą architekturę funkcji, bezpieczną obsługę plików na dysku (CSV, JSON) oraz profesjonalną modularność z venv i pip.
• Masz teraz w ręku komplet kluczowych narzędzi, które pozwolą Ci na dalszą samodzielną naukę, tworzenie własnych projektów komercyjnych oraz eksplorację fascynujących dziedzin takich jak analiza danych czy sztuczna inteligencja.
• Zdobyliśmy wiedzę, która otwiera drzwi do fascynujących dziedzin takich jak analiza danych, uczenie maszynowe, programowanie sieciowe czy automatyzacja procesów.
• Python to język o nieograniczonych możliwościach, a ukończenie tego kursu to Twój bilet do dynamicznie rozwijającej się branży IT.
• Pamiętaj, że każdy wielki projekt zaczyna się od pojedynczych linii kodu, które już teraz potrafisz pisać w sposób czysty i modularny.
• Życzę Ci ogromu sukcesów, niesłabnącej pasji oraz wielu wspaniałych projektów na Twojej programistycznej drodze.
• Gratulacje – od dziś oficjalnie należysz do globalnej społeczności deweloperów języka Python!

# Twój pierwszy krok w profesjonalną przyszłość:
print("Gratulacje! Zostałeś certyfikowanym programistą języka Python!")