---
title: "Ćwiczenie: zamiana liczb na papierze"
domain: networking
level: foundations
duration: "30 min"
cost: "za darmo"
environment: "kartka i ołówek; opcjonalnie Python 3 na twoim komputerze (Windows, macOS lub Linux)"
lang: pl
source_hash: a93324a58b98
---

# Ćwiczenie: zamiana liczb na papierze

## Cel
Poćwicz zamianę liczb między zapisem dziesiętnym, binarnym i szesnastkowym za pomocą tabeli wag pozycji, a potem odczytaj bajt po bajcie prawdziwy adres IP i adres MAC. Na końcu możesz opcjonalnie pozwolić komputerowi sprawdzić twoje odpowiedzi.

## Cele
- Zamieniać liczby między zapisem dziesiętnym a binarnym (od 0 do 255).
- Zamieniać liczby między zapisem binarnym a szesnastkowym oraz rozpoznawać zapis szesnastkowy w adresie MAC.
- Czytać adres IPv4 jako cztery liczby 8-bitowe.

## Wymagania wstępne
- Kartka i ołówek (lub plik tekstowy).
- [Lekcja Liczby binarne i szesnastkowe](lesson.pl.md) z tego modułu.
- Opcjonalnie, tylko do Kroku 4: Python 3 na twoim komputerze. Nic więcej nie jest potrzebne i nigdy nie potrzebujesz konta w chmurze.

> [!NOTE]
> Wszystko tutaj jest bezpieczne: robisz tylko obliczenia na papierze. Adresy w tym ćwiczeniu służą wyłącznie jako przykłady: `192.168.1.10` to adres prywatny (RFC 1918), a `00:00:5e:00:53:01` to adres MAC zarezerwowany na potrzeby dokumentacji (RFC 7042).

## Architektura
![Przebieg ćwiczenia. Cztery ponumerowane kroki połączone strzałkami. Krok 1, tabela wag pozycji: wypełnij osiem kolumn dla kilku liczb. Krok 2, adres IP: zamień 192.168.1.10 na cztery bajty z bitów. Krok 3, hex i adres MAC: zamień cyfry szesnastkowe, potem czytaj 00:00:5e:00:53:01 bajt po bajcie. Krok 4, sprawdź w Pythonie: opcjonalnie, niech komputer potwierdzi twoje odpowiedzi.](../../../assets/diagrams/binhex-lab-architecture.pl.svg)

*Rysunek 1. Kroki 1–3 wykonujesz na papierze; krok 4 to opcjonalne sprawdzenie na komputerze.*

## Kroki

### Krok 1 — Wypełnij tabelę wag pozycji (10 min)
Narysuj ten wiersz na kartce. To twoje narzędzie do wszystkiego, co dalej, więc przepisz go dokładnie:

| Waga pozycji | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
|---|---|---|---|---|---|---|---|---|

**Część A: z dziesiętnego na binarny.** Dla każdej liczby idź od lewej do prawej. Jeśli waga pozycji mieści się w tym, co ci zostało, zapisz `1` i odejmij ją; jeśli nie, zapisz `0`. Zamień te pięć liczb na 8 bitów:

1. 5
2. 13
3. 37
4. 100
5. 150

**Część B: z binarnego na dziesiętny.** Zapisz każdą liczbę pod wierszem wag pozycji i dodaj kolumny, w których jest 1:

1. `00000110`
2. `01000001`
3. `10100000`
4. `11111110`

Spróbuj rozwiązać wszystkie, zanim otworzysz odpowiedzi.

<details>
<summary>Pokaż odpowiedzi</summary>

| Część A: dziesiętnie | Mieszczące się kolumny | Binarnie |
|---|---|---|
| 5 | 4 + 1 | `00000101` |
| 13 | 8 + 4 + 1 | `00001101` |
| 37 | 32 + 4 + 1 | `00100101` |
| 100 | 64 + 32 + 4 | `01100100` |
| 150 | 128 + 16 + 4 + 2 | `10010110` |

| Część B: binarnie | Kolumny z jedynką | Dziesiętnie |
|---|---|---|
| `00000110` | 4 + 2 | 6 |
| `01000001` | 64 + 1 | 65 |
| `10100000` | 128 + 32 | 160 |
| `11111110` | 128 + 64 + 32 + 16 + 8 + 4 + 2 (wszystko oprócz 1) | 254 |

Skrót dla ostatniej: `11111111` to 255, a tej liczbie brakuje końcowej jedynki, więc to 254.

