Basisumwandlung -- Binär, Dezimal, Hexadezimal

In dieser Lektion beherrschen Sie die Umwandlungsmethoden zwischen drei Zahlensystemen und verstehen, warum Hexadezimal die "beste Abkürzung" für Binär ist.


Alltagsanalogie: mehrere Zählsysteme

Verschiedene Zahlenbasen sind wie verschiedene "Maßeinheiten."

Menschen sind an das Dezimalsystem gewöhnt, so wie sie daran gewöhnt sind, die Höhe in "Metern" zu messen.

Computer verwenden Binär, als würden sie in "Schaltzuständen" denken.

Hexadezimal hingegen ist die „Kurzschrift“ eines Ingenieurs – es drückt langen Binärcode kompakter aus.

Zum Beispiel: wenn das Wort „EXAMPLE“ in drei „Sprachen“ ausgedrückt wird:

  • Dezimal: die menschliche Sprache:82 85 78 79 79 66
  • Binär: die Maschinensprache:01010010 01010101 01001110 01001111 01001111 01000010
  • Hexadezimale Kurzschrift:52 55 4E 4F 4F 42

Derselbe Ausdruck ist in Binär 4-mal so lang wie in Hexadezimal.

Deshalb müssen wir die Basisumrechnung lernen.


Das Wesen der Basen: Entwicklung nach Gewichten

Die Prinzipien aller Basen sind genau dieselben –Multipliziere die Ziffer an jeder Position mit einer Potenz der Basis und addiere sie dann alle zusammen.。

Nimm die Zahl 42 als Beispiel und sieh, wie sie in jeder der drei Basen interpretiert wird:

BasisBasisVerfügbare ZiffernRepräsentiertGewichtete Expansion
decimal100 ~ 9424 x 101 + 2 x 100 = 42
binär20, 11010101x25+0x24+1x23+0x22+1x21+0x20 = 42
Hexadezimal160~9, A~F2A2 x 161 + 10 x 160 = 42

Schlüsselregel:Die 'Basis' eines Zahlensystems bestimmt die Gewichtung jeder Ziffer。

Das Dezimalsystem hat die Basis 10, und die Stellenwerte sind Potenzen von 10.0=1, Zehnerstelle 101=10, Hunderterstelle 102=100。

Binärsystem Basis 2; die Gewichte von rechts nach links sind 1, 2, 4, 8, 16, 32, 64, 128.

Das Hexadezimalsystem hat die Basis 16, und die Gewichte von rechts nach links sind 1, 16, 256, 4096.

Sobald du die "Expansion durch Gewichte" verstehst, werden alle Basisumrechnungen einfach. Der einzige Satz, den du dir merken musst, ist: Jede Ziffer mit der Basis hoch dem Positionsindex multiplizieren, dann alles summieren.


Methode 1: Dezimal zu Binär (wiederholte Division durch 2, Reste notieren)

Angenommen, du möchtest die Dezimalzahl 42 in eine Binärzahl umwandeln.

Die Methode ist ziemlich mechanisch:

  1. Teile 42 durch 2; Quotient ist 21, Rest0
  2. Teile 21 durch 2; Quotient ist 10, Rest1
  3. Teile 10 durch 2; Quotient ist 5, Rest0
  4. Teile 5 durch 2, Quotient 2, Rest1
  5. Teile 2 durch 2, Quotient 1, Rest0
  6. Teile 1 durch 2, Quotient 0, Rest1
  7. Lies die Reste von unten nach oben:101010
42 ÷ 2 = 21Rest0← (niedrigstwertiges Bit)
21 ÷ 2 = 10Rest1
10 ÷ 2 = 5Rest0
5 ÷ 2 = 2Rest1
2 ÷ 2 = 1Rest0
1 ÷ 2 = 0Rest1← (höchstwertiges Bit)
Ergebnis: Lies die Reste von unten nach oben =101010

Warum funktioniert diese Methode?

Die Essenz des Binären ist: N = d0x20 + d1x21 + d2x22 + ...

Wenn N durch 2 geteilt wird, ist der Rest d0(das niedrigstwertige Bit), und der Quotient wird fortlaufend durch 2 geteilt, um das nächste Bit zu erhalten.

