ฉันมี ABC123EFFF
ฉันต้องการมี 001010101111000001001000111110111111111111 (เช่น binary repr. โดยพูด 42 หลักและเลขศูนย์นำหน้า)
อย่างไร?
ฉันมี ABC123EFFF
ฉันต้องการมี 001010101111000001001000111110111111111111 (เช่น binary repr. โดยพูด 42 หลักและเลขศูนย์นำหน้า)
อย่างไร?
คำตอบ:
สำหรับการแก้ปัญหาศูนย์ต่อท้ายด้านซ้าย:
my_hexdata = "1a"
scale = 16 ## equals to hexadecimal
num_of_bits = 8
bin(int(my_hexdata, scale))[2:].zfill(num_of_bits)มันจะให้ 00011010 แทนรุ่นที่ถูกตัดแต่ง
import binascii
binary_string = binascii.unhexlify(hex_string)อ่าน
ส่งคืนข้อมูลไบนารีที่แสดงโดยสตริงเลขฐานสิบหกที่ระบุเป็นพารามิเตอร์
bin(int("abc123efff", 16))[2:]แปลงฐานสิบหกเป็นไบนารี
ฉันมี ABC123EFFF
ฉันต้องการมี 001010101111000001001000111110111111111111 (เช่น binary repr. โดยพูด 42 หลักและเลขศูนย์นำหน้า)
f-strings ใหม่ใน Python 3.6 ช่วยให้คุณทำสิ่งนี้ได้โดยใช้ไวยากรณ์ที่สั้นมาก:
>>> f'{0xABC123EFFF:0>42b}'
'001010101111000001001000111110111111111111'หรือแยกสิ่งนั้นด้วยความหมาย:
>>> number, pad, rjust, size, kind = 0xABC123EFFF, '0', '>', 42, 'b'
>>> f'{number:{pad}{rjust}{size}{kind}}'
'001010101111000001001000111110111111111111'สิ่งที่คุณกำลังพูดจริงๆคือคุณมีค่าในการแทนค่าฐานสิบหกและคุณต้องการแทนค่าที่เท่ากันในไบนารี
ค่าของการเทียบเท่าเป็นจำนวนเต็ม แต่คุณสามารถเริ่มต้นด้วยสตริงและหากต้องการดูไบนารีคุณต้องลงท้ายด้วยสตริง
เรามีวิธีการโดยตรงหลายวิธีในการบรรลุเป้าหมายนี้โดยไม่ต้องแฮ็กโดยใช้ชิ้นส่วน
ก่อนอื่นก่อนที่เราจะทำการจัดการไบนารีใด ๆ เลยให้แปลงเป็น int (ฉันคิดว่านี่อยู่ในรูปแบบสตริงไม่ใช่ตามตัวอักษร):
>>> integer = int('ABC123EFFF', 16)
>>> integer
737679765503หรือเราสามารถใช้ลิเทอรัลจำนวนเต็มตามที่แสดงในรูปแบบฐานสิบหก:
>>> integer = 0xABC123EFFF
>>> integer
737679765503ตอนนี้เราจำเป็นต้องแสดงจำนวนเต็มของเราในการแทนค่าฐานสอง
formatจากนั้นส่งไปที่format:
>>> format(integer, '0>42b')
'001010101111000001001000111110111111111111'นี้ใช้ข้อกำหนดการจัดรูปแบบของภาษามินิ
ในการแยกย่อยนี่คือรูปแบบไวยากรณ์ของมัน:
[[fill]align][sign][#][0][width][,][.precision][type]เพื่อให้สิ่งนั้นเป็นข้อกำหนดสำหรับความต้องการของเราเราเพียงแค่ไม่รวมสิ่งที่เราไม่ต้องการ:
>>> spec = '{fill}{align}{width}{type}'.format(fill='0', align='>', width=42, type='b')
>>> spec
'0>42b'และส่งผ่านไปยังรูปแบบ
>>> bin_representation = format(integer, spec)
>>> bin_representation
'001010101111000001001000111110111111111111'
>>> print(bin_representation)
001010101111000001001000111110111111111111str.formatเราสามารถใช้สิ่งนั้นในสตริงโดยใช้str.formatวิธีการ:
>>> 'here is the binary form: {0:{spec}}'.format(integer, spec=spec)
'here is the binary form: 001010101111000001001000111110111111111111'หรือเพียงแค่ใส่ข้อมูลจำเพาะลงในสตริงต้นฉบับโดยตรง:
>>> 'here is the binary form: {0:0>42b}'.format(integer)
'here is the binary form: 001010101111000001001000111110111111111111'มาสาธิต f-strings ใหม่ ใช้กฎการจัดรูปแบบมินิภาษาเดียวกัน:
>>> integer = 0xABC123EFFF
>>> length = 42
>>> f'{integer:0>{length}b}'
'001010101111000001001000111110111111111111'ตอนนี้เรามาใส่ฟังก์ชันนี้เป็นฟังก์ชันเพื่อส่งเสริมให้สามารถใช้ซ้ำได้:
def bin_format(integer, length):
return f'{integer:0>{length}b}'และตอนนี้:
>>> bin_format(0xABC123EFFF, 42)
'001010101111000001001000111110111111111111' หากคุณต้องการเข้ารหัสข้อมูลเป็นสตริงไบต์ในหน่วยความจำหรือบนดิสก์คุณสามารถใช้int.to_bytesวิธีนี้ซึ่งมีเฉพาะใน Python 3:
>>> help(int.to_bytes)
to_bytes(...)
int.to_bytes(length, byteorder, *, signed=False) -> bytes
...และเนื่องจาก 42 บิตหารด้วย 8 บิตต่อไบต์เท่ากับ 6 ไบต์:
>>> integer.to_bytes(6, 'big')
b'\x00\xab\xc1#\xef\xff'>>> bin( 0xABC123EFFF )'0b1010101111000001001000111110111111111111'
"{0:020b}".format(int('ABC123EFFF', 16))นี่เป็นวิธีที่ค่อนข้างดิบในการทำโดยใช้การเล่นซอเพื่อสร้างสตริงไบนารี
สิ่งสำคัญที่ต้องทำความเข้าใจคือ:
(n & (1 << i)) and 1ซึ่งจะสร้าง a 0 หรือ 1 หากตั้งค่า i'th bit ของ n
import binascii
def byte_to_binary(n):
return ''.join(str((n & (1 << i)) and 1) for i in reversed(range(8)))
def hex_to_binary(h):
return ''.join(byte_to_binary(ord(b)) for b in binascii.unhexlify(h))
print hex_to_binary('abc123efff')
>>> 1010101111000001001000111110111111111111แก้ไข: ใช้ตัวดำเนินการ ternary "ใหม่" สิ่งนี้:
(n & (1 << i)) and 1จะกลายเป็น:
1 if n & (1 << i) or 0(ซึ่ง TBH ฉันไม่แน่ใจว่าอ่านได้แค่ไหน)
01111001 11111110.
ใช้ฟังก์ชันรูปแบบในตัว()และฟังก์ชันint () มันง่ายและเข้าใจง่าย เป็นคำตอบ Aaronเวอร์ชันที่เรียบง่ายขึ้นเล็กน้อย
int ()
int(string, base)รูปแบบ()
format(integer, # of bits)ตัวอย่าง
# w/o 0b prefix
>> format(int("ABC123EFFF", 16), "040b")
1010101111000001001000111110111111111111
# with 0b prefix
>> format(int("ABC123EFFF", 16), "#042b")
0b1010101111000001001000111110111111111111
# w/o 0b prefix + 64bit
>> format(int("ABC123EFFF", 16), "064b")
0000000000000000000000001010101111000001001000111110111111111111นี่เป็นการสัมผัสวิธีแก้ปัญหาของ Glen Maynard ซึ่งฉันคิดว่าเป็นวิธีที่ถูกต้อง เพียงแค่เพิ่มองค์ประกอบช่องว่างภายใน
def hextobin(self, hexval):
'''
Takes a string representation of hex data with
arbitrary length and converts to string representation
of binary. Includes padding 0s
'''
thelen = len(hexval)*4
binval = bin(int(hexval, 16))[2:]
while ((len(binval)) < thelen):
binval = '0' + binval
return binval
ดึงมันออกจากชั้นเรียน เอาออกself, ถ้าคุณกำลังทำงานในสคริปต์แบบสแตนด์อะโลน
แทนที่เลขฐานสิบหกแต่ละหลักด้วยเลขฐานสอง 4 หลักที่ตรงกัน:
1 - 0001
2 - 0010
...
a - 1010
b - 1011
...
f - 1111ฐานสิบหก -> ทศนิยมแล้วทศนิยม -> ไบนารี
#decimal to binary
def d2b(n):
bStr = ''
if n < 0: raise ValueError, "must be a positive integer"
if n == 0: return '0'
while n > 0:
bStr = str(n % 2) + bStr
n = n >> 1
return bStr
#hex to binary
def h2b(hex):
return d2b(int(hex,16))อีกวิธีหนึ่ง:
import math
def hextobinary(hex_string):
s = int(hex_string, 16)
num_digits = int(math.ceil(math.log(s) / math.log(2)))
digit_lst = ['0'] * num_digits
idx = num_digits
while s > 0:
idx -= 1
if s % 2 == 1: digit_lst[idx] = '1'
s = s / 2
return ''.join(digit_lst)
print hextobinary('abc123efff')ฉันเพิ่มการคำนวณจำนวนบิตเพื่อเติมเต็มโซลูชันของ Onedinkenedi นี่คือฟังก์ชันผลลัพธ์:
def hextobin(h):
return bin(int(h, 16))[2:].zfill(len(h) * 4)โดยที่ 16 คือฐานที่คุณกำลังแปลงจาก (เลขฐานสิบหก) และ 4 คือจำนวนบิตที่คุณต้องการแทนตัวเลขแต่ละหลักหรือฐานบันทึก 2 ของมาตราส่วน
def conversion():
e=raw_input("enter hexadecimal no.:")
e1=("a","b","c","d","e","f")
e2=(10,11,12,13,14,15)
e3=1
e4=len(e)
e5=()
while e3<=e4:
e5=e5+(e[e3-1],)
e3=e3+1
print e5
e6=1
e8=()
while e6<=e4:
e7=e5[e6-1]
if e7=="A":
e7=10
if e7=="B":
e7=11
if e7=="C":
e7=12
if e7=="D":
e7=13
if e7=="E":
e7=14
if e7=="F":
e7=15
else:
e7=int(e7)
e8=e8+(e7,)
e6=e6+1
print e8
e9=1
e10=len(e8)
e11=()
while e9<=e10:
e12=e8[e9-1]
a1=e12
a2=()
a3=1
while a3<=1:
a4=a1%2
a2=a2+(a4,)
a1=a1/2
if a1<2:
if a1==1:
a2=a2+(1,)
if a1==0:
a2=a2+(0,)
a3=a3+1
a5=len(a2)
a6=1
a7=""
a56=a5
while a6<=a5:
a7=a7+str(a2[a56-1])
a6=a6+1
a56=a56-1
if a5<=3:
if a5==1:
a8="000"
a7=a8+a7
if a5==2:
a8="00"
a7=a8+a7
if a5==3:
a8="0"
a7=a8+a7
else:
a7=a7
print a7,
e9=e9+1ฉันมีความหวังสั้น ๆ ที่จะช่วย :-)
input = 'ABC123EFFF'
for index, value in enumerate(input):
print(value)
print(bin(int(value,16)+16)[3:])
string = ''.join([bin(int(x,16)+16)[3:] for y,x in enumerate(input)])
print(string)ก่อนอื่นฉันใช้ข้อมูลที่คุณป้อนและแจกแจงเพื่อให้ได้สัญลักษณ์แต่ละตัว จากนั้นฉันจะแปลงเป็นไบนารีและตัดแต่งจากตำแหน่งที่ 3 ไปยังจุดสิ้นสุด เคล็ดลับในการรับ 0 คือการเพิ่มค่าสูงสุดของอินพุต -> ในกรณีนี้คือ 16 เสมอ :-)
รูปแบบสั้นคือวิธีการเข้าร่วม สนุก.
# Python Program - Convert Hexadecimal to Binary
hexdec = input("Enter Hexadecimal string: ")
print(hexdec," in Binary = ", end="") # end is by default "\n" which prints a new line
for _hex in hexdec:
dec = int(_hex, 16) # 16 means base-16 wich is hexadecimal
print(bin(dec)[2:].rjust(4,"0"), end="") # the [2:] skips 0b, and the ABC123EFFF เวอร์ชันไบนารีคือ 1010101111000001001000111110111111111111
สำหรับแอปพลิเคชันเกือบทั้งหมดคุณต้องการให้เวอร์ชันไบนารีมีความยาวเท่ากับผลคูณของ 4 โดยมีช่องว่างนำหน้าเป็น 0
ในการรับสิ่งนี้ใน Python:
def hex_to_binary( hex_code ):
bin_code = bin( hex_code )[2:]
padding = (4-len(bin_code)%4)%4
return '0'*padding + bin_codeตัวอย่างที่ 1:
>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'ตัวอย่างที่ 2:
>>> hex_to_binary( 0x7123 )
'0111000100100011'โปรดทราบว่าสิ่งนี้ใช้ได้กับ Micropython ด้วย :)
เพียงแค่ใช้โมดูลcoden (หมายเหตุ: ผมผู้เขียนของโมดูล)
คุณสามารถแปลงเลขฐานสองเป็นเลขฐานสองได้ที่นั่น
pip install codena_hexadecimal_number = "f1ff"
binary_output = coden.hex_to_bin(a_hexadecimal_number)คำหลักที่ทำให้เกิดการแปลง ได้แก่ :
ดังนั้นคุณยังสามารถจัดรูปแบบ: e. hexadecimal_output = bin_to_hex (a_binary_number)
HEX_TO_BINARY_CONVERSION_TABLE = {'0': '0000',
'1': '0001',
'2': '0010',
'3': '0011',
'4': '0100',
'5': '0101',
'6': '0110',
'7': '0111',
'8': '1000',
'9': '1001',
'a': '1010',
'b': '1011',
'c': '1100',
'd': '1101',
'e': '1110',
'f': '1111'}
def hex_to_binary(hex_string):
binary_string = ""
for character in hex_string:
binary_string += HEX_TO_BINARY_CONVERSION_TABLE[character]
return binary_stringa = raw_input('hex number\n')
length = len(a)
ab = bin(int(a, 16))[2:]
while len(ab)<(length * 4):
ab = '0' + ab
print abimport binascii
hexa_input = input('Enter hex String to convert to Binary: ')
pad_bits=len(hexa_input)*4
Integer_output=int(hexa_input,16)
Binary_output= bin(Integer_output)[2:]. zfill(pad_bits)
print(Binary_output)
"""zfill(x) i.e. x no of 0 s to be padded left - Integers will overwrite 0 s
starting from right side but remaining 0 s will display till quantity x
[y:] where y is no of output chars which need to destroy starting from left"""no=raw_input("Enter your number in hexa decimal :")
def convert(a):
if a=="0":
c="0000"
elif a=="1":
c="0001"
elif a=="2":
c="0010"
elif a=="3":
c="0011"
elif a=="4":
c="0100"
elif a=="5":
c="0101"
elif a=="6":
c="0110"
elif a=="7":
c="0111"
elif a=="8":
c="1000"
elif a=="9":
c="1001"
elif a=="A":
c="1010"
elif a=="B":
c="1011"
elif a=="C":
c="1100"
elif a=="D":
c="1101"
elif a=="E":
c="1110"
elif a=="F":
c="1111"
else:
c="invalid"
return c
a=len(no)
b=0
l=""
while b<a:
l=l+convert(no[b])
b+=1
print l
len(my_hexdata) * log2(scale)สำหรับการคำนวณจำนวนบิตคือ