Jeśli wynik był błędny, dodaj ponownie kolumny swojej odpowiedzi binarnej. Powinno wyjść to, od czego zacząłeś.

</details>

### Krok 2 — Zamień adres IP na bity (7 min)
Twój domowy router ma często adres taki jak `192.168.1.10`. To cztery bajty zapisane dziesiętnie. Zamień każdy bajt na 8 bitów za pomocą swojej tabeli:

1. 192
2. 168
3. 1
4. 10

Potem zapisz cały adres jako cztery grupy po 8 bitów oddzielone kropkami.

<details>
<summary>Pokaż odpowiedź</summary>

| Dziesiętnie | Mieszczące się kolumny | Binarnie |
|---|---|---|
| 192 | 128 + 64 | `11000000` |
| 168 | 128 + 32 + 8 | `10101000` |
| 1 | 1 | `00000001` |
| 10 | 8 + 2 | `00001010` |

Adres binarnie to `11000000.10101000.00000001.00001010`. W sumie to 4 × 8 = 32 bity.

</details>

### Krok 3 — System szesnastkowy i adres MAC (8 min)
**Część A: zamiany hex.** Użyj tabeli `0=0000, 1=0001 … 7=0111, 8=1000, 9=1001, A=1010, B=1011, C=1100, D=1101, E=1110, F=1111` (możesz ją odtworzyć za pomocą wag 8, 4, 2, 1).

1. Zamień bajt hex `A7` na 8 bitów, a potem na zapis dziesiętny.
2. Zamień bajt hex `3F` na 8 bitów, a potem na zapis dziesiętny.
3. Zamień bajt binarny `11010110` na dwie cyfry hex.

**Część B: odczytaj adres MAC.** Oto adres MAC zarezerwowany na potrzeby dokumentacji: `00:00:5e:00:53:01`.

1. Ile ma bajtów i ile cyfr hex?
2. Zapisz każdy bajt dziesiętnie (podpowiedź: bajt hex to pierwsza cyfra × 16 plus druga cyfra).
3. Zapisz bajt `5e` binarnie.

<details>
<summary>Pokaż odpowiedzi</summary>

**Część A**

| Hex | Cyfra po cyfrze | Binarnie | Dziesiętnie |
|---|---|---|---|
| `A7` | A = 10 = `1010`, 7 = `0111` | `10100111` | 167 (128 + 32 + 4 + 2 + 1) |
| `3F` | 3 = `0011`, F = 15 = `1111` | `00111111` | 63 (32 + 16 + 8 + 4 + 2 + 1) |
| `11010110` | `1101` = 13 = D, `0110` = 6 = 6 | | `D6` |

**Część B**

1. Sześć bajtów i 12 cyfr hex (po dwie na bajt).
2. `00` = 0, `00` = 0, `5e` = 5 × 16 + 14 = 94, `00` = 0, `53` = 5 × 16 + 3 = 83, `01` = 1. Zatem adres MAC dziesiętnie to 0, 0, 94, 0, 83, 1.
3. `5e`: 5 = `0101`, e = 14 = `1110`, więc `01011110`.

</details>

### Krok 4 — Sprawdź odpowiedzi w Pythonie (opcjonalnie, 5 min)
Możesz pominąć ten krok. Jeśli chcesz, żeby komputer sprawdził twoją pracę, możesz użyć **Pythona**, języka programowania, który działa jak bardzo sprytny kalkulator. Nie musisz umieć programować: wpisujesz krótką linijkę i czytasz odpowiedź.

**Otwórz terminal** (okno, w którym wpisuje się polecenia tekstowe):
- **Windows:** naciśnij klawisz Start, wpisz `cmd` i naciśnij Enter. Potem wpisz `py` i naciśnij Enter.
- **macOS:** naciśnij Cmd + Spacja, wpisz `Terminal` i naciśnij Enter. Potem wpisz `python3` i naciśnij Enter.
- **Linux:** otwórz aplikację terminala. Potem wpisz `python3` i naciśnij Enter.

Powinieneś zobaczyć linię zaczynającą się od `>>>`. To Python czeka na ciebie. (Jeśli komputer zgłosi, że nie znaleziono polecenia, Pythona nie ma zainstalowanego: pomiń ten krok, jest opcjonalny.) Wpisz każdą z poniższych linijek i naciśnij Enter. Numer wersji twojego Pythona może się różnić; odpowiedzi nie.

