Python-Runde auf die nächsthöhere Potenz von 10

Wie würde ich es schaffen, math.ceilso zu arbeiten, dass eine Zahl der nächsthöheren Potenz von 10 zugewiesen wird?

# 0.04  ->  0.1
# 0.7   ->  1
# 1.1   ->  10  
# 90    ->  100  
# ...

Meine aktuelle Lösung ist ein Wörterbuch, das den Bereich der Eingabenummer überprüft, aber fest codiert ist, und ich würde eine einzeilige Lösung bevorzugen. Vielleicht fehlt mir hier ein einfacher mathematischer Trick oder eine entsprechende Numpy-Funktion?

Sie können math.ceilmit verwenden math.log10, um dies zu tun:

>>> 10 ** math.ceil(math.log10(0.04))
0.1
>>> 10 ** math.ceil(math.log10(0.7))
1
>>> 10 ** math.ceil(math.log10(1.1))
10
>>> 10 ** math.ceil(math.log10(90))
100

log10(n)gibt Ihnen die Lösung x, die zufriedenstellend 10 ** x == nist. Wenn Sie also aufrunden , erhalten xSie den Exponenten für die nächsthöhere Potenz von 10.

Beachten Sie, dass für einen Wert , nwo xbereits eine ganze Zahl, die „nächsthöhere Leistung von 10“ wird n:

>>> 10 ** math.ceil(math.log10(0.1))
0.1
>>> 10 ** math.ceil(math.log10(1))
1
>>> 10 ** math.ceil(math.log10(10))
10

Ihr Problem ist unterbestimmt. Sie müssen einen Schritt zurücktreten und einige Fragen stellen.

• Welche Art (en) sind Ihre Eingaben?
• Welche Art (en) möchten Sie für Ihre Ausgaben?
• Auf was genau möchten Sie bei Ergebnissen unter 1 runden? Möchten Sie tatsächliche Potenzen von 10 oder Gleitkomma-Annäherungen von Potenzen von 10? Sie wissen, dass negative Potenzen von 10 nicht genau in Gleitkomma ausgedrückt werden können, oder? Nehmen wir zunächst an, dass Sie Gleitkomma-Approximationen von Potenzen von 10 wünschen.
• Wenn der Eingang genau eine Potenz von 10 ist (oder die nächste Gleitkomma-Annäherung an eine Potenz von 10), sollte der Ausgang mit dem Eingang identisch sein? Oder sollte es die nächste Potenz von 10 sein? "10 -> 10" oder "10 -> 100"? Nehmen wir vorerst das erstere an.
• Können Ihre Eingabewerte ein möglicher Wert der betreffenden Typen sein? oder sind sie eingeschränkter.

In einer anderen Antwort wurde vorgeschlagen, den Logarithmus zu nehmen, dann aufzurunden (Deckenfunktion) und dann zu potenzieren.

def nextpow10(n):
    return 10 ** math.ceil(math.log10(n))

Leider weist dies Rundungsfehler auf. Zunächst wird n von einem beliebigen Datentyp in eine Gleitkommazahl mit doppelter Genauigkeit konvertiert, wodurch möglicherweise Rundungsfehler auftreten. Anschließend wird der Logarithmus berechnet, wodurch möglicherweise mehr Rundungsfehler sowohl in den internen Berechnungen als auch im Ergebnis auftreten.

Daher habe ich nicht lange gebraucht, um ein Beispiel zu finden, bei dem ein falsches Ergebnis erzielt wurde.

>>> import math
>>> from numpy import nextafter
>>> n = 1
>>> while (10 ** math.ceil(math.log10(nextafter(n,math.inf)))) > n:
...     n *= 10
... 
>>> n
10
>>> nextafter(n,math.inf)
10.000000000000002
>>> 10 ** math.ceil(math.log10(10.000000000000002))
10

Es ist auch theoretisch möglich, dass es in die andere Richtung versagt, obwohl dies viel schwieriger zu provozieren scheint.

Für eine robuste Lösung für Floats und Ints müssen wir also davon ausgehen, dass der Wert unseres Logarithmus nur ungefähr ist, und wir müssen daher einige Möglichkeiten testen. Etwas in der Art von

def nextpow10(n):
    p = round(math.log10(n))
    r = 10 ** p
    if r < n:
        r = 10 ** (p+1) 
    return r;

