जवाबों:
बाईं ओर की अनुगामी शून्य समस्या को हल करने के लिए:
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 है।
मैं 001010101111000001001000101111111111111111 (यानी बाइनरी रीप्र, 42 अंकों और अग्रणी शून्य) के साथ आना चाहता हूं।
पायथन 3.6 में नए f- स्ट्रिंग्स आपको बहुत ही ट्रिक सिंटैक्स का उपयोग करने की अनुमति देते हैं:
>>> 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- स्ट्रिंग्स का प्रदर्शन करें। वे समान मिनी-भाषा प्रारूपण नियमों का उपयोग करते हैं:
>>> 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विधि का उपयोग कर सकते हैं , जो केवल पायथन 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'द्विआधारी तारों को उत्पन्न करने के लिए बिट फ़िडलिंग का उपयोग करके इसे करने का एक काफी कच्चा तरीका है।
समझने की कुंजी बिट है:
(n & (1 << i)) and 1जो या तो 0 या 1 उत्पन्न करेगा यदि i'th बिट 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संपादित करें: "नया" टर्नरी ऑपरेटर का उपयोग करके:
(n & (1 << i)) and 1बन जाएगा:
1 if n & (1 << i) or 0(कौन सा टीबीएच मुझे यकीन नहीं है कि कितना पठनीय है)
01111001 11111110।
यह ग्लेन मेनार्ड के समाधान के लिए एक हल्का स्पर्श है, जो मुझे लगता है कि यह करने का सही तरीका है। यह सिर्फ पैडिंग तत्व जोड़ता है।
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, यदि आप एक स्टैंड-अलोन स्क्रिप्ट में काम कर रहे हैं तो बस बाहर निकालें।
अंतर्निहित प्रारूप () फ़ंक्शन और इंट () फ़ंक्शन का उपयोग करें यह सरल और समझने में आसान है। यह हारून जवाब का थोड़ा सरल संस्करण है
पूर्णांक ()
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इसका जवाब भी देखिए
प्रत्येक हेक्स अंक को संबंधित 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 :-)
संक्षिप्त रूप ist ज्वाइन विधि है। का आनंद लें।
# 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 है
लगभग सभी अनुप्रयोगों के लिए आप चाहते हैं कि द्विआधारी संस्करण की लंबाई 0 के अग्रणी पैडिंग के साथ 4 की एक बहु हो।
पायथन में इसे पाने के लिए:
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 में काम करता है :)
बस मॉड्यूल कोडन का उपयोग करें (ध्यान दें: मैं मॉड्यूल का लेखक हूं)
आप वहां हेक्साडेसिमल को बाइनरी में बदल सकते हैं।
pip install codena_hexadecimal_number = "f1ff"
binary_output = coden.hex_to_bin(a_hexadecimal_number)परिवर्तित खोजशब्द हैं:
तो आप भी प्रारूपित कर सकते हैं: ई। 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_stringimport 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)।