파이썬으로 쉽게 예쁜 수레 인쇄?

수레 목록이 있습니다. 간단히 말하면 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)

또는 실제로 정확한 숫자의 모든 소수를 계속보고 싶지만 예를 들어 후행 0을 제거하려면 형식 지정 문자열을 사용하는 것이 더 좋습니다 %g.

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

한 번만 인쇄하고 전역 동작을 변경하지 않으 np.array2string려면 위와 동일한 인수를 사용 하십시오.

아무도 그것을 추가했다, 할 수있는 권장되는 방법 2.6+ 파이썬에서 향후 주목해야한다 문자열 형식화하는 것은 함께 format파이썬 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)로의 전환을 취소합니다 prettyfloat.

비극적으로, 당신은 불변 float.__repr__하기 때문에 monkey-patch 만 할 수 없습니다 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]

파이썬 2 :

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

파이썬 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]

나는 Python 3.1이 코드 변경없이 기본적으로 더 멋지게 인쇄 할 것이라고 믿습니다. 그러나 Python 3.1에서 작동하도록 업데이트되지 않은 확장을 사용하는 경우 쓸모가 없습니다.

목록 구성은 당신의 친구입니다.

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

유효 자릿수 를 제어하려면 형식 지정자 % 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- 문자열 형식을 사용하십시오.

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]

팬더를 사용할 수 있습니다.

다음은 목록이있는 예입니다.

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에 dict를 제공하는 또 다른 방법 :

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

첫째, 컬렉션 내부의 요소는 재현을 인쇄합니다. __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를 사용하여 float의 튜플 목록을 출력하려고 시도하는 동안이 문제에 직면했습니다. 중첩 된 이해는 나쁜 생각 일 수 있지만 다음은 내가 한 일입니다.

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 3.6부터는 f- 문자열을 사용할 수 있습니다.

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

나는이 문제가 있었지만 여기에있는 해결책 중 어느 것도 내가 원하는 것을 정확하게 하지 못했습니다 (인쇄 된 출력이 유효한 파이썬 표현식이되기를 원합니다).

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 루프는 그렇게 나쁘지 않습니다. 다음을 통해 원하는 것을 얻을 수 있습니다.

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)