Jak sformatować liczbę zmiennoprzecinkową, aby nie zawierała zer na końcu? Innymi słowy, chcę, aby wynikowy ciąg był jak najkrótszy.

Na przykład:

3 -> "3"
3. -> "3"
3.0 -> "3"
3.1 -> "3.1"
3.14 -> "3.14"
3.140 -> "3.14"

Ja, zrobiłbym ('%f' % x).rstrip('0').rstrip('.')- gwarantuje formatowanie stałoprzecinkowe zamiast notacji naukowej itp. Tak, nie jest tak elegancki i elegancki %g, ale działa, (i nie wiem, jak zmusić, %gaby nigdy nie używać notacji naukowej; -).

Możesz to %gosiągnąć:

'%g'%(3.140)

lub w przypadku Python 2.6 lub nowszego:

'{0:g}'.format(3.140)

Z dokumentacji dotyczącejformat : gprzyczyn (między innymi)

nieznaczące końcowe zera [do] są usuwane ze znacznika, a kropka dziesiętna jest również usuwana, jeśli nie ma po niej pozostałych cyfr.

Co powiesz na wypróbowanie najłatwiejszego i prawdopodobnie najbardziej skutecznego podejścia? Metoda normalize () usuwa wszystkie skrajne po prawej stronie zera.

from decimal import Decimal

print (Decimal('0.001000').normalize())
# Result: 0.001

Działa w Python 2 i Python 3 .

- Zaktualizowano -

Jedynym problemem, jak wskazał @ BobStein-VisiBone, jest to, że liczby takie jak 10, 100, 1000 ... będą wyświetlane w postaci wykładniczej. Można to łatwo naprawić za pomocą następującej funkcji:

from decimal import Decimal


def format_float(f):
    d = Decimal(str(f));
    return d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize()

Po przejrzeniu odpowiedzi na kilka podobnych pytań wydaje mi się to najlepszym rozwiązaniem:

def floatToString(inputValue):
    return ('%.15f' % inputValue).rstrip('0').rstrip('.')

Moje rozumowanie:

%g nie pozbywa się notacji naukowej.

>>> '%g' % 0.000035
'3.5e-05'

15 miejsc po przecinku wydaje się unikać dziwnego zachowania i ma dużą precyzję na moje potrzeby.

>>> ('%.15f' % 1.35).rstrip('0').rstrip('.')
'1.35'
>>> ('%.16f' % 1.35).rstrip('0').rstrip('.')
'1.3500000000000001'

Mógłbym użyć format(inputValue, '.15f').zamiast '%.15f' % inputValue, ale to trochę wolniej (~ 30%).

Mógłbym użyć Decimal(inputValue).normalize(), ale ma to również kilka problemów. Po pierwsze, jest DUŻO wolniejszy (~ 11x). Odkryłem również, że chociaż ma dość dużą precyzję, nadal cierpi z powodu utraty precyzji podczas używania normalize().

>>> Decimal('0.21000000000000000000000000006').normalize()
Decimal('0.2100000000000000000000000001')
>>> Decimal('0.21000000000000000000000000006')
Decimal('0.21000000000000000000000000006')

Co najważniejsze, nadal będę się zmieniał Decimalz tego, floatco może sprawić, że skończysz na czymś innym niż liczba, którą tam umieściłeś. Myślę, że Decimaldziała najlepiej, gdy arytmetyka pozostaje w środku Decimali Decimaljest inicjalizowana ciągiem znaków.

>>> Decimal(1.35)
Decimal('1.350000000000000088817841970012523233890533447265625')
>>> Decimal('1.35')
Decimal('1.35')

Jestem pewien, że kwestię precyzji Decimal.normalize()można dopasować do tego, co jest potrzebne przy użyciu ustawień kontekstowych, ale biorąc pod uwagę już małą prędkość i niepotrzebną niedorzeczną precyzję, a także fakt, że i tak będę konwertować z liczby zmiennoprzecinkowej i tracę precyzję, nie zrobiłem tego nie sądzę, że warto było to kontynuować.

Nie przejmuję się możliwym wynikiem „-0”, ponieważ -0.0 jest prawidłową liczbą zmiennoprzecinkową i prawdopodobnie byłoby to rzadkie zjawisko, ale ponieważ wspomniałeś, że chcesz, aby wynik łańcucha był jak najkrótszy, zawsze może zastosować dodatkowy warunek przy bardzo niewielkim koszcie dodatkowej prędkości.

def floatToString(inputValue):
    result = ('%.15f' % inputValue).rstrip('0').rstrip('.')
    return '0' if result == '-0' else result

Oto rozwiązanie, które zadziałało dla mnie. Jest to mieszanka roztworu przez PolyMesh i stosowania nowej .format() składni .

for num in 3, 3., 3.0, 3.1, 3.14, 3.140:
    print('{0:.2f}'.format(num).rstrip('0').rstrip('.'))

Wyjście :

3
3
3
3.1
3.14
3.14

Aby to osiągnąć, możesz po prostu użyć formatu ():

format(3.140, '.10g') gdzie 10 to pożądana precyzja.

>>> str(a if a % 1 else int(a))

Podczas gdy formatowanie jest prawdopodobne w większości Pythonów, tutaj jest alternatywne rozwiązanie za pomocą tego more_itertools.rstripnarzędzia.

import more_itertools as mit


def fmt(num, pred=None):
    iterable = str(num)
    predicate = pred if pred is not None else lambda x: x in {".", "0"}
    return "".join(mit.rstrip(iterable, predicate))