Diese Logik ist genau dieselbe wie die "Division durch 10, um die Einerstelle zu erhalten", die du in der Grundschule gelernt hast.


Methode 2: Binär zu Dezimal (Entwicklung nach Gewichten)

Die Umwandlung von Binär zurück zu Dezimal ist noch einfacher — man addiert einfach die Gewichte direkt.

binär101010(Nummeriere die Positionen von rechts nach links als 0 bis 5):

Position543210
Binärbit101010
Gewicht (2^n)32168421
Bit x Gewicht1x320x161x80x41x20x1

1x32 + 0x16 + 1x8 + 0x4 + 1x2 + 0x1 = 42


Hexadezimal: "Kurzschreibweise" für Binär

Das größte Problem des Binärsystems istZu lang, um es auszuschreiben。

Ein 8-Bit-Wert erfordert das Schreiben von 8 Ziffern, und ein 32-Bit-Wert erfordert 32 Ziffern.

Dies ist für Menschen unbequem zu lesen und fehleranfällig.

Hexadezimal löst dieses Problem aufgrund einer wichtigen mathematischen Koinzidenz:

24= 16 → alle 4 Binärbits entsprechen genau 1 Hexadezimalziffer

Zuordnungstabelle von 4 Binärbits zu 1 Hexadezimalziffer

Binär (4 Bits)decimalHexadezimalBinär (4 Bits)decimalHexadezimal
000000100088
000111100199
001022101010A
001133101111B
010044110012C
010155110113D
011066111014E
011177111115F

Diese Tabelle ist der Kern des Hexadezimalsystems.

Sobald du sie auswendig gelernt hast, wird jede Umwandlung von Binär in Hexadezimal zu einer mechanischen "Tabelle nachschlagen und die Ziffer entnehmen"-Operation.

Beispiel: Umwandlung von Binär 11111111 in Hexadezimal

8 Binärbits werden in zwei Gruppen zu je 4 Bits aufgeteilt:

1111 = F    1111 = F→ Ergebnis:0xFF

In der Programmierung,0xDas Präfix kennzeichnet Hexadezimal (z. B.,0xFF),0bDas Präfix kennzeichnet Binär (z. B.,0b11111111). Diese Präfixe sagen dem Compiler: Dies ist keine Dezimalzahl.


Interaktive Demo: dreispaltiger synchroner Konverter

Der Konverter unten ermöglicht es Ihnen, die Entsprechung zwischen den drei Basen in Echtzeit zu beobachten.

Geben Sie einen Wert in eine beliebige Spalte ein, die anderen beiden Spalten werden automatisch synchronisiert und aktualisiert.

Achten Sie auf die hervorgehobenen Farbblöcke unter der Binärspalte — sie zeigen4 Bits pro Gruppe entsprechen 1 HexadezimalzifferZusammenhang.

Decimal

Basis=10, Ziffern=0~9

Binary

Basis=2, Ziffern=0,1

Hexadezimal Hex

Basis=16, Ziffern=0~F

Probieren Sie es aus: Geben Sie 255 in die Dezimalspalte ein und beobachten Sie, wie in der Binärspalte nur Einsen und in der Hexadezimalspalte FF stehen.

Dies ist "der Maximalwert eines Bytes" — wenn Sie das einmal verstanden haben, werden viele Konzepte klar.


Code-Demo: vollständige Basisumwandlung

Beispiel

# Vollständiges Werkzeug zur Basisumrechnung (Beispieldemo)

def decimal_to_binary(n):
    """Dezimal zu Binär: Division durch 2 und Restverfahren mit vollständigen Schritten"""
    if n == 0:
        return "0"
    steps = []
    original = n
    while n > 0:
        remainder = n % 2
        quotient = n // 2
        steps.append((n, quotient, remainder))
        n = quotient

    result = ''.join(str(r) for _, _, r in reversed(steps))
    print(f"{original} in Binär umgewandelt:")
    for val, quot, rem in steps:
        print(f{val:3d} ÷ 2 = {quot:3d} Rest {rem})
    print(f" → Ergebnis: {result}")
    return result

