Tukar nombor dan rentetan perduaan, perlapanan dan perenambelasan kepada dan daripada satu sama lain dalam Python

Perniagaan

Python boleh mengendalikan nombor dan rentetan sebagai nombor perduaan, perlapanan dan heksadesimal serta nombor perpuluhan biasa. Ia juga mudah untuk menukar antara mereka.

Dalam bahagian ini, kandungan berikut akan diterangkan bersama dengan kod sampel.

  • Tulis integer dalam perduaan, perlapanan, dan perenambelasan.
  • Tukar nombor kepada rentetan dalam tatatanda perduaan, perlapanan dan heksadesimal.
    • fungsi terbina dalam (cth. dalam bahasa pengaturcaraan)bin(),oct(),hex()
    • kaedah rentetanstr.format(), Fungsi Terbina dalamformat(), rentetan f
    • Tukar integer negatif kepada rentetan dalam format pelengkap dua.
  • Tukar rentetan dalam tatatanda binari, perlapanan dan perenambelasan kepada nombor.
    • fungsi terbina dalam (cth. dalam bahasa pengaturcaraan)int()
  • Contoh Aplikasi
    • Aritmetik rentetan binari
    • Tukar antara nombor perduaan, perlapanan dan heksadesimal

Tulis integer dalam perduaan, perlapanan, dan perenambelasan.

Dengan menambah awalan berikut, nombor integer boleh ditulis dalam perduaan, perlapanan dan perenambelasan, masing-masing.
Anda juga boleh menggunakan huruf besar.

  • Nombor binari:0batau0B
  • perlapanan:0oatau0O
  • Nombor perenambelasan:0xatau0X

Output print() akan dalam notasi perpuluhan.

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

Walaupun dengan awalan, jenisnya ialah integer 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'>

Oleh kerana ia adalah jenis integer, ia boleh digunakan untuk operasi aritmetik biasa.

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

Bermula dengan Python 3.6, adalah mungkin untuk memasukkan garis bawah _ dalam nombor. Mengulang garis bawah _ akan mengakibatkan ralat, tetapi anda boleh memasukkan seberapa banyak yang anda suka selagi anda tidak mengulanginya.

Garis bawah _ tidak menjejaskan nombor, jadi ia boleh digunakan sebagai pemisah apabila terdapat banyak digit. Contohnya, memasukkan garis bawah _ setiap empat digit adalah mudah dibaca.

print(0b111111111111 == 0b1_1_1_1_1_1_1_1_1_1_1_1)
# True

bin_num = 0b1111_1111_1111
print(bin_num)
# 4095

Tukar nombor kepada rentetan dalam tatatanda perduaan, perlapanan dan heksadesimal.

Untuk menukar nombor kepada rentetan dalam tatatanda binari, perlapanan atau perenambelasan, gunakan fungsi terbina dalam berikut.

  • fungsi terbina dalam (cth. dalam bahasa pengaturcaraan)bin(),oct(),hex()
  • kaedah rentetanstr.format(), Fungsi Terbina dalamformat(), rentetan f

Bahagian ini juga menerangkan cara untuk mendapatkan rentetan dinyatakan dalam format pelengkap dua untuk nilai negatif.

Fungsi terbina dalam bin(), oct(), hex()

Fungsi terbina dalam berikut boleh menukar nombor kepada rentetan binari, perlapanan dan perenambelasan.

  • Nombor binari:bin()
  • perlapanan:oct()
  • Nombor perenambelasan:hex()

Setiap satu mengembalikan rentetan dengan awalan berikut

  • Nombor binari:0b
  • perlapanan:0o
  • Nombor perenambelasan:0x
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'>

Jika anda tidak memerlukan awalan, gunakan slice[2:] untuk mengekstrak rentetan di belakangnya atau gunakan format() seperti yang dijelaskan seterusnya.

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

Jika anda ingin menukarnya kepada rentetan perpuluhan, anda boleh menggunakan str().

print(str(i))
# 255

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

Format fungsi terbina dalam(), kaedah rentetan str.format(), rentetan f

