---
title: "Laboratorium: sprawdzanie i klasyfikowanie własnych adresów"
domain: networking
level: beginner
duration: "45 min"
cost: "bezpłatnie"
environment: "Twój własny komputer (Linux, macOS lub Windows) z Pythonem 3"
lang: pl
source_hash: d1b39bf71f87
---

# Laboratorium: sprawdzanie i klasyfikowanie własnych adresów

## Cel
Odczytujesz konfigurację IPv4 własnego komputera (adres, prefiks, bramę i skąd pochodzą), sprawdzasz obliczenia z lekcji modułem `ipaddress` z Pythona i piszesz mały skrypt, który klasyfikuje adresy według przeznaczenia. Nic w Twojej sieci nie jest zmieniane.

## Cele
- Znaleźć swój adres IPv4, długość prefiksu, maskę podsieci i bramę domyślną w Linuksie, macOS lub Windowsie.
- Ustalić, czy adres został skonfigurowany statycznie, czy przez protokół dynamicznej konfiguracji hostów (DHCP, Dynamic Host Configuration Protocol).
- Obliczyć adres sieci, adres broadcast i zakres użytecznych hostów oraz potwierdzić je w Pythonie.
- Sklasyfikować adresy IPv4 jako prywatne, publiczne, współdzielone (translacja adresów sieciowych klasy operatorskiej, CGN, Carrier-Grade Network Address Translation), loopback, link-local, dokumentacyjne, multicast lub broadcast.
- Wyjaśnić, dlaczego flaga `is_private` w Pythonie jest szersza niż „RFC 1918”.

## Wymagania wstępne
- Komputer z Linuksem (z poleceniem `ip` z pakietu iproute2), macOS lub Windows 10/11.
- Python 3.8 lub nowszy, tylko biblioteka standardowa. To laboratorium przetestowano z Pythonem 3.14.7 i 3.11.8. Sprawdź swoją wersję poleceniem `python3 --version` (w Windowsie: `py --version`).
- Edytor tekstu.
- Nie potrzeba uprawnień administratora: wszystkie polecenia w tym laboratorium tylko odczytują konfigurację.
- [Lekcja: adresowanie IP](lesson.pl.md) z tego modułu.

> [!WARNING]
> Twoje własne adresy, brama i szczegóły dzierżawy opisują Twoją sieć. Nie publikuj wyników tych poleceń na publicznych forach ani w zrzutach ekranu. Udostępniając wyniki, zastąp wartości adresami dokumentacyjnymi (`192.0.2.0/24`, `198.51.100.0/24`, `203.0.113.0/24`).

## Architektura
![Architektura laboratorium: Twój komputer z adresem prywatnym, np. 192.168.1.23/24, router pod adresem 192.168.1.1 pełniący rolę bramy domyślnej, serwera DHCP i NAT, Twój ISP z adresem publicznym lub adresem z 100.64.0.0/10 oraz Internet](../../../assets/diagrams/ip-lab-architecture.pl.svg)

*Rysunek 1. Gdzie żyje każdy adres. Wszystko po lewej to Twoja sieć prywatna; router tłumaczy między nią a stroną publiczną. Przykładowe wartości są typowe dla sieci domowej; Twoje mogą się różnić.*

*Sprawdzasz tylko lewe pole. Pokazane wartości to przykłady; Twoje będą inne.*

## Kroki

### Krok 1 — Utwórz folder roboczy
Napiszesz dwa małe skrypty. Trzymaj je w jednym folderze, żeby sprzątanie sprowadzało się do jednego polecenia.

Linux i macOS:

```bash
mkdir -p ~/ip-lab && cd ~/ip-lab
```

Windows (PowerShell):

```powershell
New-Item -ItemType Directory -Force "$HOME\ip-lab"; Set-Location "$HOME\ip-lab"
```

Brak wyniku oznacza sukces (PowerShell wypisuje szczegóły nowego folderu).

### Krok 2 — Znajdź swój adres, prefiks i bramę
To cztery wartości, których potrzebuje każdy host. Uruchom polecenia dla swojego systemu operacyjnego i wypełnij tabelę na końcu tego kroku.

**Linux.** Wyświetl adresy IPv4, a potem trasę domyślną:

```bash
ip -4 addr show
ip route show default
```

Oczekiwany wynik (nazwy interfejsów i wartości u Ciebie będą inne):

```text
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
    inet 192.168.1.23/24 brd 192.168.1.255 scope global dynamic noprefixroute eth0
       valid_lft 86077sec preferred_lft 86077sec
default via 192.168.1.1 dev eth0 proto dhcp src 192.168.1.23 metric 100
```

Wiersz `inet` podaje razem adres i prefiks (`192.168.1.23/24`). Zignoruj `lo`: to interfejs loopback. Wiersz `default via` podaje bramę.

**macOS.** Znajdź interfejs niosący trasę domyślną, a potem jego adres:

```bash
route -n get default
ifconfig en0 | grep "inet "
```

Oczekiwany wynik (skrócony; zastąp `en0` wartością `interface` z pierwszego polecenia):

```text
   route to: default
destination: default
       mask: default
    gateway: 192.168.1.1
  interface: en0
…
	inet 192.168.1.23 netmask 0xffffff00 broadcast 192.168.1.255
```

macOS pokazuje maskę szesnastkowo: `0xffffff00` to `ff.ff.ff.00` = `255.255.255.0` = `/24`.

**Windows (PowerShell).**

```powershell
ipconfig /all
Get-NetRoute -DestinationPrefix 0.0.0.0/0
```

Oczekiwany wynik (skrócony):

```text
Ethernet adapter Ethernet:
   …
   DHCP Enabled. . . . . . . . . . . : Yes
   IPv4 Address. . . . . . . . . . . : 192.168.1.23(Preferred)
   Subnet Mask . . . . . . . . . . . : 255.255.255.0
   Lease Obtained. . . . . . . . . . : Wednesday, 4 November 2026 08:12:40
   Lease Expires . . . . . . . . . . : Thursday, 5 November 2026 08:12:40
   Default Gateway . . . . . . . . . : 192.168.1.1
   DHCP Server . . . . . . . . . . . : 192.168.1.1
   DNS Servers . . . . . . . . . . . : 192.168.1.1

ifIndex DestinationPrefix  NextHop       RouteMetric ifMetric PolicyStore
------- -----------------  -------       ----------- -------- -----------
12      0.0.0.0/0          192.168.1.1             0       25 ActiveStore
```

`0.0.0.0/0` to trasa domyślna: „każdy cel niedopasowany do bardziej szczegółowej trasy”.

> [!NOTE]
> Dokładne brzmienie, odstępy między kolumnami i formaty dat zależą od wersji systemu operacyjnego i języka interfejsu. Jeśli widzisz kilka adapterów (Wi-Fi, Ethernet, VPN, adaptery maszyn wirtualnych), użyj tego, którego brama zgadza się z trasą domyślną.

Zapisz swoje wartości:

| Wartość | Twoja |
|---|---|
| Adres IPv4 | `<address>` |
| Długość prefiksu / maska | `<prefix>` / `<mask>` |
| Brama domyślna | `<gateway>` |
| Interfejs | `<interface>` |

### Krok 3 — Sprawdź, skąd pochodzi adres
Adres z DHCP ma dzierżawę, która wygasa; adres statyczny nie. Wiedza, który masz, podpowiada, gdzie szukać, gdy coś się zepsuje.

- **Linux:** wiersz `inet` z kroku 2 zawiera `dynamic` i skończone `valid_lft` (na przykład `86077sec`) dla adresu z DHCP. Adres statyczny pokazuje `valid_lft forever` i nie ma `dynamic`. Potwierdza to `proto dhcp` przy trasie domyślnej.
- **Windows:** `DHCP Enabled. . . : Yes` oraz wiersze `Lease Obtained` / `Lease Expires` i `DHCP Server`.
- **macOS:** wypisz dzierżawę DHCP dla interfejsu:

  ```bash
  ipconfig getpacket en0
  ```

  Oczekiwany wynik (skrócony):

  ```text
  op = BOOTREPLY
  …
  yiaddr = 192.168.1.23
  …
  subnet_mask (ip): 255.255.255.0
  router (ip_mult): {192.168.1.1}
  lease_time (uint32): 0x15180
  server_identifier (ip): 192.168.1.1
  ```

  `yiaddr` („your IP address”, Twój adres IP) to adres, który dał Ci serwer. `0x15180` to 86 400 sekund: dzierżawa na 24 godziny. Brak wyniku oznacza, że interfejs nie został skonfigurowany przez DHCP.

