Говоря как простой смертный, я бы придерживался $ str [0]
. Насколько мне известно, быстрее понять смысл $ str [0]
с первого взгляда, чем substr ($ str, 0, 1)
. Это, вероятно, сводится к предпочтению.
Что касается производительности, то профиль профиля профиля. :) Или вы могли бы заглянуть в исходный код PHP ...
Это старый вопрос, но я добавил бы что-то потенциально полезное:
Я знаю, что вы написали свой пример в сырых списках 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
, может иметь что-то, но я ничего не нашел.
.replace("'", "")
, чтобы избавиться от этих запятых. str(["{0:0.2f}".format(i) for i in a]).replace("'", "")
– Steinarr Hrafn Höskuldsson
12 January 2017 в 16:51
''
вокруг него. Например, для a=[0.2222, 0.3333]
он произведет ['0.22', '0.33']
.
– jdhao
19 December 2017 в 16:14
' '.join([{0:0.2f}".format(i) for i in a])
– Neb
3 August 2018 в 08:25
Более постоянным решением является подкласс 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__
, потому что float
неизменен.
Если вы не хотите подкласса float
, но не против определения функции, map(f, x)
намного более кратким, чем [f(n) for n in x]
isinstance
, а не равенство type()
. Когда это будет сделано правильно, подкласс float по-прежнему будет считаться поплавком.
– zondo
4 January 2017 в 18:01
Список 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
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
Обратите внимание, что вы также можете умножить строку типа «% .2f» (пример: «% .2f» * 10).
>>> print "%.2f "*len(yourlist) % tuple(yourlist)
2.00 33.00 4.42 0.31
" ".join("%.2f" % x for x in yourlist)
, поскольку строка форматирования и значения интерполяции намного хуже, чем использование уродливой идиомы Python.
– u0b34a0f6ae
14 October 2009 в 20:00
Я считаю, что Python 3.1 по умолчанию будет печатать их лучше, без изменения кода. Но это бесполезно, если вы используете какие-либо расширения, которые не были обновлены для работы с Python 3.1
У меня была эта проблема, но ни одно из решений здесь не показало точно , что я хотел (я хочу, чтобы напечатанный вывод был допустимым выражением 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 () должен быть более стандартным решением, но я считаю это более читаемым)
print "[%s]"%", ".join(map(str,yourlist))
Это позволит избежать ошибок округления в двоичном представлении при печати без введения ограничения фиксированной точности (например, с помощью "%.2f"
):
[9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.0793303]
Вы можете использовать панды.
Вот пример со списком:
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')
Я просто столкнулся с этой проблемой, пытаясь использовать 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 просто переписал генератор ...
Наиболее простой вариант заключается в использовании процедуры округления:
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]
Вы можете сделать:
a = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
print ["%0.2f" % i for i in a]
Я согласен с комментарием SilentGhost, цикл for не так уж плох. Вы можете добиться того, чего хотите:
l = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
for x in l: print "%0.2f" % (x)
Чтобы контролировать количество значащих цифр, используйте спецификатор формата% 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 formatting вместо:
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]
Код ниже работает хорошо для меня.
list = map (lambda x: float('%0.2f' % x), list)
Во-первых, элементы внутри коллекции печатают их репрезентацию. вы должны узнать о __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)
С 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<--