Python - podstawy

Python jest dobrym językiem do automatyzacji, narzędzi CLI, backendu, testów i pracy z danymi. W praktyce ważniejsze od zapamiętywania wersji jest poprawne używanie środowisk wirtualnych, jawnych zależności i dokumentacji projektu.

Powiązane tematy: API i integracje systemów, JSON, YAML, TOML i XML, SQL i PostgreSQL dla developera, Testowanie oprogramowania oraz Programowanie w shellu.

1. Czym jest Python

Python to język programowania wysokiego poziomu, zaprojektowany tak, aby kod był możliwie czytelny.

Najważniejsze cechy:

prosta składnia,
dynamiczne typowanie,
automatyczne zarządzanie pamięcią,
ogromna liczba bibliotek,
działa na Linuxie, FreeBSD, macOS i Windows,
często używany do:
automatyzacji,
skryptów,
backendu,
analizy danych,
AI/ML,
administracji systemami,
testów,
narzędzi CLI.

Python jest językiem interpretowanym w praktycznym znaczeniu: zwykle uruchamiasz kod bez ręcznego etapu kompilacji do programu wykonywalnego.

Najpopularniejsza implementacja to CPython.

2. Jak działa Python

Typowy plik Pythona:

print("Hello world")

zapisujesz jako:

hello.py

i uruchamiasz:

python3 hello.py

Python:

czyta kod,
analizuje składnię,
kompiluje kod do wewnętrznego bytecode,
wykonuje go w maszynie wirtualnej Pythona.

Bytecode może być zapisywany w katalogach:

__pycache__/

z plikami podobnymi do:

module.cpython-313.pyc

Nie jest to samodzielny program jak binarka C czy Go.

3. Python 2 a Python 3

Obecnie używa się Pythona 3.

Sprawdzenie:

python3 --version

lub czasami:

python --version

Na Linuxie polecenie:

python

nie zawsze istnieje.

Dlatego bezpieczniej używać:

python3

4. Instalacja

Debian / Ubuntu

sudo apt update
sudo apt install python3

Przydatne dodatkowe pakiety:

sudo apt install python3-pip python3-venv

Sprawdzenie:

python3 --version
pip3 --version

FreeBSD

pkg install python3

Lista dostępnych wersji:

pkg search python3

Przykładowo system może zainstalować:

python311
python312
python313

Windows

Python można zainstalować z:

python.org

Podczas instalacji warto zaznaczyć:

Add Python to PATH

Uruchamianie:

python --version

lub:

py --version

Windows posiada także launcher:

py

Przykład:

py script.py

5. Interpreter interaktywny

Uruchom:

python3

Dostaniesz prompt:

>>>

Możesz wpisywać kod bez tworzenia pliku:

>>> 2 + 2
4

>>> print("hello")
hello

Wyjście:

exit()

albo:

Ctrl+D

na Linux/Unix.

Interpreter świetnie nadaje się do:

testowania składni,
sprawdzania bibliotek,
prostych obliczeń,
eksperymentów.

6. Uruchamianie pliku

Plik:

app.py

Uruchomienie:

python3 app.py

Można przekazać argumenty:

python3 app.py test.txt --verbose

7. Python jako wykonywalny skrypt

Na Linuxie / FreeBSD można dodać na początku:

#!/usr/bin/env python3

Przykład:

#!/usr/bin/env python3

print("Hello")

Nadaj prawa:

chmod +x script.py

Uruchom:

./script.py

8. Wcięcia są częścią składni

W Pythonie nie używa się klamer jak w C, Go czy JavaScript.

Zamiast:

if (x > 5) {
    console.log(x);
}

Python:

if x > 5:
    print(x)

Kod należący do bloku musi mieć wcięcie.

Najczęściej:

4 spacje

Przykład błędny:

if x > 5:
print(x)

Python zgłosi:

IndentationError

Nie mieszaj tabulatorów i spacji.

9. Komentarze

Komentarz jednoliniowy:

# komentarz

Przykład:

x = 10  # liczba użytkowników

Docstring:

def hello():
    """Wyświetla powitanie."""
    print("Hello")

Docstringi są używane do dokumentowania:

funkcji,
klas,
modułów.

10. Zmienne

Nie trzeba deklarować typu.

name = "Anna"
age = 46
price = 19.99
active = True

Typ może się zmienić:

x = 10
x = "hello"

To jest poprawne.

Python jest:

dynamicznie typowany

ale jednocześnie:

silnie typowany

Przykład:

"5" + 5

spowoduje błąd.

Trzeba zrobić:

int("5") + 5

11. Nazwy zmiennych

Typowy styl:

user_name = "Anna"
max_connections = 100

Stałe umownie:

MAX_CONNECTIONS = 100
API_URL = "https://example.com"

Nazwy klas:

class UserAccount:
    pass

Standard stylu Pythona opisuje dokument:

PEP 8

12. Podstawowe typy danych

int

Liczby całkowite:

x = 10
y = -5

float

price = 19.99

str

Tekst:

name = "Anna"

lub:

name = 'Anna'

bool

True
False

None

Brak wartości:

result = None

Odpowiednik w pewnym sensie:

null
nil

z innych języków.

13. Sprawdzanie typu

x = 10

print(type(x))

wynik:

<class 'int'>

Sprawdzanie typu:

isinstance(x, int)

14. Konwersje typów

int("123")
float("12.5")
str(100)
bool(1)

Przykład:

age = int(input("Podaj wiek: "))

15. Operatory matematyczne

a + b
a - b
a * b
a / b

Dzielenie całkowite:

10 // 3

wynik:

Reszta:

10 % 3

wynik:

Potęga:

2 ** 8

wynik:

16. Porównania

x == y
x != y
x > y
x < y
x >= y
x <= y

UWAGA:

to przypisanie.

==

to porównanie.

17. Operatory logiczne

and
or
not

Przykład:

if age >= 18 and active:
    print("OK")

18. Łańcuchy tekstowe

text = "Hello world"

Długość:

len(text)

Zmiana wielkości liter:

text.upper()
text.lower()

Usuwanie białych znaków:

text.strip()

Zamiana:

text.replace("world", "Python")

Podział:

text.split(" ")

Sprawdzenie:

"world" in text

19. f-string

Najwygodniejszy sposób składania tekstu:

name = "Anna"
age = 46

print(f"{name} ma {age} lat")

Można umieszczać wyrażenia:

print(f"2 + 2 = {2 + 2}")

Formatowanie liczb:

price = 12.3456

print(f"{price:.2f}")

wynik:

12.35

20. Dostęp do znaków tekstu

text = "Python"

Pierwszy znak:

text[0]

wynik:

Ostatni:

text[-1]

wynik:

Fragment:

text[0:3]

wynik:

Pyt

21. Listy

Lista:

users = ["Anna", "Anna", "Piotr"]

Dostęp:

users[0]

Dodawanie:

users.append("Jan")

Usuwanie:

users.remove("Anna")

Liczba elementów:

len(users)

Iteracja:

for user in users:
    print(user)

22. Tuple

Tuple jest podobne do listy, ale jest niemodyfikowalne.

point = (10, 20)

Dostęp:

point[0]

Tuple często reprezentują:

współrzędne,
pary wartości,
wyniki funkcji.

23. Słownik - dict

Bardzo ważny typ.

user = {
    "name": "Anna",
    "age": 46,
    "admin": True
}

Dostęp:

user["name"]

Bezpieczniejsze:

user.get("name")

Można podać wartość domyślną:

user.get("email", "brak")

Dodanie:

user["email"] = "user@example.com"

Iteracja:

for key, value in user.items():
    print(key, value)

24. Set

Zbiór unikalnych elementów:

numbers = {1, 2, 3}

Dodanie:

numbers.add(4)

Set automatycznie usuwa duplikaty.

{1, 1, 2, 2, 3}

da:

{1, 2, 3}

25. if / elif / else

age = 20

if age >= 18:
    print("dorosły")
else:
    print("niepełnoletni")

Kilka warunków:

if score >= 90:
    print("A")
elif score >= 75:
    print("B")
else:
    print("C")

26. Wartości traktowane jako False

Python traktuje jako fałsz między innymi:

False
None
0
0.0
""
[]
{}
set()

Dlatego często spotkasz:

if users:
    print("Lista nie jest pusta")

zamiast:

if len(users) > 0:

27. Pętla for

for x in [1, 2, 3]:
    print(x)

Range:

for i in range(5):
    print(i)

wynik:

Zakres:

range(1, 5)

wynik odpowiada:

1 2 3 4

Krok:

range(0, 10, 2)

28. enumerate

Gdy potrzebujesz indeksu:

users = ["Anna", "Anna", "Jan"]

for index, user in enumerate(users):
    print(index, user)

29. zip

Łączenie kilku kolekcji:

names = ["Anna", "Jan"]
ages = [30, 40]

for name, age in zip(names, ages):
    print(name, age)

30. Pętla while

x = 0

while x < 5:
    print(x)
    x += 1

31. break i continue

Przerwanie pętli:

for x in range(10):
    if x == 5:
        break

Pominięcie iteracji:

for x in range(10):
    if x == 5:
        continue

    print(x)

32. Funkcje

Definicja:

def hello():
    print("Hello")

Wywołanie:

hello()

Argument:

def hello(name):
    print(f"Hello {name}")

Wywołanie:

hello("Anna")

33. return

def add(a, b):
    return a + b

Użycie:

result = add(2, 3)

34. Argument domyślny

