Python функций для разделения / разбивки строк и столбцов DataFrame или Matrix

Question

Я пытаюсь разбить / разбить строки и столбцы данных или матрицы на основе набора коэффициентов. Например, рассмотрим 10 * 10 фрейм данных, который я хотел бы разбить как 4-ую строку, так и 4-й столбец, каждый из которых на 4 новых строки и столбца, основываясь на разных весах / коэффициентах (то есть 0,4, 0,3, 0,2, 0,1 в этом дело). В результате новый датафрейм будет 13 * 13. Вот исходный фрейм данных: DF1

import pandas as pd
import numpy as np
DF1 = pd.DataFrame(np.array([range(10,20), range(20,30), range(30,40), range(40,50), range(50,60), range(60,70), range(70,80), range(80,90), range(90,100), range(100,110)]))
DF1

В соответствии с весами, которые я хочу использовать, я создал 13 * 13 коэффициентов фрейма данных: COF

COF = pd.DataFrame(np.array([[1, 1, 1, 0.4, 0.3, 0.2, 0.1, 1, 1, 1, 1, 1, 1],
                             [1, 1, 1, 0.4, 0.3, 0.2, 0.1, 1, 1, 1, 1, 1, 1],
                             [1, 1, 1, 0.4, 0.3, 0.2, 0.1, 1, 1, 1, 1, 1, 1],
                             [0.4, 0.4, 0.4, 0.4, 0, 0, 0, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4],
                             [0.3, 0.3, 0.3, 0, 0.3, 0, 0, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3],
                             [0.2, 0.2, 0.2, 0, 0, 0.2, 0, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2],
                             [0.1, 0.1, 0.1, 0, 0, 0, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
                             [1, 1, 1, 0.4, 0.3, 0.2, 0.1, 1, 1, 1, 1, 1, 1],
                             [1, 1, 1, 0.4, 0.3, 0.2, 0.1, 1, 1, 1, 1, 1, 1],
                             [1, 1, 1, 0.4, 0.3, 0.2, 0.1, 1, 1, 1, 1, 1, 1],
                             [1, 1, 1, 0.4, 0.3, 0.2, 0.1, 1, 1, 1, 1, 1, 1],
                             [1, 1, 1, 0.4, 0.3, 0.2, 0.1, 1, 1, 1, 1, 1, 1],
                             [1, 1, 1, 0.4, 0.3, 0.2, 0.1, 1, 1, 1, 1, 1, 1]]))
COF

Чтобы дезагрегировать 4-ю строку и в четвертом столбце я написал этот код после создания пустого фрейма данных: DisDF1

DisDF1 = pd.DataFrame()
i = 0
while i < 13 :
    if i < 3 :
        j = 0
        while j < 13 :
            if j < 3 :
                DisDF1.loc[i,j] = COF.loc[i,j] * DF1.loc[i,j]       
            if (j > 2 & j < 7) :
                DisDF1.loc[i,j] = COF.loc[i,j] * DF1.loc[i,3]
            if j > 6 :
                DisDF1.loc[i,j] = COF.loc[i,j] * DF1.loc[i,j-3]
            j = j+1
    if (i > 2 & i < 7) :
        j = 0
        while j < 13 :
            if j < 3 :
                DisDF1.loc[i,j] = COF.loc[i,j] * DF1.loc[3,j]       
            if (j > 2 & j < 7) :
                DisDF1.loc[i,j] = COF.loc[i,j] * DF1.loc[3,3]
            if j > 6 :
                DisDF1.loc[i,j] = COF.loc[i,j] * DF1.loc[3,j-3]
            j = j+1   
    if i > 6 :
        j = 0
        while j < 13 :
            if j < 3 :
                DisDF1.loc[i,j] = COF.loc[i,j] * DF1.loc[i-3,j]       
            if (j > 2 & j < 7) :
                DisDF1.loc[i,j] = COF.loc[i,j] * DF1.loc[i-3,3]
            if j > 6 :
                DisDF1.loc[i,j] = COF.loc[i,j] * DF1.loc[i-3,j-3]
            j = j+1
    i = i+1
DisDF1

Мой код работал. Но это сложно и легко делать ошибки. Я не могу себе представить написание подобного кода для фреймов данных с тысячами строк и столбцов, с десятками строк и столбцов, которые будут дезагрегированы / разбиты. Я ищу Python функции или, возможно, более простые коды, чтобы заботиться о больших фреймах данных / матрицах для вышеупомянутой цели. Даже просто предлагая полезные методы и функции будут оценены. Большое спасибо.