```python
bin(37)
int("00100101", 2)
format(37, "08b")
hex(200)
int("c8", 16)
format(200, "02x")
```

Wynik:
```text
'0b100101'
37
'00100101'
'0xc8'
200
'c8'
```

Co robi każda linijka:
- `bin(37)` zamienia liczbę dziesiętną 37 na binarną. Python dodaje przedrostek `0b`, by pokazać, że to zapis binarny, i pomija zera wiodące, więc `0b100101` to to samo co `00100101`.
- `int("00100101", 2)` zamienia tekst binarny na liczbę dziesiętną. Liczba `2` oznacza „ten tekst jest w systemie o podstawie 2” (binarnym).
- `format(37, "08b")` znów zamienia 37 na binarne, ale dopełnione do 8 cyfr (`08b` znaczy „8 znaków, z zerami z lewej strony, binarnie”). To postać, którą zapisałeś ręcznie.
- `hex(200)` zamienia liczbę dziesiętną 200 na hex. Python dodaje przedrostek `0x`.
- `int("c8", 16)` zamienia tekst hex na liczbę dziesiętną. Liczba `16` oznacza „ten tekst jest w systemie o podstawie 16”.
- `format(200, "02x")` zamienia 200 na hex dopełnione do 2 cyfr (`02x` znaczy „2 znaki, zera z lewej strony, hex”).

Teraz sprawdź jedną ze swoich odpowiedzi. Na przykład bajt MAC `5e` i bajt IP 168:

```python
int("5e", 16)
format(168, "08b")
```

Wynik:
```text
94
'10101000'
```

Oba zgadzają się z tym, co wyszło ci na papierze. Wypróbuj jeszcze kilka własnych liczb. Aby wyjść z Pythona, wpisz `exit()` i naciśnij Enter.

> [!NOTE]
> Apostrofy (`'...'`) w wyniku pokazują tylko, że Python zwraca tekst. Nie są częścią liczby.

## Weryfikacja
Skończyłeś, gdy:
- Wszystkie twoje odpowiedzi z części A i B w Kroku 1 się zgadzają albo znalazłeś i zrozumiałeś każdy błąd.
- Zapisałeś `192.168.1.10` jako `11000000.10101000.00000001.00001010`.
- Potrafisz powiedzieć, dlaczego adres MAC ma 6 bajtów i 12 cyfr hex.
- Opcjonalnie: Python dał te same odpowiedzi co twoja kartka.

## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| Twoja odpowiedź binarna daje w sumie inną liczbę | Pominięta kolumna lub błąd w odejmowaniu | Zrób to od nowa kolumna po kolumnie, za każdym razem zapisując „zostaje po odjęciu”; sprawdź, dodając kolumny z powrotem |
| Twoja liczba binarna ma mniej niż 8 cyfr | Pominąłeś zera wiodące | Dopisz zera z lewej strony, aż będzie 8 cyfr |
| Zamiana hex wygląda źle | Potraktowałeś A–F jak 1–6 | A to 10, B to 11, C to 12, D to 13, E to 14, a F to 15 |
| Python pisze `command not found` lub `'py' is not recognized` | Python nie jest zainstalowany na twoim komputerze | Pomiń Krok 4; jest opcjonalny |
| Python pokazuje `SyntaxError` | Brakuje cudzysłowu lub nawiasu albo wpisałeś `>>>` | Wpisz linijkę dokładnie tak, jak pokazano, bez `>>>` |

## Wyzwanie (opcjonalne)
Zamień na zapis binarny adres IP swojego komputera lub telefonu. Znajdziesz go w ustawieniach sieci (szukaj „adres IPv4”). To twoja własna wartość, więc będzie inna niż w przykładach; większość domowych adresów zaczyna się od `192.168.` lub `10.`. Potem zapisz pierwszy bajt w hex.

## Sprzątanie
Nie ma nic do sprzątania: użyłeś tylko kartki i opcjonalnie okna Pythona. Wpisz `exit()`, aby zamknąć Pythona, jeśli jest jeszcze otwarty.

## Co już umiesz
- Tabela wag pozycji zamienia dowolną liczbę od 0 do 255 na 8 bitów i z powrotem.
- Jedna cyfra hex to 4 bity, więc bajt to dwie cyfry hex.
- Adres IPv4 to cztery bajty (32 bity), a adres MAC to sześć bajtów (12 cyfr hex).
- Komputer może sprawdzić twoją pracę, ale to wszystko możesz zrobić ołówkiem.