def hello(name="world"):
    print(f"Hello {name}")

hello()
hello("Anna")

35. Argumenty nazwane

def user(name, age):
    print(name, age)

Można:

user(age=30, name="Anna")

36. *args

Dowolna liczba argumentów pozycyjnych:

def add(*numbers):
    return sum(numbers)

add(1, 2, 3, 4)

37. **kwargs

Dowolne argumenty nazwane:

def show(**data):
    print(data)

show(name="Anna", age=30)

otrzymasz słownik:

{
    "name": "Anna",
    "age": 46
}

38. Typowanie opcjonalne - type hints

Python pozwala opisać typy:

def add(a: int, b: int) -> int:
    return a + b

Zmienne:

name: str = "Anna"
age: int = 46

Python zwykle nie wymusza tych typów podczas działania programu.

Służą przede wszystkim:

IDE,
analizatorom kodu,
programistom,
narzędziom takim jak mypy.

39. List comprehension

Bardzo częsta konstrukcja:

numbers = [1, 2, 3, 4]

squares = [x * x for x in numbers]

wynik:

[1, 4, 9, 16]

Z filtrem:

even = [x for x in numbers if x % 2 == 0]

40. Moduły

Plik:

math_utils.py

zawiera:

def add(a, b):
    return a + b

Inny plik:

import math_utils

print(math_utils.add(2, 3))

Można importować konkretną funkcję:

from math_utils import add

i potem:

add(2, 3)

41. Biblioteka standardowa

Python ma dużą bibliotekę standardową.

Przykłady:

import os
import sys
import json
import pathlib
import subprocess
import datetime
import logging
import argparse
import sqlite3

Nie trzeba ich instalować przez pip.

42. name i main

Bardzo częsta konstrukcja:

def main():
    print("Program startuje")


if __name__ == "__main__":
    main()

Co to oznacza?

Jeśli uruchomisz:

python3 app.py

to:

__name__

będzie miało wartość:

__main__

Jeśli natomiast plik zostanie zaimportowany jako moduł, funkcja main() nie uruchomi się automatycznie.

43. Pakiety

Przykład projektu:

project/
├── app.py
└── mypackage/
    ├── __init__.py
    ├── users.py
    └── database.py

Import:

from mypackage.users import User

__init__.py historycznie oznaczał katalog jako pakiet Pythona i nadal jest bardzo często używany.

44. pip

pip jest menedżerem pakietów Pythona.

Instalacja biblioteki:

python3 -m pip install requests

To jest zwykle lepsza forma niż:

pip3 install requests

ponieważ jednoznacznie wskazuje interpreter.

Sprawdzenie pakietów:

python3 -m pip list

Informacje:

python3 -m pip show requests

Usunięcie:

python3 -m pip uninstall requests

45. Dlaczego nie instalować wszystkiego globalnie

Jeżeli projekt A potrzebuje:

biblioteka 1.0

a projekt B:

biblioteka 2.0

mogą pojawić się konflikty.

Dlatego projekty powinny mieć własne środowiska.

46. venv - środowisko wirtualne

Tworzenie:

python3 -m venv .venv

Powstanie katalog:

.venv/

Aktywacja Linux / FreeBSD:

source .venv/bin/activate

Prompt zwykle zmieni się:

(.venv) user@server:~/project$

Od tego momentu:

python
pip

dotyczą środowiska projektu.

Instalacja:

pip install requests

Wyjście:

deactivate

47. .venv w Git

Nie wrzucaj środowiska wirtualnego do Git.

.gitignore:

.venv/
__pycache__/
*.pyc

48. requirements.txt

Klasyczny sposób zapisywania zależności.

Eksport:

pip freeze > requirements.txt

Przykład:

requests==2.32.5
flask==3.1.2

Instalacja:

pip install -r requirements.txt

49. pyproject.toml

Nowoczesne projekty Python coraz częściej używają:

pyproject.toml

Może zawierać:

dane projektu,
zależności,
konfigurację builda,
konfigurację narzędzi.

Przykład:

[project]
name = "example"
version = "0.1.0"
dependencies = [
    "requests>=2.32",
]

Jeżeli widzisz pyproject.toml, zacznij od jego przeczytania.

50. Instalacja projektu

W katalogu z projektem:

pip install .

Tryb developerski:

pip install -e .

-e oznacza editable.

Zmiany w kodzie projektu są dostępne bez ponownej instalacji.

51. Czytanie plików

Nowoczesny sposób:

from pathlib import Path

text = Path("file.txt").read_text()
print(text)

Zapis:

Path("file.txt").write_text("Hello")

Kodowanie UTF-8:

Path("file.txt").read_text(encoding="utf-8")

52. Klasyczne open()

with open("file.txt", "r", encoding="utf-8") as file:
    content = file.read()

