Как подавить научную запись при печати значений с плавающей запятой?

Вот мой код:

x = 1.0
y = 100000.0    
print x/y

Мой коэффициент отображается как 1.00000e-05.

Есть ли способ подавить научную запись и заставить ее отображать как 0.00001? Я собираюсь использовать результат в виде строки.

'%f' % (x/y)

но вам нужно управлять точностью самостоятельно. например,

'%f' % (1/10**8)

будет отображать только нули.
подробности в документах

Или для Python 3 эквивалентное старое форматирование или более новое форматирование стиля

Используя более новую версию ''.format(также не забудьте указать, сколько цифр после того, как .вы хотите отобразить, это зависит от того, насколько маленьким является плавающее число). Смотрите этот пример:

>>> a = -7.1855143557448603e-17
>>> '{:f}'.format(a)
'-0.000000'

как показано выше, по умолчанию 6 цифр! Это не полезно для нашего примера, поэтому мы могли бы использовать что-то вроде этого:

>>> '{:.20f}'.format(a)
'-0.00000000000000007186'

Обновить

Начиная с Python 3.6, это можно упростить с помощью нового отформатированного строкового литерала следующим образом:

>>> f'{a:.20f}'
'-0.00000000000000007186'

В более новых версиях Python (2.6 и более поздних) вы можете использовать ''.format()для выполнения предложенного @SilentGhost:

'{0:f}'.format(x/y)

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

import pandas as pd
pd.options.display.float_format = '{:.2f}'.format

Большинство ответов выше требуют от вас указать точность. Но что, если вы хотите отображать числа с плавающей точкой, как это, без лишних нулей:

1
0.1
0.01
0.001
0.0001
0.00001
0.000001
0.000000000001

numpy имеет ответ: np.format_float_positional

import numpy as np

def format_float(num):
    return np.format_float_positional(num, trim='-')

Это будет работать для любого показателя:

def getExpandedScientificNotation(flt):
    str_vals = str(flt).split('e')
    coef = float(str_vals[0])
    exp = int(str_vals[1])
    return_val = ''
    if int(exp) > 0:
        return_val += str(coef).replace('.', '')
        return_val += ''.join(['0' for _ in range(0, abs(exp - len(str(coef).split('.')[1])))])
    elif int(exp) < 0:
        return_val += '0.'
        return_val += ''.join(['0' for _ in range(0, abs(exp) - 1)])
        return_val += str(coef).replace('.', '')
    return return_val

Это использует ответ капитана огурца , но с 2 дополнениями.

1) позволяя функции получать номера ненаучных обозначений и просто возвращать их как есть (так что вы можете добавить много входных данных, что некоторые числа равны 0,00003123 против 3.123e-05 и по-прежнему работают).

2) добавлена ​​поддержка отрицательных чисел. (в исходной функции отрицательное число будет заканчиваться как 0,0000-108904 от -1.08904e-05)

def getExpandedScientificNotation(flt):
    was_neg = False
    if not ("e" in flt):
        return flt
    if flt.startswith('-'):
        flt = flt[1:]
        was_neg = True 
    str_vals = str(flt).split('e')
    coef = float(str_vals[0])
    exp = int(str_vals[1])
    return_val = ''
    if int(exp) > 0:
        return_val += str(coef).replace('.', '')
        return_val += ''.join(['0' for _ in range(0, abs(exp - len(str(coef).split('.')[1])))])
    elif int(exp) < 0:
        return_val += '0.'
        return_val += ''.join(['0' for _ in range(0, abs(exp) - 1)])
        return_val += str(coef).replace('.', '')
    if was_neg:
        return_val='-'+return_val
    return return_val

В дополнение к ответу SG вы также можете использовать десятичный модуль:

from decimal import Decimal
x = str(Decimal(1) / Decimal(10000))

# x is a string '0.0001'

Если это так, stringто используйте встроенное в floatнего преобразование, например: print( "%.5f" % float("1.43572e-03")) answer:0.00143572

Поскольку это лучший результат в Google, я опубликую здесь, не найдя решения своей проблемы. Если вы хотите отформатировать отображаемое значение объекта с плавающей точкой и оставить его с плавающей точкой, а не строку, вы можете использовать это решение:

Создайте новый класс, который изменяет способ отображения значений с плавающей запятой.

from builtins import float
class FormattedFloat(float):

    def __str__(self):
        return "{:.10f}".format(self).rstrip('0')

Вы можете изменить точность самостоятельно, изменив целочисленные значения в {:f}

Используя 3.6.4, у меня была похожая проблема, что случайным образом число в выходном файле было бы отформатировано с научной нотацией при использовании этого:

fout.write('someFloats: {0:0.8},{1:0.8},{2:0.8}'.format(someFloat[0], someFloat[1], someFloat[2]))

Все, что я должен был сделать, чтобы это исправить, это добавить 'f':

fout.write('someFloats: {0:0.8f},{1:0.8f},{2:0.8f}'.format(someFloat[0], someFloat[1], someFloat[2]))

Начиная с версии 3.6 (возможно, также работает с более старыми версиями 3.x), это мое решение:

import locale
locale.setlocale(locale.LC_ALL, '')

def number_format(n, dec_precision=4):
    precision = len(str(round(n))) + dec_precision
    return format(float(n), f'.{precision}n')

Цель precisionрасчета - убедиться, что у нас достаточно точности, чтобы не попадать в научную нотацию (точность по умолчанию - 6).

dec_precisionАргумент добавляет дополнительную точность использовать для знаков после запятой. Поскольку это использует nформат, незначительные нули не будут добавлены (в отличие от fформатов). nтакже позаботится о рендеринге уже круглых целых чисел без десятичной дроби.

nдействительно требует floatввода, таким образом, актерский состав.