Как использовать df.to_excel для дозаписи?

df = pd.DataFrame(tmp_matrix)
df.to_excel('matrix.xlsx', 'matrix', header=False, index=False)

import numpy as np
import codecs
import random
import pandas as pd
 
# <--------------------------------------------------------------------------->
# <-----------------------Функция для создания матриц------------------------->
# <--------------------------------------------------------------------------->
 
def create_matrix(all_criteria, for_all_matrix, for_all_priority): # функция для создания матриц размерностью all_criteria, где all_criteria - это кол-во всех критериев
 
    matrix = np.ones((all_criteria, all_criteria)) # будущая матрица
    b = np.ones((all_criteria, 1)) # строка b[i]
    priority = np.zeros((all_criteria, 1)) # строка приоритетов
    a = np.zeros((all_criteria, 1)) # строка a[i]
    mult_priorityi_ai = np.zeros((all_criteria, 1)) # строка a[i]*priority[i]
    sum_of_b = 0 # сумма b[i]
    sum_of_mult_priorityi_ai = 0 # сумма mult_priorityi_ai[i]
    mas_of_n = [0, 0, 0.58, 0.9, 1.12, 1.24, 1.32, 1.41, 1.45, 1.49] # массив, который содержит значения коэф. n
    n = mas_of_n[all_criteria-1] # коэфициент n
    
    for i in range(all_criteria):
        for j in range (all_criteria):
            if i == j:
                matrix[i][j] = 1 # главная диагональ матриц = 1
            else:
                tmp = int(random.uniform(2,9)) # диапазон заполнения матриц от 2 до 9
                matrix[j][i] = tmp
                matrix[i][j] = 1/tmp   
    
    for i in range(all_criteria):
        for j in range (all_criteria):
            b[i] *= matrix[i][j] # нахождение b[i]
            a[i] += matrix[j][i] # нахождение a[i]  
    for i in range(all_criteria):
        b[i] = pow(b[i], 1/all_criteria) # нахождение b[i]
        print("b[", i, "] = ", b[i])
    for i in range(all_criteria):
        sum_of_b += b[i] # нахождение суммы b[i]
        print("\nsum_of_b = ", sum_of_b)
    for i in range(all_criteria):
        priority[i] = b[i]/sum_of_b # нахождение приоритетов
        print("priority[", i, "] = ", priority[i])
    for i in range(all_criteria):
        mult_priorityi_ai[i] = a[i] * priority[i] # нахождение a[i]*priority[i]
        print("mult_priorityi_ai[", i, "] = ", mult_priorityi_ai[i])
    for i in range(all_criteria):
        sum_of_mult_priorityi_ai += mult_priorityi_ai[i] # нахождение суммы mult_priorityi_ai[i]
        print("sum_of_mult_priorityi_ai = ", sum_of_mult_priorityi_ai, "\n")
    IC = (sum_of_mult_priorityi_ai - all_criteria)/(all_criteria - 1) # нахождение ІС
    print("IC = ", IC)
    
    if all_criteria > 2:
        OC = IC/n # нахождение ОС
        print("OC = ", OC)
    else:
        OC = IC
        print("OC = ", OC)
 
    print("\n", matrix)
    print("<---------------------------------------------------------------------------> \n")
    
    if OC > 0.1:
        create_matrix(all_criteria, for_all_matrix, for_all_priority) # рекурсия
    else:
        for_all_matrix.append(matrix) # добавление матрицы в конец контейнера
        for_all_priority.append(priority) # добавление приоритетов в конец контейнера
        
# <--------------------------------------------------------------------------->
# <-----------------------Функция для создания матриц------------------------->
# <--------------------------------------------------------------------------->
        