Zapis:

with open("file.txt", "w", encoding="utf-8") as file:
    file.write("Hello")

Dopisanie:

with open("file.txt", "a", encoding="utf-8") as file:
    file.write("kolejna linia\n")

53. with

Konstrukcja:

with ...

zarządza zasobem.

Dzięki temu plik zostanie zamknięty automatycznie.

with open("file.txt") as f:
    data = f.read()

Nie trzeba:

f.close()

54. JSON

import json

Python → JSON:

data = {
    "name": "Anna",
    "age": 46
}

text = json.dumps(data)

JSON → Python:

data = json.loads(text)

Plik:

with open("data.json", "r") as f:
    data = json.load(f)

Zapis:

with open("data.json", "w") as f:
    json.dump(data, f, indent=2)

55. Wyjątki

Przykład błędu:

x = int("abc")

spowoduje:

ValueError

Obsługa:

try:
    x = int("abc")
except ValueError:
    print("Niepoprawna liczba")

56. try / except / else / finally

try:
    x = int(input("Liczba: "))
except ValueError:
    print("Błąd")
else:
    print("OK")
finally:
    print("Koniec")

finally wykona się niezależnie od wyniku.

57. raise

Można samemu zgłosić wyjątek:

if age < 0:
    raise ValueError("Wiek nie może być ujemny")

58. Klasy

Podstawowa klasa:

class User:
    def __init__(self, name):
        self.name = name

    def hello(self):
        print(f"Hello {self.name}")

Utworzenie obiektu:

user = User("Anna")

Wywołanie:

user.hello()

59. self

self oznacza bieżący obiekt.

self.name

to pole konkretnej instancji klasy.

Podobna koncepcja do:

this

w JavaScript, Java czy C++.

60. Dziedziczenie

class Animal:
    def speak(self):
        print("...")


class Dog(Animal):
    def speak(self):
        print("Woof")

61. dataclass

Do prostych struktur danych często używa się:

from dataclasses import dataclass


@dataclass
class User:
    name: str
    age: int

Użycie:

user = User("Anna", 30)

Python automatycznie tworzy między innymi konstruktor.

62. Lambda

Krótka anonimowa funkcja:

square = lambda x: x * x

Najczęściej spotkasz ją jako argument:

users.sort(key=lambda user: user["name"])

Nie należy przesadzać z lambda - zwykła funkcja jest często czytelniejsza.

63. import os

Obsługa systemu:

import os

print(os.getcwd())

Zmienne środowiskowe:

api_key = os.getenv("API_KEY")

To częsty sposób przechowywania sekretów.

64. pathlib

Nowoczesna obsługa ścieżek:

from pathlib import Path

path = Path("data") / "file.txt"

Sprawdzenie:

path.exists()

Katalog:

path.parent

Nazwa:

path.name

65. sys

import sys

Argumenty programu:

print(sys.argv)

Jeśli uruchomisz:

python3 app.py hello world

to:

sys.argv

będzie podobne do:

["app.py", "hello", "world"]

66. argparse

Do tworzenia prawdziwego CLI:

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("name")
parser.add_argument("--verbose", action="store_true")

args = parser.parse_args()

print(args.name)

Uruchomienie:

python3 app.py Anna --verbose

Pomoc generowana automatycznie:

python3 app.py --help

67. subprocess

Uruchamianie poleceń systemowych:

import subprocess

subprocess.run(["ls", "-la"])

Pobranie wyniku:

result = subprocess.run(
    ["uname", "-a"],
    capture_output=True,
    text=True
)

print(result.stdout)

Unikaj składania poleceń z niesprawdzonego inputu użytkownika.

68. requests

Popularna biblioteka do HTTP.

Instalacja:

pip install requests

Kod:

import requests

response = requests.get("https://example.com")

print(response.status_code)
print(response.text)

JSON:

data = response.json()

69. Backend webowy

Popularne frameworki:

Flask

Prosty i lekki.

pip install flask

Minimalna aplikacja:

from flask import Flask

app = Flask(__name__)


@app.route("/")
def index():
    return "Hello"

Uruchomienie:

flask --app app run

FastAPI

Bardzo popularny do API.

pip install fastapi uvicorn

Kod:

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def index():
    return {"hello": "world"}

Start:

uvicorn app:app --reload

Django

Duży framework posiadający m.in.:

ORM,
panel admina,
routing,
formularze,
autoryzację,
system szablonów.

Instalacja:

pip install django

Nadaje się do większych aplikacji webowych.

70. SQLite

Python ma SQLite w bibliotece standardowej:

import sqlite3

conn = sqlite3.connect("app.db")
cursor = conn.cursor()

cursor.execute("""
CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY,
    name TEXT
)
""")

conn.commit()
conn.close()

71. Logging

Zamiast wielu print() w większych programach:

import logging

logging.basicConfig(level=logging.INFO)

logging.info("Program uruchomiony")
logging.warning("Uwaga")
logging.error("Błąd")

72. Testy

Python posiada unittest:

import unittest


def add(a, b):
    return a + b


class TestMath(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)


if __name__ == "__main__":
    unittest.main()

Popularniejsze w wielu projektach jest:

pytest

Instalacja:

pip install pytest

Test:

def test_add():
    assert 2 + 3 == 5

Uruchomienie:

pytest

73. Debugowanie

Najprostsze:

print(variable)

Lepsze:

breakpoint()

Przykład:

x = 10

breakpoint()

print(x)

Uruchomienie programu zatrzyma się w debuggerze Pythona.

Podstawowe komendy:

step

continue

p x

print wartości x

quit

74. Traceback

Gdy program się wywróci, Python pokaże traceback.

Przykład:

Traceback (most recent call last):
  File "/home/user/app.py", line 12, in <module>
    run()
  File "/home/user/app.py", line 8, in run
    x = int("abc")
ValueError: invalid literal for int()

Czytaj od końca:

ValueError

to typ błędu.

Następnie zobacz:

File ...
line ...

Traceback pokazuje drogę, którą program doszedł do błędu.

75. Formatowanie kodu

Popularny formatter:

black

Instalacja:

pip install black

Uruchomienie:

black .

76. Ruff

Bardzo szybkie narzędzie do lintingu i formatowania.

Instalacja:

pip install ruff

Sprawdzenie kodu:

ruff check .

Automatyczne poprawki:

ruff check . --fix

Formatowanie:

ruff format .

77. mypy

Statyczne sprawdzanie type hints:

pip install mypy

Uruchomienie:

mypy app.py

78. Typowa struktura prostego projektu

project/
├── .gitignore
├── README.md
├── pyproject.toml
├── .venv/
├── src/
│   └── app/
│       ├── __init__.py
│       ├── main.py
│       └── utils.py
└── tests/
    └── test_main.py

W mniejszych projektach spotkasz też:

project/
├── app.py
├── utils.py
├── requirements.txt
└── README.md

79. Jak uruchomić cudzy projekt

Najpierw:

git clone ADRES_REPO
cd projekt

Sprawdź:

ls -la

Szukaj:

README.md
pyproject.toml
requirements.txt
setup.py
Pipfile
poetry.lock
uv.lock

Najważniejszy jest zwykle:

README.md

80. Typowy workflow z requirements.txt

git clone ...
cd projekt

python3 -m venv .venv

source .venv/bin/activate

pip install -r requirements.txt

Potem np.:

python app.py

81. Typowy workflow z pyproject.toml

python3 -m venv .venv
source .venv/bin/activate

pip install .

albo developersko:

pip install -e .

Następnie przeczytaj README, aby znaleźć komendę startową.

82. Uruchamianie modułu przez -m

Można uruchamiać moduły:

python3 -m moduł

Przykład:

python3 -m http.server

uruchamia prosty serwer HTTP.

Domyślnie:

http://localhost:8000

Inny port:

python3 -m http.server 9000

83. python -m pip

Lepsze:

python3 -m pip install requests

niż:

pip3 install requests

Dlaczego?

Bo masz pewność, że pip należy do tego samego interpretera:

python3

84. Sprawdzanie interpretera

which python3

Przykład:

/usr/bin/python3

Po aktywacji venv:

which python

może zwrócić:

/home/user/project/.venv/bin/python

85. Wersje Pythona

Sprawdzenie:

python3 --version

W kodzie:

import sys

print(sys.version)

Wersja jako struktura:

print(sys.version_info)

86. pycache

Python może tworzyć:

__pycache__/

To cache skompilowanego bytecode.

Możesz go usunąć.

Nie powinien trafiać do repozytorium.

.gitignore:

__pycache__/
*.py[cod]

87. Zmienne środowiskowe

Shell:

export API_KEY="abc123"

Python:

import os

api_key = os.getenv("API_KEY")

Nie zapisuj sekretów bezpośrednio w kodzie:

API_KEY = "tajny-klucz"

szczególnie jeśli kod trafia do GitHub.

88. .env

Popularny sposób lokalnego przechowywania konfiguracji:

.env

Przykład:

API_KEY=abc123
DATABASE_URL=...

Biblioteka:

pip install python-dotenv

Kod:

from dotenv import load_dotenv
import os

load_dotenv()

api_key = os.getenv("API_KEY")

.gitignore:

.env

89. Dekoratory

Spotkasz kod:

@something
def function():
    pass

@something to dekorator.

Pozwala zmodyfikować lub opakować zachowanie funkcji albo klasy.

Przykład:

@staticmethod
def hello():
    pass

We frameworkach spotkasz często:

@app.get("/")

