উত্তর:
বাম পাশের পিছনে শূন্য সমস্যার সমাধান করার জন্য:
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 আছে।
আমি চাই 00101010111100000100100011111011111111111111 (অর্থাত্ বাইনারি পুনরায়।, বলুন, 42 সংখ্যা এবং শীর্ষস্থানীয় শূন্যগুলি সহ) পেতে চান।
পাইথন ৩.6-এ নতুন এফ-স্ট্রিংগুলি আপনাকে খুব ক্ষুদ্র বাক্য গঠন ব্যবহার করে এটি করতে দেয়:
>>> f'{0xABC123EFFF:0>42b}'
'001010101111000001001000111110111111111111'বা শব্দার্থবিজ্ঞানের সাথে এটি ভেঙে দিতে:
>>> number, pad, rjust, size, kind = 0xABC123EFFF, '0', '>', 42, 'b'
>>> f'{number:{pad}{rjust}{size}{kind}}'
'001010101111000001001000111110111111111111'আপনি আসলে যা বলছেন তা হেক্সাডেসিমাল উপস্থাপনায় আপনার একটি মান রয়েছে এবং আপনি বাইনারিতে সমমানের মান উপস্থাপন করতে চান।
সমতার মানটি একটি পূর্ণসংখ্যা। তবে আপনি একটি স্ট্রিং দিয়ে শুরু করতে পারেন এবং বাইনারিতে দেখতে আপনাকে অবশ্যই একটি স্ট্রিং দিয়ে শেষ করতে হবে।
এই লক্ষ্যটি অর্জনের জন্য আমাদের কাছে বেশ কয়েকটি প্রত্যক্ষ উপায় রয়েছে, হ্যাকগুলি স্লাইস ব্যবহার ছাড়াই।
প্রথমত, আমরা যে কোনও বাইনারি হেরফের করার আগে মোটামুটি ইনট-এ রূপান্তরিত করব (আমি মনে করি এটি স্ট্রিং ফর্ম্যাটে রয়েছে, আক্ষরিক হিসাবে নয়):
>>> 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.formatstr.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'আসুন নতুন এফ-স্ট্রিংগুলি প্রদর্শন করি। তারা একই মিনি-ভাষা বিন্যাসের নিয়ম ব্যবহার করে:
>>> 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 উত্পন্ন করবে।
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- এ ()
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')আমি ওনেডিংকেনিদির দ্রবণটি পূরণের জন্য বিটের সংখ্যার জন্য গণনা যুক্ত করেছি। ফলাফলের ফাংশনটি এখানে:
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 এর বাইনারি সংস্করণটি আসলে 101010111100000100100011111011111111111111
প্রায় সমস্ত অ্যাপ্লিকেশনগুলির জন্য আপনি বাইনারি সংস্করণটির দৈর্ঘ্য চান যা 0 এর শীর্ষস্থানীয় প্যাডিং সহ 4 এর একাধিক is
পাইথনে এটি পেতে:
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'নোট করুন যে এটি মাইক্রোপথিতেও কাজ করে :)
শুধু মডিউল কোডেন ব্যবহার করুন (দ্রষ্টব্য: আমি মডিউলটির লেখক)
আপনি সেখানে হ্যাক্সেডেসিমালকে বাইনারি রূপান্তর করতে পারেন।
pip install codena_hexadecimal_number = "f1ff"
binary_output = coden.hex_to_bin(a_hexadecimal_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)।