পাইথনের কোনও ইন্টিজার (বা লং) কে বাইনারি স্ট্রিংয়ে রূপান্তর করার জন্য কি কোনও ক্যানড পাইথন পদ্ধতি রয়েছে?
গুগলে একটি অগণিত ডেক 2বিন () রয়েছে ... তবে আমি আশা করছিলাম যে আমি একটি বিল্ট-ইন ফাংশন / লাইব্রেরিটি ব্যবহার করতে পারব।
উত্তর:
পাইথনের স্ট্রিং ফর্ম্যাট পদ্ধতিটি একটি ফর্ম্যাট স্পেক নিতে পারে।
>>> "{0:b}".format(37)
'100101'str.format()কেবলমাত্র একটি মান ফর্ম্যাট করতে ওভারকিল। সরাসরি যান format()ফাংশন : format(n, 'b')। স্থানধারককে বিশ্লেষণ করার দরকার নেই এবং এটি একটি যুক্তির সাথে মিলে যায়, মান বিন্যাসকরণ ক্রিয়ায় নিজেই সরাসরি যান go কেবলমাত্র str.format()যদি আপনার ফর্ম্যাট ফলাফলটি আরও দীর্ঘ স্ট্রিংয়ে রাখার প্রয়োজন হয় (উদাহরণস্বরূপ এটি টেমপ্লেট হিসাবে ব্যবহার করুন)।
0বিন্যাসের স্ট্রিংয়ের শীর্ষস্থানীয় সংখ্যার যোগ করুন : format(10, '016b')নেতৃস্থানীয় শূন্যগুলির সাথে 16 টি সংখ্যায় ফর্ম্যাট।
0ইন "{0:b}"কি নামানো যাবে? আমি বলতে চাইছি, যে ক্ষেত্রে কেবলমাত্র একটি নম্বর ফরম্যাট করা হচ্ছে, এটি সঠিকভাবে দেওয়া ঠিক "{:b}"নয়, তাই না?
"{:08b}".format(37)
যদি আপনি এর bin()সমতুল্য হিসাবে সন্ধান করেনhex() এটি অজগর ২.6-এ যুক্ত করা হয়েছে।
উদাহরণ:
>>> bin(10)
'0b1010'str(bin(i))[2:](1000000 টোপগুলির জন্য 0.721s) এর চেয়ে দ্রুত (1000000 "{0:b}".format(i)টোপগুলির জন্য 0.369s)
str.format()যাইহোক ভুল টুল, আপনি format(i, 'b')পরিবর্তে এটি ব্যবহার করবেন । এটি আপনার প্যাডিং এবং প্রান্তিককরণ বিকল্পগুলি দেয় যদিও অ্যাকাউন্টে নিন; format(i, '016b')একটি 16-বিট শূন্য প্যাডযুক্ত বাইনারি সংখ্যায় ফর্ম্যাট করতে। এটি করার জন্য bin()আপনাকে একটি str.zfill()কল যুক্ত করতে হবে: bin(i)[2:].zfill(16)(কল করার দরকার নেই str()!)। format()এর পঠনযোগ্যতা এবং নমনীয়তা (গতিশীল ফর্ম্যাটিং এর সাথে আরও শক্ত bin()) দুর্দান্ত ট্রেড অফস, যদি না আপনার প্রয়োজন না হয় তবে পারফরম্যান্সের জন্য অনুকূল না হন, ততক্ষণ পর্যন্ত রক্ষণাবেক্ষণের জন্য অনুকূলিত হন না।
f"{37:b}"।
পাইথন আসলে না এটার জন্য ইতোমধ্যে নির্মিত কিছু আছে, যেমন অপারেশন করার ক্ষমতা '{0:b}'.format(42)জন্য, যা আপনি বিট ধরণ (একটি স্ট্রিং) দেব 42, অথবা101010 ।
আরও সাধারণ দর্শনের জন্য, কোনও ভাষা বা গ্রন্থাগার তার ব্যবহারকারীর পছন্দসই সব কিছু দেবে না। আপনি যদি এমন পরিবেশে কাজ করছেন যা আপনার যা প্রয়োজন ঠিক তা সরবরাহ করে না, আপনার যাতে কোডের স্নিপেটগুলি সংগ্রহ করা উচিত যাতে আপনার কখনও একই জিনিস দুবার লিখতে হবে না তা নিশ্চিত করার জন্য বিকাশ করা উচিত। যেমন, উদাহরণস্বরূপ, সিউডো কোড:
define intToBinString, receiving intVal:
if intVal is equal to zero:
return "0"
set strVal to ""
while intVal is greater than zero:
if intVal is odd:
prefix "1" to strVal
else:
prefix "0" to strVal
divide intVal by two, rounding down
return strValযা দশমিক মানের উপর নির্ভর করে আপনার বাইনারি স্ট্রিংটি তৈরি করবে। কেবল মনে রাখবেন এটি সিউডো কোডের জেনেরিক বিট যা নাও হতে পারে সবচেয়ে কার্যকর উপায় , যে পুনরাবৃত্তিগুলি আপনি প্রস্তাব করছেন বলে মনে হচ্ছে, এটি খুব বেশি পার্থক্য করবে না। এটি কীভাবে এটি করা যায় তার গাইডলাইন হিসাবে সত্যই বোঝানো হয়েছে।
সাধারণ ধারণাটি হ'ল (পছন্দ অনুসারে) কোডটি ব্যবহার করা:
s = "1" + sএবং s = "0" + sলাইনে রয়েছে। প্রতিটি এস এর একটি অপ্রয়োজনীয় অনুলিপি তৈরি করে। তার পরিবর্তে স্ট্রিংটি ফিরিয়ে দেওয়ার ঠিক আগে আপনার বিপরীত হওয়া উচিত।
'{0:b}'.format(42), ধীর পদ্ধতিটি সাধারণভাবে কীভাবে এটি করা যায় তার একটি উদাহরণ ছিল, যা ব্যবহৃত প্রকৃত ভাষার উপর নির্ভর করে ও (এন ^ 2) হতে পারে বা নাও হতে পারে। এটি কেবল পাইথনের মতো দেখায় পাইথন একটি আদর্শ ছদ্ম-কোড ভাষা তাই এটি পরিষ্কার করার জন্য আমি এটি পরিবর্তন করব change
s = "1" + sযখন O (N) ছিল না s। সম্ভবত এমন একটি ভাষা যেখানে সমস্ত স্ট্রিংগুলি পিছনের দিকে সঞ্চিত থাকে বা প্রতিটি চর লিঙ্কযুক্ত তালিকার নোড? যে কোনও সাধারণ ভাষার জন্য একটি স্ট্রিং মূলত অক্ষরের একটি অ্যারে। সেক্ষেত্রে স্ট্রিংয়ের উপসর্গের জন্য একটি অনুলিপি তৈরি করা দরকার, অন্য অক্ষরের আগে আপনি কীভাবে চরিত্রটি রাখবেন?
আপনি যদি 0 বি-উপসর্গ ব্যতীত একটি পাঠ্য উপস্থাপনা চান তবে আপনি এটি ব্যবহার করতে পারেন:
get_bin = lambda x: format(x, 'b')
print(get_bin(3))
>>> '11'
print(get_bin(-3))
>>> '-11'আপনি যখন কোনও এন-বিট উপস্থাপনা চান:
get_bin = lambda x, n: format(x, 'b').zfill(n)
>>> get_bin(12, 32)
'00000000000000000000000000001100'
>>> get_bin(-12, 32)
'-00000000000000000000000000001100'বিকল্পভাবে, যদি আপনি কোনও ফাংশন রাখা পছন্দ করেন:
def get_bin(x, n=0):
"""
Get the binary representation of x.
Parameters
----------
x : int
n : int
Minimum number of digits. If x needs less digits in binary, the rest
is filled with zeros.
Returns
-------
str
"""
return format(x, 'b').zfill(n)format(integer, 'b')। bin()একটি ডিবাগিং সরঞ্জাম, বিশেষত পাইথন বাইনারি পূর্ণসংখ্যার আক্ষরিক সিনট্যাক্সformat() তৈরির উদ্দেশ্যে , নির্দিষ্ট বিন্যাসগুলি তৈরি করতে বোঝানো হয়।
bin()পাইথন বাইনারি পূর্ণসংখ্যার আক্ষরিক সিনট্যাক্স তৈরির উদ্দেশ্যে একটি ডিবাগিং সরঞ্জাম? আমি নথিতে এটি খুঁজে পাইনি couldn't
oct()এবং hex()।
str.zfill()আপনি ব্যবহার করতে পারেন str.format()বা format()একটি গতিশীল দ্বিতীয় যুক্তি সহ: '{0:0{1}b}'.format(x, n)বা format(b, '0{}b'.format(n))।
zfillগতিশীল দ্বিতীয় যুক্তির চেয়ে পড়া এবং বুঝতে সহজ, সুতরাং আমি এটি রাখব।
রেফারেন্স অনুসারে:
def toBinary(n):
return ''.join(str(1 & int(n) >> i) for i in range(64)[::-1])এই ফাংশনটি ইতিবাচক পূর্ণসংখ্যাকে 18446744073709551615স্ট্রিং হিসাবে উপস্থাপিত হিসাবে রূপান্তর করতে পারে '1111111111111111111111111111111111111111111111111111111111111111'।
এটা অনেক বড় পূর্ণসংখ্যা সেবা করার জন্য পরিবর্তন করা যাবে যদিও এটা যেমন উপকারে যেমন নাও হতে পারে "{0:b}".format()বা bin()।
এটি করার একটি সহজ উপায় হ'ল স্ট্রিং বিন্যাসটি ব্যবহার করা, এই পৃষ্ঠাটি দেখুন ।
>> "{0:b}".format(10)
'1010'এবং আপনি যদি বাইনারি স্ট্রিংয়ের একটি নির্দিষ্ট দৈর্ঘ্য পেতে চান তবে আপনি এটি ব্যবহার করতে পারেন:
>> "{0:{fill}8b}".format(10, fill='0')
'00001010'যদি দুটির পরিপূরক প্রয়োজন হয় তবে নিম্নলিখিত লাইনটি ব্যবহার করা যেতে পারে:
'{0:{fill}{width}b}'.format((x + 2**n) % 2**n, fill='0', width=n)যেখানে n বাইনারি স্ট্রিংয়ের প্রস্থ।
লাম্বদা সহ এক-লাইনার :
>>> binary = lambda n: '' if n==0 else binary(n/2) + str(n%2)পরীক্ষা:
>>> binary(5)
'101'
সম্পাদনা :
কিন্তু তারপর :(
t1 = time()
for i in range(1000000):
binary(i)
t2 = time()
print(t2 - t1)
# 6.57236599922তুলনায়
t1 = time()
for i in range(1000000):
'{0:b}'.format(i)
t2 = time()
print(t2 - t1)
# 0.68017411232''সঙ্গে '0', কিন্তু এটা কোন সংখ্যার জন্য একটি নেতৃস্থানীয় 0 যোগ করা হবে।
বিকল্প সংক্ষিপ্তসার:
n=42
assert "-101010" == format(-n, 'b')
assert "-101010" == "{0:b}".format(-n)
assert "-101010" == (lambda x: x >= 0 and str(bin(x))[2:] or "-" + str(bin(x))[3:])(-n)
assert "0b101010" == bin(n)
assert "101010" == bin(n)[2:] # But this won't work for negative numbers.অবদানকারী অন্তর্ভুক্ত জন Fouhy , কাঠ বার্নিশ করার কাজের গুয়েন , mVChr , মার্টিন Thoma । এবং মার্টিজন পিটারস
str.format()কেবলমাত্র একটি মান ফর্ম্যাট করতে ওভারকিল। সরাসরি যান format()ফাংশন: format(n, 'b')। স্থানধারককে বিশ্লেষণ করার দরকার নেই এবং সেভাবে এটি একটি যুক্তির সাথে মেলে।
পূর্ববর্তী উত্তরগুলি বেশিরভাগ ব্যবহৃত বিন্যাস () হিসাবে ব্যবহৃত হয়, এখানে একটি এফ-স্ট্রিং বাস্তবায়ন রয়েছে।
integer = 7
bit_count = 5
print(f'{integer:0{bit_count}b}')আউটপুট:
00111
সুবিধার জন্য এখানে ফর্ম্যাট স্ট্রিং লিটারালগুলির জন্য পাইথন ডক্স লিঙ্কটি রয়েছে: https://docs.python.org/3/references/lexical_analysis.html#f-strings ।
>>> format(123, 'b')
'1111011'নম্পি প্যাক / আনপ্যাকবিট ব্যবহার করে, তারা আপনার সেরা বন্ধু।
Examples
--------
>>> a = np.array([[2], [7], [23]], dtype=np.uint8)
>>> a
array([[ 2],
[ 7],
[23]], dtype=uint8)
>>> b = np.unpackbits(a, axis=1)
>>> b
array([[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 1, 1],
[0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)আমাদের মধ্যে যাদের স্বাক্ষরিত পূর্ণসংখ্যা (পরিসর -২ ** (অঙ্ক -১) থেকে ২ ** (অঙ্ক -১) -১) তে 2 এর পরিপূরক বাইনারি স্ট্রিংয়ে রূপান্তর করা দরকার, এটি কাজ করে:
def int2bin(integer, digits):
if integer >= 0:
return bin(integer)[2:].zfill(digits)
else:
return bin(2**digits + integer)[2:]এটি উত্পাদন করে:
>>> int2bin(10, 8)
'00001010'
>>> int2bin(-10, 8)
'11110110'
>>> int2bin(-128, 8)
'10000000'
>>> int2bin(127, 8)
'01111111'তবুও বিটওয়াইড অপারেটরগুলি ব্যবহার করে অন্য একটি অ্যালগরিদমের সাথে আরেকটি সমাধান।
def int2bin(val):
res=''
while val>0:
res += str(val&1)
val=val>>1 # val=val/2
return res[::-1] # reverse the stringস্ট্রিংটি বিপরীত না করে একটি দ্রুত সংস্করণ।
def int2bin(val):
res=''
while val>0:
res = chr((val&1) + 0x30) + res
val=val>>1
return res আপনি এটি করতে পারেন:
bin(10)[2:]বা:
f = str(bin(10))
c = []
c.append("".join(map(int, f[2:])))
print cআমি সবেমাত্র প্রয়োগ করেছি কোডটি এখানে। এটি কোনও পদ্ধতি নয় তবে আপনি এটি ব্যবহারের জন্য প্রস্তুত কার্য হিসাবে ব্যবহার করতে পারেন !
def inttobinary(number):
if number == 0:
return str(0)
result =""
while (number != 0):
remainder = number%2
number = number/2
result += str(remainder)
return result[::-1] # to invert the stringএখানে ডিভোড () ফুকশন ব্যবহার করে একটি সহজ সমাধান রয়েছে যা ভগ্নাংশ ছাড়াই অনুস্মারক এবং বিভাগের ফলাফল দেয়।
def dectobin(number):
bin = ''
while (number >= 1):
number, rem = divmod(number, 2)
bin = bin + str(rem)
return bindectobin(10)ফলাফল '0101'
numpy.binary_repr(num, width=None)উপরের ডকুমেন্টেশন লিঙ্ক থেকে উদাহরণ:
>>> np.binary_repr(3) '11' >>> np.binary_repr(-3) '-11' >>> np.binary_repr(3, width=4) '0011'যখন ইনপুট নম্বরটি নেতিবাচক এবং প্রস্থ নির্দিষ্ট করা হয় তখন দুটির পরিপূরক ফিরে আসে:
>>> np.binary_repr(-3, width=3) '101' >>> np.binary_repr(-3, width=5) '11101'
এখানে নিয়মিত গণিত ব্যবহারের আরও একটি উপায় রয়েছে, কোনও লুপ নেই, কেবল পুনরাবৃত্তি। (তুচ্ছ মামলায় 0 কিছুই দেয় না)
def toBin(num):
if num == 0:
return ""
return toBin(num//2) + str(num%2)
print ([(toBin(i)) for i in range(10)])
['', '1', '10', '11', '100', '101', '110', '111', '1000', '1001']ডিইসি, বিন, এইচএক্স: এর জন্য সমস্ত প্রয়োজনীয় ফাংশন সহ ক্যালকুলেটর: (পাইথন ৩.৫ দিয়ে তৈরি এবং পরীক্ষিত)
আপনি ইনপুট পরীক্ষার নম্বরগুলি পরিবর্তন করতে পারেন এবং রূপান্তরিতগুলি পেতে পারেন।
# CONVERTER: DEC / BIN / HEX
def dec2bin(d):
# dec -> bin
b = bin(d)
return b
def dec2hex(d):
# dec -> hex
h = hex(d)
return h
def bin2dec(b):
# bin -> dec
bin_numb="{0:b}".format(b)
d = eval(bin_numb)
return d,bin_numb
def bin2hex(b):
# bin -> hex
h = hex(b)
return h
def hex2dec(h):
# hex -> dec
d = int(h)
return d
def hex2bin(h):
# hex -> bin
b = bin(h)
return b
## TESTING NUMBERS
numb_dec = 99
numb_bin = 0b0111
numb_hex = 0xFF
## CALCULATIONS
res_dec2bin = dec2bin(numb_dec)
res_dec2hex = dec2hex(numb_dec)
res_bin2dec,bin_numb = bin2dec(numb_bin)
res_bin2hex = bin2hex(numb_bin)
res_hex2dec = hex2dec(numb_hex)
res_hex2bin = hex2bin(numb_hex)
## PRINTING
print('------- DECIMAL to BIN / HEX -------\n')
print('decimal:',numb_dec,'\nbin: ',res_dec2bin,'\nhex: ',res_dec2hex,'\n')
print('------- BINARY to DEC / HEX -------\n')
print('binary: ',bin_numb,'\ndec: ',numb_bin,'\nhex: ',res_bin2hex,'\n')
print('----- HEXADECIMAL to BIN / HEX -----\n')
print('hexadec:',hex(numb_hex),'\nbin: ',res_hex2bin,'\ndec: ',res_hex2dec,'\n')সংখ্যাগুলির বাইনারি গণনা করতে:
print("Binary is {0:>08b}".format(16))একটি সংখ্যার হেক্সা দশমিক গণনা করতে :
print("Hexa Decimal is {0:>0x}".format(15))16% অবধি সমস্ত বাইনারি নম্বর গণনা করতে ::
for i in range(17):
print("{0:>2}: binary is {0:>08b}".format(i))17 পর্যন্ত হেক্সা দশমিক সংখ্যা গণনা করতে
for i in range(17):
print("{0:>2}: Hexa Decimal is {0:>0x}".format(i))
##as 2 digit is enogh for hexa decimal representation of a numberআপনি যদি "খাঁটি" পাইথন ছেড়ে দিতে চান তবে প্রচুর ফায়ারপাওয়ার অর্জন করতে চান তবে সেজে রয়েছে - উদাহরণটি এখানে :
sage: a = 15
sage: a.binary()
'1111'আপনি নোট করবেন যে এটি স্ট্রিং হিসাবে ফিরে আসে, তাই এটির মতো একটি নম্বর হিসাবে এটি ব্যবহার করতে আপনি যেমন কিছু করতে চান
sage: eval('0b'+b)
15try:
while True:
p = ""
a = input()
while a != 0:
l = a % 2
b = a - l
a = b / 2
p = str(l) + p
print(p)
except:
print ("write 1 number")দশমিক বাইনারি রূপান্তর করতে আমি ম্যাট্রিক্স অপারেশন ব্যবহার করে একটি পদ্ধতি পেয়েছি।
import numpy as np
E_mat = np.tile(E,[1,M])
M_order = pow(2,(M-1-np.array(range(M)))).T
bindata = np.remainder(np.floor(E_mat /M_order).astype(np.int),2)Eহ'ল ইনপুট দশমিক ডেটা, Mবাইনারি অর্ডার। bindataআউটপুট বাইনারি ডেটা, যা এম বাইনারি ম্যাট্রিক্সের 1 আকারে।
এখানে দশমিক রূপান্তরকারী থেকে একটি সাধারণ বাইনারি যা ক্রমাগত লুপ হয়
t = 1
while t > 0:
binaryNumber = input("Enter a binary No.")
convertedNumber = int(binaryNumber, 2)
print(convertedNumber)
print("")এটি আমার উত্তর এটি ভাল কাজ করে ..!
def binary(value) :
binary_value = ''
while value !=1 :
binary_value += str(value%2)
value = value//2
return '1'+binary_value[::-1]0? যেমন binary(0)আপনি যা প্রত্যাশা করেন তা পাবেন?