Управление количеством десятичных знаков в распечатке смешанного списка (pprint.pformat, json.dumps)

Question

У меня есть «смешанный список» (здесь имеется в виду список, который может включать списки, символы, строки, целые числа или числа с плавающей запятой), и я хотел бы напечатать его - то есть получить его строковое представление, надеюсь,«довольно» - однако таким образом, что число с плавающей запятой в этой структуре данных ограничено. Затем, в принципе, я мог бы захотеть сохранить эту строку в файл и загрузить ее снова.

Как правило, я бы хотел, чтобы все значения с абсолютным значением> 0,01 были отформатированы с двумя десятичными знаками. только остальные, отформатированные с научной нотацией.

Глядя на некоторые сообщения SO, мне удалось придумать следующий пример (работает с Python 2.7.16 и Python 3.7.4 на MSYS2, Windows10):

#!/usr/bin/env python

import math
import pprint

# /1264225/format-plavaet-s-pomoschy-standartnogo-modulya-json
import json
from json import encoder
encoder.FLOAT_REPR = lambda o: format(o, '.2f')

# /1264225/format-plavaet-s-pomoschy-standartnogo-modulya-json
def round_floats(o):
  if isinstance(o, float): return "{:.2f}".format(o) if abs(o)>0.01 else "{:.2e}".format(o)
  if isinstance(o, dict): return {k: round_floats(v) for k, v in o.items()}
  if isinstance(o, (list, tuple)): return [round_floats(x) for x in o]
  return o

import collections
try: # https://stackoverflow.com/questions/53978542/how-to-use-collections-abc
  import collections.abc
  collectionsAbc = collections.abc
except (ImportError, AttributeError) as e:
  collectionsAbc = collections
import numbers

# https://stackoverflow.com/questions/7076254/rounding-decimals-in-nested-data-structures-in-python
def fpformat(thing, formatfunc):
  if isinstance(thing, dict):
    try: # Python 2
      thingiter = thing.iteritems()
    except: # Python 3
      thingiter = thing.items()
    return type(thing)((key, fpformat(value, formatfunc)) for key, value in thingiter)
  if isinstance(thing, collectionsAbc.Container):
    return type(thing)(fpformat(value, formatfunc) for value in thing)
  if isinstance(thing, numbers.Number):
    return formatfunc(thing)
  return thing
def formatfloat(thing):
  return "%.3g" % float(thing)

#############

# make a source array, mixed data

tarr = [
  ["aa",         "bb",        "cc",        "dd",        "ee"          ],
  [ {'v': 1.1},  {'w': 2.2},  {'x': 3.3},  {'y': 4.4},  {'z': 5.5555} ],
  [ 10,          20,          30,          40,          50            ],
  [ 11.1,        22.22,       33.333,      44.4444,     55.55555      ]
]

# create some more decimals:
appendrow = []

for ind, tnum in enumerate(tarr[2]):
  tpnum = ((ind+1.0)/(ind+2.0))*math.pi*tnum
  appendrow.append(tpnum)

tarr.append(appendrow)

appendrow = []

for ind, tnum in enumerate(tarr[2]):
  tpnum = ((ind+1.0)/(ind+2.0))*math.pi*tnum/100000.0
  appendrow.append(tpnum)

tarr.append(appendrow)

tarr_ppf_string = pprint.pformat(tarr)

print("printout 1:\n{}\n".format(tarr_ppf_string))

tarr_ppf_string2 = pprint.pformat(round_floats(tarr))

print("printout 2:\n{}\n".format(tarr_ppf_string2))

tarr_json_string = json.dumps(tarr)

print("printout 3:\n{}\n".format(tarr_json_string))

tarr_json_string2 = json.dumps(round_floats(tarr))

print("printout 4:\n{}\n".format(tarr_json_string2))

tarr_fp_string = fpformat(tarr, formatfloat)

print("printout 5:\n{}\n".format(tarr_fp_string))

Вывод этого скрипта в Python 3 таков:

printout 1:
[['aa', 'bb', 'cc', 'dd', 'ee'],
 [{'v': 1.1}, {'w': 2.2}, {'x': 3.3}, {'y': 4.4}, {'z': 5.5555}],
 [10, 20, 30, 40, 50],
 [11.1, 22.22, 33.333, 44.4444, 55.55555],
 [15.707963267948966,
  41.8879020478639,
  70.68583470577035,
  100.53096491487338,
  130.89969389957471],
 [0.00015707963267948965,
  0.00041887902047863906,
  0.0007068583470577034,
  0.0010053096491487337,
  0.0013089969389957472]]

printout 2:
[['aa', 'bb', 'cc', 'dd', 'ee'],
 [{'v': '1.10'}, {'w': '2.20'}, {'x': '3.30'}, {'y': '4.40'}, {'z': '5.56'}],
 [10, 20, 30, 40, 50],
 ['11.10', '22.22', '33.33', '44.44', '55.56'],
 ['15.71', '41.89', '70.69', '100.53', '130.90'],
 ['1.57e-04', '4.19e-04', '7.07e-04', '1.01e-03', '1.31e-03']]

printout 3:
[["aa", "bb", "cc", "dd", "ee"], [{"v": 1.1}, {"w": 2.2}, {"x": 3.3}, {"y": 4.4}, {"z": 5.5555}], [10, 20, 30, 40, 50], [11.1, 22.22, 33.333, 44.4444, 55.55555], [15.707963267948966, 41.8879020478639, 70.68583470577035, 100.53096491487338, 130.89969389957471], [0.00015707963267948965, 0.00041887902047863906, 0.0007068583470577034, 0.0010053096491487337, 0.0013089969389957472]]

