Bir şamandırayı, sonunda sıfır içermeyecek şekilde nasıl biçimlendirebilirim? Başka bir deyişle, ortaya çıkan dize mümkün olduğunca kısa olmasını istiyorum.

Örneğin:

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

Ben, yapardım ('%f' % x).rstrip('0').rstrip('.')- bilimsel gösterim, vb. Yerine sabit noktalı biçimlendirmeyi garanti eder. Evet, kaygan ve zarif değil %g, ama işe yarıyor (ve %gasla bilimsel gösterimi kullanmaya zorlamayacağımı bilmiyorum ; -).

Bunu %gbaşarmak için kullanabilirsiniz :

'%g'%(3.140)

veya Python 2.6 veya üstü için:

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

İçin dokümanlardanformat : gnedenler (diğer şeylerin yanı sıra)

önemsiz sondaki sıfırlar [kaldırılacak] önemden kaldırılır ve ondalık noktadan sonra kalan basamak yoksa da ondalık nokta kaldırılır.

En kolay ve muhtemelen en etkili yaklaşımı denemeye ne dersiniz? Normalize () yöntemi , en sağdaki tüm sıfırları kaldırır.

from decimal import Decimal

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

Çalışıyor Python 2 ve Python 3 .

-- Güncellenmiş --

@ BobStein-VisiBone'un belirttiği gibi tek sorun, 10, 100, 1000 ... gibi sayıların üstel gösterimde görüntülenmesidir. Bu, aşağıdaki işlev kullanılarak kolayca sabitlenebilir:

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()

Birkaç benzer sorunun cevabını inceledikten sonra, bu benim için en iyi çözüm gibi görünüyor:

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

Akıl yürütmem:

%g bilimsel gösterimden kurtulamaz.

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

15 ondalık basamak garip davranışlardan kaçınıyor gibi görünüyor ve ihtiyaçlarım için çok fazla hassasiyete sahip.

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

Bunun format(inputValue, '.15f').yerine kullanabilirdim '%.15f' % inputValue, ama bu biraz daha yavaş (~% 30).

Kullanabilirdim Decimal(inputValue).normalize(), ama bunun da birkaç sorunu var. Birincisi, çok daha yavaş (~ 11x). Ayrıca oldukça büyük bir hassasiyete sahip olmasına rağmen, kullanırken hala hassas kayıptan muzdarip olduğunu gördüm normalize().

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

En önemlisi, hala oraya koyduğunuz sayıdan başka bir şeyle sonuçlanmanıza neden olabilecek Decimalbirinden dönüştürüyorum float. Ben Decimalaritmetik kalır Decimalve Decimalbir dize ile başlatıldığında en iyi çalışır düşünüyorum .

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

Ben eminim hassas sorunu Decimal.normalize()bağlam ayarları kullanılarak gerekenlere ayarlanabilir, ancak zaten düşük hız ve saçma hassasiyete ihtiyaç duymadan ve yine de bir şamandıradan dönüştüğüm ve yine de hassasiyeti kaybettiğim düşünülürse, yapmadım takip etmeye değer olduğunu düşünmüyorum.

-0.0 geçerli bir kayan nokta sayısı olduğundan ve muhtemelen zaten nadir bir olay olacağı için olası "-0" sonucuyla ilgilenmiyorum, ancak bahsettiğinizden dolayı dize sonucunu mümkün olduğunca kısa tutmak istiyorsunuz, her zaman çok az ekstra hız maliyetiyle ekstra bir koşul kullanabilir.

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

İşte benim için işe yarayan bir çözüm. Bu bir karışımıdır çözümü ile POLYMESH yeni ve kullanımı .format() sözdizimi .

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

Çıktı :

3
3
3
3.1
3.14
3.14

Bunu başarmak için format () yöntemini kullanabilirsiniz:

format(3.140, '.10g') burada 10 istediğiniz hassasiyettir.

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

Biçimlendirme büyük olasılıkla en Pythonic yol olsa da, burada more_itertools.rstriparacı kullanan alternatif bir çözüm var .

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"

Sayı, bir yüklemi tatmin eden sondaki karakterlerden arındırılmış bir dizeye dönüştürülür. İşlev tanımı fmtgerekli değildir, ancak burada geçen tüm onayları test etmek için kullanılır. Not: string girişleri üzerinde çalışır ve isteğe bağlı tahminleri kabul eder.

Ayrıca bu üçüncü taraf kitaplığıyla ilgili ayrıntılara bakın more_itertools,.

"3.0" olarak görünen 3. ve 3.0 ile yaşayabiliyorsanız, sıfırları float gösterimlerinden sağa soran çok basit bir yaklaşım:

print("%s"%3.140)

(istisnaları işaret ettiği için @ellimilial teşekkürler)

QuantiPhy paketini kullanmak bir seçenektir. Normalde QuantiPhy, birimler ve SI ölçek faktörleri olan sayılarla çalışırken kullanılır, ancak çeşitli güzel sayı biçimlendirme seçeneklerine sahiptir.

    >>> 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

Ve bu durumda e-notasyonu kullanmaz:

    >>> 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

Tercih edebileceğiniz bir alternatif, SI birimleriyle, belki de birimlerle kullanmaktır.

    >>> 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, süper sıfırları kaldırmak ve elde edilen dizgiyi olabildiğince kısa yapmak istiyor.

% G üstel biçimlendirme çok büyük ve çok küçük değerler için ortaya çıkan dize kısaltır bulmak. Sorun, ne çok büyük ne de çok küçük olan 128.0 gibi üstel gösterime ihtiyaç duymayan değerler için gelir.

Sayıları yalnızca Decimal.normalize çok uzun olan dizeler oluşturduğunda% g üstel gösterimi kullanan kısa dizeler olarak biçimlendirmenin bir yolu. Bu en hızlı çözüm olmayabilir (Decimal.normalize kullandığından)

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']

Şamandıra için bunu kullanabilirsiniz:

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

Dene:

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

Ondalık için buradaki çözüme bakın: https://stackoverflow.com/a/42668598/5917543

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

Bunu sıfırları izlemek için şamandıraları biçimlendirmek için kullanıyorum.

İşte cevap:

import numpy

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

çıkış "3.14" ve "3"

trim='-' hem arkadaki sıfırları hem de ondalıkları kaldırır.

% G'yi yeterince geniş genişlikle kullanın, örneğin '% .99g'. Oldukça büyük bir sayı için sabit nokta gösteriminde yazdırılır.

EDIT: çalışmıyor

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

Bunun gibi kullanabilirsiniz max():

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

Bunu en pitonik bir şekilde şöyle yapabilirsiniz:

python3:

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

% F ile başa çıkmak ve

% .2f

, burada: .2f == .00 yüzer.

Misal:

print "Fiyat:% .2f"% fiyatlar [ürün]

çıktı:

Fiyat: 1.50