Ten moduł w całości poświęcony jest operacjom na plikach w języku Python -- od otwierania i zamykania plików za pomocą funkcji open() oraz menedżera kontekstu with, przez różne tryby dostępu (odczyt, zapis, dopisywanie, tryb wyłączny), aż po szczegółowe metody czytania (read, readline, readlines, iteracja) i zapisu danych (write, writelines, print). Omówione zostały kluczowe zagadnienia, takie jak ścieżki względne i bezwzględne, kodowanie znaków UTF-8, zarządzanie wskaźnikiem pozycji (tell/seek) oraz sprawdzanie istnienia pliku przed otwarciem. Szczególną uwagę poświęcono bezpiecznemu przetwarzaniu plików -- od obsługi błędów wejścia-wyjścia przez tryb wyłącznego tworzenia 'x', aż po wydajne techniki pracy z dużymi plikami tekstowymi. Moduł wprowadza również praktyczną pracę z popularnymi formatami danych CSV i JSON wraz z dedykowanymi modułami csv i json, a także nowoczesnym narzędziem pathlib do zarządzania ścieżkami.

• Otwieranie i zamykanie plików -- funkcja open(), tryby dostępu (r, w, a, x), menedżer kontekstu with vs tradycyjne close()
• Metody odczytu danych -- read(), readline(), readlines(), iteracja po obiekcie pliku, usuwanie znaków nowej linii strip()
• Zapis danych do pliku -- write(), writelines(), przekierowanie print() z parametrem file, tryb dopisywania 'a'
• Zaawansowane techniki -- kodowanie UTF-8, zarządzanie wskaźnikiem tell()/seek(), sprawdzanie istnienia pliku (pathlib), obsługa błędów I/O
• Formaty danych i dobre praktyki -- CSV i JSON z modułami csv/json, pathlib, ścieżki względne, wydajne przetwarzanie dużych plików

• W codziennym programowaniu dane przechowywane w zmiennych i strukturach pamięci RAM istnieją tylko w trakcie działania aplikacji.
• Po wyłączeniu programu lub restarcie komputera wszystkie te informacje znikają bezpowrotnie.
• Aby zachować stan pracy aplikacji na przyszłość, potrzebujemy trwałego nośnika danych, jakim jest dysk twardy.
• Praca z plikami pozwala nam zapisywać wyniki obliczeń, konfiguracje oraz bazy danych w sposób trwały.
• Umożliwia to również wymianę danych między różnymi programami i systemami na całym świecie.

• Pliki na dysku komputera możemy podzielić na dwie główne kategorie: pliki tekstowe oraz pliki binarne.
• Pliki tekstowe składają się z czytelnych dla człowieka znaków zapisanych zgodnie z określonym standardem kodowania (np. UTF-8).
• Przykłady to dokumenty .txt, .py, .html, .csv czy .json, które można bez problemu otworzyć w zwykłym notatniku.
• Pliki binarne zawierają surowe bajty (ciągi zer i jedynek), które są zrozumiałe wyłącznie dla dedykowanych programów.
• Są to np. zdjęcia .jpg, skompilowane programy .exe, archiwa .zip czy pliki audio .mp3.

• Aby otworzyć dowolny plik w programie, musimy precyzyjnie wskazać jego lokalizację w strukturze katalogów za pomocą ścieżki (ang. path).
• Ścieżka bezwzględna (ang. absolute path) określa pełne położenie pliku od samego korzenia dysku, np. C:\Users\User\documents\dane.txt.
• Ścieżka względna (ang. relative path) wskazuje lokalizację pliku w odniesieniu do katalogu roboczego, w którym aktualnie uruchomiony jest nasz skrypt Python.
• W systemie Windows separatorem katalogów jest tradycyjnie ukośnik wsteczny \, podczas gdy w systemach Linux i macOS używa się zwykłego ukośnika /.
• W Pythonie warto używać standardowych ukośników / lub modułu pathlib, aby kod działał poprawnie na każdym systemie operacyjnym.

# Przykład ścieżki względnej i bezwzględnej
sciezka_wzgledna = "dane/raport.txt"
sciezka_bezwzgledna = "C:/PythonProjects/dane/raport.txt"
            

• Do nawiązania połączenia z plikiem na dysku służy wbudowana w Pythona funkcja open().
• Jako pierwszy argument funkcja ta przyjmuje ścieżkę do pliku, a jako drugi – tryb otwarcia (np. do odczytu lub zapisu).
• Wywołanie open() tworzy i zwraca specjalny obiekt plikowy (ang. file object), który działa jak wirtualny pomost między programem a dyskiem.
• Obiekt ten posiada liczne metody pozwalające na interakcję z zawartością pliku.
• Jeśli spróbujemy otworzyć do odczytu plik, który fizycznie nie istnieje, Python natychmiast zgłosi błąd FileNotFoundError.

# Otwarcie pliku do odczytu (domyślny tryb to 'r')
plik = open("notatki.txt")
print(type(plik))  # Zwróci obiekt typu _io.TextIOWrapper
            

• Funkcja open() pozwala na precyzyjne określenie intencji, z jakimi otwieramy plik, za pomocą tzw. trybów (ang. modes).
• Tryb 'r' (read) służy wyłącznie do odczytu zawartości istniejącego pliku i jest to tryb domyślny.
• Tryb 'w' (write) otwiera plik do zapisu – jeśli plik już istnieje, jego zawartość zostanie bezpowrotnie skasowana, a jeśli nie istnieje, zostanie utworzony nowy.
• Tryb 'a' (append) służy do dopisywania nowych danych na sam koniec pliku, bez niszczenia istniejącej zawartości.
• Z kolei dodanie liter 'b' (np. 'rb', 'wb') przełącza operacje na tryb binarny, niezbędny do pracy z plikami graficznymi czy spakowanymi.

plik_odczyt = open("dane.txt", "r")    # Tylko odczyt
plik_zapis = open("logi.txt", "a")    # Dopisywanie na koniec
            

• Po zakończeniu jakichkolwiek operacji na pliku niezwykle ważne jest jawne zamknięcie połączenia za pomocą metody .close().
• Pozostawienie otwartego pliku blokuje go w systemie operacyjnym, co może uniemożliwić innym aplikacjom dostęp do niego.
• Ponadto, systemy operacyjne przechowują dane w pamięci podręcznej (buforze) i dopiero zamknięcie pliku gwarantuje fizyczne zapisanie wszystkich danych na dysku.
• Niezamknięte pliki mogą prowadzić do wycieków zasobów systemowych (ang. resource leaks) i spowolnienia komputera.
• Dobry programista zawsze dba o to, by po skończonej pracy posprzątać po sobie i zwolnić blokady plików.

