พิมพ์ลอยใน python สวย ๆ ง่ายๆ?

ฉันมีรายชื่อลอย ถ้าฉันพูดง่ายๆprintมันจะแสดงแบบนี้:

[9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

ฉันสามารถใช้print "%.2f"ซึ่งจะต้องใช้การforวนซ้ำเพื่อสำรวจรายการ แต่จะใช้ไม่ได้กับโครงสร้างข้อมูลที่ซับซ้อนมากขึ้น ฉันต้องการอะไรสักอย่าง (ฉันกำลังสร้างมันขึ้นมาทั้งหมด)

>>> import print_options
>>> print_options.set_float_precision(2)
>>> print [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
[9.0, 0.05, 0.03, 0.01, 0.06, 0.08]

เป็นคำถามเก่า แต่ฉันจะเพิ่มสิ่งที่อาจเป็นประโยชน์:

ฉันรู้ว่าคุณเขียนตัวอย่างของคุณในรายการ Python ดิบ แต่ถ้าคุณตัดสินใจที่จะใช้numpyอาร์เรย์แทน (ซึ่งจะถูกต้องสมบูรณ์ในตัวอย่างของคุณเพราะดูเหมือนว่าคุณจะจัดการกับอาร์เรย์ของตัวเลข) มีคำสั่งนี้ (เกือบจะตรงทั้งหมด) กล่าวว่าคุณสร้างขึ้น:

import numpy as np
np.set_printoptions(precision=2)

หรือดีกว่าในกรณีของคุณหากคุณยังต้องการดูทศนิยมทั้งหมดของตัวเลขที่แม่นยำจริงๆ แต่กำจัดเลขศูนย์ต่อท้ายเช่นใช้สตริงการจัดรูปแบบ%g:

np.set_printoptions(formatter={"float_kind": lambda x: "%g" % x})

สำหรับการพิมพ์เพียงครั้งเดียวและไม่เปลี่ยนพฤติกรรมทั่วโลกให้ใช้np.array2stringกับอาร์กิวเมนต์เดียวกันกับด้านบน

เนื่องจากไม่มีใครเพิ่มมันควรสังเกตว่านับจาก Python 2.6+ วิธีที่แนะนำในการสร้างสตริงคือformatการเตรียมพร้อมสำหรับ Python 3+

print ["{0:0.2f}".format(i) for i in a]

ไวยากรณ์การจัดรูปแบบสตริงใหม่ไม่ยากที่จะใช้ แต่ก็ค่อนข้างมีประสิทธิภาพ

แม้ว่านั่นอาจจะpprintมีบางอย่าง แต่ฉันก็ไม่พบอะไรเลย

วิธีแก้ปัญหาที่ถาวรกว่าคือคลาสย่อยfloat:

>>> class prettyfloat(float):
    def __repr__(self):
        return "%0.2f" % self

>>> x
[1.290192, 3.0002, 22.119199999999999, 3.4110999999999998]
>>> x = map(prettyfloat, x)
>>> x
[1.29, 3.00, 22.12, 3.41]
>>> y = x[2]
>>> y
22.12

ปัญหาเกี่ยวกับคลาสย่อยfloatคือการแบ่งโค้ดที่กำลังมองหาประเภทของตัวแปรอย่างชัดเจน แต่เท่าที่ฉันสามารถบอกได้นั่นเป็นปัญหาเดียวของมัน และง่ายx = map(float, x)undoes prettyfloatแปลง

น่าเศร้าที่คุณไม่สามารถเพียงแค่ลิงปะfloat.__repr__เพราะfloatไม่เปลี่ยนรูป

หากคุณไม่ต้องการคลาสย่อยfloatแต่ไม่ต้องคำนึงถึงการกำหนดฟังก์ชั่นmap(f, x)มีความรัดกุมมากกว่า[f(n) for n in x]

คุณทำได้:

a = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
print ["%0.2f" % i for i in a]

โปรดทราบว่าคุณสามารถคูณสตริงเช่น "% .2f" (ตัวอย่าง: "% .2f" * 10)

>>> print "%.2f "*len(yourlist) % tuple(yourlist)
2.00 33.00 4.42 0.31 

print "[%s]"%", ".join(map(str,yourlist))

สิ่งนี้จะหลีกเลี่ยงข้อผิดพลาดในการปัดเศษในการแสดงไบนารีเมื่อพิมพ์โดยไม่ต้องใช้ข้อ จำกัด ความแม่นยำคงที่ (เช่นการจัดรูปแบบด้วย"%.2f"):

[9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.0793303]

l = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

Python 2:

print ', '.join('{:0.2f}'.format(i) for i in l)

Python 3:

print(', '.join('{:0.2f}'.format(i) for i in l))

เอาท์พุต:

9.00, 0.05, 0.03, 0.01, 0.06, 0.08

ตัวเลือกที่ง่ายที่สุดควรใช้รูทีนการปัดเศษ:

import numpy as np
x=[9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

print('standard:')
print(x)
print("\nhuman readable:")
print(np.around(x,decimals=2))

สิ่งนี้สร้างผลลัพธ์:

standard:
[9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.0793303]

human readable:
[ 9.    0.05  0.03  0.01  0.06  0.08]

ในการควบคุมจำนวนเลขนัยสำคัญให้ใช้ตัวระบุรูปแบบ% g

ตั้งชื่อโซลูชันของ Emile ว่า prettylist2f นี่คือสิ่งที่แก้ไข:

prettylist2g = lambda l : '[%s]' % ', '.join("%.2g" % x for x in l)

การใช้งาน:

>>> c_e_alpha_eps0 = [299792458., 2.718281828, 0.00729735, 8.8541878e-12]
>>> print(prettylist2f(c_e_alpha_eps0)) # [299792458.00, 2.72, 0.01, 0.00]
>>> print(prettylist2g(c_e_alpha_eps0)) # [3e+08, 2.7, 0.0073, 8.9e-12]

หากคุณต้องการความยืดหยุ่นในจำนวนเลขนัยสำคัญให้ใช้การจัดรูปแบบ f-stringแทน:

prettyflexlist = lambda p, l : '[%s]' % ', '.join(f"{x:.{p}}" for x in l)
print(prettyflexlist(3,c_e_alpha_eps0)) # [3e+08, 2.72, 0.0073, 8.85e-12]

ฉันเชื่อว่า Python 3.1 จะพิมพ์ได้ดีกว่าโดยค่าเริ่มต้นโดยไม่มีการเปลี่ยนแปลงรหัสใด ๆ แต่จะไม่มีประโยชน์หากคุณใช้ส่วนขยายใด ๆ ที่ยังไม่ได้รับการอัปเดตให้ทำงานกับ Python 3.1

รายชื่อ comps เป็นเพื่อนของคุณ

print ", ".join("%.2f" % f for f in list_o_numbers)

ลองมัน:

>>> nums = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999]
>>> print ", ".join("%.2f" % f for f in nums)
9.00, 0.05, 0.03, 0.01

คุณสามารถใช้แพนด้า

นี่คือตัวอย่างพร้อมรายการ:

In: import pandas as P
In: P.set_option('display.precision',3)
In: L = [3.4534534, 2.1232131, 6.231212, 6.3423423, 9.342342423]
In: P.Series(data=L)
Out: 
0    3.45
1    2.12
2    6.23
3    6.34
4    9.34
dtype: float64

หากคุณมี dict d และคุณต้องการให้คีย์เป็นแถว:

In: d
Out: {1: 0.453523, 2: 2.35423234234, 3: 3.423432432, 4: 4.132312312}

In: P.DataFrame(index=d.keys(), data=d.values())
Out:  
    0
1   0.45
2   2.35
3   3.42
4   4.13

และอีกวิธีในการกำหนดให้ DataFrame:

P.DataFrame.from_dict(d, orient='index')

ใน Python 3.6 คุณสามารถใช้ f-strings:

list_ = [9.0, 0.052999999999999999, 
         0.032575399999999997, 0.010892799999999999, 
         0.055702500000000002, 0.079330300000000006]

print(*[f"{element:.2f}" for element in list_])
#9.00 0.05 0.03 0.01 0.06 0.08

คุณสามารถใช้พารามิเตอร์การพิมพ์ในขณะที่ทำให้โค้ดอ่านง่ายมาก:

print(*[f"{element:.2f}" for element in list_], sep='|', end='<--')
#9.00|0.05|0.03|0.01|0.06|0.08<--

ขั้นแรกองค์ประกอบภายในคอลเลกชันจะพิมพ์ตัวแทน คุณควรเรียนรู้เกี่ยวกับและ__repr____str__

นี่คือความแตกต่างระหว่าง print repr (1.1) และ print 1.1 มารวมสตริงเหล่านั้นทั้งหมดแทนการเป็นตัวแทน:

numbers = [9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.07933]
print "repr:", " ".join(repr(n) for n in numbers)
print "str:", " ".join(str(n) for n in numbers)

ฉันเพิ่งพบปัญหานี้ในขณะที่พยายามใช้ pprint เพื่อส่งออกรายการสิ่งทอ ความเข้าใจที่ซ้อนกันอาจเป็นความคิดที่ไม่ดี แต่นี่คือสิ่งที่ฉันทำ:

tups = [
        (12.0, 9.75, 23.54),
        (12.5, 2.6, 13.85),
        (14.77, 3.56, 23.23),
        (12.0, 5.5, 23.5)
       ]
pprint([['{0:0.02f}'.format(num) for num in tup] for tup in tups])

ตอนแรกฉันใช้นิพจน์เครื่องกำเนิดไฟฟ้า แต่ pprint เพิ่งสร้างซ้ำเครื่องกำเนิดไฟฟ้า ...

ฉันมีปัญหานี้ แต่ไม่มีวิธีแก้ปัญหาใดที่ทำตามที่ฉันต้องการได้อย่างแน่นอน (ฉันต้องการให้ผลลัพธ์ที่พิมพ์ออกมาเป็นนิพจน์ python ที่ถูกต้อง) ดังนั้นวิธีการเกี่ยวกับสิ่งนี้:

prettylist = lambda l : '[%s]' % ', '.join("%.2f" % f for f in l)

การใช้งาน:

>>> ugly = [9.0, 0.052999999999999999, 0.032575399999999997,
            0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
>>> prettylist = lambda l : '[%s]' % ', '.join("%.2f" % f for f in l)
>>> print prettylist(ugly)
[9.00, 0.05, 0.03, 0.01, 0.06, 0.08]

(ฉันรู้ว่า. format () ควรจะเป็นโซลูชันมาตรฐานมากกว่า แต่ฉันพบว่าสิ่งนี้อ่านง่ายกว่า)

ฉันเห็นด้วยกับความคิดเห็นของ SilentGhost, for loop ไม่ได้แย่ขนาดนั้น คุณสามารถบรรลุสิ่งที่คุณต้องการด้วย:

l = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
for x in l: print "%0.2f" % (x)

รหัสด้านล่างใช้งานได้ดีสำหรับฉัน

list = map (lambda x: float('%0.2f' % x), list)