Ich glaube, dieser Code sollte korrekte Ergebnisse für alle Argumente in einem vernünftigen realen Größenbereich liefern. Es wird für sehr kleine oder sehr große Anzahlen von nicht ganzzahligen und nicht Gleitkommatypen unterbrochen, da Probleme beim Konvertieren in Gleitkommatypen auftreten. Python-Sonderfälle Ganzzahlargumente für die Funktion log10, um einen Überlauf zu verhindern. Bei einer ausreichend massiven Ganzzahl können jedoch möglicherweise falsche Ergebnisse aufgrund von Rundungsfehlern erzwungen werden.

Um die beiden Implementierungen zu testen, habe ich das folgende Testprogramm verwendet.

n = -323 # 10**-324 == 0
while n < 1000:
    v = 10 ** n
    if v != nextpow10(v): print(str(v)+" bad")
    try:
        v = min(nextafter(v,math.inf),v+1)
    except:
        v += 1
    if v > nextpow10(v): print(str(v)+" bad")
    n += 1

Dies findet viele Fehler in der naiven Implementierung, aber keine in der verbesserten Implementierung.

Es scheint, dass Sie eher die niedrigste nächste Potenz von 10 wollen ... Hier ist eine Möglichkeit, reine Mathematik und kein Protokoll, sondern Rekursion zu verwenden.

def ceiling10(x):
    if (x > 10):
        return ceiling10(x / 10) * 10
    else:
        if (x <= 1):
            return ceiling10(10 * x) / 10
        else:
            return 10
for x in [1 / 1235, 0.5, 1, 3, 10, 125, 12345]:
    print(x, ceiling10(x))

y = math.ceil(x)
z = y + (10 - (y % 10))

So etwas vielleicht? Es ist nur aus meinem Kopf, aber es hat funktioniert, als ich ein paar Nummern im Terminal ausprobiert habe.

Schau dir das an!

>>> i = 0.04123; print i, 10 ** len( str( int( i ) ) ) if int( i ) > 1  else 10 if i > 1.0 else 1 if i > 0.1 else  10 ** ( 1 - min( [ ("%.100f" % i ).replace('.','').index( k ) for k in [ str( j ) for j in xrange( 1, 10 ) if str( j ) in "%.100f" % i  ] ]  ) )               
0.04123 0.1
>>> i = 0.712; print i, 10 ** len( str( int( i ) ) ) if int( i ) > 1  else 10 if i > 1.0 else 1 if i > 0.1 else  10 ** ( 1 - min( [ ("%.100f" % i ).replace('.','').index( k ) for k in [ str( j ) for j in xrange( 1, 10 ) if str( j ) in "%.100f" % i  ] ]  ) )                 
0.712 1
>>> i = 1.1; print i, 10 ** len( str( int( i ) ) ) if int( i ) > 1  else 10 if i > 1.0 else 1 if i > 0.1 else  10 ** ( 1 - min( [ ("%.100f" % i ).replace('.','').index( k ) for k in [ str( j ) for j in xrange( 1, 10 ) if str( j ) in "%.100f" % i  ] ]  ) )                   
1.1 10
>>> i = 90; print i, 10 ** len( str( int( i ) ) ) if int( i ) > 1  else 10 if i > 1.0 else 1 if i > 0.1 else  10 ** ( 1 - min( [ ("%.100f" % i ).replace('.','').index( k ) for k in [ str( j ) for j in xrange( 1, 10 ) if str( j ) in "%.100f" % i  ] ]  ) )                    
90 100

Dieser Code basiert auf dem Prinzip der Zehnermacht in len( str( int( float_number ) ) ).

Es gibt 4 Fälle:

• 1. int( i ) > 1.

  FloatZahl - konvertiert in int, danach Zeichenfolge str()daraus, gibt uns eine, stringmit lengthder wir genau suchen. Also, erster Teil, für die Eingabe i > 1.0- es ist zehn 10Potenzen dieser Länge.

• 2. & 3. Kleine Verzweigung: i > 1.0und i > 0.1<=> ist 10und 1jeweils.
• 4. Und letzter Fall, wenn i < 0.1: Hier sollen zehn in negativer Macht sein. Um das erste Nicht-Null-Element nach dem Komma zu erhalten, habe ich eine solche Konstruktion verwendet ("%.100f" % i ).replace('.','').index( k ), bei der k über das [1:10]Intervall läuft . Nehmen Sie danach das Minimum der Ergebnisliste. Und um eins verringern, ist es die erste Null, die gezählt werden soll. Auch hier können Standard-Pythons index()abstürzen, wenn sie nicht mindestens ein Nicht-Null-Element aus dem [1:10]Intervall finden. Deshalb muss ich am Ende die Auflistung nach Vorkommen "filtern" : if str( j ) in "%.100f" % i. Zusätzlich, um genauer zu werden - %.100fkann anders genommen werden.