albo:

@app.route("/")

Nie musisz od razu rozumieć mechanizmu dekoratorów, aby czytać większość kodu.

90. Generator i yield

Zwykła funkcja:

def numbers():
    return [1, 2, 3]

Generator:

def numbers():
    yield 1
    yield 2
    yield 3

Iteracja:

for n in numbers():
    print(n)

Generator tworzy wartości na bieżąco zamiast trzymać cały wynik w pamięci.

91. Iterator

Python często używa protokołu iteratorów.

Przykład:

for item in items:
    ...

Lista, generator, plik i wiele innych obiektów może być iterowane.

Funkcja:

iter()

tworzy iterator.

next()

pobiera kolejny element.

92. async / await

Python obsługuje programowanie asynchroniczne.

Przykład:

import asyncio


async def main():
    await asyncio.sleep(1)
    print("gotowe")


asyncio.run(main())

Spotkasz je szczególnie w:

API,
crawlerach,
botach,
aplikacjach sieciowych,
kodzie korzystającym z wielu połączeń.

93. await

await mówi mniej więcej:

poczekaj na wynik tej operacji, ale pozwól pętli zdarzeń wykonywać inne zadania.

Nie oznacza automatycznie:

nowy wątek

Asyncio jest innym modelem współbieżności.

94. threading

Python posiada wątki:

import threading

W CPython istnieje mechanizm:

GIL - Global Interpreter Lock

który wpływa na wykonywanie kodu CPU-bound w wielu wątkach.

Do operacji:

sieciowych,
dyskowych,
I/O

wątki nadal mogą być bardzo użyteczne.

95. multiprocessing

Dla zadań mocno obciążających CPU można używać:

multiprocessing

Procesy mają osobne interpretery i mogą wykorzystać wiele rdzeni CPU.

96. Popularne biblioteki

HTTP

requests
httpx
aiohttp

Backend

Flask
FastAPI
Django

Dane

NumPy
pandas
Polars

Wykresy

Matplotlib
Plotly

AI / ML

PyTorch
TensorFlow
scikit-learn
transformers

CLI

argparse
click
typer

Testy

pytest

Browser automation

Playwright
Selenium

97. Gdzie Python jest słabszym wyborem

Python zwykle nie jest pierwszym wyborem dla:

kodu wymagającego maksymalnej wydajności,
sterowników,
kernela,
bardzo małych systemów embedded,
frontendowego kodu wykonywanego bezpośrednio w przeglądarce,
aplikacji wymagających jednej bardzo małej binarki bez runtime.

W takich miejscach częściej pojawia się:

C
C++
Rust
Go
JavaScript

98. Python a JavaScript

Python:

name = "Anna"

if name:
    print(name)

JavaScript:

const name = "Anna";

if (name) {
    console.log(name);
}

Największa różnica wizualna:

Python używa:

wcięć

zamiast:

{}

99. Python a Go

Python:

def add(a, b):
    return a + b

Go:

func add(a int, b int) int {
    return a + b
}

Python jest bardziej dynamiczny.

Go jest:

statycznie typowany,
kompilowany do binarki,
bardziej restrykcyjny,
zwykle prostszy w deploymencie.

100. Typowe błędy początkujących

Złe wcięcie

IndentationError

Literówka w nazwie

NameError

Zły typ

TypeError

Niepoprawna wartość

ValueError

Brak klucza

KeyError

Brak elementu listy

IndexError

Brak pliku

FileNotFoundError

Brak modułu

ModuleNotFoundError

Najczęściej oznacza:

brak biblioteki,
nieaktywne venv,
uruchomienie złego interpretera.

101. Jak sprawdzić, skąd ładowany jest moduł

import requests

print(requests.__file__)

Przydatne, gdy masz kilka środowisk lub wersji pakietu.

102. help()

W interpreterze:

help(str)

lub:

help(list.append)

Wyjście:

help()

i wpisz:

quit

103. dir()

Lista atrybutów obiektu:

dir(str)

Przydatne do eksploracji API.

104. Dokumentacja funkcji

print(print.__doc__)

albo:

help(print)

105. dir + type + help

Trzy bardzo przydatne narzędzia do eksploracji:

type(obj)
dir(obj)
help(obj)

Pozwalają szybko zrozumieć nieznany obiekt.

106. Instalacja narzędzi CLI - pipx

Niektórych narzędzi nie warto instalować do projektu.

Przykłady:

black
ruff
poetry
httpie

Do takich programów często wygodne jest:

pipx

Debian:

sudo apt install pipx
pipx ensurepath

Instalacja:

pipx install ruff

Każde narzędzie dostaje własne środowisko.

107. Poetry, uv i inne narzędzia

W projektach możesz spotkać:

Poetry
Pipenv
uv
Hatch
PDM

