Aqui está a lógica:

Você já tem todos os nomes de grupos no formato client_group_user_counts. Vamos usar isso para gerar vários arquivos. Também mapearemos nomes de grupos para nomes de arquivos (não exatamente obrigatório para este programa, mas é útil caso sua lógica fique mais complexa no futuro).

Então, vamos iterar products_income. Procuramos o nome do arquivo de saída com o group_namevalor e escrevemos o registro formatado.

Depois de escrever todos os registros, faremos uma iteração client_packagepara escrever a receita total. Mas espere, reformataremos esse dicionário para que as chaves sejam os nomes dos grupos e os valores sejam a receita total - isso apenas nos poupará algumas etapas de pesquisa.

Finalmente, iremos iterar client_group_user_counts. Como as chaves já são nomes de grupos, podemos usá-las para procurar o arquivo de saída. Então só precisamos escrever os próprios nomes de usuário no arquivo de saída

Aqui está o código:

# create all the output files
outfiles = {k: open(f"{k}.txt", 'w') for k in client_group_user_counts}

# turn client_package into a dict for easier access
client_package = {row['client_group']: row['total_income'] for row in client_package}

# write everything to the correct files
for row in products_income:
    cgroup = row['client_group']
    prodCount = row['count']
    prodName = row['product']
    income = row['monthly_income']

    outfile = outfiles[cgroup]
    outfile.write(f"group {cgroup} has {prodCount} product {prodName}, monthly income is {income}.\n")

# add the additional space
for outfile in outfiles.values():
    outfile.write('\n')

# write the total income summary
for group, income in client_package.items():
    outfiles[group].write(f"group {group} total income is {income}.\n\n")

# add the users
for group,users in client_group_user_counts.items():
    outfiles[group].write(f"group {group} has total {len(users)} users, and this is its users:\n")
    for user in users:
        outfiles[group].write(f"{user}\n")

# close the files
for outfile in outfiles.values():
    outfile.close()

Eu primeiro reformularia os dicionários para evitar que eles fossem ultrapassados ​​mais tarde.

Em seguida, faça um loop apenas uma vez sobre cada chave e abra o arquivo com uma withinstrução:

products = {}
for d in products_income:
    (products
     .setdefault(d['client_group'], []) 
     .append('group {client_group} has {count} product {product}, monthly income is {monthly_income}.'.format(**d))
    )
packages = {}
for d in client_package:
    (packages
     .setdefault(d['client_group'], []) 
     .append('group {client_group} total income is {total_income}.'.format(**d))
    )

for group, users in client_group_user_counts.items():
    with open(f'{group}.txt', 'w') as f:
        f.write('\n'.join(products[group])+'\n\n')
        f.write('\n'.join(packages[group])+'\n\n')
        f.write(f'group {group} has total {len(users)} users, and this is its users:\n')
        f.write('\n'.join(users))

Exemplo A.txt:

group A has 2 product A, monthly income is 370.
group A has 2 product D, monthly income is 304.
group A has 1 product G, monthly income is 196.

group A total income is 870.

group A has total 5 users, and this is its users:
user1
user2
user3
user4
user5

Como os resultados são agregados por "ID do grupo", você deseja iterar client_group_user_countsprimeiro. Isso também permitirá que você crie open()um arquivo específico para o "ID do grupo" atual

Isso poderia precisar de alguma refatoração, mas deve lhe dar uma ideia

Dado:

products_income = [
    {'client_group': 'A', 'count': 2, 'product': 'A', 'monthly_income': 370},
    {'client_group': 'B', 'count': 1, 'product': 'B', 'monthly_income': 215},
    {'client_group': 'C', 'count': 3, 'product': 'C', 'monthly_income': 495},
    {'client_group': 'A', 'count': 2, 'product': 'D', 'monthly_income': 304},
    {'client_group': 'B', 'count': 1, 'product': 'E', 'monthly_income': 110},
    {'client_group': 'B', 'count': 2, 'product': 'F', 'monthly_income': 560},
    {'client_group': 'A', 'count': 1, 'product': 'G', 'monthly_income': 196},
    ]

client_package = [
    {'client_group': 'A', 'total_income': 870},
    {'client_group': 'B', 'total_income': 885},
    {'client_group': 'C', 'total_income': 495}
]

client_group_user_counts = {
    'A': ['user1', 'user2', 'user3', 'user4', 'user5'], # 5 users
    'B': ['user21', 'user22', 'user23', 'user24'], # 4 users
    'C': ['user41', 'user42', 'user43'], # 3 users
}

Tentar:

for group_key, group_users in client_group_user_counts.items():
    packages = [row for row in client_package if row["client_group"] == group_key]
    products = [row for row in products_income if row["client_group"] == group_key]
    with open(f"{group_key}.txt", "w", encoding="utf-8", newline="") as file_out:
        for product in products:
            file_out.write(f"group {group_key} has {product['count']} product {product['product']}, monthly income is {product['monthly_income']}.\n")
        file_out.write("\n")
        file_out.write(f"group {group_key} total income is {packages[0]['total_income']}.\n")
        file_out.write("\n")
        file_out.write(f"group {group_key} has total {len(group_users)} users, and this is its users:\n")
        for user in group_users:
            file_out.write(f"{user}\n")

Não sei se entendi a estrutura do seu programa ou não, se estiver errado, corrija o meu. Como você possui os grupos, client_group_user_countsvocê pode obter todos os grupos a partir de suas chaves.

groups = client_group_user_counts.keys()

Agora que você tem todos os grupos, pode iterar sobre os grupos e imprimir o que mencionou acima.

for group in groups :
    for product in products_income:
        if product['client_group']==group:
            print(f"group {group} has {product['count']} product {product['product']}, monthly income is {product['monthly_income']}.")
    for package in client_package:
        if package['client_group']==group:
            print(f"group {group} total income is {package['total_income']}.")
    print(f"group {group} has total {len(client_group_user_counts[group])} users, and this is its users:")
    print('\n'.join(client_group_user_counts[group]))
    print()

Mas geralmente é recomendado usar bibliotecas como o pandas para realizar tarefas mais complexas.