Automatyzacja zadań w Pythonie - Praktyczne przykłady

Za pomocą Pythona możesz automatycznie porządkować pliki, pobierać dane ze stron, przetwarzać arkusze Excel, uruchamiać polecenia systemowe, wysyłać raporty, cyklicznie wykonywać zadania albo sterować przeglądarką. W praktyce oznacza to mniej powtarzalnego klikania i więcej czasu na zadania, które wymagają realnej decyzji.

W tym artykule znajdziesz praktyczne przykłady automatyzacji zadań w Pythonie z użyciem bibliotek os, shutil, subprocess, requests, BeautifulSoup, pandas, Selenium oraz schedule.

Do czego przydaje się automatyzacja zadań w Pythonie?

Automatyzacja w Pythonie sprawdza się wszędzie tam, gdzie regularnie wykonujesz ten sam zestaw czynności. Może to być pobieranie plików, zmiana nazw dokumentów, kopiowanie danych między folderami, sprawdzanie statusu strony, generowanie raportów lub przetwarzanie danych z Excela.

Najczęstsze przykłady zastosowań to:

• porządkowanie plików w katalogach,
• automatyczne kopiowanie i archiwizacja dokumentów,
• pobieranie danych ze stron internetowych,
• analiza plików CSV i Excel,
• uruchamianie poleceń systemowych,
• cykliczne wykonywanie raportów,
• automatyczne testowanie formularzy w przeglądarce,
• monitorowanie stron i usług,
• łączenie kilku prostych zadań w jeden skrypt.

Python jest szczególnie wygodny, gdy chcesz szybko napisać skrypt, który rozwiązuje konkretny problem bez budowania dużej aplikacji.

Automatyzacja plików z użyciem os i shutil

Biblioteki os i shutil służą do pracy z plikami oraz katalogami. Dzięki nim możesz tworzyć foldery, kopiować pliki, przenosić dokumenty, sprawdzać zawartość katalogów i automatycznie organizować dane na dysku.

Przykład: automatyczne przenoszenie plików do folderów według rozszerzenia.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import os
import shutil
from pathlib import Path

def organize_files(source_folder: str):
    source_path = Path(source_folder)

    if not source_path.exists():
        raise FileNotFoundError(f"Folder nie istnieje: {source_folder}")

    for file_path in source_path.iterdir():
        if file_path.is_file():
            extension = file_path.suffix.lower().replace(".", "")

            if not extension:
                extension = "bez_rozszerzenia"

            target_folder = source_path / extension
            target_folder.mkdir(exist_ok=True)

            shutil.move(str(file_path), str(target_folder / file_path.name))
            print(f"Przeniesiono: {file_path.name} -> {target_folder}")

organize_files("pobrane_pliki")

Taki skrypt może uporządkować katalog z pobranymi plikami, fakturami, raportami lub zdjęciami. Zamiast ręcznie przenosić dokumenty, wystarczy uruchomić jeden skrypt.

Tworzenie kopii zapasowej plików

Automatyzacja zadań w Pythonie często dotyczy backupu. Możesz przygotować prosty skrypt, który kopiuje wybrane pliki do katalogu archiwum.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import shutil
from pathlib import Path
from datetime import datetime

def create_backup(source_folder: str, backup_folder: str):
    source = Path(source_folder)
    backup = Path(backup_folder)

    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    target = backup / f"backup_{timestamp}"

    shutil.copytree(source, target)
    print(f"Utworzono kopię zapasową: {target}")

create_backup("dokumenty", "backupy")

To dobry punkt wyjścia do automatycznego zabezpieczania ważnych plików. Skrypt można później połączyć z harmonogramem, aby wykonywał się codziennie lub raz w tygodniu.

Skrypty automatyzujące z subprocess

Moduł subprocess pozwala uruchamiać polecenia systemowe bezpośrednio z poziomu Pythona. Jest przydatny, gdy chcesz połączyć logikę skryptu z narzędziami CLI, systemem operacyjnym albo procesami deploymentu.

Przykład uruchomienia polecenia i odczytania wyniku:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import subprocess

result = subprocess.run(
    ["python", "--version"],
    capture_output=True,
    text=True
)