f = open("dane.txt", "r")
# ... wykonujemy operacje na pliku ...
f.close()  # Bezpieczne zwolnienie blokady pliku w systemie
            

• Aby wyeliminować problem zapominania o zamykaniu plików, Python oferuje genialne i nowoczesne rozwiązanie – menedżer kontekstu za pomocą słowa kluczowego with.
• Konstrukcja with open(...) as f: tworzy wydzielony blok kodu, wewnątrz którego mamy dostęp do obiektu pliku pod zmienną f.
• Kluczową zaletą tego rozwiązania jest fakt, że Python automatycznie i bezwzględnie zamknie plik po wyjściu z tego bloku.
• Zamknięcie nastąpi nawet wtedy, gdy wewnątrz bloku dojdzie do niespodziewanego błędu aplikacji (wyjątku) lub wywołania instrukcji return.
• Jest to obecnie absolutny standard branżowy i najbardziej polecany sposób pracy z plikami w Pythonie.

with open("witaj.txt", "r") as f:
    tresc = f.read()
    print(tresc)
# W tym miejscu plik jest już automatycznie zamknięty!
            

• Stosowanie bloku with jest znacznie lepsze niż tradycyjne podejście, ponieważ w tle realizuje bezpieczny schemat obsługi błędów typu try-finally.
• W klasycznym podejściu, jeśli podczas czytania pliku wystąpiłby błąd (np. brak uprawnień lub uszkodzenie struktury), program zostałby przerwany przed linijką .close(), pozostawiając plik zablokowanym.
• Aby napisać to bezpiecznie bez with, musielibyśmy tworzyć rozbudowane bloki try ... finally, co czyni kod nieczytelnym i skomplikowanym.
• Menedżer kontekstu with redukuje ten cały szablon kodowy do zaledwie jednej, prostej i czytelnej linijki.
• Czyni to kod czystszym, bardziej pythonowym oraz odpornym na błędy wykonania.

# Odpowiednik with bez użycia with (bardzo rozwlekły):
f = None
try:
    f = open("dane.txt", "r")
    dane = f.read()
finally:
    if f: f.close()  # Wykona się zawsze, ale kod jest skomplikowany
            

• Metoda .read() wywołana na obiekcie pliku pozwala na wczytanie jego całej zawartości na raz do pamięci RAM komputera.
• Wynik działania tej metody jest zwracany jako pojedynczy, potencjalnie bardzo długi ciąg znaków (string).
• Jest to niezwykle proste i wygodne podejście, gdy pracujemy z małymi plikami tekstowymi, takimi jak pliki konfiguracyjne czy krótkie notatki.
• Należy jednak pamiętać, że ponowne wywołanie .read() na tym samym obiekcie pliku zwróci pusty ciąg znaków, ponieważ wskaźnik pozycji odczytu dotarł już do końca pliku.
• Jeśli chcemy ponownie przeczytać dane, musimy ponownie otworzyć plik lub cofnąć wskaźnik.

with open("notatka.txt", "r") as f:
    caly_tekst = f.read()  # Wczytuje cały plik jako jeden string
    print(caly_tekst)
            

• Gdy pracujemy z plikami o strukturze linijkowej, bardzo przydatną metodą jest .readline().
• Każde wywołanie tej metody wczytuje z pliku dokładnie jedną kolejną linię tekstu – od bieżącej pozycji wskaźnika aż do napotkania znaku nowej linii \n lub końca pliku.
• Metoda ta zwraca wczytany tekst jako string, zachowując na jego końcu znak \n (chyba że to ostatnia linia pliku).
• Jeśli dojdziemy do końca pliku i wywołamy .readline(), Python nie zgłosi błędu, lecz zwróci pusty string "".
• Pozwala to na kontrolowanie odczytu pliku krok po kroku, bez konieczności ładowania całego dokumentu na raz.

with open("dane.txt", "r") as f:
    pierwsza_linia = f.readline()  # Czyta 1. linię
    druga_linia = f.readline()     # Czyta 2. linię
            

• Metoda .readlines() służy do wczytania wszystkich linii pliku tekstowego jednocześnie i zapisania ich w postaci uporządkowanej listy stringów.
• Każdy element tej listy reprezentuje dokładnie jedną linię tekstu z oryginalnego pliku, włączając w to znak nowej linii \n znajdujący się na jej końcu.
• Jest to bardzo wygodne rozwiązanie, ponieważ pozwala nam na łatwe sprawdzanie liczby linii za pomocą len() oraz swobodne operowanie na wczytanych danych za pomocą indeksów (np. pobranie tylko pierwszej lub ostatniej linii).
• Podobnie jak przy .read(), należy jednak pamiętać o ograniczeniach pamięci RAM przy bardzo dużych plikach.

with open("menu.txt", "r") as f:
    lista_linii = f.readlines()  # Zwraca listę stringów
print(f"Liczba linii: {len(lista_linii)}")
            

• Najbardziej eleganckim, wydajnym i zalecanym sposobem czytania pliku tekstowego w Pythonie jest bezpośrednie iterowanie po obiekcie pliku za pomocą pętli for.
• Obiekt pliku jest pod maską inteligentnym iteratorem, który w każdym obrocie pętli dynamicznie dostarcza kolejną linię tekstu z dysku.
• Taki model działania sprawia, że w pamięci RAM komputera przechowywana jest w danej chwili wyłącznie jedna, aktualnie przetwarzana linia tekstu.
• Rozwiązanie to jest niezwykle optymalne wydajnościowo i pozwala na bezproblemowe przetwarzanie plików o gigantycznych rozmiarach (liczących nawet setki milionów linii) bez ryzyka zawieszenia systemu.

with open("duzy_plik.txt", "r") as f:
    for linia in f:  # Czyta linię po linii bezpośrednio z dysku
        print(linia.upper())
            