Format fungsi terbina dalam () dan kaedah rentetan str.format() dan rentetan f juga boleh menukar nombor kepada rentetan perduaan, perlapanan dan perenambelasan.

Dengan menyatakan argumen kedua format() seperti berikut, ia boleh ditukar kepada rentetan binari, perlapanan dan perenambelasan.

  • Nombor binari:b
  • perlapanan:o
  • Nombor perenambelasan: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'>

Jika anda ingin mendapatkan rentetan dengan awalan 0b,0o,0x, tambahkan # pada rentetan spesifikasi pemformatan.

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

Ia juga mungkin untuk mengisi 0 dengan sebarang nombor digit. Ambil perhatian bahawa bilangan aksara untuk awalan (dua aksara) juga mesti diambil kira apabila mengisi sifar dengan awalan.

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

Kaedah rentetan str.format() boleh digunakan untuk penukaran juga.

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

Bermula dengan Python 3.6, anda juga boleh menggunakan rentetan f.f'xxx'

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

Tukar integer negatif kepada rentetan dalam format pelengkap dua.

Apabila integer negatif ditukar kepada rentetan binari atau perenambelasan menggunakan bin() atau format(), nilai mutlak akan mempunyai tanda tolak.

x = -9

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

Dalam Python, operasi bitwise pada integer negatif juga dilakukan dalam perwakilan pelengkap dua. Oleh itu, jika anda ingin mendapatkan rentetan yang dinyatakan dalam bentuk pelengkap dua, anda boleh mengambil OR& dengan bilangan maksimum digit bit yang diperlukan, seperti berikut.

  • 4bit:0b1111（=0xf）
  • 8bit:0xff
  • 16bit:0xffff
print(bin(x & 0xff))
print(format(x & 0xffff, 'x'))
# 0b11110111
# fff7

Tukar rentetan dalam tatatanda binari, perlapanan dan perenambelasan kepada nombor.

Fungsi terbina dalam int()

Untuk menukar rentetan dalam tatatanda perduaan, perlapanan atau heksadesimal kepada nombor, gunakan fungsi terbina dalam int().

Dengan int(rentetan, radix), rentetan str dalam perduaan, perlapanan, tatatanda heksadesimal, dsb. boleh ditukar kepada int berangka berdasarkan radix. Jika radix diabaikan, nombor itu dianggap sebagai perpuluhan.

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'>

Jika radix ditetapkan kepada 0, penukaran dilakukan berdasarkan awalan rentetan berikut.

  • Awalan binari:0batau0B
  • Awalan perlapanan:0oatau0O
  • Awalan heksadesimal:0xatau0X
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

Jika nombor asas ialah 0 dan tiada awalan, ia akan ditukar sebagai nombor perpuluhan, tetapi ambil perhatian bahawa jika permulaan (sebelah kiri) diisi dengan 0, ralat akan berlaku.

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

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

Dalam kes lain, rentetan yang diisi sifar boleh ditukar seperti sedia ada.

print(int('010'))
# 10

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

Jika rentetan tidak boleh ditukar dengan radix atau awalan yang ditentukan, ralat berlaku.

# 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'

Contoh Aplikasi

Aritmetik rentetan binari

Contohnya, untuk melakukan operasi pada rentetan dalam tatatanda binari dengan awalan 0b.

Anda boleh menukarnya dengan mudah kepada nilai berangka (integer jenis int), melakukan operasi padanya dan kemudian menukarnya kembali kepada rentetan str sekali lagi.

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

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

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

Tukar antara nombor perduaan, perlapanan dan heksadesimal

Ia juga mudah untuk menukar rentetan perduaan, perlapanan, dan perenambelasan antara satu sama lain. Setelah ditukar kepada int angka, ia boleh ditukar kepada rentetan daripada sebarang format.

Pengisian sifar, awalan, dsb. boleh dikawal oleh rentetan spesifikasi pemformatan.

a_0b = '0b1110001010011'

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

print(format(int(a, 0), '#010o'))
# 0o00000011
Copied title and URL