ฉันจะจัดรูปแบบการลอยเพื่อไม่ให้มีศูนย์ต่อท้ายได้อย่างไร กล่าวอีกนัยหนึ่งฉันต้องการให้สตริงผลลัพธ์สั้นที่สุดเท่าที่จะทำได้

ตัวอย่างเช่น:

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

ฉันฉันจะทำ('%f' % x).rstrip('0').rstrip('.')- รับประกันการจัดรูปแบบจุดคงที่มากกว่าสัญกรณ์ทางวิทยาศาสตร์ ฯลฯ ฯลฯ ใช่ไม่ลื่นและสง่างามเหมือน%gแต่มันใช้งานได้ (และฉันไม่รู้ว่าจะบังคับ%gให้ใช้สัญลักษณ์ทางวิทยาศาสตร์ไม่ได้หรือไม่ -)

คุณสามารถใช้%gเพื่อให้บรรลุสิ่งนี้:

'%g'%(3.140)

หรือสำหรับ Python 2.6 หรือดีกว่า:

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

จากเอกสารสำหรับformat : gสาเหตุ (เหนือสิ่งอื่นใด)

ศูนย์ที่ไม่มีนัยสำคัญต่อท้าย [จะ] ถูกลบออกจากซิกนิฟิแคนด์และจุดทศนิยมจะถูกลบออกหากไม่มีตัวเลขที่เหลืออยู่ตามหลัง

ลองใช้วิธีที่ง่ายและมีประสิทธิภาพมากที่สุด วิธีการทำให้ปกติ ()ลบศูนย์ท้ายสุดทั้งหมดออก

from decimal import Decimal

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

ทำงานในหลาม 2และงูหลาม 3

- อัปเดต -

ปัญหาเดียวที่ @ BobStein-VisiBone ชี้ให้เห็นคือตัวเลขเช่น 10, 100, 1,000 ... จะแสดงเป็นเลขชี้กำลังแทน สามารถแก้ไขได้อย่างง่ายดายโดยใช้ฟังก์ชั่นต่อไปนี้แทน:

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

หลังจากดูคำตอบของคำถามที่คล้ายกันหลายข้อดูเหมือนว่าจะเป็นทางออกที่ดีที่สุดสำหรับฉัน:

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

เหตุผลของฉัน:

%g ไม่กำจัดสัญกรณ์วิทยาศาสตร์

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

15 ตำแหน่งทศนิยมดูเหมือนจะหลีกเลี่ยงพฤติกรรมที่แปลกและมีความแม่นยำมากมายสำหรับความต้องการของฉัน

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

ฉันสามารถใช้format(inputValue, '.15f').แทนได้'%.15f' % inputValueแต่มันช้าลงเล็กน้อย (~ 30%)

ฉันสามารถใช้งานได้Decimal(inputValue).normalize()แต่ก็มีปัญหาเล็กน้อยเช่นกัน สำหรับหนึ่งมันช้ากว่ามาก (~ 11x) normalize()ฉันยังพบว่าแม้ว่ามันจะมีความแม่นยำมากสวยก็ยังคงได้รับความทุกข์จากการสูญเสียความแม่นยำเมื่อใช้

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

สิ่งสำคัญที่สุดคือฉันจะยังคงเปลี่ยนDecimalจากสิ่งfloatที่สามารถทำให้คุณจบลงด้วยสิ่งอื่นนอกเหนือจากหมายเลขที่คุณใส่ไว้ ฉันคิดว่าDecimalทำงานได้ดีที่สุดเมื่อเลขคณิตอยู่ในDecimalและDecimalเริ่มต้นได้ด้วยสตริง

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

ฉันแน่ใจว่าDecimal.normalize()สามารถแก้ไขปัญหาความแม่นยำของสิ่งที่จำเป็นโดยใช้การตั้งค่าบริบท แต่เมื่อพิจารณาความเร็วที่ช้าอยู่แล้วและไม่ต้องการความแม่นยำที่ไร้สาระและความจริงที่ว่าฉันยังคงแปลงจากการลอยและการสูญเสียความแม่นยำอยู่ดี ไม่คิดว่ามันคุ้มค่าที่จะติดตาม

ฉันไม่กังวลกับผลลัพธ์ "-0" ที่เป็นไปได้เนื่องจาก -0.0 เป็นเลขทศนิยมที่ถูกต้องและอาจเป็นเหตุการณ์ที่เกิดขึ้นได้ยาก แต่เนื่องจากคุณพูดถึงว่าคุณต้องการให้ผลลัพธ์สตริงสั้นที่สุดเท่าที่จะทำได้ สามารถใช้เงื่อนไขเพิ่มเติมได้เสมอด้วยค่าใช้จ่ายที่เพิ่มขึ้นเล็กน้อย

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

