Die Konvertierung von float.hex () - Wert zu binary in Python

Frage ich mich, wie konvertiert man das Ergebnis von float.hex() binären, zum Beispiel von 0x1.a000000000000p+2 zu 110.1.

Kann bitte jemand helfen? Danke.

InformationsquelleAutor Qiang Li | 2011-10-05

python

10
```
def float_to_binary(num):
    exponent=0
    shifted_num=num
    while shifted_num != int(shifted_num):        
        shifted_num*=2
        exponent+=1
    if exponent==0:
        return '{0:0b}'.format(int(shifted_num))
    binary='{0:0{1}b}'.format(int(shifted_num),exponent+1)
    integer_part=binary[:-exponent]
    fractional_part=binary[-exponent:].rstrip('0')
    return '{0}.{1}'.format(integer_part,fractional_part)

def floathex_to_binary(floathex):
    num = float.fromhex(floathex)
    return float_to_binary(num)


print(floathex_to_binary('0x1.a000000000000p+2'))    
# 110.1

print(floathex_to_binary('0x1.b5c2000000000p+1'))    
# 11.01101011100001
```
Erklärung:

float.fromhex gibt einen float num. Wir würden gerne eine Binär-Repräsentation.

{0:b}.format(...) gibt binären Darstellungen von zahlen, aber nicht schwimmt.

Aber wenn wir multiplizieren Sie die Schwimmer genug von Potenzen von 2, das heißt, eine Verschiebung der binären Darstellung auf der linken Seite genug Platz, wir am Ende mit einem integer, shifted_num.

Einmal haben wir die ganze Zahl ist, sind wir frei Haus, denn nun können wir {0:b}.format(...).

Können wir re-legen Sie die Punkttaste (err, binäre Punkt?) durch die Verwendung eines bit-string-slicing-basiert auf der Anzahl der Orte, die wir hatten, die nach Links verschoben ist (exponent).

Technischen Punkt: Die Anzahl der Ziffern in der binären Darstellung der shifted_num kleiner sein kann als exponent. In diesem Fall müssen wir ein pad die binäre Darstellung mit mehr 0 ist auf der linken Seite, also binäre schneiden mit binary[:-exponent] nicht leer ist. Wir verwalten, die mit '{0:0{1}b}'.format(...). Die 0{1} im format-string legt die Breite des formatierten string zu {1} auf der linken Seite aufgefüllt mit Nullen. (Die {1} wird ersetzt durch die Anzahl exponent.)
- Können Sie bitte erklären, ein wenig, besonders über die Verwendung von shifted_num mit einem bestimmten Exponenten 20? Vielen Dank.
- Li: ich habe einige Erklärung. Hoffe, es hilft. Ich glaube nicht, dass meine Funktion ist perfekt-ich glaube 20 ist vielleicht zu klein... noch immer daran....
- es funktioniert, ich habe noch nicht genau verstanden wie, aber es funktioniert. Obwohl Ihre Ergebnisse sind weniger Ziffern (rund 52 bis 63 auf einige Aufsätze). Wissen Sie, warum ?
- Ich weiß nicht, was du meinst (in Bezug auf "52 bis 63"). Können Sie ein Beispiel geben?
- Dein code ist in Ordnung. Ich upvote. Ich verstehe immer noch nicht, es gründlich (ich habe nicht sah es in den Griff). Ich sehe, Sie haben etwas verändert: Hinzugefügt hast die if-Anweisung if exponent==0: , jetzt ist es völlig korrekt; vor, dass, ohne diese Bedingung, wird Ihr code gab seltsame Ergebnisse für big-big-zahlen. Jetzt funktioniert es perfectyly
- Über "52 bis 63", es ist die Länge der einige binäre Darstellungen, die ich mit meinem code für bestimmte zahlen, während Ihr code war nachgeben von der kürzeren Dauer der 0/1 für die gleichen zahlen. Wie Ihr code war nicht OK, für den großen zahlen, ich dachte, es war wegen dem code. Aber ich habe geprüft, die mit der Aufmerksamkeit, die Ausführung von mir und ich sehe, es ist ein problem, weil der Unterricht if pdec-tin==0: . !! Offensichtlich war, könnte es löst Probleme!!!!
- Ich hab den Grund! In der Tat ist es nicht die Anweisung if pdec-tin==0: selbst das problem verursacht. Wie ich schon in meiner Bearbeitung beantworten, es gibt jetzt eine Anleitung a,_,p = '{:f}'.format(fromh).partition('.') Aber , da bin ich mir nicht so viel geübt mit format() , ist die Tatsache, dass das Muster ist einfach {:f} macht, dass der resultierende string ist beschränkt in der Präzision, die wohl standardmäßig. Also, wenn ich an die Zahl x = 780.2265625, die daraus resultierenden h = x.hex() == '0 x 1.861d000000000p+9' und dann float.fromhex(h) == 780.2265625, das ist richtig, .....
- dann '{:f}'.format(float.fromhex(h)) ist nur 780.226562 . Ich hatte gewählt, der Wert 780.2265625, da der Teil nach dem Punkt ist genau darstellbar, im Binär -, nicht angenähert. Aber 780.226562 nicht mehr, so dass die Bedingung if pdec-tin==0: wurde nie respektiert, auch wenn pdec und zinn Decimal-Instanzen und-bits Hinzugefügt wurden, mehr als die, die notwendig zur Darstellung des 780.2265625. Ich brauche etwas wie, dass a,_,p = '{:.15f}'.format(fromh).partition('.') um das problem zu beheben, und jetzt ist mein code geben genau die gleichen Ergebnisse wie Ihr. Ouf !
InformationsquelleAutor unutbu

