Định dạng phao nổi trong Python mà không cần các số thừa thừa

Question

Làm thế nào để định dạng một phao để nó không làm mờ các số 0? Nói cách khác, tôi muốn chuỗi kết quả càng ngắn càng tốt ..?

Giống như:

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

Answer 1

nhớ, tôi muốn làm ('%f' % x).rstrip('0').rstrip('.') - đảm bảo điểm cố định định dạng chứ không phải là ký hiệu khoa học, vv vv Vâng, không phải là trơn và thanh lịch như %g, nhưng, nó hoạt động (và tôi không biết làm thế nào để buộc %g không bao giờ sử dụng ký pháp khoa học ;-).

Answer 2

Bạn có thể sử dụng %g để đạt được điều này:

'%g'%(3.140) 

hoặc, đối với Python 2.6 hoặc tốt hơn:

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

Từ docs for format: g nguyên nhân (trong số những thứ khác)

số 0 không đáng kể [được] bị xóa khỏi tên miền và dấu thập phân cũng bị xóa nếu có không còn chữ số nào theo sau.

Answer 3

Sử dụng% g có chiều rộng đủ lớn, ví dụ '% .99g'. Nó sẽ in bằng ký hiệu điểm cố định cho bất kỳ số lượng lớn nào hợp lý.

EDIT: nó không hoạt động

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

Answer 4

Có thể sử dụng chức năng format:

{}.format(float) 

Answer 5

gì về việc cố gắng tiếp cận dễ dàng nhất và có lẽ hiệu quả nhất? Phương pháp bình thường hóa() xóa tất cả các số 0 ở cuối cùng bên phải.

from decimal import Decimal 

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

trình trong Python 2 và Python 3.

- Cập nhật -

Vấn đề duy nhất là @ BobStein-VisiBone chỉ ra, đó là con số như 10, 100, 1000 ... sẽ được hiển thị trong trình bày mũ. Điều này có thể dễ dàng cố định bằng cách sử dụng chức năng sau thay vì:

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

Answer 6

Sau khi nhìn qua câu trả lời cho một số câu hỏi tương tự, điều này có vẻ là giải pháp tốt nhất đối với tôi:

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

lập luận của tôi:

%g không loại bỏ ký pháp khoa học.

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

15 chữ số thập phân dường như tránh hành vi lạ và có nhiều chính xác cho nhu cầu của tôi.

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

Tôi có thể đã sử dụng format(inputValue, '.15f'). thay vì '%.15f' % inputValue, nhưng đó là một chút chậm hơn (~ 30%).

Tôi có thể đã sử dụng Decimal(inputValue).normalize(), nhưng điều này cũng có một số vấn đề. Đối với một, nó là A LOT chậm hơn (~ 11x). Tôi cũng thấy rằng mặc dù nó có độ chính xác khá lớn, nó vẫn bị mất chính xác khi sử dụng normalize().

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

Quan trọng nhất, tôi sẽ vẫn được chuyển đổi để Decimal từ một float có thể làm cho bạn kết thúc với một cái gì đó khác hơn số bạn đặt vào đó. Tôi nghĩ rằng Decimal hoạt động tốt nhất khi số học nằm trong Decimal và Decimal được khởi tạo bằng một chuỗi.

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

tôi chắc chắn rằng vấn đề chính xác của Decimal.normalize() có thể được điều chỉnh để những gì cần thiết sử dụng cài đặt bối cảnh, nhưng xem xét tốc độ đã chậm và không cần độ chính xác vô lý và thực tế là tôi vẫn muốn được chuyển đổi từ một nổi và mất chính xác anyway, tôi không nghĩ rằng nó là giá trị theo đuổi.

Tôi không quan tâm đến kết quả "-0" có thể do -0.0 là số dấu phẩy động hợp lệ và có thể hiếm khi xảy ra, nhưng vì bạn đã đề cập bạn muốn giữ kết quả chuỗi ngắn càng tốt, bạn luôn có thể sử dụng thêm một điều kiện với chi phí tăng thêm rất ít.

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

Answer 7

Tôi nghĩ có cách dễ dàng hơn để thực hiện việc này với chức năng str.format mới. Nếu bạn chỉ chuyển đổi nó với str (ví dụ: str(.0300) ->0.3), nó thực hiện những gì mong muốn, chủ yếu. Nếu số lượng nhỏ hoặc đủ lớn, nó sẽ sử dụng ký hiệu số mũ, nhưng hầu hết nó sẽ chỉ in một số dấu phẩy động mà không có dấu 0 (hoặc hàng đầu). Nếu chuỗi định dạng là trống rỗng, sau đó nó về cơ bản phải viện đến đầu ra của str(), vì vậy đây sẽ làm việc nếu đó là chức năng mong muốn:

'{0}'.format(fp_num) 

Thậm chí điều này sẽ có tác dụng nếu đó là điều duy nhất được formated:

'{}'.format(fp_num) 

Answer 8

OP muốn loại bỏ các số không siêu và làm cho chuỗi kết quả càng ngắn càng tốt.

Tôi tìm thấy định dạng số mũ% g rút ngắn chuỗi kết quả cho các giá trị rất lớn và rất nhỏ. Vấn đề xảy ra đối với các giá trị không cần ký hiệu mũ, như 128.0, không phải là rất lớn hoặc rất nhỏ.

Dưới đây là một cách để định dạng số dưới dạng chuỗi ngắn chỉ sử dụng ký hiệu số mũ% g khi Decimal.normalize tạo chuỗi quá dài. Đây có thể không phải là giải pháp nhanh nhất (vì nó sử dụng Thập phân.bình thường)

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

Answer 9

Bạn chỉ có thể sử dụng định dạng() để đạt được điều này:

format(3.140, '.10g') nơi 10 là chính xác mà bạn muốn.

Answer 10

Đối với float bạn có thể sử dụng này:

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

thử nghiệm nó:

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

Đối Decimal thấy giải pháp ở đây: https://stackoverflow.com/a/42668598/5917543

Answer 11

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

Answer 12

Dưới đây là một giải pháp mà làm việc cho tôi. Đó là sự pha trộn của solution bởi PolyMesh và sử dụng .format()syntax mới.

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

Output:

3 
3 
3 
3.1 
3.14 
3.14 

Answer 13

Trong khi định dạng là khả năng mà hầu hết các cách Pythonic, đây là một giải pháp thay thế bằng công cụ 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" 

Số được chuyển thành một chuỗi, được tước các ký tự theo sau thỏa mãn vị từ. Định nghĩa hàm fmt là không bắt buộc, nhưng nó được sử dụng ở đây để kiểm tra các xác nhận, tất cả đều vượt qua. Lưu ý: nó hoạt động trên đầu vào chuỗi và chấp nhận các biến vị ngữ tùy chọn.

Xem thêm chi tiết về thư viện bên thứ ba này, more_itertools.

Answer 14

Bạn có thể đạt được điều đó theo cách pythonic nhất như thế:

python3:

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