if result.returncode == 0:
    print("Wynik polecenia:")
    print(result.stdout)
else:
    print("Błąd:")
    print(result.stderr)

W praktyce subprocess może służyć do uruchamiania testów, kompresowania plików, wywoływania narzędzi systemowych, startowania procesów lub sprawdzania konfiguracji środowiska.

Przykład uruchomienia testów w projekcie:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import subprocess

def run_tests():
    result = subprocess.run(
        ["pytest"],
        capture_output=True,
        text=True
    )

    print(result.stdout)

    if result.returncode != 0:
        print("Testy zakończyły się błędem.")
        print(result.stderr)
        return False

    print("Testy zakończone sukcesem.")
    return True

run_tests()

To prosty sposób na automatyzację powtarzalnych zadań programistycznych.

Web scraping z requests i BeautifulSoup

Biblioteki requests i BeautifulSoup pozwalają pobierać oraz analizować zawartość stron internetowych. To przydatne, gdy chcesz automatycznie zebrać linki, tytuły artykułów, ceny produktów, informacje kontaktowe lub dane do dalszej analizy.

Przykład pobierania wszystkich linków ze strony:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import requests
from bs4 import BeautifulSoup

def get_links(url: str):
    response = requests.get(url, timeout=10)
    response.raise_for_status()

    soup = BeautifulSoup(response.text, "html.parser")
    links = []

    for link in soup.find_all("a"):
        href = link.get("href")

        if href:
            links.append(href)

    return links

links = get_links("https://www.example.com")

for link in links:
    print(link)

Web scraping warto stosować odpowiedzialnie. Przed pobieraniem danych sprawdź regulamin strony, plik robots.txt i nie wysyłaj zbyt wielu zapytań w krótkim czasie.

Automatyczne przetwarzanie danych z pandas

Biblioteka pandas jest jednym z najważniejszych narzędzi do pracy z danymi w Pythonie. Pozwala automatycznie czytać pliki CSV i Excel, filtrować dane, tworzyć raporty oraz zapisywać wyniki do nowych plików.

Przykład: filtrowanie zamówień powyżej określonej kwoty.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pandas as pd

def filter_orders(input_file: str, output_file: str, min_value: float):
    df = pd.read_csv(input_file)

    filtered = df[df["wartosc_zamowienia"] >= min_value]

    filtered.to_csv(output_file, index=False)
    print(f"Zapisano raport: {output_file}")

filter_orders(
    input_file="zamowienia.csv",
    output_file="zamowienia_powyzej_1000.csv",
    min_value=1000
)

Taki skrypt może zastąpić ręczne filtrowanie danych w Excelu. Możesz go rozbudować o grupowanie, sortowanie, generowanie podsumowań i wysyłkę raportu.

Przykład prostego raportu sprzedaży:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
import pandas as pd

df = pd.read_excel("sprzedaz.xlsx")

report = df.groupby("kategoria")["wartosc"].sum().reset_index()
report = report.sort_values("wartosc", ascending=False)

report.to_excel("raport_sprzedazy.xlsx", index=False)

print("Raport został wygenerowany.")

To jeden z najczęstszych scenariuszy automatyzacji w pracy biurowej, analitycznej i biznesowej.

Automatyzacja przeglądarki z Selenium

Selenium pozwala sterować przeglądarką z poziomu Pythona. Przydaje się wtedy, gdy zwykłe requests nie wystarcza, bo strona wymaga logowania, obsługuje JavaScript albo wymaga kliknięcia w elementy interfejsu.

Przykład otwarcia strony i pobrania tytułu:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()

try:
    driver.get("https://www.example.com")

    title = driver.title
    print(f"Tytuł strony: {title}")

    links = driver.find_elements(By.TAG_NAME, "a")

    for link in links:
        print(link.get_attribute("href"))

finally:
    driver.quit()

Selenium jest często używane do testowania aplikacji webowych, automatycznego wypełniania formularzy oraz pobierania danych ze stron dynamicznych. Trzeba jednak pamiętać, że automatyzacja przeglądarki jest wolniejsza niż pobieranie danych przez API lub requests.

Harmonogramowanie zadań z schedule

