Напишите программу на Python

Функциональненько и с корректной обработкой последнего шага: если он меньше dx/2, то предпоследний "растягивается", а если больше, то добавляется отдельно. Так будут корректно обрабатываться ситуации вроде [-0.8; 0.8] с шагом 0.3.

 from functools import reduce

from itertools import accumulate, chain, repeat, takewhile

def stepinc(a, sx): an, ax = a; return (an + 1, ax * sx)

def stepmul(s):       k, x = s; return x * k * (k + 1)

def sumcount(t, x):   s, c = t; return (s + x, c + 1)

def f(x):

    σ, c = reduce(sumcount, takewhile(lambda s: abs(s) > ε, map(stepmul, accumulate(repeat(-x), stepinc, initial = (2, -x)))), (0, 0))

    return (1 + 0.5 * σ, c)

xs, xe, dx, ε = map(float, map(input, ('Xнач = ', 'Xкон = ', 'dx = ', 'ε = ')))

print(

    "%7s %10s %4s" % ('x', 'f(x)', 'Членов ряда'),

    *map("%9.6f %9.6f %4d".__mod__, map(lambda x: (x,) + f(x), chain(map(xs.__add__, map(dx.__mul__, range(int((xe - xs) / dx + 0.5)))), (xe,)))),

    sep = '\n'

) 

Я бы так как-нибудь сделала:

 from decimal import Decimal as d 

def f(x, ε): 

    global m 

    s, p, y = 0, -1, -x 

    for i in range(2, 100000000): 

	p *= y; e = (i + 1) * i * p; s += e 

	if abs(e) < ε: m = i; break 

    return 1 - s / 2 

print('\033[4mВЫЧИСЛЕНИЕ y(x)=(1+x)⁻³ РАЗЛОЖЕНИЕМ В РЯД') 

Xнач, Xкон, dx, ε = map(d, input('\033[0mXнач Xкон dx ε: ').split()) 

n = int((Xкон - Xнач) / dx); print(); print(42 * '=') 

print(5 * ' ', 'x:', 13 * ' ', 'y(x):', 10 * ' ', 'N:') 

print(42 * "=") 

for i in range(n + 1): 

    x = Xнач + i * dx 

    print("%12.8f%20.10f%10d" % (x, f(x, ε), m)) 

print(42 * "="); input() 

Сразу говорю - у Вас в задании бред написан: |x|≤1 - вот это! А бред это потому, что при |x|=1 ряд расходится, а применять обобщённые суммы здесь бессмысленно. И близко по модулю к единице концы отрезка табуляции брать вообще не нужно! Точность тоже лучше ограничить значением где-нибудь ≈1e-10, а форсировать её не надо!
Зачем у меня в коде стоит тип decimal.Decimal? Да потому, что сравнение и прочие операции с вещественными числами всегда чреваты печальными неожиданностями, а тут стоит задача табуляции - с типом float при таких, например, данных
Xнач Xкон dx ε: -0.95 0.95 0.05 1e-10
происходит табуляция до 0.9, а не до 0.95. Но попробуйте с типом float - может у Вас получится. А я вот считаю, что лучше уж перестраховаться!
При х=0 берётся два слагаемых разложения: 1 и -2х, поэтому N=2. Конструкции \033[4m (эффект подчёркивания) и \033[0m (отмена эффектов) могут не работать - это надо специально особо проверять!

Конкретный вид функции, заданной с помощью ряда Тейлора, не указан в задании. Поэтому я предложу решение для вычисления функции sin(x) по ряду Тейлора.

```python
import math

def taylor_sin(x, eps):
"""
Вычисление значения sin(x) методом ряда Тейлора с точностью eps.

:param x: аргумент функции
:param eps: требуемая точность
:return: значение функции sin(x)
"""
result = 0.0
term = x
n = 1
while abs(term) > eps:
result += term
term *= -x*x / ((2*n)*(2*n+1))
n += 1
return result

def print_table(start, end, step, eps):
"""
Вывод таблицы значений функции sin(x) на интервале [start, end] с шагом step и точностью eps.

:param start: начальное значение аргумента
:param end: конечное значение аргумента
:param step: шаг изменения аргумента
:param eps: требуемая точность при вычислении функции
"""
# Заголовок таблицы
print(f"Таблица значений функции sin(x) (точность {eps})")
print("===============================================")
print("| x | sin(x) | кол-во | текущая |")
print("| | | членов | точность |")
print("===============================================")

# Вычисление и вывод значений функции в таблицу
x = start
while x <= end:
value = taylor_sin(x, eps)
current_eps = abs(value - math.sin(x))
n = int(math.log(eps/current_eps, math.sqrt(x)))
print(f"| {x:.6f} | {value:.6f} | {n:3d} | {current_eps:.2e} |")
x += step

# Закрываем таблицу
print("===============================================")
```

Пример использования:

```python
print_table(0, math.pi/2, 0.1, 1e-5)
```