Hinweis, dass die binäre form 0x1.a000000000000p+2 ist nicht 101.1 (oder genauer 0b101.1 )

aber 0b110.1 (in meinem Python 2.7, binäre zahlen dargestellt werden wie die)

Ersten, eine nützliche Methode der float-Instanzen float.hex() und seine inverse-Funktion, die einen float-Methode der Klasse float.fromhex()

fh =  12.34.hex()
print fh
print float.fromhex(fh)

Ergebnis

0x1.8ae147ae147aep+3  # hexadecimal representation of a float
12.34

"Beachten Sie, dass float.hex() ist eine Instanzmethode, während schweben.fromhex() ist eine Methode der Klasse."

http://docs.python.org/library/stdtypes.html#float.fromhex

Zweitens, ich habe nicht eine Python-Funktion zu transformieren, eine hexadezimale Darstellung einer float in eine binäre Darstellung dieses schweben, das heißt mit einem Punkt ( noch als einen direkt zu verwandeln, eine dezimal-Darstellung einer float in eine binäre eins).

So habe ich eine Funktion für diesen Zweck.

Vor der hand, diese Funktion wandelt die hexadezimale Darstellung in eine dezimale Darstellung (string) die Eingabe von float.

Dann gibt es zwei Probleme:

how, um den Teil vor dem Punkt ?

Dieser Teil ist eine ganze Zahl, es ist einfach zu bedienen bin()
how, um den Teil nach dem Punkt ??

Das problem dieser transformation wurde schon mehrfach gefragt, auf SO, aber ich Verstand nicht, die Lösungen, so schrieb ich meine eigene.

Dann, hier ist die Funktion, die Sie möchten, Qiang Li:

def hexf2binf(x):
    '''Transforms an hexadecimal float with a dot into a binary float with a dot'''
    a,_,p = str(float.fromhex(x)).partition('.')
    # the following part transforms the part after the dot into a binary after the dot
    tinies = [ Decimal(1) / Decimal(2**i) for i in xrange(1,400)]
    bits = []
    pdec = Decimal('.'+p)
    for tin in tinies:
        if pdec-tin==0:
            bits.append('1')
            break
        elif pdec-tin>0:
            bits.append('1')
            pdec -= tin
        else:
            bits.append('0')
    pbin = ''.join(bits) # it's the binary after the dot
    # the integer before the dot is easily transformed into a binary
    return '.'.join((bin(int(a)),pbin))

