Легкая печать плакатов в python?

Ответ 1

Более постоянным решением является подкласс 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.

Трагически, вы не можете просто monkey-patch float.__repr__, потому что float неизменяемый.

Если вы не хотите подкласса float, но не против определения функции, map(f, x) намного более кратким, чем [f(n) for n in x]

Ответ 2

Поскольку никто не добавил его, следует отметить, что в будущем, начиная с Python 2.6+, рекомендуемый способ сделать string formating равен format, чтобы подготовиться к Python 3 +.

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

Новый строковый синтаксис не сложно но все же довольно мощный.

Я, хотя это может быть pprint, может иметь что-то, но я ничего не нашел.

Ответ 3

Вы можете сделать:

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

Ответ 4

Обратите внимание, что вы также можете умножить строку типа "%.2f" (пример: "%.2f" * 10).

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

Ответ 5

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

Это позволит избежать ошибок округления в двоичном представлении при печати без введения ограничения фиксированной точности (например, с помощью "%.2f"):

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

Ответ 6

Список 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

Ответ 7

Я считаю, что Python 3.1 будет печатать их лучше по умолчанию, без изменения кода. Но это бесполезно, если вы используете какие-либо расширения, которые не были обновлены для работы с Python 3.1

Ответ 8

Самый простой способ - использовать процедуру округления:

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]

Ответ 9

Вы можете использовать pandas.

Вот пример со списком:

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

И еще один способ дать dict DataFrame:

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

Ответ 10

Во-первых, элементы внутри коллекции печатают их репрезентацию. вы должны узнать о __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)

Ответ 11

Я просто столкнулся с этой проблемой, пытаясь использовать 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 просто переписал генератор...

Ответ 12

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

Ответ 13

У меня была эта проблема, но ни одно из решений здесь не делало именно то, что я хотел (я хочу, чтобы напечатанный вывод был допустимым выражением 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() должен быть более стандартным решением, но я считаю, что это более читаемо)

Ответ 14

Нижеприведенный код работает хорошо.

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

Ответ 15

Чтобы контролировать количество значимых цифр, используйте спецификатор формата% 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]

Ответ 16

Я согласен с комментарием SilentGhost, цикл for не так уж плох. Вы можете добиться того, чего хотите:

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