Systemy liczbowe

Hejka
Jak napisać program zmieniający liczbę z dowolnego systemu na dowolny? Proszę o jakieś tipy :D
Może chociaż zmieniający z systemu dwójkowego na dziesiętny. :)

Wystarczy zaimplementować odpowiednie algorytmy.

Przepraszam za głupie pytania, ale jestem totalnym świeżakiem. Chodzi o funkcje z biblioteki? Możesz powiedzieć coś więcej? ;)

https://www.matematyka.pl/31826.htm

Masz tu parę z dziesiętnego na binary/szesnastkowy, funkcja na parę linijek.

Nie jestem dobrym Pythonowcem więc mogę się w tym momencie mylić, ale odpowiedziałbym tak:

print(hex(5)) # 0x5
print(oct(5)) # 0o5
print(bin(5)) # 0b101

var = int(0b101) # 5
var = int(0o5) # 5
var = int(0x5) # 5

1 grupa - dec -> inny system
2 grupa - inny system -> dec

Typy dwójkowy, ósemkowy, dziesiętny i szesnastkowy są wbudowane w Pythona, jak np zamieniasz z dwójkowego na dziesiętny, to będzie int(0b i tu twoja liczba w systemie dwójkowym bez żadnych spacji), np int(0b1010). Z dziesiętnego na dwójkowy przeliczasz przez bin(liczba, zaś co do szesnastkowego to int(0xliczba) jak na dziesiętny oraz hex(liczba) jak z dziesiętnego na szesnastkowy. Dla ósemkowego to odpowiednio int(0oliczba) oraz oct(liczba)

Przede wszystkim to pogoogluj trochę :)

print int('0x5', 16)  # hex to int
print int('11111111', 2)  # bin to int

i tak dalej :)

#!/usr/bin/env python3

def convertInt2Base(value, base):
    assert base > 1
    import string
    digs = string.digits + string.ascii_uppercase

    sign = -1 if value < 0 else 1
    if value == 0:
        return digs[0]

    value *= sign
    digits = []

    while value:
        digits.append(digs[value % base])
        value //= base

    if sign < 0:
        digits.append('-')

    digits.reverse()

    return ''.join(digits)

if __name__ == '__main__':
    print(convertInt2Base(1024, 2))
    print(convertInt2Base(255, 16))
    print(convertInt2Base(10, 8))

Pewnie można szybciej i sprawniej ale często prostota jest ważniejsza niż "honowanie" kodu.

Dziękuję bardzo wszystkim. Spróbuję to zrozumieć. :D

Tu Masz prosty do zrozumienia algorytm rekurencyjny:

def dec_to_bin(n, out=""):
    if n == 0:
        return out[::-1]
    out += str(n % 2)
    return dec_to_bin(n // 2, out)

print(dec_to_bin(111))

Jak to działa? Jak widać:)

• Bierze resztę z dzielenia przez dwa wejściowej liczby i dodaje ją do wynikowego stringa out (to będzie ostatnia cyfra binarna wyniku)
• Wykonuje to samo (rekurencyjnie) dla liczby 2 krotnie mniejszej (wywołanie funkcji od n // 1, out)
• W miedzy czasie sprawdzany jest warunek zatrzymania sie rekurencji, jeśli w końcu wywołamy funkcję od zera (a będziemy musieli), to zwracamy wynik (odwrócony) i funkcja kończy działanie.
  Notka o pythonie:
• out[::-1] to jedno z miagicznych pythonowych "hojo mojo" - odwraca string lub listę;
• out="" - parametr domyślny funkcji - nie tzreba go potem wpisywać przy wywołaniu (wołamy jak funkcję jednej zmiennej);
• n // 2 - to dzielenie w integerach, czyli 5 /// 2 zwraca 2, 1 // 3 zwraca 0, itd.

Zapewne rekurencja nie jest idealna (dla wielkich liczb rozwali stos ), ale prostota tego algorytmu czyni go idealnym przykładem do analizy, zrozumienia działania.
W drugą stronę(bin - dec) jest już prosto, bo, np:
1001(bin) = 1 * 2^3 + 0 * 2^2 + 0 * 2^1 + 1 * 2^0 = 9
Czyli wystarczy, posumować po długości stringa wejściowego.