Die Python-Funktion bin() ist eine eingebaute Funktion, die Ganzzahlen in ihre binäre Darstellung als Zeichenkette umwandelt. Sie liefert das Ergebnis als String mit dem Präfix 0b, das die Binärform kennzeichnet. Diese Funktion ist besonders nützlich bei Aufgaben, die bitweise Operationen, Datenanalyse oder die Visualisierung von Binärdaten erfordern. Mit ihrer einfachen Syntax erleichtert bin() die Arbeit mit binären Zahlen in Python und unterstützt die effiziente Umsetzung zahlreicher Programmieraufgaben.

01 · Abschnitt

Einführung

Die bin() Funktion ist eine eingebaute Funktion in Python, die zur Konvertierung von Ganzzahlen in ihre binäre Darstellung verwendet wird. Sie konvertiert eine Ganzzahl in eine binäre Darstellung.

02 · Abschnitt

Syntax

Python Syntax 
bin(x)
Parameter
x

Eine Ganzzahl, die konvertiert werden soll. Es muss eine Ganzzahl sein. Sie kann dabei positiv, negativ oder null sein.

03 · Abschnitt

Rückgabewert

Typ: str (String)

Format des Rückgabewerts:

  • Positive Zahlen: '0b' + binäre_darstellung
  • Negative Zahlen: '-0b' + binäre_darstellung_des_absolutwerts
  • Null: 0b0
04 · Abschnitt

Besonderheiten

Umgang mit negativen Zahlen

Negative Zahlen werden nicht im Zweierkomplement dargestellt. Stattdessen wird das Minuszeichen vor das 0b Präfix gesetzt. Dies unterscheidet sich von der internen Speicherrepräsentation.

Präfix-Handling

  • Das 0b Präfix ist immer Teil des Rückgabewerts
  • Zum Entfernen des Präfixes kann String-Slicing verwendet werden. bin(x)[2:]

Typ-Konvertierung

  • Funktioniert nur mit int Objekten
  • Für andere Typen muss zuerst eine Konvertierung zu int erfolgen
05 · Abschnitt

Beispiele

Grundlegende Verwendung mit positiven Zahlen

Kurz-Informationen

  • 0 in binär ist 0b0 (nur eine Null)
  • 1 in binär ist 0b1 (entspricht sich selbst)
  • 8 in binär ist 0b1000 (2³ = 8, also 1 and der 4. Stelle)
  • 255 in binär ist 0b11111111 (2⁸ - 1, alle 8 Bits gesetzt)
Python Beispiel 
res_one = bin(0)
res_two = bin(1)
res_three = bin(8)
res_four = bin(255)

print(f"bin(0) = {res_one}")
print(f"bin(1) = {res_two}")
print(f"bin(8) = {res_three}")
print(f"bin(255) = {res_four}")
Output 
bin(0) = 0b0
bin(1) = 0b1
bin(8) = 0b1000
bin(255) = 0b11111111

Negative Zahlen

Negative Zahlen erhalten ein Minuszeichen vor dem 0b Präfix. Die binäre Darstellung entspricht dem Absolutwert der Zahl. Dies ist nicht die Zweierkomplement-Darstellung, die Computer intern verwenden.

Python Beispiel 
negative_examples = [-1, -8, -255]

for num in negative_examples:
    bin_repr = bin(num)
    print(f"bin({num}) = {bin_repr}")
Output 
bin(-1) = -0b1
bin(-8) = -0b1000
bin(-255) = -0b11111111

Präfix entfernen

Man kann den Präfix entfernen, wenn man Werte ohne diesen benötigt.

Python Beispiel 
numbers = [42, 100, 1024]

for num in numbers:
    with_prefix = bin(num)
    without_prefix = bin(num)[2:]

    print(f"Zahl: {num}")
    print(f"  Mit Präfix: {with_prefix}")
    print(f"  Ohne Präfix: {without_prefix}")
    print()
Output 
Zahl: 42
Mit Präfix: 0b101010
Ohne Präfix: 101010

Zahl: 100
Mit Präfix: 0b1100100
Ohne Präfix: 1100100

Zahl: 1024
Mit Präfix: 0b10000000000
Ohne Präfix: 10000000000

Bit-Länge und Analyse

Man kann mit Hilfe von bin() die Bit-Länge ermitteln bzw. errechnen, wie viele Bits zur Darstellung benötigt werden.