assert fmt(3) == "3"
assert fmt(3.) == "3"
assert fmt(3.0) == "3"
assert fmt(3.1) == "3.1"
assert fmt(3.14) == "3.14"
assert fmt(3.140) == "3.14"
assert fmt(3.14000) == "3.14"
assert fmt("3,0", pred=lambda x: x in set(",0")) == "3"

Liczba jest konwertowana na ciąg, który jest pozbawiony końcowych znaków, które spełniają predykat. Definicja funkcji fmtnie jest wymagana, ale służy tutaj do testowania twierdzeń, które wszystkie przekazują. Uwaga: działa na wejściach łańcuchowych i akceptuje predykaty opcjonalne.

Zobacz także szczegółowe informacje na temat tej biblioteki stron trzecich, more_itertools.

Jeśli możesz żyć z wersjami 3. i 3.0 wyświetlanymi jako „3.0”, bardzo proste podejście, które usuwa zera z pływających reprezentacji:

print("%s"%3.140)

(dzięki @ellimilial za wskazanie wyjątków)

Korzystanie z pakietu QuantiPhy jest opcją. Zazwyczaj QuantiPhy jest używane podczas pracy z liczbami z jednostkami i współczynnikami skali SI, ale ma wiele fajnych opcji formatowania liczb.

    >>> from quantiphy import Quantity

    >>> cases = '3 3. 3.0 3.1 3.14 3.140 3.14000'.split()
    >>> for case in cases:
    ...    q = Quantity(case)
    ...    print(f'{case:>7} -> {q:p}')
          3 -> 3
         3. -> 3
        3.0 -> 3
        3.1 -> 3.1
       3.14 -> 3.14
      3.140 -> 3.14
    3.14000 -> 3.14

I nie będzie używać notacji elektronicznej w tej sytuacji:

    >>> cases = '3.14e-9 3.14 3.14e9'.split()
    >>> for case in cases:
    ...    q = Quantity(case)
    ...    print(f'{case:>7} -> {q:,p}')
    3.14e-9 -> 0
       3.14 -> 3.14
     3.14e9 -> 3,140,000,000

Alternatywą, którą możesz preferować, jest użycie współczynników skali SI, być może z jednostkami.

    >>> cases = '3e-9 3.14e-9 3 3.14 3e9 3.14e9'.split()
    >>> for case in cases:
    ...    q = Quantity(case, 'm')
    ...    print(f'{case:>7} -> {q}')
       3e-9 -> 3 nm
    3.14e-9 -> 3.14 nm
          3 -> 3 m
       3.14 -> 3.14 m
        3e9 -> 3 Gm
     3.14e9 -> 3.14 Gm

OP chce usunąć zbędne zera i uczynić otrzymany ciąg tak krótkim, jak to możliwe.

Uważam, że formatowanie wykładnicze% g skraca wynikowy ciąg znaków dla bardzo dużych i bardzo małych wartości. Problem pojawia się w przypadku wartości, które nie wymagają notacji wykładniczej, takich jak 128.0, która nie jest ani bardzo duża, ani bardzo mała.

Oto jeden ze sposobów formatowania liczb jako krótkich ciągów, które wykorzystują notację wykładniczą% g tylko wtedy, gdy Decimal.normalize tworzy ciągi, które są zbyt długie. To może nie być najszybsze rozwiązanie (ponieważ używa Decimal.normalize)

def floatToString (inputValue, precision = 3):
    rc = str(Decimal(inputValue).normalize())
    if 'E' in rc or len(rc) > 5:
        rc = '{0:.{1}g}'.format(inputValue, precision)        
    return rc

inputs = [128.0, 32768.0, 65536, 65536 * 2, 31.5, 1.000, 10.0]

outputs = [floatToString(i) for i in inputs]

print(outputs)

# ['128', '32768', '65536', '1.31e+05', '31.5', '1', '10']

Dla float możesz użyć tego:

def format_float(num):
    return ('%i' if num == int(num) else '%s') % num

Sprawdź to:

>>> format_float(1.00000)
'1'
>>> format_float(1.1234567890000000000)
'1.123456789'

W przypadku systemu dziesiętnego zobacz rozwiązanie tutaj: https://stackoverflow.com/a/42668598/5917543

"{:.5g}".format(x)

Używam tego do formatowania liczb zmiennoprzecinkowych do śledzenia zer.

Oto odpowiedź:

import numpy

num1 = 3.1400
num2 = 3.000
numpy.format_float_positional(num1, 3, trim='-')
numpy.format_float_positional(num2, 3, trim='-')

wyjście „3.14” i „3”

trim='-' usuwa zarówno końcowe zera, jak i dziesiętne.

Użyj% g o wystarczająco dużej szerokości, na przykład „% .99g”. Będzie drukowany w notacji stałej dla dowolnej dość dużej liczby.

EDYCJA: to nie działa

>>> '%.99g' % 0.0000001
'9.99999999999999954748111825886258685613938723690807819366455078125e-08'

Możesz użyć w max()ten sposób:

print(max(int(x), x))

Możesz to osiągnąć w najbardziej pythonowy sposób:

python3:

"{:0.0f}".format(num)

Obsługa% f i powinieneś umieścić

% .2f

, gdzie: .2f == .00 zmiennoprzecinkowe.

Przykład:

drukuj „Cena:% .2f”% ceny [produkt]

wynik:

Cena: 1,50