Как использовать десятичное значение шага в range()?

Да, NumPy может быть немного избыточным для такой простой задачи. Вы можете использовать списковое выражение, чтобы генерировать значения с шагом 1/x до y, как вы уже показали в вашем примере.

Ваш код:

x = 100
y = 2
[p / x for p in range(0, int(x * y))]

даёт следующий результат:

[0.0, 0.01, 0.02, 0.03, ..., 1.97, 1.98, 1.99]

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

Если вам нужна простота и легкость, ваше решение с использованием списковых выражений вполне удачно. Однако, если вы работаете с большими массивами данных и нуждаетесь в более сложной математической обработке, тогда NumPy может оказаться полезным инструментом.

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

Во-первых, в вашем первом фрагменте вы использовали i * 100 в качестве части выражения for, что является неправильным синтаксисом. Вместо этого, вы можете использовать другой подход для достижения желаемого результата.

Ваше исправление во втором фрагменте верно и будет вызывать нужный вывод. Вот пример кода, который правильно реализует вашу идею:

for i in range(0, 11, 1):
    print(i / 10.0)

Этот код производит желаемый вывод от 0.0 до 1.0, увеличивая i от 0 до 10 и деля его на 10.0, чтобы получить значение с плавающей запятой.

Если вы хотите, чтобы значение i увеличивалось до 100, но выводилось в виде дробных значений от 0.0 до 1.0, вы можете делать это следующим образом:

for i in range(0, 101, 10):
    print(i / 100.0)

Это будет выводить: 0.0, 0.1, 0.2, ..., 1.0, так как мы разбиваем диапазон от 0 до 100 с шагом 10 и делим каждое значение на 100.0.

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

В scipy есть встроенная функция arange, которая является обобщением конструктора range() в Python и может использоваться для работы с вещественными числами. Чтобы использовать её, вам нужно импортировать её следующим образом:

from scipy import arange

Теперь вы можете создавать массивы с плавающей запятой, указывая начальное значение, конечное значение и шаг. Например:

arr = arange(0.0, 1.0, 0.1)
print(arr)

Этот код создаст массив [0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9].

Функция range() в Python возвращает последовательность целых чисел, поэтому вы не сможете использовать её для выполнения шагов с дробными значениями.

Я бы посоветовал использовать цикл while:

i = 0.0
while i <= 1.0:
    print(i)
    i += 0.1

Если вам интересно, Python преобразует ваше значение 0.1 в 0, что и вызывает ошибку, сообщающую, что аргумент не может быть равен нулю.

В Python 2.7 выражение

[x * 0.1 for x in range(0, 10)]

возвращает следующий список:

[0.0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9]

Это связано с тем, что числа с плавающей запятой в большинстве языков программирования, включая Python, не могут точно представлять некоторые десятичные дроби. Поэтому, когда вы умножаете целые числа на 0.1, возникают незначительные ошибки округления.

Чтобы получить желаемый результат, где значения округлены до одного знака после запятой, вы можете использовать функцию round:

[ round(x * 0.1, 1) for x in range(0, 10)]

Это даст вам следующий список:

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

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