Zijn er standaard Python-methoden om een geheel getal (of lang) in Python om te zetten in een binaire tekenreeks?
Er zijn talloze dec2bin()-functies beschikbaar op Google… Maar ik hoopte dat ik een ingebouwde functie/bibliotheek zou kunnen gebruiken.
Antwoord 1, autoriteit 100%
De tekenreeksopmaakmethode van Python kan een formaatspecificatie hebben.
>>> "{0:b}".format(37)
'100101'
Specifieke documenten opmaken voor Python 2
Specifieke documenten opmaken voor Python 3
Antwoord 2, autoriteit 61%
Als u op zoek bent naar bin()als een equivalent van hex(), is het toegevoegd in python 2.6.
Voorbeeld:
>>> bin(10)
'0b1010'
Antwoord 3, autoriteit 7%
Python heefthier eigenlijk al iets voor ingebouwd, de mogelijkheid om bewerkingen uit te voeren zoals '{0:b}'.format(42), die geef je het bitpatroon (in een string) voor 42of 101010.
Voor een meer algemene filosofie: geen enkele taal of bibliotheek zal zijn gebruikersbestand allesgeven dat ze wensen. Als u in een omgeving werkt die niet precies biedt wat u nodig hebt, moet u tijdens het ontwikkelen codefragmenten verzamelen om ervoor te zorgen dat u nooit twee keer hetzelfde hoeft te schrijven. Zoals bijvoorbeeld de pseudo-code:
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
die uw binaire tekenreeks zal construeren op basis van de decimale waarde. Houd er rekening mee dat dit een generiek stukje pseudo-code is, wat misschien niet de meestefficiënte manier is om het te doen, maar met de herhalingen die u lijkt te suggereren, zal het niet veel uitmaken. Het is eigenlijk alleen bedoeld als richtlijn over hoe het kan worden gedaan.
Het algemene idee is om code te gebruiken van (in volgorde van voorkeur):
- de taal of ingebouwde bibliotheken.
- bibliotheken van derden met geschikte licenties.
- je eigen collectie.
- iets nieuws dat je moet schrijven (en opslaan in je eigen verzameling voor later).
Antwoord 4, autoriteit 5%
Als u een tekstuele weergave wilt zonder het 0b-voorvoegsel, kunt u dit gebruiken:
get_bin = lambda x: format(x, 'b')
print(get_bin(3))
>>> '11'
print(get_bin(-3))
>>> '-11'
Als u een n-bits weergave wilt:
get_bin = lambda x, n: format(x, 'b').zfill(n)
>>> get_bin(12, 32)
'00000000000000000000000000001100'
>>> get_bin(-12, 32)
'-00000000000000000000000000001100'
Als alternatief, als je liever een functie hebt:
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)
Antwoord 5, autoriteit 4%
Als referentie:
def toBinary(n):
return ''.join(str(1 & int(n) >> i) for i in range(64)[::-1])
Deze functie kan een positief geheel getal zo groot als 18446744073709551615converteren, weergegeven als string '1111111111111111111111111111111111111111111111111111111111111111'.
Het kan worden aangepast om een veel groter geheel getal weer te geven, hoewel het misschien niet zo handig is als "{0:b}".format()of bin().
Antwoord 6, autoriteit 3%
Dit is voor python 3 en het behoudt de voorloopnullen!
print(format(0, '08b'))
Antwoord 7, autoriteit 3%
Een eenvoudige manier om dat te doen is door de tekenreeksindeling te gebruiken, zie deze pagina.
>> "{0:b}".format(10)
'1010'
En als je een vaste lengte van de binaire string wilt hebben, kun je dit gebruiken:
>> "{0:{fill}8b}".format(10, fill='0')
'00001010'
Als het complement van twee vereist is, kan de volgende regel worden gebruikt:
'{0:{fill}{width}b}'.format((x + 2**n) % 2**n, fill='0', width=n)
waarbij n de breedte van de binaire tekenreeks is.
Antwoord 8, autoriteit 2%
one-liner met lambda:
>>> binary = lambda n: '' if n==0 else binary(n/2) + str(n%2)
test:
>>> binary(5)
'101'
BEWERKEN:
maar dan 🙁
t1 = time()
for i in range(1000000):
binary(i)
t2 = time()
print(t2 - t1)
# 6.57236599922
in vergelijking met
t1 = time()
for i in range(1000000):
'{0:b}'.format(i)
t2 = time()
print(t2 - t1)
# 0.68017411232
Antwoord 9, autoriteit 2%
Omdat de voorgaande antwoorden meestal format() gebruikten,
hier is een f-string implementatie.
integer = 7
bit_count = 5
print(f'{integer:0{bit_count}b}')
Uitvoer:
00111
Voor het gemak is hier de python docs-link voor opgemaakte tekenreeksen: https ://docs.python.org/3/reference/lexical_analysis.html#f-strings.
Antwoord 10
Het verbaast me dat er geen goede manier is om dit te bereiken met behulp van opmaakstrings. TLDR:
>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'
Lager verhaal
Dit is de functionaliteit van opmaakstrings die beschikbaar zijn in Python 3.6:
>>> x, y, z = 1, 2, 3
>>> f'{x} {y} {2*z}'
'1 2 6'
U kunt ook binair aanvragen:
>>> f'{z:b}'
'11'
Geef de breedte op:
>>> f'{z:8b}'
' 11'
Nul opvulling aanvragen:
f'{z:08b}'
'00000011'
En voeg een algemeen voorvoegsel toe om een binair getal aan te duiden:
>>> f'0b{z:08b}'
'0b00000011'
Je kunt Python ook het voorvoegsel voor je laten toevoegen, maar ik vind het niet zo leuk als de versie hierboven omdat je rekening moet houden met het voorvoegsel:
>>> f'{z:#010b}'
'0b00000011'
Meer informatie is beschikbaar in officiële documentatie op Geformatteerde letterlijke tekenreeksenen Formaatspecificatie minitaal.
Antwoord 11
Samenvatting van alternatieven:
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.
Bijdragers zijn onder andere John Fouhy, Tung Nguyen , mVChr, Martin Thomas. en Martijn Pieters.
Antwoord 12
>>> format(123, 'b')
'1111011'
Antwoord 13
Voor degenen onder ons die getekende gehele getallen (bereik -2**(digits-1) tot 2**(digits-1)-1) moeten converteren naar 2’s complementaire binaire strings, werkt dit:
def int2bin(integer, digits):
if integer >= 0:
return bin(integer)[2:].zfill(digits)
else:
return bin(2**digits + integer)[2:]
Dit levert:
>>> int2bin(10, 8)
'00001010'
>>> int2bin(-10, 8)
'11110110'
>>> int2bin(-128, 8)
'10000000'
>>> int2bin(127, 8)
'01111111'
Antwoord 14
Als ze numpy pack/unpackbits gebruiken, zijn ze je beste vrienden.
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)
Antwoord 15
je kunt het zo doen:
bin(10)[2:]
of :
f = str(bin(10))
c = []
c.append("".join(map(int, f[2:])))
print c
Antwoord 16
Tenzij ik verkeerd begrijp wat je bedoelt met binaire string, denk ik dat de module die je zoekt struct
Antwoord 17
Nog een andere oplossing met een ander algoritme, door bitsgewijze operatoren te gebruiken.
def int2bin(val):
res=''
while val>0:
res += str(val&1)
val=val>>1 # val=val/2
return res[::-1] # reverse the string
Een snellere versie zonder de string om te draaien.
def int2bin(val):
res=''
while val>0:
res = chr((val&1) + 0x30) + res
val=val>>1
return res
Antwoord 18
def binary(decimal) :
otherBase = ""
while decimal != 0 :
otherBase = str(decimal % 2) + otherBase
decimal //= 2
return otherBase
print binary(10)
uitvoer:
1010
Antwoord 19
Python 3.6 heeft een nieuwe benadering voor het opmaken van tekenreeksen toegevoegd, genaamd geformatteerde tekenreeksletters of f-tekenreeksen .
Voorbeeld:
name = 'Bob'
number = 42
f"Hello, {name}, your number is {number:>08b}"
Uitvoer zal zijn ‘Hallo, Bob, je nummer is 000001010!’
Een bespreking van deze vraag is hier te vinden – Hier
Antwoord 20
Hier is de code die ik zojuist heb geïmplementeerd. Dit is geen methodemaar je kunt het gebruiken als een kant-en-klare functie!
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
Antwoord 21
n=input()
print(bin(n).replace("0b", ""))
Antwoord 22
numpy.binary_repr(num, width=None)
Voorbeelden uit de documentatielink hierboven:
>>> np.binary_repr(3) '11' >>> np.binary_repr(-3) '-11' >>> np.binary_repr(3, width=4) '0011'Het complement van twee wordt geretourneerd wanneer het invoergetal negatief is en de breedte is opgegeven:
>>> np.binary_repr(-3, width=3) '101' >>> np.binary_repr(-3, width=5) '11101'
Antwoord 23
Het geaccepteerde antwoord ging niet over negatieve getallen, die ik zal bespreken.
Naast de bovenstaande antwoorden kunt u ook gewoon de bingebruiken en hex-functies. En in de tegenovergestelde richting, gebruik de binaire notatie:
>>> bin(37)
'0b100101'
>>> 0b100101
37
Maar met negatieve getallen wordt het iets ingewikkelder. De vraag specificeert niet hoe u met negatieve getallen wilt omgaan.
Python voegt gewoon een minteken toe, dus het resultaat voor -37 zou dit zijn:
>>> bin(-37)
'-0b100101'
In binaire computer-/hardwaregegevens bestaan geen negatieve tekens. We hebben alleen maaren en nullen. Dus als u binaire gegevensstromen leest of produceert die door andere software/hardware moeten worden verwerkt, moet u eerst weten welke notatie wordt gebruikt.
Eén notatie is teken-magnitude-notatie, waarbij het eerste bit het negatieve vertegenwoordigt teken, en de rest is de werkelijke waarde. In dat geval zou -37 0b1100101zijn en 37 zou 0b0100101zijn. Dit lijkt op wat python produceert, maar voeg gewoon een 0 of 1 toe voor positieve / negatieve getallen.
Meer gebruikelijk is de Two’s complement-notatie, die ingewikkelder lijkt en de resultaat is heel anders dan de tekenreeksopmaak van Python. U kunt de details in de link lezen, maar met een 8-bits geheel getal met teken zou -37 0b11011011zijn en 37 zou 0b00100101zijn.
Python heeft geen gemakkelijke manier om deze binaire representaties te produceren. Je kunt numpygebruiken om de complementaire binaire waarden van Two om te zetten in python-getallen:
>>> import numpy as np
>>> np.int8(0b11011011)
-37
>>> np.uint8(0b11011011)
219
>>> np.uint8(0b00100101)
37
>>> np.int8(0b00100101)
37
Maar ik weet geen gemakkelijke manier om het tegenovergestelde te doen met ingebouwde functies. Het bitstring-pakketkan echter helpen.
>>> from bitstring import BitArray
>>> arr = BitArray(int=-37, length=8)
>>> arr.uint
219
>>> arr.int
-37
>>> arr.bin
'11011011'
>>> BitArray(bin='11011011').int
-37
>>> BitArray(bin='11011011').uint
219
Antwoord 24
Enigszins vergelijkbare oplossing
def to_bin(dec):
flag = True
bin_str = ''
while flag:
remainder = dec % 2
quotient = dec / 2
if quotient == 0:
flag = False
bin_str += str(remainder)
dec = quotient
bin_str = bin_str[::-1] # reverse the string
return bin_str
Antwoord 25
hier is een eenvoudige oplossing met de functie divmod() die de herinnering en het resultaat van een deling zonder de breuk retourneert.
def dectobin(number):
bin = ''
while (number >= 1):
number, rem = divmod(number, 2)
bin = bin + str(rem)
return bin
Antwoord 26
Hier is nog een andere manier om gewone wiskunde te gebruiken, geen lussen, alleen recursie. (Trivial case 0 levert niets op).
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']
Antwoord 27
Rekenmachine met alle benodigde functies voor DEC,BIN,HEX:
(gemaakt en getest met Python 3.5)
U kunt de ingevoerde testnummers wijzigen en de geconverteerde krijgen.
# 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')
Antwoord 28
Om binaire getallen te berekenen:
print("Binary is {0:>08b}".format(16))
De hexadecimaal van een getal berekenen:
print("Hexa Decimal is {0:>0x}".format(15))
Om alle binaire nee tot 16 te berekenen::
for i in range(17):
print("{0:>2}: binary is {0:>08b}".format(i))
Hexa decimaal nee berekenen tot 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
Antwoord 29
try:
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")
Antwoord 30
Ik heb een methode gevonden die matrixbewerking gebruikt om decimaal naar binair om te zetten.
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)
Eis ingevoerde decimale gegevens,Mis de binaire volgorde. bindatazijn binaire uitvoergegevens, in een formaat van 1 bij M binaire matrix.