Python Beispiel - Bit-Länge 
def analyze_binary(num):
    binary_str = bin(num)
    pure_binary = binary_str[2:] if num >= 0 else binary_str[3:]
    bit_length = len(pure_binary)

    print(f"Dezimal: {num}")
    print(f"Binär: {binary_str}")
    print(f"Bit-Länge: {bit_length}")
    print(f"Benötigte Potenz von 2: 2^{bit_length - 1} bis 2^{bit_length}-1)")
    print("-" * 40)

test_numbers = [1, 2, 4, 7, 15]

for num in test_numbers:
    analyze_binary(num)
Output 
Dezimal: 1
Binär: 0b1
Bit-Länge: 1
Benötigte Potenz von 2: 2^0 bis 2^1-1
----------------------------------------
Dezimal: 2
Binär: 0b10
Bit-Länge: 2
Benötigte Potenz von 2: 2^1 bis 2^2-1
----------------------------------------
Dezimal: 4
Binär: 0b100
Bit-Länge: 3
Benötigte Potenz von 2: 2^2 bis 2^3-1
----------------------------------------
Dezimal: 7
Binär: 0b111
Bit-Länge: 3
Benötigte Potenz von 2: 2^2 bis 2^3-1
----------------------------------------
Dezimal: 15
Binär: 0b1111
Bit-Länge: 4
Benötigte Potenz von 2: 2^3 bis 2^4-1
----------------------------------------

Berechtigungssystem

Das nachfolgende Beispiel, zeigt eine beispielhafte Anwendung für Anzeige von Berechtigungen.

Python Beispiel - Berechtigungen 
def show_permissions(permission_code):
    binary_repr = bin(permission_code)[2:].zfill(9)

    permissions = []

    for i in range(0, 9, 3):
        group = binary_repr[i:i+3]
        perm = ""
        perm += "r" if group[0] == "1" else "-"
        perm += "w" if group[1] == "1" else "-"
        perm += "x" if group[2] == "1" else "-"
        permissions.append(perm)

    print(f"Berechtigung {permission_code} (binär: {binary_repr})")
    print(f"Owner: {permissions[0]}, Group: {permissions[1]}, Others: {permissions[2]}")


# Beispiele für Berechtigungen
show_permissions(0b111101100)
show_permissions(0b111111111)
show_permissions(0b110100100)
Output 
Berechtigung 492 (binär: 111101100)
Owner: rwx, Group: r-x, Others: r--
Berechtigung 511 (binär: 111111111)
Owner: rwx, Group: rwx, Others: rwx
Berechtigung 420 (binär: 110100100)
Owner: rw-, Group: r--, Others: r--

Bit-Flags für Konfiguration

Python Beispiel - Bit-Flags 
class FeatureFlags:
    
    FEATURE_A = 1   # 0b0001
    FEATURE_B = 2   # 0b0010
    FEATURE_C = 4   # 0b0100
    FEATURE_D = 8   # 0b1000

    def __init__(self, flags=0):
        self.flags = flags

    def enable_feature(self, feature):
        self.flags |= feature

    def disable_feature(self, feature):
        self.flags &= ~feature

    def is_enabled(self, feature):
        return bool(self.flags & feature)

    def show_status(self):
        print(f"Aktueller Status (binär: {bin(self.flags)})")

        features = [
            (self.FEATURE_A, "Feature A"),
            (self.FEATURE_B, "Feature B"),
            (self.FEATURE_C, "Feature C"),
            (self.FEATURE_D, "Feature D"),
        ]

        for flag, name in features:
            status = "AN" if self.is_enabled(flag) else "AUS"
            print(f"   {name}: {status}")

config = FeatureFlags()
config.show_status()

print("\nAktiviere Feature A und C:")
config.enable_feature(FeatureFlags.FEATURE_A)
config.enable_feature(FeatureFlags.FEATURE_C)
config.show_status()

print("\nDeaktiviere Feature A:")
config.disable_feature(FeatureFlags.FEATURE_A)
config.show_status()
Output 
Aktueller Status (binär: 0b0)
Feature A: AUS
Feature B: AUS
Feature C: AUS
Feature D: AUS

Aktiviere Feature A und C:
Aktueller Status (binär: 0b101)
Feature A: AN
Feature B: AUS
Feature C: AN
Feature D: AUS

Deaktiviere Feature A:
Aktueller Status (binär: 0b100)
Feature A: AUS
Feature B: AUS
Feature C: AN
Feature D: AUS
/ Weiter

Zurück zu Builtin Functions

Zur Übersicht