Zur Durchführung der Verifizierung, schrieb ich eine Funktion zu verwandeln, die Teil einer Binär float nach einem Punkt in seine dezimale Darstellung:

from decimal import Decimal, getcontext()

getcontext().prec = 500
# precision == 500 , to be large !

tinies = [ Decimal(1) / Decimal(2**i) for i in xrange(1,400)]
com = dict((i,tin) for i,tin in enumerate(tinies,1))




def afterdotbinary2float(sbin, com = com):
    '''Transforms a binary lying after a dot into a float after a dot'''
    if sbin.startswith('0b.') or sbin.startswith('.'):
        sbin = sbin.split('.')[1]
    if all(c in '01' for c in sbin):
        return sum(int(c)*com[i] for i,c in enumerate(sbin,1))
    else:
        return None

Schließlich, die Anwendung dieser Funktionen:

from decimal import Decimal

getcontext().prec = 500
# precision == 500 , to be large !


tinies = [ Decimal(1) / Decimal(2**i) for i in xrange(1,400)]
com = dict((i,tin) for i,tin in enumerate(tinies,1))


def afterdotbinary2float(sbin, com = com):
    '''Transforms a binary lying after a dot into a float after a dot'''
    if sbin.startswith('0b.') or sbin.startswith('.'):
        sbin = sbin.split('.')[1]
    if all(c in '01' for c in sbin):
        return sum(int(c)*com[i] for i,c in enumerate(sbin,1))
    else:
        return None    



def hexf2binf(x):
    '''Transforms an hexadecimal float with a dot into a binary float with a dot'''
    a,_,p = str(float.fromhex(x)).partition('.')
    # the following part transforms the float after the dot into a binary after the dot
    tinies = [ Decimal(1) / Decimal(2**i) for i in xrange(1,400)]
    bits = []
    pdec = Decimal('.'+p)
    for tin in tinies:
        if pdec-tin==0:
            bits.append('1')
            break
        elif pdec-tin>0:
            bits.append('1')
            pdec -= tin
        else:
            bits.append('0')
    pbin = ''.join(bits) # it's the binary after the dot
    # the float before the dot is easily transformed into a binary
    return '.'.join((bin(int(a)),pbin))



for n in (45.625 , 780.2265625 , 1022.796875):
    print 'n ==',n,'      transformed with its method hex() to:'
    nhexed = n.hex()
    print 'nhexed = n.hex() ==',nhexed
    print '\nhexf2binf(nhexed) ==',hexf2binf(nhexed)
    print "\nVerification:\nbefore,_,after = hexf2binf(nhexed).partition('.')"
    before,_,after = hexf2binf(nhexed).partition('.')
    print 'before ==',before,'   after ==',after
    print 'int(before,2) ==',int(before,2)
    print 'afterdotbinary2float(after) ==',afterdotbinary2float(after)
    print '\n---------------------------------------------------------------\n'

Ergebnis

n == 45.625       transformed with its method hex() to:
nhexed = n.hex() == 0x1.6d00000000000p+5

hexf2binf(nhexed) == 0b101101.101

Verification:
before,_,after = hexf2binf(nhexed).partition('.')
before == 0b101101    after == 101
int(before,2) == 45
afterdotbinary2float(after) == 0.625

---------------------------------------------------------------

n == 780.2265625       transformed with its method hex() to:
nhexed = n.hex() == 0x1.861d000000000p+9

hexf2binf(nhexed) == 0b1100001100.0011101

Verification:
before,_,after = hexf2binf(nhexed).partition('.')
before == 0b1100001100    after == 0011101
int(before,2) == 780
afterdotbinary2float(after) == 0.2265625

---------------------------------------------------------------

n == 1022.796875       transformed with its method hex() to:
nhexed = n.hex() == 0x1.ff66000000000p+9

hexf2binf(nhexed) == 0b1111111110.110011

Verification:
before,_,after = hexf2binf(nhexed).partition('.')
before == 0b1111111110    after == 110011
int(before,2) == 1022
afterdotbinary2float(after) == 0.796875

