Конвертиране на двоични, осмични и шестнадесетични числа и низове във и от тях в Python

Python може да обработва числа и низове като двоични, осмични и шестнадесетични числа, както и като обичайните десетични числа. Също така е лесно да се преобразуват между тях.

В този раздел ще бъде обяснено следното съдържание заедно с примерен код.

• Записване на цели числа в двоична, осмична и шестнадесетична система.
• Конвертиране на числа в низове в двоичен, осмичен и шестнадесетичен запис.
  • вградена функция (напр. в език за програмиране)bin(),oct(),hex()
  • низ методstr.format(), Вградени функцииformat(), f низ
  • Конвертиране на отрицателно цяло число в низ във формат за допълване на две.
• Конвертиране на низове в двоичен, осмичен и шестнадесетичен запис в числа.
  • вградена функция (напр. в език за програмиране)int()
• Примери за приложение
  • Аритметика на двоичен низ
  • Конвертиране между двоични, осмични и шестнадесетични числа

Записване на цели числа в двоична, осмична и шестнадесетична система.

Чрез добавяне на следните префикси целочислените числа int могат да бъдат записани съответно в двоична, осмична и шестнадесетична система.
Можете да използвате и главни букви.

• Двоично число:0bили0B
• Октал:0oили0O
• Шестнадесетично число:0xили0X

Изходът на print() ще бъде в десетична бройна система.

bin_num = 0b10
oct_num = 0o10
hex_num = 0x10

print(bin_num)
print(oct_num)
print(hex_num)
# 2
# 8
# 16

Bin_num = 0B10
Oct_num = 0O10
Hex_num = 0X10

print(Bin_num)
print(Oct_num)
print(Hex_num)
# 2
# 8
# 16

Дори с префикса, типът е цяло число int.

print(type(bin_num))
print(type(oct_num))
print(type(hex_num))
# <class 'int'>
# <class 'int'>
# <class 'int'>

print(type(Bin_num))
print(type(Oct_num))
print(type(Hex_num))
# <class 'int'>
# <class 'int'>
# <class 'int'>

Тъй като това е целочислен тип, той може да се използва за обикновени аритметични операции.

result = 0b10 * 0o10 + 0x10
print(result)
# 32

От версия 3.6 на Python е възможно в числата да се вмъкват подчертавания _. Повтарянето на подчертаване _ ще доведе до грешка, но можете да вмъкнете колкото искате, стига да не го повтаряте.

Подчертаването _ не влияе на числото, така че може да се използва като разделител, когато има много цифри. Например, ако вмъкнете долна черта _ на всеки четири цифри, това е лесно за четене.

print(0b111111111111 == 0b1_1_1_1_1_1_1_1_1_1_1_1)
# True

bin_num = 0b1111_1111_1111
print(bin_num)
# 4095

Конвертиране на числа в низове в двоичен, осмичен и шестнадесетичен запис.

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

• вградена функция (напр. в език за програмиране)bin(),oct(),hex()
• низ методstr.format(), Вградени функцииformat(), f низ

В този раздел също така е обяснено как да получите низ, изразен във формат на двойка за отрицателни стойности.

Вградени функции bin(), oct(), hex()

Следните вградени функции могат да преобразуват числа в двоични, осмични и шестнадесетични низове.

• Двоично число:bin()
• Октал:oct()
• Шестнадесетично число:hex()

Всяка от тях връща низ със следните префикси

• Двоично число:0b
• Октал:0o
• Шестнадесетично число:0x

• bin() — Built-in Functions — Python 3.10.0 Documentation
• oct() — Built-in Functions — Python 3.10.0 Documentation
• hex() — Built-in Functions — Python 3.10.0 Documentation

i = 255

print(bin(i))
print(oct(i))
print(hex(i))
# 0b11111111
# 0o377
# 0xff

print(type(bin(i)))
print(type(oct(i)))
print(type(hex(i)))
# <class 'str'>
# <class 'str'>
# <class 'str'>

Ако не се нуждаете от префикса, използвайте slice[2:], за да извлечете низа зад него, или използвайте format(), както е обяснено по-нататък.

print(bin(i)[2:])
print(oct(i)[2:])
print(hex(i)[2:])
# 11111111
# 377
# ff

Ако искате да го превърнете в десетичен низ, можете да използвате функцията str().

• str() — Built-in Functions — Python 3.10.0 Documentation

print(str(i))
# 255

print(type(str(i)))
# <class 'str'>

Вградена функция format(), стрингов метод str.format(), f string

Вградената функция format() и низовите методи str.format() и f-string също могат да преобразуват числа в двоични, осмични и шестнадесетични низове.

• format() — Built-in Functions — Python 3.10.0 Documentation

Чрез посочване на втория аргумент на format(), както следва, той може да бъде преобразуван съответно в двоични, осмични и шестнадесетични низове.

• Двоично число:b
• Октал:o
• Шестнадесетично число:x

print(format(i, 'b'))
print(format(i, 'o'))
print(format(i, 'x'))
# 11111111
# 377
# ff

print(type(format(i, 'b')))
print(type(format(i, 'o')))
print(type(format(i, 'x')))
# <class 'str'>
# <class 'str'>
# <class 'str'>

