क्या पायथन में बाइनरी स्ट्रिंग में एक इंटेगर (या लॉन्ग) को परिवर्तित करने के लिए कोई डिब्बाबंद पायथन तरीके हैं?
Google पर dec2bin () फ़ंक्शन के असंख्य हैं ... लेकिन मुझे उम्मीद थी कि मैं एक अंतर्निहित फ़ंक्शन / लाइब्रेरी का उपयोग कर सकता हूं।
जवाबों:
पायथन की स्ट्रिंग प्रारूप विधि एक प्रारूप युक्ति ले सकती है।
>>> "{0:b}".format(37)
'100101'str.format()सिर्फ एक मूल्य को प्रारूपित करने के लिए ओवरकिल है। सीधे जाकर format()समारोह : format(n, 'b')। प्लेसहोल्डर को पार्स करने और इसे एक तर्क से मिलान करने की आवश्यकता नहीं है, सीधे मूल्य स्वरूपण ऑपरेशन के लिए सीधे जाएं। str.format()यदि आपको फॉर्मेट किए गए परिणाम को एक लंबी स्ट्रिंग में रखने की आवश्यकता हो तो ही इसका उपयोग करें (उदाहरण के लिए इसे टेम्पलेट के रूप में उपयोग करें)।
0स्ट्रिंग के साथ अंकों की संख्या जोड़ें : format(10, '016b')अग्रणी शून्य के साथ 16 अंकों के प्रारूप।
0में "{0:b}"नहीं गिराया जा सकता है? मेरा मतलब है, उस मामले में जहां केवल एक नंबर को फॉर्मेट किया जा रहा है, यह सही है "{:b}", है न?
"{:08b}".format(37)
यदि आप bin()एक समकक्ष के रूप में देख रहे हैं hex(), तो यह अजगर 2.6 में जोड़ा गया था।
उदाहरण:
>>> bin(10)
'0b1010'str(bin(i))[2:](1000000 के लिए 0.369s) की तुलना में "{0:b}".format(i)(1000000 के लिए 0.721)
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), उसका उपयोग करने की धीमी विधि केवल एक उदाहरण थी कि इसे कैसे किया जाए, जो वास्तविक रूप से प्रयुक्त भाषा के आधार पर O (n ^ 2) हो या न हो। यह केवल पायथन की तरह दिखता है क्योंकि पायथन एक आदर्श छद्म कोड भाषा है, इसलिए मैं इसे स्पष्ट करने के लिए बदलूंगा।
s = "1" + sजब O (N) नहीं था s। हो सकता है कि एक भाषा जहां सभी तार पीछे की ओर जमा हो या प्रत्येक चार एक लिंक की गई सूची में एक नोड है? किसी भी विशिष्ट भाषा के लिए एक स्ट्रिंग मूल रूप से वर्णों की एक सरणी है। उस स्थिति में एक स्ट्रिंग को उपसर्ग करने के लिए यह आवश्यक है कि एक प्रतिलिपि बनाई गई हो, आप अन्य पात्रों से पहले चरित्र को कैसे रख सकते हैं?
यदि आप 0b-उपसर्ग के बिना एक पाठीय प्रतिनिधित्व चाहते हैं, तो आप इसका उपयोग कर सकते हैं:
get_bin = lambda x: format(x, 'b')
print(get_bin(3))
>>> '11'
print(get_bin(-3))
>>> '-11'जब आप एक n- बिट प्रतिनिधित्व चाहते हैं:
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()पायथन बाइनरी पूर्णांक शाब्दिक सिंटैक्स का उत्पादन करने के उद्देश्य से एक डिबगिंग टूल है? मुझे वह दस्तावेज में नहीं मिला।
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.योगदानकर्ता शामिल जॉन फ़ूही , तुंग गुयेन , mVChr , मार्टिन थोमा । और मार्टिज़न पीटर।
str.format()बस एक प्रारूप को ओवरकिल करना है। सीधे जाकर format()समारोह: format(n, 'b')। प्लेसहोल्डर को पार्स करने की आवश्यकता नहीं है और इसे उस तरह से तर्क से मिलाएं।
जैसा कि पूर्ववर्ती उत्तर ज्यादातर प्रयुक्त प्रारूप () है, यहां एक एफ-स्ट्रिंग कार्यान्वयन है।
integer = 7
bit_count = 5
print(f'{integer:0{bit_count}b}')आउटपुट:
00,111
यहाँ सुविधा के लिए स्वरूपित स्ट्रिंग शाब्दिक के लिए अजगर डॉक्स लिंक है: https://docs.python.org/3/reference/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 ** (अंक -1) से 2 ** (अंक -1) -1) को 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यहाँ divmod () fucntion का उपयोग करते हुए सरल समाधान है जो कि रिमाइंडर और अंश के बिना विभाजन का परिणाम देता है।
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']DEC, BIN, HEX: के लिए सभी परिशिष्ट कार्यों के साथ कैलकुलेटर (बनाया और पायथन 3.5 के साथ परीक्षण)
आप इनपुट टेस्ट नंबर बदल सकते हैं और परिवर्तित प्राप्त कर सकते हैं।
# 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आउटपुट बाइनरी डेटा है, जो M बाइनरी मैट्रिक्स द्वारा 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)आप आप क्या अपेक्षा मिलेगा?