---------------------------------------------------------------

Für die zwei zahlen:

from decimal import Decimal

tinies = [ Decimal(1) / Decimal(2**i) for i in xrange(1,400)]
com = dict((i,tin) for i,tin in enumerate(tinies,1))


def hexf2binf(x, tinies = tinies):
    '''Transforms an hexadecimal float with a dot into a binary float with a dot'''
    a,_,p = str(float.fromhex(x)).partition('.')
    # the following part transforms the float after the dot into a binary after the dot
    bits = []
    pdec = Decimal('.'+p)
    for tin in tinies:
        if pdec-tin==0:
            bits.append('1')
            break
        elif pdec-tin>0:
            bits.append('1')
            pdec -= tin
        else:
            bits.append('0')
    pbin = ''.join(bits) # it's the binary after the dot
    # the float before the dot is easily transformed into a binary
    return '.'.join((bin(int(a)),pbin))


print hexf2binf('0x1.a000000000000p+2')
print
print hexf2binf('0x1.b5c2000000000p+1')

als ein Ergebnis, das zeigt:

0b110.1

0b11.011010111000010000000000000000000000010000011111100001111111101001000110110000101101110000000001111110011100110101011100011110011101111010001011111001011101011000000011001111111010111011000101000111100100110000010110001000111010111101110111011111000100100110110101011100101001110011000100000000010001101111111010001110100100101110111000111111001011101101010011011111011001010011111111010101011010110

Ich weiß, ich hatte gesehen, mein Fehler. Aber es dauerte eine lange Zeit, um das problem zu lösen. Nun, meine Antwort verdient seinen zwei upvotes , denke ich
Ich dachte, Sie waren Recht, was die '0b' nach einem Punkt, so dass ich korrigiert.

InformationsquelleAutor eyquem

1

Gegeben, die eine hexadezimale Zeichenfolge h finden Sie die entsprechenden float mit
```
x = float.fromhex(h)
```
Also wirklich, du bist interessant, in der Lage zu produzieren, einen "festen Punkt" binäre Darstellung einer float. Seine möglich, es gibt keine endliche Darstellung, so dass Sie wahrscheinlich wollen, beschränken Sie die Länge es sein kann. (z.B. die binäre Darstellung der Mathematik.pi würde nicht zu Ende ...)

So etwas wie das folgende funktionieren könnte
```
def binaryRepresentation(x, n=8):
    # the base and remainder ... handle negatives as well ...
    base = int(x)
    fraction = abs(int(round( (x - base) * (2**n) )))

    # format and remove redundant zeros
    return "{0:b}.{1:b}".format(base, fraction).rstrip("0")
```
- Ich habe versucht, deine Funktion auf, die die zwei zahlen '0 x 1.a000000000000p+2' und '0 x 1.b5c2000000000p+1'. Ich habe den Fehler ValueError: invalid literal for int() with base 10: '0x1.a000000000000p+2' Dann legte ich x = float.fromhex(h) in der Funktion am Anfang (und ersetzen den parameter w mit h) und dann das Programm ausgeführt; es ergab sich : 11.11011 und 11.11011. Ja, das gleiche. Führen Sie einen code vor der Veröffentlichung.
- Die post klar, dass So really you're interesting in being able to produce a "fixed point" binary representation of any float und die Funktion macht genau das. Warum eine Funktion schreiben, die nur wandelt hex in Binär-als eine, die konvertiert schwimmt auf binäre ist weitaus nützlicher. Weitere binaryRepresentation(float.fromhex('0x1.a000000000000p+2')) und binaryRepresentation(float.fromhex('0x1.b5c2000000000p+1')) produzieren 110.1 und 11.11011 beziehungsweise. Ja nicht die gleiche. Sie sollten Lesen, ein posting richtig, bevor Sie kommentieren es.
- "Warum eine Funktion schreiben, die nur wandelt hex in Binär-als eine, die konvertiert schwimmt auf binäre ist weit mehr nützlich." ich Stimme zu: konvertieren von "dezimal" schwebt binary scheint mir häufiger wünschen, dass die Umwandlung von "hexadezimal" schwebt in Binär. Der Punkt ist, dass die OP will nicht die letztere, sondern die erstere. Also , ich persönlich habe Mühe zu schreiben, wie eine Funktion, und folglich war ich davon ausgegangen, dass Ihre Funktion erhalten sollen "hexadezimal" float als Argumente auch nicht "dezimal" schwebt. Aber das war nicht der Fall. Wo ist mein Fehler, dass ?
- In Bezug auf die Durchführung Ihrer Funktion, ist es klar, ich habe ein Fehler. Ich fügte x = float.fromhex(h) und ich dachte, ersetzen Sie den parameter x Ihrer Funktion mit dem parameter h , aber ich muss es getestet haben, haben den gleichen Wert als argument sicherlich der Grund, warum ich erhielt zwei mal den gleichen Wert 11.11011 ; tut mir Leid.
- So, ich habe erneut getestet, Ihre Funktion und dieses mal habe ich in der Tat erhalten die Werte 110.1 und 11.11011 , das ist richtig. Aber der Wert 11.11011 ist sicher falsch, weil meine Funktion und der unutbu 's-Funktion das gleiche Ergebnis: 11.01101011100001 für '0 x 1.b5c2000000000p+1", die die float - 3.41998291015625 . Mein Kommentar war sicherlich ein wenig zu viel zu schnell geschrieben, entschuldigen Sie, aber Ihre Antwort ist nicht befreit von Annäherung zu
InformationsquelleAutor donkopotamus

