Python преобразует десятичный код в шестнадцатеричный

Ответ 1

Если вы хотите закодировать это самостоятельно, вместо использования встроенной функции hex(), вы можете просто выполнить рекурсивный вызов перед печатью текущей цифры:

def ChangeHex(n):
    if (n < 0):
        print(0)
    elif (n<=1):
        print n,
    else:
        ChangeHex( n / 16 )
        x =(n%16)
        if (x < 10):
            print(x), 
        if (x == 10):
            print("A"),
        if (x == 11):
            print("B"),
        if (x == 12):
            print("C"),
        if (x == 13):
            print("D"),
        if (x == 14):
            print("E"),
        if (x == 15):
            print ("F"),

Ответ 2

Как насчет этого:

hex(dec).split('x')[-1]

Пример:

>>> d = 30
>>> hex(d).split('x')[-1]
'1e'

~ Рич

Используя -1 в результате split(), это будет работать, даже если split возвращает список из 1 элемента.

Ответ 3

Это не совсем то, что вы просили, но вы можете использовать функцию "hex" в python:

>>> hex(15)
'0xf'

Ответ 4

Я думаю, что это решение элегантно:

def toHex(dec):
    x = (dec % 16)
    digits = "0123456789ABCDEF"
    rest = dec / 16
    if (rest == 0):
        return digits[x]
    return toHex(rest) + digits[x]

numbers = [0, 11, 16, 32, 33, 41, 45, 678, 574893]
print [toHex(x) for x in numbers]
print [hex(x) for x in numbers]

Этот вывод:

['0', 'B', '10', '20', '21', '29', '2D', '2A6', '8C5AD']
['0x0', '0xb', '0x10', '0x20', '0x21', '0x29', '0x2d', '0x2a6', '0x8c5ad']

Ответ 5

Я использую

"0x%X" % n

где n - десятичное число для преобразования.

Ответ 6

Если без '0x' префикса:

'{0:x}'.format(int(dec))

else использовать встроенный hex() funtion.

Ответ 7

Метод строкового формата Python может принимать спецификацию формата.

От десятичной до двоичной

"{0:b}".format(154)
'10011010'

От десятичной до восьмеричной

"{0:o}".format(154)
'232'

От десятичного до шестнадцатеричного

"{0:x}".format(154)
'9a'

Формат спецификаций для Python 2

Формат спецификаций для Python 3

Ответ 8

Чтобы получить чистое шестнадцатеричное значение, это может быть полезно. Это основано на ответе Джо:

def gethex(decimal):
    return hex(decimal)[2:]

Ответ 9

def main():
    result = int(input("Enter a whole, positive, number to be converted to hexadecimal: "))
    hexadecimal = ""
    while result != 0:
        remainder = changeDigit(result % 16)
        hexadecimal = str(remainder) + hexadecimal
        result = int(result / 16)
    print(hexadecimal)

def changeDigit(digit):
    decimal =     [10 , 11 , 12 , 13 , 14 , 15 ]
    hexadecimal = ["A", "B", "C", "D", "E", "F"]
    for counter in range(7):
        if digit == decimal[counter - 1]:
            digit = hexadecimal[counter - 1]
    return digit

main()

Это самое плотное, что я мог бы сделать для преобразования десятичного в шестнадцатеричный. ПРИМЕЧАНИЕ. Это в версии 3.5.1 Python.

Ответ 10

Помимо использования встроенной функции hex(), это хорошо работает:

letters = [0,1,2,3,4,5,6,7,8,9,'A','B','C','D','E','F']
decimal_number = int(input("Enter a number to convert to hex: "))
print(str(letters[decimal_number//16])+str(letters[decimal_number%16]))

Однако это работает только для преобразования десятичных чисел до 255 (чтобы получить шестнадцатеричное шестнадцатеричное число).

Ответ 11

Вместо того, чтобы печатать все в функции, вы можете просто позволить ей вернуть значение в шестнадцатеричном формате и делать с ним все, что хотите.

def ChangeHex(n):
    x = (n % 16)
    c = ""
    if (x < 10):
        c = x
    if (x == 10):
        c = "A"
    if (x == 11):
        c = "B"
    if (x == 12):
        c = "C"
    if (x == 13):
        c = "D"
    if (x == 14):
        c = "E"
    if (x == 15):
        c = "F"

    if (n - x != 0):
        return ChangeHex(n / 16) + str(c)
    else:
        return str(c)

print(ChangeHex(52))

Есть, вероятно, более элегантные способы разбора алфавитных компонентов шестнадцатеричного кода вместо использования условных выражений.

Ответ 12

Версия с итерацией:

def toHex(decimal):
    hex_str = ''
    digits = "0123456789ABCDEF"
    if decimal == 0:
       return '0'

    while decimal != 0:
        hex_str += digits[decimal % 16]
        decimal = decimal // 16

    return hex_str[::-1] # reverse the string

numbers = [0, 16, 20, 45, 255, 456, 789, 1024]
print([toHex(x) for x in numbers])
print([hex(x) for x in numbers])

Ответ 13

hex_map = {0:0, 1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8, 9:9, 10:'A', 11:'B', 12:'C', 13:'D', 14:'E', 15:'F'}

def to_hex(n):
    result = ""
    if n == 0:
        return '0'
    while n != 0:
        result += str(hex_map[(n % 16)])
        n = n // 16
    return '0x'+result[::-1]

Ответ 14

n = eval(input("Enter the number:"))
def ChangeHex(n):
    if (n < 0):
        print(0)
    elif (n<=1):
        print(n),
    else:
        ChangeHex( n / 16 )
        x =(n%16)
        if (x < 10):
            print(x), 
        if (x == 10):
            print("A"),
        if (x == 11):
            print("B"),
        if (x == 12):
            print("C"),
        if (x == 13):
            print("D"),
        if (x == 14):
            print("E"),
        if (x == 15):
            print ("F"),

Ответ 15

Это лучший способ использовать его

hex(53350632996854).lstrip("0x").rstrip("L")
# lstrip helps remove "0x" from the left  
# rstrip helps remove "L" from the right 
# L represents a long number

Пример:

>>> decimal = 53350632996854
>>> hexadecimal = hex(decimal).lstrip("0x")
>>> print(hexadecimal)
3085a9873ff6

если вам нужен верхний регистр, можете использовать "верхнюю функцию", например:

decimal = 53350632996854
hexadecimal = hex(decimal).lstrip("0x").upper()
print(hexadecimal)
3085A9873FF6

Ответ 16

Чтобы поставить число в правильном порядке, я изменил ваш код, чтобы иметь переменную (и) для вывода. Это позволяет вам расположить символы в правильном порядке.

s=""
def ChangeHex(n):
    if (n < 0):
        print(0)
    elif (n<=1):
        print(n)
    else:
        x =(n%16)
        if (x < 10):
            s=str(x)+s, 
        if (x == 10):
            s="A"+s,
        if (x == 11):
            s="B"+s,
        if (x == 12):
            s="C"+s,
        if (x == 13):
            s="D"+s,
        if (x == 14):
            s="E"+s,
        if (x == 15):
            s="F"+s,
        ChangeHex( n / 16 )        

ПРИМЕЧАНИЕ: Это было сделано в Python 3.7.4, поэтому он может не работать для вас.

Ответ 17

нерекурсивный подход для преобразования десятичного в шестнадцатеричный

def to_hex(dec):

    hex_str = ''
    hex_digits = ('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F')
    rem = dec % 16

    while dec >= rem:
        remainder = dec % 16
        quotient = dec / 16
        if quotient == 0:
            hex_str += hex_digits[remainder]
        else:
            hex_str += str(remainder)
        dec = quotient

    return hex_str[::-1] # reverse the string

Ответ 18

Это работает довольно хорошо:

def toHex(n):
    result, remainder = n, []
    while result > 0:
        rem = result%16
        result = result // 16
        if rem < 10:
            remainder.append(str(rem))
        else:
            if rem == 10:
                remainder.append('A')
            if rem == 11:
                remainder.append('B')
            if rem == 12:
                remainder.append('C')
            if rem == 13:
                remainder.append('D')
            if rem == 14:
                remainder.append('E')
            if rem == 15:
                remainder.append('F')
    return ''.join(remainder[::-1])

Ответ 19

dec = int(input("Enter a number below 256: "))
hex1 = dec // 16

if hex1 >= 10:
    hex1 = hex(dec)

hex2 = dec % 16
if hex2 >= 10:
    hex2 = hex(hex2)

print(hex1.strip("0x"))

Работает хорошо.