• Podczas odczytywania pliku za pomocą metod .readline(), .readlines() lub bezpośredniej pętli for, każda wczytana linia zachowuje na swoim końcu oryginalny niewidoczny znak nowej linii \n.
• Obecność tego znaku sprawia, że standardowe wywołanie print(linia) wyświetli w konsoli tekst przedzielony dodatkową pustą linią (ponieważ print domyślnie dodaje własny koniec linii).
• Aby pozbyć się tego niechcianego białego znaku na końcu stringa, stosuje się metodę .rstrip('\n') lub ogólną metodę .strip().
• Metoda .strip() dodatkowo usuwa wszelkie inne białe znaki, takie jak tabulatory czy spacje na początku i końcu tekstu, co ułatwia czyszczenie danych.

with open("dane.txt", "r") as f:
    for linia in f:
        czysta_linia = linia.rstrip("\r\n")  # Usunięcie znaku nowej linii
        print(czysta_linia)
            

• Aby zapisać dane tekstowe do pliku, otwieramy plik w trybie zapisu 'w' (write) lub dopisywania 'a' (append), a następnie korzystamy z metody .write().
• Metoda ta jako argument przyjmuje wyłącznie ciąg znaków (string) i zapisuje go bezpośrednio do pliku na dysku.
• W przeciwieństwie do funkcji print(), metoda .write() nie dodaje automatycznie znaku nowej linii na końcu zapisanego tekstu – jeśli chcemy przedzielić dane, musimy jawnie dopisać znak \n.
• Ponadto, próba przekazania do .write() wartości innego typu (np. liczby) skończy się błędem TypeError – dane muszą najpierw zostać rzutowane na string za pomocą funkcji str().

with open("raport.txt", "w") as f:
    f.write("Pierwsza linia raportu\n")  # Musimy sami dodać \n
    f.write(f"Wynik: {100}\n")
            

• Jeśli dysponujemy listą lub inną kolekcją stringów i chcemy zapisać je wszystkie na raz do pliku, idealnym narzędziem jest metoda .writelines().
• Metoda ta pobiera dowolną sekwencję tekstów i zapisuje je jeden po drugim do otwartego pliku.
• Bardzo ważnym szczegółem technicznym, o którym należy bezwzględnie pamiętać, jest fakt, że .writelines() również nie dodaje automatycznie znaków nowej linii \n między elementami sekwencji.
• Jeśli nasza lista zawiera teksty bez \n, zostaną one zapisane na dysku jako jeden, długi, ciągły tekst bez przerw.
• Przed zapisem warto więc upewnić się, że elementy listy posiadają odpowiednie znaki końca linii.

linie = ["Linia 1\n", "Linia 2\n", "Linia 3\n"]
with open("notatnik.txt", "w") as f:
    f.writelines(linie)  # Zapis całej listy stringów
            

• Mało znaną, a niezwykle wygodną i elastyczną techniką zapisu danych do pliku w Pythonie jest użycie dobrze znanej funkcji print().
• Funkcja print() posiada specjalny, opcjonalny parametr o nazwie file, który domyślnie jest ustawiony na standardowe wyjście konsoli (sys.stdout).
• Jeśli jako parametr file przekażemy nasz otwarty obiekt pliku tekstowego, np. print(dane, file=f), to cały tekst zamiast w konsoli zostanie zapisany bezpośrednio w pliku na dysku.
• Rozwiązanie to niesie za sobą ogromne zalety: automatycznie wykonuje rzutowanie wszystkich typów danych (np. liczb, list) na napisy oraz samoczynnie dba o dodawanie znaku nowej linii \n.

with open("wyniki.txt", "w") as f:
    # print automatycznie zrzutuje liczbę na str i doda znak nowej linii
    print("Średni wynik:", 84.5, file=f)
            

• Gdy chcemy dodać nowe informacje na koniec istniejącego pliku (np. dopisać kolejne zdarzenie w dzienniku logów systemowych), absolutnie nie możemy użyć trybu 'w'.
• Użycie trybu 'w' spowodowałoby natychmiastowe wyczyszczenie całej dotychczasowej zawartości pliku.
• Rozwiązaniem tego problemu jest otwarcie pliku w trybie dopisywania 'a' (append).
• W trybie 'a' system operacyjny automatycznie ustawia wskaźnik zapisu na samym końcu pliku.
• Wszelkie operacje zapisu za pomocą metod .write() czy print() będą dodawać dane na końcu dokumentu, zachowując wszystkie wcześniej zapisane informacje w nienaruszonym stanie.

with open("historia.txt", "a") as f:
    f.write("Kolejny krok użytkownika\n")  # Zostanie dopisane na końcu
            

• Czasami w logice naszej aplikacji zachodzi potrzeba utworzenia zupełnie nowego pliku z zastrzeżeniem, że plik ten pod żadnym pozorem nie może jeszcze istnieć na dysku.
• Klasyczny tryb zapisu 'w' w przypadku wykrycia istniejącego pliku po prostu go nadpisze, co może doprowadzić do utraty ważnych danych.
• Rozwiązaniem tego problemu jest użycie specjalnego trybu wyłącznego tworzenia 'x' (exclusive creation).
• Jeśli plik o podanej ścieżce nie istnieje, Python bez problemu utworzy go i otworzy do zapisu.
• Jeśli jednak plik już istnieje, interpreter natychmiast zgłosi błąd FileExistsError i przerwie operację, chroniąc przed nadpisaniem.

try:
    with open("wazny_raport.txt", "x") as f:
        f.write("Raport z roku 2026")
except FileExistsError:
    print("Błąd! Plik o tej nazwie już istnieje!")
            

• Komputery nie rozumieją liter bezpośrednio, lecz operują wyłącznie na liczbach binarnych (bajtach).
• Kodowanie znaków (ang. character encoding) to zestaw reguł, który decyduje, jakie liczby odpowiadają poszczególnym literom i znakom specjalnym.
• Najbardziej uniwersalnym, nowoczesnym i powszechnie stosowanym standardem kodowania na świecie jest UTF-8, który potrafi poprawnie zapisać znaki ze wszystkich języków (w tym polskie ogonki: ą, ę, ś, ż itp.).
• Podczas otwierania plików tekstowych w Pythonie niezwykle dobrą praktyką jest jawne ustawianie parametru encoding="utf-8".
• Zapobiega to problemom ze zniekształcaniem polskich znaków (tzw. 'krzaczki') przy uruchamianiu kodu na różnych systemach operacyjnych.

# Jawne zadeklarowanie kodowania UTF-8 gwarantuje poprawność polskich znaków
with open("polskie_znaki.txt", "w", encoding="utf-8") as f:
    f.write("Zażółć gęślą jaźń")
            

