So runden Sie eine Zahl in Python auf signifikante Zahlen

Ich muss einen Float runden, um in einer Benutzeroberfläche angezeigt zu werden. ZB zu einer signifikanten Zahl:

1234 -> 1000

0,12 -> 0,1

0,012 -> 0,01

0,062 -> 0,06

6253 -> 6000

1999 -> 2000

Gibt es eine gute Möglichkeit, dies mit der Python-Bibliothek zu tun, oder muss ich es selbst schreiben?

Sie können negative Zahlen verwenden, um ganze Zahlen zu runden:

>>> round(1234, -3)
1000.0

Wenn Sie also nur die höchstwertige Ziffer benötigen:

>>> from math import log10, floor
>>> def round_to_1(x):
...   return round(x, -int(floor(log10(abs(x)))))
... 
>>> round_to_1(0.0232)
0.02
>>> round_to_1(1234243)
1000000.0
>>> round_to_1(13)
10.0
>>> round_to_1(4)
4.0
>>> round_to_1(19)
20.0

Sie müssen wahrscheinlich darauf achten, dass float in eine Ganzzahl umgewandelt wird, wenn es größer als 1 ist.

% g in der Zeichenfolgenformatierung formatiert einen Float, der auf eine bestimmte Anzahl von signifikanten Zahlen gerundet ist. Manchmal wird die wissenschaftliche 'e'-Notation verwendet. Konvertieren Sie daher die abgerundete Zeichenfolge zurück in einen Gleitkommawert und dann durch% s Zeichenfolgenformatierung.

>>> '%s' % float('%.1g' % 1234)
'1000'
>>> '%s' % float('%.1g' % 0.12)
'0.1'
>>> '%s' % float('%.1g' % 0.012)
'0.01'
>>> '%s' % float('%.1g' % 0.062)
'0.06'
>>> '%s' % float('%.1g' % 6253)
'6000.0'
>>> '%s' % float('%.1g' % 1999)
'2000.0'

Wenn Sie eine andere als eine signifikante Dezimalstelle haben möchten (ansonsten dieselbe wie Evgeny):

>>> from math import log10, floor
>>> def round_sig(x, sig=2):
...   return round(x, sig-int(floor(log10(abs(x))))-1)
... 
>>> round_sig(0.0232)
0.023
>>> round_sig(0.0232, 1)
0.02
>>> round_sig(1234243, 3)
1230000.0

f'{float(f"{i:.1g}"):g}'
# Or with Python <3.6,
'{:g}'.format(float('{:.1g}'.format(i)))

Diese Lösung unterscheidet sich von allen anderen, weil:

1. es löst genau die OP-Frage
2. es ist nicht braucht jedes zusätzliches Paket
3. es ist nicht braucht jede benutzerdefinierte Hilfsfunktion oder mathematische Operation

Für eine beliebige Anzahl nvon signifikanten Zahlen können Sie verwenden:

print('{:g}'.format(float('{:.{p}g}'.format(i, p=n))))

Prüfung:

a = [1234, 0.12, 0.012, 0.062, 6253, 1999, -3.14, 0., -48.01, 0.75]
b = ['{:g}'.format(float('{:.1g}'.format(i))) for i in a]
# b == ['1000', '0.1', '0.01', '0.06', '6000', '2000', '-3', '0', '-50', '0.8']

Hinweis : Mit dieser Lösung ist es nicht möglich, die Anzahl der signifikanten Ziffern dynamisch von der Eingabe anzupassen, da es keine Standardmethode gibt, um Zahlen mit unterschiedlicher Anzahl von nachgestellten Nullen ( 3.14 == 3.1400) zu unterscheiden. Wenn Sie dies tun müssen, werden nicht standardmäßige Funktionen benötigt, wie sie im Präzisionspaket enthalten sind.

Ich habe das Paket präzise erstellt, das genau das tut, was Sie wollen. Sie können Ihren Zahlen mehr oder weniger wichtige Zahlen geben.

Es gibt auch Standard-, wissenschaftliche und technische Notationen mit einer bestimmten Anzahl von signifikanten Zahlen aus.

In der akzeptierten Antwort steht die Zeile

>>> round_to_1(1234243)
1000000.0

Das spezifiziert tatsächlich 8 Sig Feigen. Für die Nummer 1234243 zeigt meine Bibliothek nur eine signifikante Zahl an:

>>> from to_precision import to_precision
>>> to_precision(1234243, 1, 'std')
'1000000'
>>> to_precision(1234243, 1, 'sci')
'1e6'
>>> to_precision(1234243, 1, 'eng')
'1e6'