Ich zadaniem jest zarządzanie:

zależnościami,
środowiskami,
buildem projektu.

Jeśli projekt używa jednego z nich, najlepiej używać narzędzia przewidzianego przez autora projektu zamiast przebudowywać projekt na własną rękę.

108. uv

uv to nowoczesne i bardzo szybkie narzędzie do zarządzania Pythonem, środowiskami i zależnościami.

Możesz spotkać plik:

uv.lock

Typowy workflow może wyglądać:

uv sync

a uruchomienie:

uv run python app.py

Jeżeli repo posiada uv.lock, przeczytaj README projektu przed ręcznym instalowaniem pakietów pipem.

109. Docker i Python

Przykładowy Dockerfile:

FROM python:3.13-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python", "app.py"]

Budowanie:

docker build -t my-python-app .

Uruchomienie:

docker run --rm my-python-app

110. Przykładowy .gitignore

# Python
__pycache__/
*.py[cod]

# virtualenv
.venv/
venv/

# secrets
.env

# tests / tools
.pytest_cache/
.mypy_cache/
.ruff_cache/

# IDE
.vscode/
.idea/

111. Minimalny program CLI

#!/usr/bin/env python3

def main():
    name = input("Jak masz na imię? ")

    if not name:
        print("Nie podałeś imienia.")
        return

    print(f"Cześć, {name}!")


if __name__ == "__main__":
    main()

Uruchomienie:

python3 app.py

112. Prosty skrypt przetwarzający plik

from pathlib import Path


def main():
    path = Path("input.txt")

    if not path.exists():
        print("Brak pliku.")
        return

    text = path.read_text(encoding="utf-8")

    lines = text.splitlines()

    print(f"Liczba linii: {len(lines)}")
    print(f"Liczba znaków: {len(text)}")


if __name__ == "__main__":
    main()

113. Proste pobranie API

import requests


def main():
    response = requests.get(
        "https://api.github.com",
        timeout=10,
    )

    response.raise_for_status()

    data = response.json()

    print(data)


if __name__ == "__main__":
    main()

Instalacja:

python3 -m venv .venv
source .venv/bin/activate

pip install requests

Uruchomienie:

python app.py

114. response.raise_for_status()

Przy requests:

response.raise_for_status()

zgłosi wyjątek dla błędów HTTP takich jak:

404
500
403

To często lepsze niż zakładanie, że każde zapytanie się udało.

115. Czytanie kodu Pythona - kolejność

Gdy otwierasz nieznany projekt:

przeczytaj README.md,
znajdź pyproject.toml lub requirements.txt,
znajdź punkt startowy,
szukaj main(),
szukaj:

if __name__ == "__main__":

zobacz importy,
znajdź konfigurację,
sprawdź zmienne środowiskowe,
zobacz katalog testów,
dopiero potem czytaj implementację szczegółową.

116. Jak rozpoznać punkt wejścia

Może nim być:

main.py
app.py
server.py
cli.py
manage.py

lub wpis w:

pyproject.toml

Na przykład:

[project.scripts]
myapp = "myapp.cli:main"

oznacza mniej więcej:

uruchom funkcję main z modułu myapp.cli

117. Jak znaleźć zależności

Szukaj:

requirements.txt
requirements-dev.txt
pyproject.toml
Pipfile
poetry.lock
uv.lock

Nigdy nie zakładaj, że samo:

pip install -r requirements.txt

jest właściwe dla każdego projektu.

Najpierw przeczytaj README.

118. Jak sprawdzić importy

Przykład:

import os
import requests

from pathlib import Path
from flask import Flask
from project.database import Database

Możesz podzielić je na:

standard library

os
pathlib

zewnętrzne biblioteki

requests
flask

kod projektu

project.database

To pomaga szybko zrozumieć architekturę.

119. Jak czytać traceback

Załóżmy:

Traceback...
File "app.py", line 20
File "users.py", line 10
File "database.py", line 42

KeyError: 'name'

Najpierw:

KeyError: 'name'

Potem:

database.py line 42

To najbliższe miejsce faktycznego błędu.

Dopiero potem patrz wyżej na ścieżkę wywołań.

120. Przydatne polecenia

Wersja:

python3 --version

Interpreter:

which python3

pip:

python3 -m pip --version

Pakiety:

python3 -m pip list

Środowisko:

python3 -m venv .venv

Aktywacja:

source .venv/bin/activate

Instalacja zależności:

pip install -r requirements.txt

Uruchomienie:

python app.py

Testy:

pytest

Wyjście z venv:

deactivate

121. Cheat sheet składni

zmienna

x = 10

tekst

name = "Anna"

lista

items = [1, 2, 3]

słownik

user = {"name": "Anna"}

if

if x > 5:
    print(x)

for

for item in items:
    print(item)

while

while x > 0:
    x -= 1