• Kiedy plik zostaje otwarty, system operacyjny przechowuje wirtualny kursor, określający bieżącą pozycję odczytu lub zapisu (tzw. wskaźnik pozycji pliku).
• Pozycja ta jest wyrażana w bajtach od początku pliku.
• Do sprawdzenia, na którym bajcie aktualnie znajduje się nasz wskaźnik, służy metoda .tell().
• Z kolei do ręcznego przemieszczenia wskaźnika w inne miejsce pliku używamy metody .seek(offset, whence).
• Przesunięcie wskaźnika za pomocą .seek(0) pozwala na powrót na sam początek pliku, co umożliwia ponowne odczytanie całej zawartości bez konieczności zamykania i ponownego otwierania strumienia.

with open("dane.txt", "r") as f:
    f.read(5)  # Odczyt 5 znaków
    pozycja = f.tell()  # Zwróci pozycję: 5
    f.seek(0)   # Powrót na początek pliku
            

• Zanim spróbujemy otworzyć plik do odczytu, dobrą praktyką mającą na celu zapobieganie nagłemu wywieszeniu się programu jest sprawdzenie, czy dany plik fizycznie istnieje na dysku.
• Python udostępnia do tego celu kilka bardzo wygodnych i bezpiecznych narzędzi.
• Tradycyjnym podejściem jest użycie funkcji os.path.exists() z wbudowanego modułu os.
• Nowocześniejszym, w pełni obiektowym i wysoce zalecanym rozwiązaniem jest skorzystanie z metody .exists() z klasy Path wbudowanego modułu pathlib.
• Narzędzia te zwracają wartość logiczną True lub False, co pozwala na elastyczne sterowanie logiką aplikacji.

from pathlib import Path
plik = Path("ustawienia.json")
if plik.exists():
    print("Wczytuję ustawienia...")
else:
    print("Plik nie istnieje! Tworzę domyślną konfigurację...")
            

• Operacje wejścia-wyjścia na plikach są z natury obarczone bardzo dużym ryzykiem wystąpienia błędów wykonania, które leżą całkowicie poza kontrolą samego kodu programu.
• Plik może zostać usunięty przez innego użytkownika, możemy nie mieć odpowiednich uprawnień systemowych do zapisu w danym folderze lub dysk może być przepełniony.
• Wszelkie tego typu problemy wywołują w Pythonie wyjątki, takie jak FileNotFoundError czy PermissionError.
• Aby uchronić naszą aplikację przed nagłym przerwaniem działania, wszystkie operacje na plikach powinny być zabezpieczone eleganckim blokiem try-except, który w kontrolowany sposób obsłuży ewentualne problemy.

try:
    with open("chroniony.txt", "r") as f:
        dane = f.read()
except FileNotFoundError:
    print("Błąd: Plik nie został odnaleziony na dysku.")
except PermissionError:
    print("Błąd: Brak uprawnień do odczytu tego pliku.")
            

• Wybór między ścieżką względną a bezwzględną ma kolosalne znaczenie dla mobilności i uniwersalności napisanego przez nas programu.
• Ścieżki bezwzględne (np. Z:/_AI_/dane.txt) są sztywne i zadziałają tylko i wyłącznie na komputerze, na którym struktura katalogów jest identyczna.
• Jeśli przekażemy kod koledze lub wdrożymy go na serwerze Linux, program natychmiast zgłosi błąd, ponieważ nie odnajdzie takiego punktu montowania dysku.
• Ścieżki względne (np. dane/raport.txt) budują relację od folderu projektu, dzięki czemu program będzie działał bez żadnych zmian na każdym komputerze, na którym zostanie pobrany i rozpakowany.

# Złe podejście (sztywne):
# open("C:/Users/Kamil/Desktop/projekt/notatka.txt")
# Dobre podejście (mobilne):
with open("notatka.txt", "r") as f:
    tekst = f.read()
            

• Gdy stajemy przed koniecznością przetworzenia plików tekstowych o gigantycznych rozmiarach (np. logów serwera ważących kilkanaście gigabajtów), tradycyjne metody wczytywania jak .read() czy .readlines() natychmiast doprowadzą do przepełnienia pamięci RAM i awarii systemu (ang. Out Of Memory error).
• W takich sytuacjach musimy zastosować technikę przetwarzania strumieniowego (ang. streaming).
• Najprostszym sposobem jest bezpośrednia pętla for linia in f, która pobiera dane partiami, linijka po linijce.
• Innym, bardziej zaawansowanym rozwiązaniem przy plikach binarnych lub bezstrukturalnych jest wczytywanie pliku porcjami o określonym rozmiarze (np. po 4096 bajtów) za pomocą metody .read(rozmiar).

with open("gigantyczny_log.txt", "r") as f:
    # Czytanie porcjami po 4096 znaków
    while True:
        porcja = f.read(4096)
        if not porcja:
            break  # Koniec pliku
        # Przetwarzanie porcji danych
            

• Połączenie menedżera kontekstu with z blokiem obsługi wyjątków try-except stanowi absolutny wzorzec czystego, profesjonalnego i bezpiecznego otwierania plików w Pythonie.
• Dobrą praktyką jest otoczenie całego bloku with strukturą try-except.
• Sprawia to, że program jest w pełni ubezpieczony na wypadek jakichkolwiek problemów przy samym otwieraniu pliku (np. brak pliku na dysku, brak uprawnień) jak i przy ewentualnych błędach podczas przetwarzania danych wewnątrz bloku with.
• Plik zostanie poprawnie i bezpiecznie zamknięty przez menedżer kontekstu, a wszelkie błędy zostaną przechwycone i zalogowane bez awarii całej aplikacji.

try:
    with open("konfiguracja.txt", "r") as f:
        konfig = f.read()
except IOError as e:
    print(f"Błąd wejścia-wyjścia podczas pracy z plikiem: {e}")
            

• Zrozumienie fundamentalnych i szczegółowych różnic w działaniu wskaźnika pliku między trybami 'w' (write) oraz 'a' (append) to klucz do zapobiegania utracie danych.
• W trybie 'w' plik jest otwierany, a jego zawartość jest natychmiast skracana do zera bajtów (czyszczona) – wskaźnik znajduje się na początku pustego dokumentu.
• W trybie 'a' istniejąca zawartość pliku jest w pełni chroniona.
• Co ciekawe, w trybie 'a' system operacyjny wymusza, by każdy kolejny zapis fizycznie odbywał się na samym końcu pliku, niezależnie od tego, czy próbowalibyśmy ręcznie cofnąć wskaźnik za pomocą metody .seek().