Großen BEARBEITEN über die großen zahlen

Der folgende code zeigt ein problem mit meiner Lösung in meiner anderen Antwort.

Beachten Sie, dass ich verändert die parameter meiner Funktion hexf2binf(floathex) von h zu floathex zu machen, die selben wie der parameter verwendet, von unutbu in seiner Funktion floathex_to_binary(floathex)

from decimal import Decimal,getcontext
getcontext.prec = 500
tinies = [ Decimal(1) / Decimal(2**i) for i in xrange(1,400)]
com = dict((i,tin) for i,tin in enumerate(tinies,1))

def hexf2binf(floathex, tinies = tinies):
    fromh = float.fromhex(floathex)
    print 'fromh = float.fromhex(h)    DONE'
    print 'fromh ==',fromh
    print "str(float.fromhex(floathex)) ==",str(float.fromhex(floathex))

    a,_,p = str(float.fromhex(floathex)).partition('.')
    print 'before the dot ==',a
    print 'after the dot ==',p
    # the following part transforms the float after the dot into a binary after the dot
    bits = []
    pdec = Decimal('.'+p)
    for tin in tinies:
        if pdec-tin==0:
            bits.append('1')
            break
        elif pdec-tin>0:
            bits.append('1')
            pdec -= tin
        else:
            bits.append('0')
    pbin = ''.join(bits) # it's the binary after the dot
    # the float before the dot is easily transformed into a binary
    return '.'.join((bin(int(a)),pbin))



x = x = 123456789012345685803008.0
print '   x = {:f}'.format(x)
h = x.hex()
print '   h = x.hex() ==',h

print '\nENTERING hexf2binf(floathex) with h as argument'
v = hexf2binf(h)
print '\nhexf2binf(x)==',v

Ergebnis

   x = 123456789012345685803008.000000
   h = x.hex() == 0x1.a249b1f10a06dp+76

ENTERING hexf2binf(floathex) with h as argument
fromh = float.fromhex(h)    DONE
fromh == 1.23456789012e+23
str(float.fromhex(floathex)) == 1.23456789012e+23
before the dot == 1
after the dot == 23456789012e+23

hexf2binf(x)== 0b1.111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

Ist das problem durch die Anweisung str(float.fromhex(x)) im Unterricht a,_,p = str(float.fromhex(x)).partition('.') produziert , für eine große Zahl, eine Darstellung der schweben.fromhex(x) mit einem Exponenten.