def binary_to_decimal(bin_str):
    """Binär zu Dezimal: gewichtete Expansionsmethode"""
    decimal = 0
    length = len(bin_str)
    print(fBinär {bin_str} nach Gewichten expandiert:)
    for i, ch in enumerate(bin_str):
        power = length - 1 - i
        if ch == '1':
            value = 2 ** power
            decimal += value
            print(fBit {power}: 1 x 2^{power} = {value})
    print(f" → Summe: {decimal}")
    return decimal

def bin_to_hex(bin_str):
    """Binär zu Hexadezimal: Nachschlagen in einer Tabelle in 4-Bit-Gruppen"""
    while len(bin_str) % 4 != 0:
        bin_str = '0' + bin_str
    hex_map = {
        '0000':'0','0001':'1','0010':'2','0011':'3',
        '0100':'4','0101':'5','0110':'6','0111':'7',
        '1000':'8','1001':'9','1010':'A','1011':'B',
        '1100':'C','1101':'D','1110':'E','1111':'F'
    }
    result = ''
    groups = []
    for i in range(0, len(bin_str), 4):
        group = bin_str[i:i+4]
        hex_char = hex_map[group]
        groups.append(f"{group} → {hex_char}")
        result += hex_char
    print(f"Binär {bin_str} zu Hexadezimal:")
    for g in groups:
        print(f"  {g}")
    print(f"  → 0x{result}")
    return result

def hex_to_bin(hex_str):
    """Hexadezimal zu Binär: jede Ziffer in 4 Bits erweitern"""
    rev_map = {
        '0':'0000','1':'0001','2':'0010','3':'0011',
        '4':'0100','5':'0101','6':'0110','7':'0111',
        '8':'1000','9':'1001','A':'1010','B':'1011',
        'C':'1100','D':'1101','E':'1110','F':'1111'
    }
    hex_str = hex_str.upper()
    result = ''
    for ch in hex_str:
        expanded = rev_map[ch]
        result += expanded
        print(f"  {ch} → {expanded}")
    # Führende Nullen entfernen (aber mindestens eine Ziffer behalten)
    result = result.lstrip('0') or '0'
    print(f" → {result}")
    return result

Umfassender Test: Zentriert auf ASCII-Code 82 des EXAMPLE-Zeichens 'R'
print("=" * 50)
print(Testwert: 82 (ASCII 'R' aus EXAMPLE))
print("=" * 50)
bin_result = decimal_to_binary(82)
print(f"82 → binär: {bin_result}\n")

dec_result = binary_to_decimal(bin_result)
print()

hex_result = bin_to_hex(bin_result)
print()

print("Umgekehrte Überprüfung: hexadezimal → binär")
hex_to_bin(hex_result)

print("\n" + "=" * 50)
print(Testwert: 255 (Maximalwert eines Bytes))
print("=" * 50)
bin_255 = decimal_to_binary(255)
print(fBinär: {bin_255})
hex_255 = bin_to_hex(bin_255)
print(f"Hexadezimal: 0x{hex_255}")
print(Hinweis: Die binäre Darstellung von 255 besteht aus 8 Bits, die alle 1 sind, aber die hexadezimale Darstellung verwendet nur 2 Ziffern, FF.)

Fortgeschritten: Schnelle Umwandlung von Hexadezimal in Dezimal

Sie kennen bereits zwei Methoden zur Umwandlung in Dezimal: Eine ist die Entwicklung nach Gewichten (jede Hexadezimalziffer multipliziert mit einer Potenz von 16), und die andere ist die Umwandlung zuerst in Binär und dann in Dezimal.

Aber es gibt eine praktischere Methode –Binär als 'Zwischensprache' zu verwenden。

Jede Basisumwandlung kann Binär als Brücke verwenden:

Dezimal ←→ Binär ←→ Hexadezimal

Denn die direkte Umwandlung zwischen Dezimal und Hexadezimal ist mit mehr Rechenaufwand verbunden, aber die Umwandlung von jeder Basis in Binär und zurück ist sehr einfach.

Dezimal in Binär: durch 2 teilen und den Rest nehmen.

Hexadezimal in Binär: durch Nachschlagen in der Tabelle erweitern (jede einzelne Ziffer wird zu 4 Bits).

Weitere Erweiterungen