Ако искате да получите низ с префикс 0b,0o,0x, добавете # към низът за спецификация на форматирането.

print(format(i, '#b'))
print(format(i, '#o'))
print(format(i, '#x'))
# 0b11111111
# 0o377
# 0xff

Възможно е също така да се попълни 0 с произволен брой цифри. Имайте предвид, че броят на знаците за префикса (два знака) също трябва да се вземе предвид, когато попълвате нула с префикс.

print(format(i, '08b'))
print(format(i, '08o'))
print(format(i, '08x'))
# 11111111
# 00000377
# 000000ff

print(format(i, '#010b'))
print(format(i, '#010o'))
print(format(i, '#010x'))
# 0b11111111
# 0o00000377
# 0x000000ff

За преобразуване може да се използва и методът за символни низове str.format().

• str.format() — Built-in Functions — Python 3.10.0 Documentation

print('{:08b}'.format(i))
print('{:08o}'.format(i))
print('{:08x}'.format(i))
# 11111111
# 00000377
# 000000ff

От версия 3.6 на Python можете да използвате и символа f.f'xxx'

print(f'{i:08b}')
print(f'{i:08o}')
print(f'{i:08x}')
# 11111111
# 00000377
# 000000ff

Конвертиране на отрицателно цяло число в низ във формат за допълване на две.

Когато отрицателно цяло число се преобразува в двоичен или шестнадесетичен низ с помощта на bin() или format(), абсолютната стойност ще има знак минус.

x = -9

print(x)
print(bin(x))
# -9
# -0b1001

В Python побитовите операции с отрицателни цели числа също се извършват в представяне на допълнението на две. Следователно, ако искате да получите низ, изразен във вид на две допълнения, можете да извършите битово логическо OR& с максималния брой необходими битови цифри, както следва.

• 4bit:0b1111（=0xf）
• 8bit:0xff
• 16bit:0xffff

print(bin(x & 0xff))
print(format(x & 0xffff, 'x'))
# 0b11110111
# fff7

Конвертиране на низове в двоичен, осмичен и шестнадесетичен запис в числа.

Вградена функция int()

За преобразуване на низ в двоичен, осмичен или шестнадесетичен запис в число използвайте вградената функция int().

• int() — Built-in Functions — Python 3.10.0 Documentation

С помощта на int(string, radix) низът str в двоичен, осмичен, шестнадесетичен и т.н. запис може да се преобразува в цифров int въз основа на радикса. Ако радиксът е пропуснат, числото се счита за десетично.

print(int('10'))
print(int('10', 2))
print(int('10', 8))
print(int('10', 16))
# 10
# 2
# 8
# 16

print(type(int('10')))
print(type(int('10', 2)))
print(type(int('10', 8)))
print(type(int('10', 16)))
# <class 'int'>
# <class 'int'>
# <class 'int'>
# <class 'int'>

Ако радиксът е зададен на 0, преобразуването се извършва въз основа на следния префикс на низ.

• Двоичен префикс:0bили0B
• Октален префикс:0oили0O
• Шестнадесетичен префикс:0xили0X

print(int('0b10', 0))
print(int('0o10', 0))
print(int('0x10', 0))
# 2
# 8
# 16

print(int('0B10', 0))
print(int('0O10', 0))
print(int('0X10', 0))
# 2
# 8
# 16

Ако базовото число е 0 и няма префикс, то ще бъде преобразувано като десетично число, но имайте предвид, че ако началото (лявата страна) е запълнено с 0, ще възникне грешка.

print(int('10', 0))
# 10

# print(int('010', 0))
# ValueError: invalid literal for int() with base 0: '010'

В други случаи символните низове с нулево съдържание могат да бъдат конвертирани както са.

print(int('010'))
# 10

print(int('00ff', 16))
print(int('0x00ff', 0))
# 255
# 255

Ако низът не може да бъде конвертиран с посочения радикс или префикс, се появява грешка.

# print(int('ff', 2))
# ValueError: invalid literal for int() with base 2: 'ff'

# print(int('0a10', 0))
# ValueError: invalid literal for int() with base 0: '0a10'

# print(int('0bff', 0))
# ValueError: invalid literal for int() with base 0: '0bff'

Примери за приложение

Аритметика на двоичен низ

Например, за да извършите операция върху низ в двоичен запис с префикс 0b.

Можете лесно да го преобразувате в числова стойност (тип цяло число int), да извършвате операции с него и след това отново да го преобразувате в символен низ.

a = '0b1001'
b = '0b0011'

c = int(a, 0) + int(b, 0)

print(c)
print(bin(c))
# 12
# 0b1100

Конвертиране между двоични, осмични и шестнадесетични числа

Също така е лесно да конвертирате двоични, осмични и шестнадесетични низове един в друг. Веднъж преобразуван в цифров int, той може да бъде преобразуван в низ с произволен формат.

Попълването с нули, префиксирането и т.н. може да се контролира чрез низ за спецификация на форматирането.

a_0b = '0b1110001010011'

print(format(int(a, 0), '#010x'))
# 0x00000009

print(format(int(a, 0), '#010o'))
# 0o00000011