Anschließend werden DIE TEILE VOR DEM PUNKT (a ante) UND NACH DEM PUNKT (p (post) FALSCH.

Korrektur ist einfach: ersetzen der ungenauen Anweisung hinzu:

a,_,p = '{:f}'.format(float.fromhex(x)).partition('.')

Nota bene:

Auf einem typischen Computer läuft, Python, gibt es 53 bits of precision
für eine Python-float, so wird der Wert intern abgespeichert, wenn Sie
geben Sie die dezimale Zahl 0,1 ist die binäre Bruchteil
0.00011001100110011001100110011001100110011001100110011010
http://docs.python.org/tutorial/floatingpoint.html

Dass bedeutet, dass, wenn ein großer Wert für ein float ist geschrieben in einem code, dessen interne Repräsentation ist in der Tat eine Annäherung der geschriebenen Wert.

Das ist dargestellt durch den folgenden code:

x1 = 123456789012345685803008.0
print 'x1 == 123456789012345685803008.0'
h1 = x1.hex()
print 'h1 = x1.hex() ==',h1
y1 = float.fromhex(h1)
print 'y1 = float.fromhex(h1) == {:f}'.format(y1)
print

x2 = 123456789012345678901234.64655
print 'x2 == 123456789012345678901234.64655'
h2 = x2.hex()
print 'h2 = x2.hex() ==',h2
y2 = float.fromhex(h2)
print 'y2 = float.fromhex(h2) == {:f}'.format(y2)
print

Ergebnis

x1 == 123456789012345685803008.0
h1 = x1.hex() == 0x1.a249b1f10a06dp+76
y1 = float.fromhex(h1) == 123456789012345685803008.000000

x2 == 123456789012345678901234.64655
h2 = x2.hex() == 0x1.a249b1f10a06dp+76
y2 = float.fromhex(h2) == 123456789012345685803008.000000

Werte h1 und h2 sind die gleichen, weil Sie zwar verschiedene Werte zugewiesen Bezeichner x1 und x2 in das Skript, das OBJEKTE x1 und x2 vertreten sind, mit der gleichen Näherung in der Maschine.

Die interne Darstellung von 123456789012345685803008.0 ist der genaue Wert von 123456789012345685803008.0 und ist die interne Darstellung von 123456789012345678901234.64655 aber seine Annäherung, daher der Abzug von h1 und h2 von x1 und x2 gibt den gleichen Wert zu h1 und h2.

Dieses problem existiert, wenn wir schreiben eine Zahl in Dezimaldarstellung in einem Skript. Es existiert nicht, wenn wir schreiben direkt eine Nummer in hexadezimaler oder binärer Darstellung.

, Was ich wollte, zu betonen

ist, dass ich schrieb eine Funktion afterdotbinary2float(sbin, com = com) durchführen Prüfung auf den Ergebnissen hexf2binf( ). Diese überprüfung funktioniert gut, wenn die Anzahl übergeben hexf2binf( ) ist nicht groß, aber wegen der internen Angleichung von großen zahlen (= mit einer Menge von Ziffern), Frage ich mich, ob diese überprüfung nicht verdreht ist. In der Tat, wenn eine große Anzahl kommt in der Funktion, es wurde bereits angenähert : die Ziffern nach dem Punkt umgewandelt worden in eine Reihe von Nullen;

wie hier gezeigt nach:

from decimal import Decimal, getcontext
getcontext().prec = 500
tinies = [ Decimal(1) / Decimal(2**i) for i in xrange(1,400)]
com = dict((i,tin) for i,tin in enumerate(tinies,1))


def afterdotbinary2float(sbin, com = com):
    '''Transforms a binary lying after a dot into a float after a dot'''
    if sbin.startswith('0b.') or sbin.startswith('.'):
        sbin = sbin.split('.')[1]
    if all(c in '01' for c in sbin):
        return sum(int(c)*com[i] for i,c in enumerate(sbin,1))
    else:
        return None



def hexf2binf(floathex, tinies = tinies):
    '''Transforms an hexadecimal float with a dot into a binary float with a dot'''
    a,_,p = '{:.400f}'.format(float.fromhex(floathex)).partition('.')
    # the following part transforms the float after the dot into a binary after the dot
    bits = []
    pdec = Decimal('.'+p)
    for tin in tinies:
        if pdec-tin==0:
            bits.append('1')
            break
        elif pdec-tin>0:
            bits.append('1')
            pdec -= tin
        else:
            bits.append('0')
    pbin = ''.join(bits) # it's the binary after the dot
    # the float before the dot is easily transformed into a binary
    return '.'.join((bin(int(a)),pbin))



for n in (123456789012345685803008.0, 123456789012345678901234.64655, Decimal('123456789012345.2546') ):
    print 'n == {:f}      transformed with its method hex() to:'.format(n)
    nhexed = n.hex()
    print 'nhexed = n.hex() ==',nhexed
    print '\nhexf2binf(nhexed) ==',hexf2binf(nhexed)
    print "\nVerification:\nbefore,_,after = hexf2binf(nhexed).partition('.')"
    before,_,after = hexf2binf(nhexed).partition('.')
    print 'before ==',before,'   after ==',after
    print 'int(before,2) ==',int(before,2)
    print 'afterdotbinary2float(after) ==',afterdotbinary2float(after)
    print '\n---------------------------------------------------------------\n'

Ergebnis

n == 123456789012345685803008.000000      transformed with its method hex() to:
nhexed = n.hex() == 0x1.a249b1f10a06dp+76

hexf2binf(nhexed) == 0b11010001001001001101100011111000100001010000001101101000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Verification:
before,_,after = hexf2binf(nhexed).partition('.')
before == 0b11010001001001001101100011111000100001010000001101101000000000000000000000000    after == 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
int(before,2) == 123456789012345685803008
afterdotbinary2float(after) == 0E-399

---------------------------------------------------------------

n == 123456789012345685803008.000000      transformed with its method hex() to:
nhexed = n.hex() == 0x1.a249b1f10a06dp+76

hexf2binf(nhexed) == 0b11010001001001001101100011111000100001010000001101101000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Verification:
before,_,after = hexf2binf(nhexed).partition('.')
before == 0b11010001001001001101100011111000100001010000001101101000000000000000000000000    after == 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
int(before,2) == 123456789012345685803008
afterdotbinary2float(after) == 0E-399

---------------------------------------------------------------

n == 123456789012345.2546      transformed with its method hex() to:

Traceback (most recent call last):
  File "I:\verfitruc.py", line 41, in <module>
    nhexed = n.hex()
AttributeError: 'Decimal' object has no attribute 'hex'

Fazit: ein Test mit zahlen 123456789012345685803008.0 und 123456789012345678901234.64655 keinen Unterschied macht und kein Interesse.

So, ich wollte testen, un-zahlen approximiert, und ich ging einen Decimal-float-Zahl. Wie Sie sehen, das problem ist, dass eine solche Instanz noch nicht die hex() Methode.

Endlich, ich bin nicht ganz sicher, meine Funktion für die großen zahlen, aber es funktioniert richtig für die gemeinsamen zahlen haben, nachdem ich Sie korrigiert die falsche Anweisung.

BEARBEITEN

Ich fügte hinzu, '.400' in die Anweisung:

a,_,p = '{:.400f}'.format(fromh).partition('.')

andernfalls wird der Wert von p könnte abgeschnitten werden, so dass eine binäre Darstellung eine etwas andere Nummer als die, die an die Funktion übergeben.

Legte ich 400, weil es die Länge, die ich definiert für die Liste tinies enthält die Dezimal-Instanzen, entsprechend 1/2 , 1/4 , 1/8 , 1/16 etc

Jedoch, obwohl es ist selten, dass eine Zahl mit mehr als 400 stellen nach dem Komma hat keinen Sinn, das hinzufügen unbefriedigend bleibt für mich: der code ist nicht absolut Allgemeine, ist der Fall von unutbu 's code.

InformationsquelleAutor eyquem

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.