นี่เป็นวิธีแก้ปัญหาที่เหมาะกับฉัน มันเป็นความผสมผสานของการแก้ปัญหาโดยPolymeshและการใช้งานของใหม่ไวยากรณ์.format()

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

ผลผลิต :

3
3
3
3.1
3.14
3.14

คุณสามารถใช้รูปแบบ () เพื่อทำสิ่งนี้:

format(3.140, '.10g') โดยที่ 10 คือความแม่นยำที่คุณต้องการ

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

ในขณะที่การจัดรูปแบบเป็นไปได้ว่าวิธี Pythonic ส่วนใหญ่นี่เป็นวิธีการแก้ปัญหาอื่นโดยใช้more_itertools.rstripเครื่องมือ

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"

จำนวนจะถูกแปลงเป็นสตริงซึ่งมีอักขระต่อท้ายที่ตรงกับเพรดิเคต fmtไม่จำเป็นต้องใช้คำจำกัดความของฟังก์ชั่นแต่จะใช้ที่นี่เพื่อทดสอบการยืนยันซึ่งทั้งหมดผ่าน หมายเหตุ: ใช้งานได้กับอินพุตสตริงและยอมรับเพรดิเคตเพิ่มเติม

ดูรายละเอียดเพิ่มเติมในห้องสมุดบุคคลที่สามmore_itertoolsนี้

หากคุณสามารถใช้ชีวิตด้วย 3 และ 3.0 ปรากฏเป็น "3.0" วิธีการง่ายๆที่ศูนย์ทางขวาจากการเป็นตัวแทนลอย:

print("%s"%3.140)

(ขอบคุณ @ellimilial สำหรับการชี้ข้อยกเว้น)

การใช้แพ็คเกจ QuantiPhy เป็นตัวเลือก QuantiPhy ปกติจะใช้เมื่อทำงานกับตัวเลขกับหน่วยและตัวคูณ SI SI แต่มีตัวเลือกการจัดรูปแบบตัวเลขที่หลากหลาย

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

และจะไม่ใช้สัญลักษณ์อิเล็กทรอนิกส์ในสถานการณ์นี้:

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

อีกทางเลือกหนึ่งที่คุณอาจชอบคือการใช้ตัวคูณสเกล SI กับหน่วย

    >>> 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 ต้องการลบศูนย์ superflouous และสร้างสตริงผลลัพธ์ให้สั้นที่สุด

ฉันพบว่าการจัดรูปแบบเลขชี้กำลัง% g ทำให้สตริงผลลัพธ์สั้นลงสำหรับค่าที่มากและน้อย ปัญหามาสำหรับค่าที่ไม่จำเป็นต้องมีเครื่องหมายเอ็กซ์โพเนนเชียลเช่น 128.0 ซึ่งไม่ใหญ่มากหรือเล็กมาก

ต่อไปนี้เป็นวิธีหนึ่งในการจัดรูปแบบตัวเลขเป็นสตริงแบบสั้นที่ใช้เครื่องหมายเอ็กซ์โพเนนเชียล% g เฉพาะเมื่อ Decimal.normalize สร้างสตริงที่ยาวเกินไป นี่อาจไม่ใช่วิธีที่เร็วที่สุด (เนื่องจากใช้ Decimal.n ปกติize)

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

สำหรับโฟลทคุณสามารถใช้สิ่งนี้:

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

ทดสอบมัน

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

สำหรับทศนิยมดูวิธีแก้ปัญหาที่นี่: https://stackoverflow.com/a/42668598/5917543

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

ฉันใช้สิ่งนี้เพื่อจัดรูปแบบลอยตัวไปตามศูนย์

นี่คือคำตอบ:

import numpy

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

เอาท์พุท "3.14" และ "3"

trim='-' ลบทั้งศูนย์ต่อท้ายและทศนิยม

ใช้% g ที่มีความกว้างเพียงพอที่ใหญ่เช่น '% .99g' มันจะพิมพ์ด้วยเครื่องหมายจุดคงที่สำหรับจำนวนมากพอสมควร

แก้ไข: มันไม่ทำงาน

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

คุณสามารถใช้max()สิ่งนี้:

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

คุณสามารถทำสิ่งนั้นได้ในแบบ pythonic ส่วนใหญ่เช่นนั้น:

python3:

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

จัดการ% f และคุณควรใส่

% .2f

ที่: .2f == .00 ลอยตัว

ตัวอย่าง:

พิมพ์ "ราคา:% .2f"% prices [ผลิตภัณฑ์]

เอาท์พุท:

ราคา: 1.50