Es wird auch die letzte signifikante Zahl gerundet und kann automatisch auswählen, welche Notation verwendet werden soll, wenn keine Notation angegeben ist:

>>> to_precision(599, 2)
'600'
>>> to_precision(1164, 2)
'1.2e3'

Um eine Ganzzahl auf eine signifikante Zahl zu runden, besteht die Grundidee darin, sie in einen Gleitkomma mit einer Ziffer vor dem Punkt umzuwandeln und diese zu runden und dann wieder in ihre ursprüngliche Ganzzahlgröße umzuwandeln.

Dazu müssen wir die größte Potenz von 10 weniger als die ganze Zahl kennen. Wir können dafür den Boden der log 10-Funktion verwenden.

from math import log10, floor
def round_int(i,places):
    if i == 0:
        return 0
    isign = i/abs(i)
    i = abs(i)
    if i < 1:
        return 0
    max10exp = floor(log10(i))
    if max10exp+1 < places:
        return i
    sig10pow = 10**(max10exp-places+1)
    floated = i*1.0/sig10pow
    defloated = round(floated)*sig10pow
    return int(defloated*isign)

Um die Frage direkt zu beantworten, ist hier meine Version mit Namen aus der R-Funktion :

import math

def signif(x, digits=6):
    if x == 0 or not math.isfinite(x):
        return x
    digits -= math.ceil(math.log10(abs(x)))
    return round(x, digits)

Mein Hauptgrund für die Veröffentlichung dieser Antwort sind die Kommentare, in denen ich mich beschwere, dass "0,075" auf 0,07 statt 0,08 rundet. Dies ist, wie von "Novice C" hervorgehoben, auf eine Kombination von Gleitkomma-Arithmetik zurückzuführen, die sowohl eine endliche Genauigkeit als auch eine Basis-2-Darstellung aufweist . Die Zahl, die 0,075 am nächsten kommt und tatsächlich dargestellt werden kann, ist etwas kleiner, daher wird die Rundung anders ausgeführt, als Sie es naiv erwarten könnten.

Beachten Sie auch, dass dies für jede Verwendung von nicht-dezimaler Gleitkomma-Arithmetik gilt, z. B. haben C und Java beide das gleiche Problem.

Um dies genauer zu zeigen, bitten wir Python, die Zahl im "Hex" -Format zu formatieren:

0.075.hex()

was uns gibt : 0x1.3333333333333p-4. Der Grund dafür ist, dass die normale Dezimaldarstellung häufig eine Rundung beinhaltet und daher nicht so ist, wie der Computer die Zahl tatsächlich "sieht". Wenn Sie an dieses Format nicht gewöhnt sind, sind einige nützliche Referenzen die Python-Dokumente und der C-Standard .

Um zu zeigen, wie diese Zahlen ein wenig funktionieren, können wir zu unserem Ausgangspunkt zurückkehren, indem wir Folgendes tun:

0x13333333333333 / 16**13 * 2**-4

was sollte ausdrucken 0.075. 16**13Dies liegt daran, dass nach dem Dezimalpunkt 13 hexadezimale Ziffern stehen und dass hexadezimale 2**-4Exponenten die Basis 2 sind.

Jetzt haben wir eine Vorstellung davon, wie Floats dargestellt werden. Wir können das decimalModul verwenden, um uns mehr Präzision zu verschaffen und uns zu zeigen, was los ist:

from decimal import Decimal

Decimal(0x13333333333333) / 16**13 / 2**4

Geben: 0.07499999999999999722444243844und hoffentlich erklären, warum zu round(0.075, 2)bewertet0.07

def round_to_n(x, n):
    if not x: return 0
    power = -int(math.floor(math.log10(abs(x)))) + (n - 1)
    factor = (10 ** power)
    return round(x * factor) / factor

round_to_n(0.075, 1)      # 0.08
round_to_n(0, 1)          # 0
round_to_n(-1e15 - 1, 16) # 1000000000000001.0

Hoffentlich nehmen Sie das Beste aus allen obigen Antworten (abzüglich der Möglichkeit, es als einzeiliges Lambda zu formulieren;)). Noch nicht erforscht, zögern Sie nicht, diese Antwort zu bearbeiten:

round_to_n(1e15 + 1, 11)  # 999999999999999.9

Ich habe Indgars Lösung so modifiziert, dass sie mit negativen und kleinen Zahlen (einschließlich Null) umgeht.

from math import log10, floor
def round_sig(x, sig=6, small_value=1.0e-9):
    return round(x, sig - int(floor(log10(max(abs(x), abs(small_value))))) - 1)

Wenn Sie ohne Zeichenfolgen runden möchten, ist der Link, den ich gefunden habe, in den obigen Kommentaren vergraben:

http://code.activestate.com/lists/python-tutor/70739/

kommt mir am besten vor. Wenn Sie dann mit Zeichenfolgenformatierungsdeskriptoren drucken, erhalten Sie eine angemessene Ausgabe, und Sie können die numerische Darstellung für andere Berechnungszwecke verwenden.

Der Code unter dem Link besteht aus drei Zeilen: def, doc und return. Es hat einen Fehler: Sie müssen nach explodierenden Logarithmen suchen. Das ist einfach. Vergleichen Sie die Eingabe mit sys.float_info.min. Die Komplettlösung lautet:

import sys,math

def tidy(x, n):
"""Return 'x' rounded to 'n' significant digits."""
y=abs(x)
if y <= sys.float_info.min: return 0.0
return round( x, int( n-math.ceil(math.log10(y)) ) )

Es funktioniert für jeden skalaren numerischen Wert, und n kann ein Wert sein, floatwenn Sie die Antwort aus irgendeinem Grund verschieben müssen. Sie können das Limit tatsächlich verschieben auf:

sys.float_info.min*sys.float_info.epsilon

ohne einen Fehler zu provozieren, wenn Sie aus irgendeinem Grund mit winzigen Werten arbeiten.

Ich kann mir nichts vorstellen, was dies sofort bewältigen könnte. Aber es ist ziemlich gut für Gleitkommazahlen gehandhabt.

>>> round(1.2322, 2)
1.23

Ganzzahlen sind schwieriger. Sie werden nicht als Basis 10 im Speicher gespeichert, daher sind wichtige Orte keine Selbstverständlichkeit. Es ist jedoch ziemlich trivial zu implementieren, sobald sie eine Zeichenfolge sind.

Oder für ganze Zahlen:

>>> def intround(n, sigfigs):
...   n = str(n)
...   return n[:sigfigs] + ('0' * (len(n)-(sigfigs)))

>>> intround(1234, 1)
'1000'
>>> intround(1234, 2)

Wenn Sie eine Funktion erstellen möchten, die eine beliebige Zahl verarbeitet, würde ich es vorziehen, beide in Zeichenfolgen zu konvertieren und nach einer Dezimalstelle zu suchen, um zu entscheiden, was zu tun ist:

>>> def roundall1(n, sigfigs):
...   n = str(n)
...   try:
...     sigfigs = n.index('.')
...   except ValueError:
...     pass
...   return intround(n, sigfigs)

Eine andere Möglichkeit besteht darin, nach Typ zu suchen. Dies ist weitaus weniger flexibel und spielt wahrscheinlich nicht gut mit anderen Zahlen wie DecimalObjekten:

>>> def roundall2(n, sigfigs):
...   if type(n) is int: return intround(n, sigfigs)
...   else: return round(n, sigfigs)

Die veröffentlichte Antwort war die beste verfügbare, wenn sie gegeben wurde, hat jedoch eine Reihe von Einschränkungen und liefert keine technisch korrekten signifikanten Zahlen.

numpy.format_float_positional unterstützt das gewünschte Verhalten direkt. Das folgende Fragment gibt den xauf 4 signifikante Zahlen formatierten Float zurück , wobei die wissenschaftliche Notation unterdrückt ist.

import numpy as np
x=12345.6
np.format_float_positional(x, precision=4, unique=False, fractional=False, trim='k')
> 12340.

Ich bin auch darauf gestoßen, aber ich brauchte Kontrolle über den Rundungstyp. Daher habe ich eine Schnellfunktion geschrieben (siehe Code unten), die Wert, Rundungstyp und gewünschte signifikante Ziffern berücksichtigen kann.

import decimal
from math import log10, floor

def myrounding(value , roundstyle='ROUND_HALF_UP',sig = 3):
    roundstyles = [ 'ROUND_05UP','ROUND_DOWN','ROUND_HALF_DOWN','ROUND_HALF_UP','ROUND_CEILING','ROUND_FLOOR','ROUND_HALF_EVEN','ROUND_UP']

    power =  -1 * floor(log10(abs(value)))
    value = '{0:f}'.format(value) #format value to string to prevent float conversion issues
    divided = Decimal(value) * (Decimal('10.0')**power) 
    roundto = Decimal('10.0')**(-sig+1)
    if roundstyle not in roundstyles:
        print('roundstyle must be in list:', roundstyles) ## Could thrown an exception here if you want.
    return_val = decimal.Decimal(divided).quantize(roundto,rounding=roundstyle)*(decimal.Decimal(10.0)**-power)
    nozero = ('{0:f}'.format(return_val)).rstrip('0').rstrip('.') # strips out trailing 0 and .
    return decimal.Decimal(nozero)