funkcja

def add(a, b):
    return a + b

klasa

class User:
    pass

wyjątek

try:
    ...
except ValueError:
    ...

import

import os

plik

with open("file.txt") as f:
    data = f.read()

122. Minimalny workflow nowego projektu

mkdir projekt
cd projekt

python3 -m venv .venv

source .venv/bin/activate

Utwórz:

app.py

Kod:

def main():
    print("Hello Python")


if __name__ == "__main__":
    main()

Uruchom:

python app.py

Jeżeli potrzebujesz biblioteki:

pip install requests

Zapis zależności:

pip freeze > requirements.txt

123. Minimalny workflow pobranego projektu

git clone URL
cd REPO

Przeczytaj:

less README.md

Sprawdź pliki:

ls -la

Utwórz środowisko:

python3 -m venv .venv
source .venv/bin/activate

Jeśli projekt posiada:

requirements.txt

to najczęściej:

pip install -r requirements.txt

Jeśli ma:

pyproject.toml

to może być:

pip install -e .

ale zawsze najpierw sprawdź instrukcję autora.

124. Najważniejsze rzeczy do zapamiętania

Jeżeli chcesz przede wszystkim rozumieć i uruchamiać kod Pythona, zapamiętaj te rzeczy:

Python używa wcięć zamiast klamer.
Pliki mają zwykle rozszerzenie:

.py

Uruchomienie:

python3 app.py

Projekty powinny używać:

venv

Biblioteki instalujesz przez:

pip

Zależności znajdziesz najczęściej w:

requirements.txt
pyproject.toml

Najważniejsze typy:

int
float
str
bool
list
tuple
dict
set
None

Najważniejsze konstrukcje:

if
for
while
def
class
try
import
with

Przy błędzie czytaj koniec tracebacka.
Cudzego projektu nie uruchamiaj w ciemno. Najpierw:

README → zależności → venv → instalacja → konfiguracja → start

Nie zapisuj sekretów w kodzie ani w repozytorium.
python -m ... jest bardzo przydatnym mechanizmem.
type(), dir() i help() pozwalają szybko eksplorować nieznany kod.
pathlib jest zwykle wygodniejsze od starego stylu ręcznego składania ścieżek.
Python jest świetnym językiem do automatyzacji i klejenia różnych systemów w całość.

125. Komendy, które warto znać na pamięć

python3 --version

python3

python3 app.py

python3 -m venv .venv

source .venv/bin/activate

python -m pip install PACKAGE

python -m pip install -r requirements.txt

python -m pip list

pytest

deactivate

Jeżeli swobodnie rozumiesz powyższe polecenia oraz konstrukcje opisane w tym kompendium, jesteś w stanie uruchomić, przejrzeć i wstępnie debugować większość zwykłych projektów napisanych w Pythonie.

Oficjalne źródła

Python documentation: https://docs.python.org/3/
Python downloads and supported releases: https://www.python.org/downloads/
venv: https://docs.python.org/3/library/venv.html
Packaging guide: https://packaging.python.org/

Praktyczna baza wiedzy technicznej.

Python - podstawy

1. Czym jest Python

2. Jak działa Python

3. Python 2 a Python 3

4. Instalacja

Debian / Ubuntu

FreeBSD

Windows

5. Interpreter interaktywny

6. Uruchamianie pliku

7. Python jako wykonywalny skrypt

8. Wcięcia są częścią składni

9. Komentarze

10. Zmienne

11. Nazwy zmiennych

12. Podstawowe typy danych

int

float

str

bool

None

13. Sprawdzanie typu

14. Konwersje typów

15. Operatory matematyczne

16. Porównania

17. Operatory logiczne

18. Łańcuchy tekstowe

19. f-string

20. Dostęp do znaków tekstu

21. Listy

22. Tuple

23. Słownik - dict

24. Set

25. if / elif / else

26. Wartości traktowane jako False

27. Pętla for

28. enumerate

29. zip

30. Pętla while

31. break i continue

32. Funkcje

33. return

34. Argument domyślny

35. Argumenty nazwane

36. *args

37. **kwargs

38. Typowanie opcjonalne - type hints

39. List comprehension

40. Moduły

41. Biblioteka standardowa

42. name i main

43. Pakiety

44. pip

45. Dlaczego nie instalować wszystkiego globalnie

46. venv - środowisko wirtualne

47. .venv w Git

48. requirements.txt

49. pyproject.toml

50. Instalacja projektu

51. Czytanie plików

52. Klasyczne open()

53. with

54. JSON

55. Wyjątki

56. try / except / else / finally

57. raise

58. Klasy

59. self

60. Dziedziczenie

61. dataclass

62. Lambda

63. import os

64. pathlib

65. sys

66. argparse

67. subprocess

68. requests

69. Backend webowy

Flask