def output(for_all_matrix, for_all_priority, size_of_all_criteria, all_criteria): 
    
    for k in range(len(size_of_all_criteria)):
        for n in range(size_of_all_criteria[k]):
            tmp_for_matrix = for_all_matrix[k]
            tmp_for_priority = for_all_priority[k]
            
            tmp_matrix = np.zeros((size_of_all_criteria[k]+1, size_of_all_criteria[k]+2), dtype = object)
            
            max_j = size_of_all_criteria[k]+1
            
            for i in range(size_of_all_criteria[k]+1):    
                for j in range(size_of_all_criteria[k]+2):
                         
                    if( i == 0 and j != max_j):
                        tmp_matrix[i][j] = all_criteria[j+k] 
                    elif( j == max_j and i ==0 ):
                        tmp_matrix[i][j] = "Priority"
                    
                    if(i > 0):
                        if(j == 0):
                            tmp_matrix[i][j] = all_criteria[i+k]
                        elif(j == max_j):
                            tmp_matrix[i][j] = tmp_for_priority[i-1][0]
                        else:
                            tmp_matrix[i][j] = tmp_for_matrix[i-1][j-1]        
                            
    
    df = pd.DataFrame(tmp_matrix)
    df.to_excel('matrix.xlsx', 'matrix', header=False, index=False)
 
    
                
# <--------------------------------------------------------------------------->
# <-------------------------Аналог главной функции---------------------------->
# <--------------------------------------------------------------------------->
                
size_of_all_criteria = [3, 2, 3, 3, 2, 3, 4, 2, 3, 2, 3, 2] # размерность матриц, в зависимости от критериев
for_all_matrix = [] # контейнер для матриц
for_all_priority = [] # контейнер для прниоритетов
len_of_all_criteria = (len(size_of_all_criteria))
for i in range(len_of_all_criteria):
    create_matrix(size_of_all_criteria[i], for_all_matrix, for_all_priority) # вызов функции create_matrix
print("Matrices are consistent!")
 
with codecs.open('all_criteria.txt', 'r', encoding='utf-8') as file:
    all_criteria = file.read().splitlines() # считывание файла с критериями
file.close()
 
all_alternatives = ["Computer Science", "Computer Engineering", "Cybersecurity"] # льтернативы
 
global_priority = for_all_priority[0] # глобальные приоритеты
local_priority = for_all_priority[1:4] # локальные приоритеты
second_global_priority = []
 
for i in range(len(global_priority)):
    for j in range(len(local_priority[i])):
        second_global_priority.extend(global_priority[i]*local_priority[i][j]) # новые глобальные приоритеты
 
second_local_priority = for_all_priority[4:12] # новые локальные приоритеты
 
third_global_priority = []
for i in range(len(second_global_priority)):
    for j in range(len(second_local_priority[i])):
        third_global_priority.extend(second_global_priority[i]*second_local_priority[i][j]) # новые глобальные приоритеты
 
for_all_alternative_matrix = [] # контейнер матриц для альтернатив
for_all_alternative_priority = [] # контейнер для приоритетов 
for i in range(20):
    create_matrix(3, for_all_alternative_matrix, for_all_alternative_priority) # вызов функции
    
sum_of_all_priority = [0, 0, 0] # будущая сумма приоритетов
for i in range(len(all_alternatives)):
    for j in range(len(for_all_alternative_priority[i])):
        sum_of_all_priority[i] += third_global_priority[i]*for_all_alternative_priority[i][j] # СУММПРОИЗВ
        
max_index = sum_of_all_priority.index(max(sum_of_all_priority)) # какому индексу соответсвует максимальное значение
 
for i in range(len(size_of_all_criteria)):
    output(for_all_matrix, for_all_priority, size_of_all_criteria, all_criteria)
    
print("Answer:", all_alternatives[max_index], "\n") # вывод ответа

with pd.ExcelWriter('output.xlsx',
                    mode='a') as writer:  
    df.to_excel(writer, sheet_name='Sheet_name_3')

startrow = len(df)+1  # оставляем 1 пустую строку между вставками
append_df_to_excel(filepath, df, index=False, header=None, startrow=startrow)