for x in list(map(float, '-1.234 1.2345 0.03 -90.25 90.34543 9123.3 111'.split())):
    print (x, 'rounded UP: ',myrounding(x,'ROUND_UP',3))
    print (x, 'rounded normal: ',myrounding(x,sig=3))

Verwenden der neuen Formatierung von Python 2.6+ (da% -Style veraltet ist):

>>> "{0}".format(float("{0:.1g}".format(1216)))
'1000.0'
>>> "{0}".format(float("{0:.1g}".format(0.00356)))
'0.004'

In Python 2.7+ können Sie die führenden 0s weglassen .

Diese Funktion führt eine normale Runde durch, wenn die Zahl größer als 10 ** ist (- decimal_positions). Andernfalls wird mehr Dezimalzahl hinzugefügt, bis die Anzahl der aussagekräftigen Dezimalstellen erreicht ist:

def smart_round(x, decimal_positions):
    dp = - int(math.log10(abs(x))) if x != 0.0 else int(0)
    return round(float(x), decimal_positions + dp if dp > 0 else decimal_positions)

Ich hoffe es hilft.

https://stackoverflow.com/users/1391441/gabriel , geht das Folgende auf Ihre Besorgnis über rnd (.075, 1) ein? Vorsichtsmaßnahme: Gibt den Wert als Float zurück

def round_to_n(x, n):
    fmt = '{:1.' + str(n) + 'e}'    # gives 1.n figures
    p = fmt.format(x).split('e')    # get mantissa and exponent
                                    # round "extra" figure off mantissa
    p[0] = str(round(float(p[0]) * 10**(n-1)) / 10**(n-1))
    return float(p[0] + 'e' + p[1]) # convert str to float

>>> round_to_n(750, 2)
750.0
>>> round_to_n(750, 1)
800.0
>>> round_to_n(.0750, 2)
0.075
>>> round_to_n(.0750, 1)
0.08
>>> math.pi
3.141592653589793
>>> round_to_n(math.pi, 7)
3.141593

Dies gibt eine Zeichenfolge zurück, sodass Ergebnisse ohne Bruchteile und kleine Werte, die sonst in der E-Notation erscheinen würden, korrekt angezeigt werden:

def sigfig(x, num_sigfig):
    num_decplace = num_sigfig - int(math.floor(math.log10(abs(x)))) - 1
    return '%.*f' % (num_decplace, round(x, num_decplace))

Wenn eine Frage so gründlich beantwortet wurde, warum nicht eine weitere hinzufügen?

Dies passt etwas besser zu meiner Ästhetik, obwohl viele der oben genannten vergleichbar sind

import numpy as np

number=-456.789
significantFigures=4

roundingFactor=significantFigures - int(np.floor(np.log10(np.abs(number)))) - 1
rounded=np.round(number, roundingFactor)

string=rounded.astype(str)

print(string)

Dies funktioniert für einzelne Zahlen und Numpy-Arrays und sollte für negative Zahlen gut funktionieren.

Es gibt noch einen zusätzlichen Schritt, den wir hinzufügen könnten: np.round () gibt eine Dezimalzahl zurück, auch wenn gerundet eine Ganzzahl ist (dh für signifikante Zahlen = 2 erwarten wir möglicherweise, dass wir -460 zurückbekommen, aber stattdessen erhalten wir -460.0). Wir können diesen Schritt hinzufügen, um dies zu korrigieren:

if roundingFactor<=0:
    rounded=rounded.astype(int)

Leider funktioniert dieser letzte Schritt für eine Reihe von Zahlen nicht - das überlasse ich Ihnen, lieber Leser, um herauszufinden, ob Sie es brauchen.

Das sigfig- Paket / die Bibliothek behandelt dies. Nach der Installation können Sie Folgendes tun:

>>> from sigfig import round
>>> round(1234, 1)
1000
>>> round(0.12, 1)
0.1
>>> round(0.012, 1)
0.01
>>> round(0.062, 1)
0.06
>>> round(6253, 1)
6000
>>> round(1999, 1)
2000

import math

  def sig_dig(x, n_sig_dig):
      num_of_digits = len(str(x).replace(".", ""))
      if n_sig_dig >= num_of_digits:
          return x
      n = math.floor(math.log10(x) + 1 - n_sig_dig)
      result = round(10 ** -n * x) * 10 ** n
      return float(str(result)[: n_sig_dig + 1])


    >>> sig_dig(1234243, 3)
    >>> sig_dig(243.3576, 5)

        1230.0
        243.36