# Tryb 'w' czyści wszystko. Tryb 'a' dopisuje na koniec.
with open("logi.txt", "w") as f: f.write("A")  # Plik zawiera "A"
with open("logi.txt", "a") as f: f.write("B")  # Plik zawiera "AB"
            

• Tryb 'x' (wyłączne tworzenie) to doskonałe narzędzie w systemach, w których wiele procesów lub użytkowników może próbować zapisać plik w tym samym czasie.
• Typowym przykładem jest generowanie unikalnych plików logów sesji czy zapisywanie transakcji bankowych.
• Otwarcie pliku w trybie 'x' daje nam 100% pewność, że jeśli procesowi uda się wykonać operację bez błędu, to plik został stworzony od zera przez nas i nikt inny nie nadpisał cudzych danych.
• W przypadku wykrycia, że plik już istnieje, zgłaszany jest wyjątek FileExistsError, co pozwala na natychmiastową reakcję i np. zmianę nazwy generowanego dokumentu.

import random
nazwa = f"sesja_{random.randint(100, 999)}.log"
try:
    with open(nazwa, "x") as f: f.write("Log sesji...")
except FileExistsError:
    print("Wylosowano istniejącą nazwę pliku, spróbuj ponownie!")
            

• Jeśli nie zdefiniujemy jawnie parametru encoding podczas otwierania pliku tekstowego, Python automatycznie użyje domyślnego kodowania systemowego.
• Na systemach Linux i macOS jest to zazwyczaj standard UTF-8, jednak na systemach Windows domyślnym kodowaniem bywa przestarzałe kodowanie Windows-1250 (lub CP1250).
• Taka niespójność prowadzi do bardzo częstych problemów przy przenoszeniu kodu – plik z polskimi znakami zapisany poprawnie na Windowsie otworzy się na Linuxie z błędami kodowania (i odwrotnie).
• Jawne przekazywanie parametru encoding="utf-8" do funkcji open() całkowicie eliminuje te różnice i gwarantuje, że pliki tekstowe będą odczytywane identycznie na każdym systemie operacyjnym na świecie.

# Zły zapis (użyje domyślnego kodowania OS): open("dane.txt", "w")
# Prawidłowy zapis (niezależny od systemu):
with open("dane.txt", "w", encoding="utf-8") as f:
    f.write("Zażółć gęślą jaźń")
            

• Pliki CSV (ang. Comma-Separated Values) to niezwykle popularny format tekstowy służący do przechowywania danych tabelarycznych, w którym kolejne kolumny są oddzielone przecinkami (lub średnikami), a wiersze znakami nowej linii.
• Choć plik CSV można teoretycznie czytać za pomocą zwykłych metod tekstowych i rozbijania wierszy metodą .split(","), to w praktyce jest to bardzo podatne na błędy (np. gdy wewnątrz pola tekstowego również znajduje się przecinek).
• Do poprawnej, profesjonalnej i bezpiecznej pracy z tym formatem Python udostępnia dedykowany, wbudowany moduł csv.
• Funkcja csv.reader(f) automatycznie i bezbłędnie parsuje strukturę wierszy, radząc sobie z cudzysłowami, separatorami i przejściami do nowej linii.

import csv
with open("studenci.csv", "r", encoding="utf-8") as f:
    czytnik = csv.reader(f, delimiter=",")
    for wiersz in czytnik:
        print(wiersz)  # Każdy wiersz to lista wartości, np. ['Jan', 'Kowalski', '23']
            

• Moduł csv oferuje jeszcze wygodniejsze i bardziej zaawansowane narzędzie do odczytu danych tabelarycznych – klasę csv.DictReader.
• Zamiast zwracać każdy wiersz jako zwykłą listę wartości (gdzie musimy pamiętać, pod którym indeksem znajduje się dana kolumna), DictReader automatycznie wczytuje pierwszy wiersz pliku jako nagłówek tabeli.
• Wszystkie kolejne wiersze są zwracane w postaci eleganckich słowników (słowników klucz-wartość), w których kluczami są nazwy kolumn z nagłówka, a wartościami dane z bieżącego wiersza.
• Drastycznie podnosi to czytelność kodu programu, pozwalając na intuicyjny dostęp do danych po nazwach kolumn, np. wiersz["Imię"].

import csv
with open("pracownicy.csv", "r", encoding="utf-8") as f:
    czytnik = csv.DictReader(f)
    for wiersz in czytnik:
        print(f"{wiersz['Imie']} zarabia {wiersz['Pensja']} zł")
            

• JSON (ang. JavaScript Object Notation) to niezwykle lekki, czytelny i obecnie najpopularniejszy na świecie format wymiany danych strukturalnych, powszechnie stosowany w komunikacji sieciowej (API) oraz plikach konfiguracyjnych.
• Struktura formatu JSON idealnie odpowiada zagnieżdżonym typom danych w Pythonie – listom oraz słownikom.
• Do pracy z tym formatem służy wbudowany moduł json.
• Proces wczytywania i zamiany tekstu JSON na pythonowe obiekty (słowniki, listy) nazywamy deserializacją.
• Moduł json udostępnia do tego celu dwie kluczowe funkcje: json.load(f) do czytania danych bezpośrednio z otwartego pliku oraz json.loads(s) do parsowania tekstu zapisanego w zwykłym stringu.

import json
json_str = '{"imie": "Anna", "wiek": 25, "programista": true}'
# Deserializacja ze stringa: json.loads (s - string)
dane = json.loads(json_str)
print(dane["imie"])  # Wyświetli: Anna (typ dict!)
            

• Proces odwrotny do deserializacji, polegający na zamianie pythonowych struktur danych (słowników, list, liczb, wartości logicznych) na tekst w formacie JSON, nazywamy serializacją (lub zrzucaniem danych).
• Wbudowany moduł json udostępnia do tego celu dwie komplementarne funkcje.
• Funkcja json.dump(obj, f) serializuje obiekt Pythona i zapisuje go bezpośrednio do otwartego pliku na dysku.
• Funkcja json.dumps(obj) wykonuje serializację i zwraca wynik w postaci sformatowanego stringa tekstowego, gotowego np. do wysłania siecią.
• Moduł json potrafi automatycznie przekształcać pythonowe typy danych: słowniki na obiekty JSON, listy na tablice JSON, a wartości True/False na true/false.