Biblioteka schedule pozwala uruchamiać zadania cyklicznie, np. co 10 minut, codziennie o 8:00 albo raz w tygodniu. To proste rozwiązanie do lokalnych automatyzacji.

Przykład zadania wykonywanego co 10 sekund:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
import schedule
import time

def job():
    print("Zadanie zostało wykonane.")

schedule.every(10).seconds.do(job)

while True:
    schedule.run_pending()
    time.sleep(1)

Przykład codziennego raportu:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
import schedule
import time
from datetime import datetime

def generate_daily_report():
    print(f"Generuję raport: {datetime.now()}")

schedule.every().day.at("08:00").do(generate_daily_report)

while True:
    schedule.run_pending()
    time.sleep(30)

schedule dobrze sprawdza się w prostych skryptach. W bardziej zaawansowanych projektach można użyć narzędzi systemowych, takich jak cron w Linuxie, Harmonogram zadań w Windows albo kolejki zadań, np. Celery.

Łączenie kilku zadań w jeden proces

Największa wartość automatyzacji pojawia się wtedy, gdy łączysz kilka małych czynności w jeden przepływ pracy. Przykład: pobierz dane, przetwórz je, zapisz raport i utwórz kopię zapasową.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import pandas as pd
import shutil
from pathlib import Path
from datetime import datetime

def generate_report():
    df = pd.read_csv("zamowienia.csv")
    report = df.groupby("status")["id"].count().reset_index()
    report.columns = ["status", "liczba_zamowien"]

    output_file = "raport_statusow.csv"
    report.to_csv(output_file, index=False)

    return output_file

def backup_file(file_path: str):
    backup_dir = Path("backupy")
    backup_dir.mkdir(exist_ok=True)

    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    target = backup_dir / f"{timestamp}_{Path(file_path).name}"

    shutil.copy(file_path, target)
    print(f"Utworzono backup: {target}")

report_file = generate_report()
backup_file(report_file)

print("Proces automatyzacji zakończony.")

Taki schemat możesz dostosować do własnych potrzeb. Zamiast danych sprzedażowych możesz przetwarzać leady, faktury, pliki produktowe, logi systemowe albo dane z formularzy.

Dobre praktyki przy automatyzacji zadań w Pythonie

Dobry skrypt automatyzujący powinien być nie tylko skuteczny, ale też bezpieczny i łatwy do utrzymania. Warto od początku stosować kilka prostych zasad:

• zapisuj konfigurację poza kodem,
• używaj czytelnych nazw funkcji i zmiennych,
• dodawaj obsługę błędów,
• loguj ważne zdarzenia,
• sprawdzaj, czy pliki i foldery istnieją,
• nie nadpisuj ważnych danych bez kopii zapasowej,
• testuj skrypt na małej próbce danych,
• dziel większy proces na małe funkcje,
• nie wysyłaj zbyt wielu zapytań do stron i API,
• dokumentuj sposób uruchamiania skryptu.

Dzięki temu automatyzacja będzie mniej podatna na błędy i łatwiejsza do rozbudowy.

Zobacz też

• Asynchroniczność w Pythonie - wprowadzenie do asyncio
• List Comprehension w Pythonie - praktyczne przykłady
• Testowanie jednostkowe w Pythonie - wprowadzenie do unittest

Podsumowanie

Automatyzacja zadań w Pythonie to praktyczny sposób na oszczędność czasu i ograniczenie powtarzalnej pracy. Za pomocą prostych skryptów możesz porządkować pliki, tworzyć backupy, uruchamiać polecenia systemowe, pobierać dane ze stron, przetwarzać arkusze i wykonywać zadania według harmonogramu.

Najważniejsze biblioteki na start to os, shutil, pathlib, subprocess, requests, BeautifulSoup, pandas, Selenium i schedule. Nie musisz znać ich wszystkich od razu. Wystarczy, że zaczniesz od jednego powtarzalnego zadania i stopniowo rozbudujesz skrypt.

Jeśli chcesz nauczyć się automatyzacji praktycznie, wybierz jedno zadanie z codziennej pracy, opisz jego kroki i spróbuj zamienić je na funkcje w Pythonie. To najprostszy sposób, aby przejść od nauki składni do narzędzi, które realnie pomagają w pracy.