Em Python, as funções str() e json.dumps() são usadas para transformar objetos em representações de texto, mas elas produzem saídas distintas em vários cenários.

Uma diferença fundamental reside no uso de aspas. Considere uma lista com elementos de texto:

dados_texto = ['gamma', 'delta']
convertido_str = str(dados_texto)
convertido_json = json.dumps(dados_texto)
print(f"Saída com str: {convertido_str}")  # Resultado: ['gamma', 'delta']
print(f"Saída com json.dumps: {convertido_json}")  # Resultado: ["gamma", "delta"]
sao_iguais = convertido_json == convertido_str
print(f"As saídas coincidem? {sao_iguais}")  # Resultado: False

Valores booleanos também têm representações diferentes. Enalisemos uma sequência com booleanos:

sequencia_bool = [True, False, True]
str_resultado = str(sequencia_bool)
json_resultado = json.dumps(sequencia_bool)
print(f"via str: {str_resultado}")  # Exibe: [True, False, True]
print(f"via json.dumps: {json_resultado}")  # Exibe: [true, false, true]
comparacao = str_resultado == json_resultado
print(f"Resultados idênticos? {comparacao}")  # Resultado: False

O tratamento do valor None também varia entre as duas funções:

colecao_nula = (7, None, 'teste')
forma_str = str(colecao_nula)
forma_json = json.dumps(colecao_nula)
print(f"Forma com str: {forma_str}")  # Exibe: (7, None, 'teste')
print(f"Forma com json.dumps: {forma_json}")  # Exibe: [7, null, "teste"]
igual = forma_str == forma_json
print(f"Igualdade: {igual}")  # Resultado: False

Ao processar uma string que já está em formato JSON, json.dumps() a encapsula em outra camada, enquanto json.loads() realiza a operação inversa.

texto_json = '{"nome": "exemplo", "valor": 50, "flag": null}'
objeto_python = json.loads(texto_json)
print(f"Tipo: {type(objeto_python)}, Conteúdo: {objeto_python}")
# Saída: Tipo: <class>, Conteúdo: {'nome': 'exemplo', 'valor': 50, 'flag': None}
</class>

texto_json = '{"nome": "exemplo", "valor": 50, "flag": null}'
serializado = json.dumps(texto_json)
print(f"Após dumps: {serializado}, Tipo: {type(serializado)}")
# Resultado: Após dumps: "{\"nome\": \"exemplo\", \"valor\": 50, \"flag\": null}", Tipo: <class>
# Desserializando novamente
primeira_desserializacao = json.loads(serializado)
print(f"Primeira desserialização: {primeira_desserializacao}, Tipo: {type(primeira_desserializacao)}")
# Resultado: Primeira desserialização: {"nome": "exemplo", "valor": 50, "flag": null}, Tipo: <class>
# Desserializando mais uma vez para obter o dicionário
segunda_desserializacao = json.loads(primeira_desserializacao)
print(f"Dicionário final: {segunda_desserializacao}, Tipo: {type(segunda_desserializacao)}")
# Saída: Dicionário final: {'nome': 'exemplo', 'valor': 50, 'flag': None}, Tipo: <class>
</class></class></class>

Para situações que envolvem substituição dinâmica em templates JSON, pode-se combinar expressões regulares com funções de conversão. No exemplo abaixo, um placeholder é substituído por um dicionário convertido em string JSON:

import re
import json

modelo = '{"campoA": "dados1", "campoB": ${conteudo}$, "campoC": null}'
valor_substituto = {"item1": "valor1", "item2": "valor2"}
substituto_json = json.dumps(valor_substituto, ensure_ascii=False)
saida_processada = re.sub(r'\${(.*?)}\$', substituto_json, modelo, count=1)
objeto_saida = json.loads(saida_processada)
print(f"Objeto resultante: {objeto_saida}")
# Saída: Objeto resultante: {'campoA': 'dados1', 'campoB': {'item1': 'valor1', 'item2': 'valor2'}, 'campoC': None}

# Caso onde o valor substituto é uma string simples, convertida via str()
modelo_alt = '{"campoX": "info1", "campoY": "${placeholder}$", "campoZ": null}'
valor_texto = "hello_world"
texto_escapado = str(valor_texto)
saida_com_str = re.sub(r'\${(.*?)}\$', texto_escapado, modelo_alt, count=1)
# Primeiro, obtemos a string JSON completa
json_bruto = json.loads(saida_com_str)
print(f"Tipo intermediário: {type(json_bruto)}, Valor: {json_bruto}")
# Resultado: Tipo intermediário: <class>, Valor: {"campoX": "info1", "campoY": "hello_world", "campoZ": null}
# Desserializar para o dicionário final
resultado_final = json.loads(json_bruto)
print(f"Dicionário completo: {resultado_final}")
# Saída: Dicionário completo: {'campoX': 'info1', 'campoY': 'hello_world', 'campoZ': None}
</class>