import json
profil = {"login": "user1", "punkty": 150, "premium": False}
# Serializacja do pliku z pięknym formatowaniem (indent=4)
with open("gracz.json", "w") as f:
    json.dump(profil, f, indent=4)
            

• Tradycyjnie do zarządzania ścieżkami plików, sprawdzania rozszerzeń czy łączenia folderów w Pythonie używano modułu os.path.
• Operuje on jednak wyłącznie na zwykłych stringach, co przy rozbudowanych operacjach prowadzi do powstawania mało czytelnego kodu z mnóstwem zagnieżdżonych funkcji, np. os.path.join(os.path.dirname(...)).
• W nowszych wersjach Pythona wprowadzono nowoczesny, obiektowy moduł pathlib.
• Zamiast stringów, moduł pathlib reprezentuje ścieżki jako interaktywne obiekty klasy Path.
• Umożliwia to wykonywanie zaawansowanych operacji za pomocą intuicyjnych metod i właściwości obiektu, drastycznie podnosząc czytelność i profesjonalizm napisanego kodu.

from pathlib import Path
# Nowoczesne, obiektowe łączenie ścieżek za pomocą operatora /
katalog = Path("Z:/_AI_/projekty")
plik = katalog / "notatka.txt"
print(plik.suffix)  # Pobranie rozszerzenia: .txt
print(plik.name)    # Nazwa pliku: notatka.txt
            

• Zanim przystąpimy do zapisu pliku na dysku, musimy upewnić się, że cały katalog nadrzędny (folder), w którym plik ma się znaleźć, fizycznie istnieje w systemie operacyjnym.
• Próba zapisu pliku w nieistniejącym folderze zakończy się natychmiastowym błędem FileNotFoundError.
• Do automatycznego i bezpiecznego tworzenia katalogów służy funkcja os.makedirs() z wbudowanego modułu os.
• Posiada ona niesamowitą zaletę – potrafi stworzyć całą strukturę zagnieżdżonych podfolderów za jednym razem (np. stworzy folder rok_2026, a w nim podfolder raporty).
• Dodatkowo, ustawienie opcjonalnego parametru exist_ok=True chroni program przed zgłoszeniem błędu, jeśli folder już istnieje.

import os
sciezka_folderu = "kopie/zapasowe/logi"
# Tworzy całą ścieżkę folderów. Jeśli istnieją - nie zgłasza błędu.
os.makedirs(sciezka_folderu, exist_ok=True)
            

• Aby operacje zapisu na dysku były jak najszybsze, systemy operacyjne oraz Python nie zapisują każdej pojedynczej litery bezpośrednio na fizycznym dysku twardym przy każdym wywołaniu metody .write().
• Zamiast tego dane są gromadzone w szybkiej pamięci podręcznej – tzw. buforze zapisu.
• Fizyczny zrzut danych na dysk (ang. flush) następuje automatycznie dopiero w momencie zapełnienia tego bufora lub przy zamknięciu pliku metodą .close().
• Jeśli jednak nasz program działa w trybie ciągłym i chcemy mieć 100% pewność, że zapisane dane są natychmiast bezpiecznie zrzucone na dysk (np. w systemach monitoringu), możemy wymusić tę operację ręcznie za pomocą metody .flush().

with open("ciagly_monitoring.log", "a") as f:
    f.write("Ważne zdarzenie systemowe\n")
    f.flush()  # Dane natychmiast trafiają na dysk fizyczny, omijając buforowanie
            

• Napiszmy kompletny, użyteczny i w pełni bezpieczny program, który realizuje funkcjonalność logowania zdarzeń aplikacji (ang. logger) do pliku tekstowego na dysku.
• Program pobiera komunikaty od użytkownika, a następnie dopisuje je na koniec pliku dziennik.log w trybie 'a'.
• Kluczowym elementem profesjonalnego logowania jest automatyczne dołączanie dokładnej daty i godziny każdego wpisu – w tym celu korzystamy z wbudowanego modułu datetime.
• Całość operacji jest zabezpieczona blokiem try-except, dzięki czemu ewentualne problemy z dyskiem nie spowodują przerwania pracy głównej aplikacji, co jest krytycznym wymogiem stabilności systemów IT.

import datetime

def zapisz_log(komunikat):
    try:
        teraz = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        with open("dziennik.log", "a", encoding="utf-8") as f:
            f.write(f"[{teraz}] {komunikat}\n")
    except IOError:
        print("Błąd zapisu logu na dysk!")

zapisz_log("Uruchomienie systemu")
            

• Przyjrzyjmy się kompletnemu programowi, który generuje profesjonalny raport sprzedaży i zapisuje go w formacie CSV gotowym do otwarcia w arkuszach kalkulacyjnych, takich jak Microsoft Excel czy Google Sheets.
• Dane wejściowe to lista słowników reprezentujących poszczególne produkty z ich cenami netto.
• Program otwiera plik raport_sprzedazy.csv i korzysta z klasy csv.writer, która precyzyjnie dba o prawidłowe zapisywanie wartości oddzielonych przecinkami.
• Program automatycznie wylicza stawkę podatku VAT (23%) oraz kwotę brutto dla każdego produktu, a następnie zapisuje elegancko sformatowany wiersz nagłówkowy oraz wiersze danych bezpośrednio na dysk.

import csv
produkty = [{"nazwa": "Laptop", "netto": 3000}, {"nazwa": "Mysz", "netto": 100}]
with open("raport.csv", "w", newline="", encoding="utf-8") as f:
    pisarz = csv.writer(f)
    pisarz.writerow(["Nazwa", "Cena Netto", "VAT (23%)", "Cena Brutto"])
    for p in produkty:
        vat = p["netto"] * 0.23
        brutto = p["netto"] + vat
        pisarz.writerow([p["nazwa"], p["netto"], vat, brutto])
            

• Przeanalizujmy w pełni funkcjonalny program realizujący funkcjonalność zapisu i odczytu aktualnego stanu gry (np. postępu gracza, salda punktów i zebranego ekwipunku) w formacie JSON na dysk.
• Zapisywanie takich danych strukturalnych jako zwykły tekst byłoby koszmarem programistycznym – wymagałoby ręcznego parsowania każdego pola.
• Zastosowanie modułu json rozwiązuje ten problem całkowicie.
• Program definiuje słownik reprezentujący profil gracza, a następnie serializuje gałąź profilu bezpośrednio do pliku zapis_gry.json w czytelnej formie z wcięciami.
• Dodatkowo program zawiera funkcję odczytu, która w ułamku sekundy wczytuje stan gry z dysku i odtwarza w pełni funkcjonalną strukturę słownika w pamięci Pythona.