Zapisz: statyczny czy DHCP? Które urządzenie jest serwerem DHCP? W większości sieci domowych jest to to samo urządzenie co brama.

### Krok 4 — Sprawdź obliczenia z lekcji w Pythonie
Uruchom interaktywną sesję Pythona poleceniem `python3` (Windows: `py`) i wpisz wiersze po `>>>`. Potwierdzisz przykład `192.0.2.130/26` z sekcji Jak to działa w lekcji.

```python
>>> import ipaddress
>>> iface = ipaddress.ip_interface("192.0.2.130/26")
>>> iface.network
>>> iface.netmask
>>> iface.network.broadcast_address
>>> iface.network.num_addresses
>>> list(iface.network.hosts())[0]
>>> list(iface.network.hosts())[-1]
```

Oczekiwany wynik, wiersz po wierszu:

```text
IPv4Network('192.0.2.128/26')
IPv4Address('255.255.255.192')
IPv4Address('192.0.2.191')
64
IPv4Address('192.0.2.129')
IPv4Address('192.0.2.190')
```

64 adresy minus adres sieci i broadcast dają 62 użyteczne hosty z lekcji. Teraz sprawdź odpowiedź z szybkiego sprawdzianu i zerknij na IPv6:

```python
>>> ipaddress.ip_address("198.51.100.200") in ipaddress.ip_network("198.51.100.192/27")
>>> ipaddress.ip_interface("2001:db8:0:10::82/64").network
```

```text
True
IPv6Network('2001:db8:0:10::/64')
```

Wyjdź poleceniem `exit()`.

> [!TIP]
> `ipaddress.ip_network("192.0.2.130/26")` zgłasza `ValueError: 192.0.2.130/26 has host bits set`, ponieważ sieć trzeba zapisać z jej adresem sieci. Użyj `ip_interface()` dla „tego adresu w tej sieci” albo przekaż `strict=False`.

### Krok 5 — Napisz kalkulator adresów
Skrypt pozwala powtórzyć obliczenia dla dowolnego adresu, także Twojego. Zapisz poniższy kod jako `ipcalc.py` w folderze `ip-lab`:

```python
"""Show the network facts for an IPv4 address with a prefix, e.g. 192.0.2.130/26."""
import ipaddress
import sys


def dotted_binary(addr):
    return ".".join(f"{int(octet):08b}" for octet in str(addr).split("."))


iface = ipaddress.IPv4Interface(sys.argv[1] if len(sys.argv) > 1 else "192.0.2.130/26")
net = iface.network

print(f"Address       {iface.ip}")
print(f"  in binary   {dotted_binary(iface.ip)}")
print(f"Prefix        /{net.prefixlen}  ({net.prefixlen} network + {32 - net.prefixlen} host bits)")
print(f"Subnet mask   {net.netmask}")
print(f"  in binary   {dotted_binary(net.netmask)}")
print(f"Network       {net.network_address}")
print(f"Broadcast     {net.broadcast_address}")
if net.prefixlen <= 30:
    print(f"First host    {net.network_address + 1}")
    print(f"Last host     {net.broadcast_address - 1}")
    print(f"Usable hosts  {net.num_addresses - 2}  (2^{32 - net.prefixlen} - 2)")
else:
    print("Special case: /31 and /32 have no separate network and broadcast addresses (see module 06).")
```

Uruchom go bez argumentów (przykład z lekcji), a potem z błędem z lekcji dotyczącym `/20`:

```bash
python3 ipcalc.py
python3 ipcalc.py 172.20.13.77/20
```

W Windowsie użyj `py` zamiast `python3`. Oczekiwany wynik:

```text
Address       192.0.2.130
  in binary   11000000.00000000.00000010.10000010
Prefix        /26  (26 network + 6 host bits)
Subnet mask   255.255.255.192
  in binary   11111111.11111111.11111111.11000000
Network       192.0.2.128
Broadcast     192.0.2.191
First host    192.0.2.129
Last host     192.0.2.190
Usable hosts  62  (2^6 - 2)
Address       172.20.13.77
  in binary   10101100.00010100.00001101.01001101
Prefix        /20  (20 network + 12 host bits)
Subnet mask   255.255.240.0
  in binary   11111111.11111111.11110000.00000000
Network       172.20.0.0
Broadcast     172.20.15.255
First host    172.20.0.1
Last host     172.20.15.254
Usable hosts  4094  (2^12 - 2)
```

Teraz uruchom go dla własnego adresu z kroku 2:

```bash
python3 ipcalc.py <address>/<prefix>
```

`<address>/<prefix>` to Twój adres IPv4 i długość prefiksu, na przykład `192.168.1.23/24`. Jeśli masz tylko maskę w zapisie dziesiętnym z kropkami (Windows, macOS), Python też ją przyjmie: `192.168.1.23/255.255.255.0`.

Sprawdź: czy Twoja brama domyślna leży między `First host` a `Last host`? Musi.

### Krok 6 — Sklasyfikuj adresy według przeznaczenia
Obiekty `ipaddress` w Pythonie mają flagi takie jak `is_private`, `is_global`, `is_loopback`, `is_link_local` i `is_multicast`. Ten skrypt porównuje je z jawną tabelą bloków specjalnego przeznaczenia z lekcji. Zapisz go jako `classify.py`:

```python
"""Classify IPv4 addresses by purpose and compare with Python's ipaddress flags."""
import ipaddress
import sys

# Special-purpose blocks (RFC 6890 and the IANA IPv4 Special-Purpose Address Registry).
# Checked in order: the first match wins, so 255.255.255.255 comes before 240.0.0.0/4.
BLOCKS = [
    ("0.0.0.0/8", "This network (RFC 791)"),
    ("10.0.0.0/8", "Private (RFC 1918)"),
    ("100.64.0.0/10", "Shared / CGN (RFC 6598)"),
    ("127.0.0.0/8", "Loopback (RFC 1122)"),
    ("169.254.0.0/16", "Link-local (RFC 3927)"),
    ("172.16.0.0/12", "Private (RFC 1918)"),
    ("192.0.2.0/24", "Documentation (RFC 5737)"),
    ("192.168.0.0/16", "Private (RFC 1918)"),
    ("198.51.100.0/24", "Documentation (RFC 5737)"),
    ("203.0.113.0/24", "Documentation (RFC 5737)"),
    ("224.0.0.0/4", "Multicast (RFC 5771)"),
    ("255.255.255.255/32", "Limited broadcast (RFC 919)"),
    ("240.0.0.0/4", "Reserved (RFC 1112)"),
]
BLOCKS = [(ipaddress.IPv4Network(net), label) for net, label in BLOCKS]

SAMPLES = [
    "192.168.1.10", "10.20.30.40", "172.20.1.5", "172.32.1.5", "100.64.12.34",
    "127.0.0.1", "169.254.17.3", "192.0.2.130", "198.51.100.7", "203.0.113.250",
    "224.0.0.251", "255.255.255.255", "0.0.0.0",
]


def purpose(addr):
    for net, label in BLOCKS:
        if addr in net:
            return label
    if addr.is_global:
        return "Public (global unicast)"
    return "Other special (see IANA)"


def mark(flag):
    return "yes" if flag else "-"


print(f"{'Address':<16} {'Purpose':<28} {'private':>7} {'global':>6} {'loopbk':>6} {'link-l':>6} {'mcast':>5}")
for text in sys.argv[1:] or SAMPLES:
    a = ipaddress.IPv4Address(text)
    print(f"{text:<16} {purpose(a):<28} {mark(a.is_private):>7} {mark(a.is_global):>6} "
          f"{mark(a.is_loopback):>6} {mark(a.is_link_local):>6} {mark(a.is_multicast):>5}")
```

Uruchom go na wbudowanych próbkach:

```bash
python3 classify.py
```

Oczekiwany wynik:

```text
Address          Purpose                      private global loopbk link-l mcast
192.168.1.10     Private (RFC 1918)               yes      -      -      -     -
10.20.30.40      Private (RFC 1918)               yes      -      -      -     -
172.20.1.5       Private (RFC 1918)               yes      -      -      -     -
172.32.1.5       Public (global unicast)            -    yes      -      -     -
100.64.12.34     Shared / CGN (RFC 6598)            -      -      -      -     -
127.0.0.1        Loopback (RFC 1122)              yes      -    yes      -     -
169.254.17.3     Link-local (RFC 3927)            yes      -      -    yes     -
192.0.2.130      Documentation (RFC 5737)         yes      -      -      -     -
198.51.100.7     Documentation (RFC 5737)         yes      -      -      -     -
203.0.113.250    Documentation (RFC 5737)         yes      -      -      -     -
224.0.0.251      Multicast (RFC 5771)               -    yes      -      -   yes
255.255.255.255  Limited broadcast (RFC 919)      yes      -      -      -     -
0.0.0.0          This network (RFC 791)           yes      -      -      -     -
```

Przeczytaj tabelę uważnie. Cztery wyniki zaskakują większość osób:
- **`172.32.1.5` jest publiczny.** Blok RFC 1918 `172.16.0.0/12` kończy się na `172.31.255.255`.
- **`is_private` to nie „RFC 1918”.** Python oznacza adres jako prywatny, gdy rejestr IANA mówi, że *nie jest globalnie osiągalny*. Obejmuje to loopback, link-local, dokumentację, `0.0.0.0` i broadcast. Aby sprawdzić konkretnie RFC 1918, samodzielnie sprawdź trzy bloki, tak jak robi to `BLOCKS`.
- **`100.64.12.34` nie jest ani prywatny, ani globalny.** Python traktuje przestrzeń współdzieloną CGN (RFC 6598) jako przypadek szczególny: nie jest osiągalna z Internetu, ale nie jest też Twoja do użycia.
- **`224.0.0.251` jest „globalny”.** `is_global` pochodzi z rejestru adresów specjalnego przeznaczenia, a multicastu tam nie ma (ma własny rejestr). `is_global` nie znaczy „publiczny adres unicast, który możesz pingować”.

> [!NOTE]
> Python 3.12.4 i 3.13 poprawiły tabele stojące za `is_private` i `is_global`, by zgadzały się z rejestrem IANA (CVE-2024-4032; poprawkę przeniesiono także do wydań bezpieczeństwa niektórych starszych gałęzi). Dla wszystkich adresów z `SAMPLES` powyższy wynik jest identyczny w Pythonie 3.14.7 i 3.11.8, który poprzedza poprawkę. Wyniki różnią się dla niektórych adresów w `192.0.0.0/24`: na przykład `192.0.0.100` jest `global` w 3.11.8 i `private` w 3.14.7. Jeśli w prawdziwym kodzie polegasz na tych flagach, sprawdź swoją wersję Pythona.

### Krok 7 — Sklasyfikuj własne adresy
Przekaż jako argumenty swój adres i bramę z kroku 2:

```bash
python3 classify.py <address> <gateway>
```

Dla przykładowych wartości (`192.168.1.23`, brama `192.168.1.1`) wynik to:

```text
Address          Purpose                      private global loopbk link-l mcast
192.168.1.23     Private (RFC 1918)               yes      -      -      -     -
192.168.1.1      Private (RFC 1918)               yes      -      -      -     -
```

Większość komputerów domowych i biurowych dostaje adres prywatny i łączy się z Internetem przez translację adresów sieciowych (NAT, Network Address Translation) routera. Jeśli Twój adres jest publiczny, Twoja sieć przydziela adresy publiczne bezpośrednio (robią tak niektóre uczelnie i centra danych). Jeśli jest to link-local (`169.254.x.x`), DHCP zawiodło: zobacz Rozwiązywanie problemów.

## Weryfikacja
Ukończyłeś laboratorium, jeśli na każdą kontrolę możesz odpowiedzieć „tak”:

| Kontrola | Jak potwierdzić |
|---|---|
| Zapisałeś adres, prefiks, bramę i interfejs | Tabela z kroku 2 jest wypełniona |
| Wiesz, czy Twój adres jest statyczny, czy z DHCP | Krok 3: `dynamic` / `DHCP Enabled: Yes` / wynik `ipconfig getpacket` |
| Python zgadza się z lekcją | Krok 4 wypisuje `192.0.2.128/26`, `192.0.2.191` i 64 adresy |
| Twoja brama leży w Twojej sieci | `python3 ipcalc.py <address>/<prefix>` pokazuje bramę między `First host` a `Last host` |
| Potrafisz wyjaśnić `is_private` a RFC 1918 | `python3 classify.py` pokazuje `yes` w kolumnie `private` dla `192.0.2.130`, choć nie jest to RFC 1918 |

## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `python3: command not found` (lub w Windowsie otwiera się Microsoft Store) | Python nie jest zainstalowany albo w Windowsie jest zainstalowany jako `py` | Użyj `py` w Windowsie albo zainstaluj Pythona 3 z python.org lub menedżera pakietów |
| `ip: command not found` w Linuksie | Minimalny system bez iproute2 | Zainstaluj pakiet `iproute2` albo użyj `hostname -I` tylko dla adresów |
| Wyświetlono kilka adresów i adapterów | Wirtualna sieć prywatna (VPN), Docker, maszyna wirtualna albo jednocześnie aktywne Wi-Fi i Ethernet | Użyj interfejsu wskazanego w trasie domyślnej (`ip route show default`, `route -n get default`, `Get-NetRoute`) |
| Twój adres zaczyna się od `169.254.` i nie ma bramy | Żaden serwer DHCP nie odpowiedział (rozwiązanie awaryjne z RFC 3927) | Sprawdź kabel lub połączenie Wi-Fi, a potem odnów dzierżawę (na przykład połącz się ponownie z siecią). Nie ustawiaj adresu statycznego, żeby to „naprawić” |
| `ipconfig getpacket en0` nic nie wypisuje w macOS | Interfejs nie jest `en0` albo nie został skonfigurowany przez DHCP | Użyj interfejsu z wyniku `route -n get default` |
| `AddressValueError` lub `NetmaskValueError` w skrypcie | Literówka, adres IPv6 lub brak prefiksu | Podaj adres IPv4, np. `192.168.1.23/24`; skrypty obsługują tylko IPv4 |

## Wyzwanie (opcjonalne)
1. Znajdź zewnętrzny (od strony sieci rozległej, WAN, wide area network) adres swojego routera na jego stronie administracyjnej. Przepuść go przez `classify.py`. Jeśli leży w `100.64.0.0/10`, Twój ISP stosuje Carrier-Grade NAT: co to oznacza dla hostowania usługi w domu?
2. Rozszerz `classify.py`, by przyjmował także adresy IPv6 (`ipaddress.ip_address()` zwraca jeden z dwóch typów) i sklasyfikuj `::1`, `fe80::1` oraz `2001:db8::1`. Porównaj wyniki z [modułem 07](../07-ipv6/README.pl.md).
3. Uruchom `python3 ipcalc.py 192.0.2.130/<n>` dla każdego prefiksu od `/24` do `/30`. Zapisz, jak przesuwają się adresy sieci i broadcast. Ten wzorzec wykorzystasz w [module 06](../06-subnetting/README.pl.md).

## Sprzątanie
Laboratorium utworzyło tylko folder `ip-lab` i jego dwa skrypty. Usuń je.

Linux i macOS:

```bash
cd ~ && rm -r ~/ip-lab
```

Windows (PowerShell):

```powershell
Set-Location $HOME; Remove-Item -Recurse -Force "$HOME\ip-lab"
```

Żadne ustawienia sieci nie zostały zmienione, więc nie ma nic więcej do cofnięcia.

## Co już umiesz
- Każdy host potrzebuje adresu, prefiksu (lub maski), bramy domyślnej i serwerów systemu nazw domen (DNS, Domain Name System), a wszystkie te wartości odczytasz wbudowanymi poleceniami w każdym systemie operacyjnym.
- Adres z DHCP pokazuje dzierżawę i serwer DHCP; adres statyczny nie pokazuje żadnego z nich.
- Sieć, broadcast i zakres hostów wynikają bezpośrednio z prefiksu, a moduł `ipaddress` z Pythona to niezawodny sposób sprawdzania obliczeń.
- „Prywatny” ma dwa znaczenia: bloki RFC 1918 oraz szersze „niedostępny globalnie” w Pythonie. Wiedz, którego używa Twoje narzędzie.
- Twoja brama musi zawsze leżeć w Twojej własnej sieci.