printout 4:
[["aa", "bb", "cc", "dd", "ee"], [{"v": "1.10"}, {"w": "2.20"}, {"x": "3.30"}, {"y": "4.40"}, {"z": "5.56"}], [10, 20, 30, 40, 50], ["11.10", "22.22", "33.33", "44.44", "55.56"], ["15.71", "41.89", "70.69", "100.53", "130.90"], ["1.57e-04", "4.19e-04", "7.07e-04", "1.01e-03", "1.31e-03"]]

printout 5:
[['<generator object fpformat.<locals>.<genexpr> at 0x6ffffcc57d0>', '<generator object fpformat.<locals>.<genexpr> at 0x6ffffcc57d0>', '<generator object fpformat.<locals>.<genexpr> at 0x6ffffcc57d0>', '<generator object fpformat.<locals>.<genexpr> at 0x6ffffcc57d0>', '<generator object fpformat.<locals>.<genexpr> at 0x6ffffcc57d0>'], [{'v': '1.1'}, {'w': '2.2'}, {'x': '3.3'}, {'y': '4.4'}, {'z': '5.56'}], ['10', '20', '30', '40', '50'], ['11.1', '22.2', '33.3', '44.4', '55.6'], ['15.7', '41.9', '70.7', '101', '131'], ['0.000157', '0.000419', '0.000707', '0.00101', '0.00131']]

По сути, я бы хотел получить «распечатку 2» - за исключением цифроставшиеся числа, а не распечатанные в виде строк;то есть, я бы хотел, чтобы эта распечатка была такой:

[['aa', 'bb', 'cc', 'dd', 'ee'],
 [{'v': 1.1'}, {'w': 2.20}, {'x': 3.30}, {'y': 4.40}, {'z': 5.56}],
 [10, 20, 30, 40, 50],
 [11.10, 22.22, 33.33, 44.44, 55.56],
 [15.71, 41.89, 70.69, 100.53, 130.90],
 [1.57e-04, 4.19e-04, 7.07e-04, 1.01e-03, 1.31e-03]]

Как мне добиться такой распечатки в Python? (нужно это для Python 3, но решение для Python 2 тоже было бы неплохо)

Answer 1

СТАРЫЙ ОТВЕТ

Проблема в том, что вы вставляете числа как строки, а не как числа. Вы печатаете словари, содержащие строки, и поэтому они печатаются как строки. Вы хотите вставить числа как числа с плавающей точкой.

Вы можете округлять числа с плавающей точкой до определенного количества десятичных знаков без преобразования их в строки.

def round_floats(o):
  if isinstance(o, float): return round(o, 2) #Line 13, using round instead of
                                                  #string formatting
  if isinstance(o, dict): return {k: round_floats(v) for k, v in o.items()}
  if isinstance(o, (list, tuple)): return [round_floats(x) for x in o]
  return o

Замена использования форматирования строки с помощью *Функция 1008 * выдает следующий вывод для printout2:

printout 2:
[['aa', 'bb', 'cc', 'dd', 'ee'],
 [{'v': 1.1}, {'w': 2.2}, {'x': 3.3}, {'y': 4.4}, {'z': 5.56}],
 [10, 20, 30, 40, 50],
 [11.1, 22.22, 33.33, 44.44, 55.56],
 [15.71, 41.89, 70.69, 100.53, 130.9],
 [0.0, 0.0, 0.0, 0.0, 0.0]]

---

NEW ANSWER

EDIT - после большой отладки мы сталкиваемся с небольшой проблемой. Невозможно принудительно заставить pretty-print все время использовать определенное экспоненциальное форматирование.

Я пытался использовать этот бит кода для переопределения оператора float для симпатичного принтера, но это не такт работать для списков. Это решение не переопределяет форматер для типа, если он вложен в список / словарь / структуру. К сожалению, без переписывания половины кода симпатичного принтера это решение не представляется жизнеспособным.

Хорошая новость в том, что в этом нет необходимости. Вы можете просто использовать два десятичных знака точности со всеми вашими числами. Это не гарантирует того, что число будет представлено в научной нотации, но в большинстве случаев это вас устроит.

def round_floats(o):
  if isinstance(o, float): return float("{:.2f}".format(o) if abs(o)>0.01 else "{:.2e}".format(o))
  #Edited line 13, just casting back to float
  if isinstance(o, dict): return {k: round_floats(v) for k, v in o.items()}
  if isinstance(o, (list, tuple)): return [round_floats(x) for x in o]

Может быть лучше вместо этого использовать десятичный класс для настройкиточность чисел.

import decimal
decimal.getcontext().prec = 3

def round_floats(o):
  if isinstance(o, float): return float(+decimal.Decimal(o))
  if isinstance(o, dict): return {k: round_floats(v) for k, v in o.items()}
  if isinstance(o, (list, tuple)): return [round_floats(x) for x in o]

В любом случае, плохая новость заключается в том, что числа около 0 ведут себя не так, как вы хотите. Число, подобное 0.0001, останется с тем же представлением (в отличие от 1.0e-4). Однако он выполняет вычисление и проверяет, какая нотация (научная или обычная) занимает меньше места, поэтому при таком подходе каждое представление гарантированно будет максимально коротким.

Вывод:

[['aa', 'bb', 'cc', 'dd', 'ee'],
 [{'v': 1.1}, {'w': 2.2}, {'x': 3.3}, {'y': 4.4}, {'z': 5.56}],
 [10, 20, 30, 40, 50],
 [11.1, 22.2, 33.3, 44.4, 55.6],
 [15.7, 41.9, 70.7, 101.0, 131.0],
 [0.000157, 0.000419, 0.000707, 0.00101, 0.00131]]
 #Note that the bottom row is badly represented, but this representation is
 #not longer than writing out the same number in scientific notation. If
 #These numbers were smaller, they would be represented scientifically.