import json

def zapisz_stan(stan, plik="stan.json"):
    with open(plik, "w") as f: json.dump(stan, f, indent=4)

def wczytaj_stan(plik="stan.json"):
    try:
        with open(plik, "r") as f:
            return json.load(f)
    except FileNotFoundError:
        return {"poziom": 1, "zloto": 0}  # Domyślny stan początkowy
            

• Podczas zapisywania plików CSV przy użyciu modułu csv na systemach operacyjnych Windows, bardzo częstym i irytującym problemem jest powstawanie pustych linii (pustych wierszy) przedzielających każdy wiersz danych w arkuszu.
• Problem ten wynika z faktu, że moduł csv posiada własny, wewnętrzny mechanizm kontroli znaków końca linii, podczas gdy funkcja open() pod systemem Windows automatycznie dokonuje dodatkowej konwersji znaków końca linii na styl Windowsowy (\r\n).
• Aby całkowicie zapobiec temu zjawisku i zagwarantować stuprocentową poprawność zapisu, należy przy otwieraniu pliku do zapisu CSV bezwzględnie przekazywać parametr newline="".
• Informuje to funkcję open(), by nie ingerowała w znaki końca linii przekazywane przez moduł csv.

# Zawsze otwieraj plik do zapisu CSV z parametrem newline=""
with open("dane.csv", "w", newline="", encoding="utf-8") as f:
    pisarz = csv.writer(f)
    pisarz.writerow(["A", "B"])  # Zapisuje bez pustych wierszy
            

• Przejdźmy do serii praktycznych ćwiczeń programistycznych, które pozwolą utrwalić całą zdobytą wiedzę w praktyce.
• Pierwsze zadanie polega na napisaniu programu, który w bezpieczny sposób (korzystając z menedżera kontekstu with oraz obsługi wyjątków try-except) otworzy plik tekstowy o nazwie artykul.txt i wyświetli jego zawartość w konsoli.
• Program musi dodatkowo oczyścić każdą wczytaną linię ze znaków nowej linii \n oraz białych znaków za pomocą metody .strip().
• W przypadku braku pliku na dysku, aplikacja zamiast zgłoszenia awarii powinna poinformować użytkownika o braku dokumentu przyjaznym komunikatem w konsoli.

try:
    with open("artykul.txt", "r", encoding="utf-8") as f:
        for linia in f:
            print(linia.strip())  # Oczyszczenie i wyświetlenie linii
except FileNotFoundError:
    print("Błąd! Nie znaleziono pliku artykul.txt!")
            

• Drugie ćwiczenie to stworzenie interaktywnego, konsolowego notatnika.
• Program ma działać w pętli while True, umożliwiając użytkownikowi wprowadzanie z klawiatury kolejnych notatek tekstowych.
• Każda wprowadzona notatka powinna być natychmiast dopisywana na koniec pliku notatki.txt za pomocą trybu 'a'.
• Wpisanie przez użytkownika słowa kluczowego "koniec" powinno przerwać pętlę i zakończyć działanie aplikacji.
• Program musi precyzyjnie dbać o dodawanie znaku nowej linii \n po każdym wpisie, tak aby kolejne notatki były zapisywane w pliku w osobnych wierszach, tworząc uporządkowany dziennik.

with open("notatki.txt", "a", encoding="utf-8") as f:
    while True:
        wpis = input("Wpisz notatkę (lub 'koniec'): ")
        if wpis.lower() == "koniec":
            break
        f.write(wpis + "\n")  # Zapis z jawnym nowym wierszem
            

• Trzecie zadanie ćwiczeniowe polega na napisaniu programu, który wykonuje kopię zapasową wskazanego pliku tekstowego.
• Program powinien otworzyć oryginalny plik (np. dane.txt) w trybie odczytu 'r', a plik docelowy (np. kopia_dane.txt) w trybie zapisu 'w'.
• Aby program był maksymalnie wydajny i potrafił skopiować nawet bardzo duże pliki, proces kopiowania powinien odbywać się strumieniowo – linia po linii, za pomocą pętli for.
• Taka konstrukcja gwarantuje minimalne zużycie pamięci RAM, kopiując dane na bieżąco.
• Dodatkowo program powinien zliczać i na koniec wyświetlić informację, ile linii tekstu zostało pomyślnie skopiowanych.

try:
    licznik = 0
    with open("dane.txt", "r") as f_in, open("kopia.txt", "w") as f_out:
        for linia in f_in:
            f_out.write(linia)  # Kopiowanie linii
            licznik += 1
    print(f"Skopiowano pomyślnie {licznik} linii.")
except FileNotFoundError:
    print("Plik źródłowy nie istnieje!")
            

• Czwarte ćwiczenie ma na celu stworzenie prostego programu do analizy statystycznej tekstu (analogicznie do polecenia wc w systemie Linux).
• Program powinien otworzyć wskazany plik tekstowy i przeanalizować całą jego zawartość.
• Zadaniem aplikacji jest obliczenie trzech kluczowych wartości: łącznej liczby linii w pliku, łącznej liczby słów (wyrazów przedzielonych spacjami) oraz łącznej liczby wszystkich pojedynczych znaków (wliczając w to spacje i znaki specjalne).
• Program powinien wyświetlić wyniki w postaci eleganckiego podsumowania w konsoli.
• Do podziału linii na wyrazy warto wykorzystać wbudowaną metodę .split().

with open("tekst.txt", "r", encoding="utf-8") as f:
    linie = f.readlines()  # Lista wszystkich linii

ile_linii = len(linie)
ile_slow = sum(len(linia.split()) for linia in linie)
ile_znakow = sum(len(linia) for linia in linie)

print(f"Linie: {ile_linii}, Słowa: {ile_slow}, Znaki: {ile_znakow}")
            

• Piąte, najbardziej zaawansowane ćwiczenie to stworzenie kompletnego systemu rejestracji błędów (ang. crash logger).
• Program powinien symulować działanie aplikacji i w przypadku wystąpienia awarii (lub na żądanie użytkownika) generować szczegółowy wpis diagnostyczny w pliku zdarzenia.log.
• Wpis ten musi zawierać: unikalny identyfikator błędu, dokładną datę i godzinę zdarzenia, kategorię błędu (np. CRITICAL, WARNING) oraz opis problemu.
• Zapis musi być realizowany w trybie dopisywania 'a'.
• Dodatkowo, program powinien raz na dobę automatycznie tworzyć kopię zapasową pliku logów, jeśli jego rozmiar przekroczy określoną granicę (np. 1 megabajt).

