Как исправить неправильный подсчёт копеек?

Вещественные числа не годятся для того чтобы точно представлять десятичные дроби:

@>>> 0.3
0.3
@>>> f'{0.3:.20f}'
'0.29999999999999998890'

Десятичная дробь 0.3 внутри компьютера хранится в виде очень близкого но другого числа. Сосчитаем налог 30% от 101 рубля. Должно получиться 30 рублей 30 копеек. А на деле немного меньше:

@>>> 101 * 0.3
30.299999999999997

Вычитаем целые рубли и умножаем на 100 чтобы перевести число в копейки:

@>>> 100 * (101 * 0.3 - 30)
29.999999999999716

Получилось немного меньше 30 копеек, как должно бы быть. Сейчас произойдет катастрофа - небольшая ошибка приведёт к потере копейки:

@>>> int(100 * (101 * 0.3 - 30))
29

Вещественные числа придуманы для инженерных расчётов. При их проектировании ставились две цели - точность и быстрота. И они действительно точные и быстрые. То что 0.3 нельзя записать в виде компьютерного числа - не важно. Его можно представить с огромной точностью - а это и нужно для инженерных расчётов. И совсем не годится для бухгалтерии.

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

Сразу нарушу собственное правило: для простоты чтения вещественные рубли всё-таки будут использованы. Но они сразу же переводятся в копейки. Это решение будет ошибаться, но только для очень больших, астрономических, сумм:

def get_money(s):
    return int(round(100 * float(s)))

Проценты тоже будут хранится как целые числа. Для получения процента от суммы сумма и процент перемножаются и делятся на сто. Результат округляется вниз к целому:

def get_percent(money, percent):
    return money * percent // 100

Основной код читает доходы, складывает их, вычисляет проценты - всё в целых копейках. Из-за округления вниз сумма расходов может быть меньше суммы дохода. Ошибка income - sum(expenses) добавляется к последнему расходу в списке:

def main():
    percents = (
        ('Отпуск'              , 10),
        ('Пропитание и еда'    , 30),
        ('Коммунальные платежи',  5),
        ('Досуг'               , 15),
        ('Накопления'          , 40)
    )

    income = get_money(input()) + get_money(input())
    expenses = [get_percent(income, p[1]) for p in percents]

    expenses[-1] += income - sum(expenses)

    assert sum(expenses) == income

    for (w, _), e in zip(percents, expenses): 
        print(f'{w}: {e // 100} руб. {e % 100} коп.')


main()

1. Для операций с деньгами можно использовать класс Decimal из стандартного модуля decimal.

   Все операции с ним примерно как с float (кроме создания объекта), но его преимущество в том, что он хранит число именно так как мы его видим в десятичном формате, никаких неожиданностей типа 0.1 + 0.2 != 0.3.

   Из особенностей - при операциях с объектами Decimal (типа сложения/вычитания/умножения/деления) нельзя использовать Decimal и float вместе, можно использовать int или другой Decimal. Например, Decimal("1000.0") * 0.15 не будет работать, вместо этого нужно писать Decimal("1000.0") * Decimal("0.15") или Decimal("1000.0") * 15 / 100.

   Но в целом Decimal работает, конечно, медленнее чем float (просто из-за того что это более сложный формат, сам модуль decimal при этом реализован на Си).

2. Чтобы дробную часть превратить в копейки, нужно просто умножить на 100 и привести к целому, т.е. вместо kopOtp = int((100*(otp-rubOtp))% 100) пишите kopOtp = int((otp - rubOtp) * 100)

3. Чтобы все дробные копейки переходили в накопления, а не терялись, накопления нужно считать не через процент, а из общей суммы доходов вычесть все расходы

from decimal import Decimal

# mather = Decimal(input())
# dad = Decimal(input())

# income = mather + dad
income = Decimal("50001.25")

#Отпуск 10%
otp = income * 10 / 100
# .quantize(Decimal(".01")) округляет результат до .01 (т.е. до 1 копейки в нашем случае)
otp = otp.quantize(Decimal(".01"))  
rubOtp = int(otp)
kopOtp = int((otp - rubOtp) * 100)

#Пропитание и еда 30%
eda = income * 30 / 100
eda = eda.quantize(Decimal(".01"))  
rubEda = int(eda)
kopEda = int((eda - rubEda) * 100)

#Комунальные услуги 5%
kom = income * 5 / 100
kom = kom.quantize(Decimal(".01"))
rubKom = int(kom)
kopKom = int((kom - rubKom) * 100)

#Досуг 15%
dos = income * 15 / 100
dos = dos.quantize(Decimal(".01"))
rubDos = int(dos)
kopDos = int((dos - rubDos) * 100)

#Все остальное идет в накопление
nak = income - otp - eda - kom - dos
nak = nak.quantize(Decimal(".01"))
rubNak = int(nak)
kopNak = int((nak - rubNak) * 100)

print("Отпуск:", rubOtp,'руб.', kopOtp,'коп.')
print("Пропитание и еда:", rubEda,'руб.', kopEda,'коп.')
print("Коммунальные платежи:", rubKom,'руб.', kopKom,'коп.')
print("Досуг:", rubDos,'руб.', kopDos,'коп.')
print("Накопления:", rubNak,'руб.', kopNak,'коп.')

Вывод:

Отпуск: 5000 руб. 12 коп.
Пропитание и еда: 15000 руб. 38 коп.
Коммунальные платежи: 2500 руб. 6 коп.
Досуг: 7500 руб. 19 коп.
Накопления: 20000 руб. 50 коп.