import datetime, os

def rejestruj_blad(kategoria, opis):
    teraz = datetime.datetime.now().strftime("%d.%m.%Y %H:%M")
    linia_logu = f"[{teraz}] {kategoria.upper()}: {opis}\n"
    with open("zdarzenia.log", "a", encoding="utf-8") as f:
        f.write(linia_logu)

rejestruj_blad("error", "Połączenie z bazą danych zostało zerwane!")
            

• Chociaż do obsługi plików CSV zaleca się stosowanie wbudowanego modułu csv, warto dogłębnie zrozumieć, jak ten format działa 'pod maską' na poziomie czystego tekstu.
• W najprostszej postaci plik CSV to zwykły plik tekstowy, w którym kolejne kolumny są rozdzielone przecinkiem, średnikiem lub tabulatorem.
• Możemy odczytać taki plik za pomocą pętli for linia in f, a następnie rozbić każdy wiersz na poszczególne pola tekstowe za pomocą wbudowanej metody .split(",").
• Należy jednak pamiętać, że ta uproszczona metoda zawiedzie, gdy wewnątrz komórki znajdzie się separator ujęty w cudzysłów (np. "Kowalski, Jan").
• Dlatego w poważnych projektach zawsze należy zastępować to podejście modułem csv.

with open("dane.csv", "r") as f:
    for linia in f:
        pola = linia.strip().split(",")  # Ręczny podział wiersza
        print(f"Nazwisko: {pola[0]}, Wiek: {pola[1]}")
            

• Aby zagwarantować pełną zgodność z oficjalnym standardem RFC 4180 i bezbłędnie przetwarzać pliki CSV o dowolnym stopniu skomplikowania, musimy bezwzględnie korzystać z wbudowanego modułu csv.
• Klasa csv.reader pozwala na bezpieczne wczytywanie danych w postaci list wartości, automatycznie ignorując separatory umieszczone wewnątrz cudzysłowów.
• Klasa csv.writer udostępnia metody takie jak .writerow() do wygodnego i poprawnego zapisywania całych wierszy danych w jednym kroku.
• Z kolei klasa csv.DictReader automatycznie mapuje wiersze na wygodne w użyciu słowniki.
• Narzędzia te stanowią kompletny i niezawodny pakiet do obsługi danych tabelarycznych w języku Python.

import csv
# Zapisywanie danych do pliku CSV z automatycznym maskowaniem znaków
with open("eksport.csv", "w", newline="") as f:
    pisarz = csv.writer(f)
    pisarz.writerow(["Jan Kowalski", "Warszawa, ul. Cicha 5"])
            

• Format JSON to obecnie de facto standard w świecie tworzenia aplikacji webowych, mobilnych oraz chmurowych.
• Python dzięki wbudowanemu modułowi json oferuje niesamowicie łatwą i kompletną integrację z tym standardem.
• Funkcja json.dump(obj, f) pozwala na bezpośrednie zapisanie dowolnego słownika lub listy na dysk w formacie JSON, a json.load(f) wczytuje te dane i odtwarza ich strukturę w ułamku sekundy.
• JSON doskonale radzi sobie z zagnieżdżonymi strukturami – słownik może zawierać inne słowniki, listy czy liczby, a parser bez problemu zachowa tę hierarchię.
• Jest to kluczowe przy przechowywaniu złożonych konfiguracji systemowych czy stanów aplikacji.

import json
konfig = {"port": 8080, "debug": True, "baza": ["localhost", "db"]}
# Zapisujemy skomplikowaną strukturę zagnieżdżoną na dysk
with open("config.json", "w") as f: json.dump(konfig, f, indent=2)
            

• Podsumowując naukę pracy z plikami, warto zestawić najważniejsze profesjonalne zalecenia oraz wyeliminować typowe złe nawyki początkujących programistów.
• Do dobrych praktyk bezwzględnie zaliczamy: zawsze stosuj menedżer kontekstu with, zawsze jawnie definiuj kodowanie encoding="utf-8", stosuj ścieżki względne zamiast bezwzględnych oraz zabezpieczaj operacje dyskowe blokiem try-except.
• Do złych nawyków, które należy jak najszybciej wykorzenić, należą: ręczne otwieranie i zamykanie plików za pomocą open i close (podatne na wycieki przy błędach), wczytywanie olbrzymich plików na raz metodą .read(), oraz ignorowanie wyjątków wejścia-wyjścia.

• W części 11 opanowaliśmy niezwykle ważny obszar programowania w Pythonie, jakim jest trwała obsługa plików na dysku fizycznym komputera.
• Dopełniliśmy fundamenty wiedzy, ucząc się bezpiecznego otwierania strumieni za pomocą funkcji open() i automatycznego ich zamykania poprzez menedżer kontekstu with.
• Poznaliśmy podstawowe metody odczytu (read, readline, readlines) oraz zapisu (write, writelines, print).
• Nauczyliśmy się precyzyjnie operować na najpopularniejszych w branży IT formatach wymiany danych – ustrukturyzowanych tabelach CSV oraz zagnieżdżonych strukturach JSON.
• Dodatkowo poznaliśmy nowoczesny moduł pathlib do bezpiecznej obsługi ścieżek niezależnie od używanego systemu operacyjnego.

• W kolejnej, finałowej części naszego kursu (Część 12) zrobimy olbrzymi krok w stronę profesjonalnej inżynierii oprogramowania.
• Dowiemy się, jak dzielić nasz kod na wiele osobnych plików, czyli tworzyć i importować własne moduły oraz pakiety.
• Poznamy potęgę menedżera pakietów pip oraz nauczymy się pobierać niesamowite biblioteki zewnętrzne z repozytorium PyPI.
• Na koniec opanujemy kluczowe narzędzie każdego profesjonalnego programisty Python – izolowane środowiska wirtualne venv, które pozwalają na bezkonkurencyjne zarządzanie zależnościami projektów.

# W części 12 poznamy m.in.:
# - Tworzenie własnych modułów i pakietów
# - Zastosowanie instrukcji import, from ... import, import ... as
# - Pracę z pip oraz wirtualnymi środowiskami venv