Ler e gravar dados tabulares em CSV

produto;quantidade;observacao
Caderno;2;"Capa azul; 96 folhas"
Caneta;5;Ponta fina
Mochila;1;Uso diário

from pathlib import Path
import csv

caminho = Path("cadastro.csv")

with caminho.open(
    mode="r",
    encoding="utf-8",
    newline="",
) as arquivo:
    reader = csv.DictReader(arquivo, delimiter=";")

    for registro in reader:
        print(registro["produto"])
        print(registro["quantidade"])
        print(registro["observacao"])

import csv

COLUNAS_ESPERADAS = {"produto", "quantidade", "observacao"}


def validar_cabecalho(reader):
    cabecalho = reader.fieldnames

    if cabecalho is None:
        raise ValueError("arquivo vazio: cabeçalho ausente")

    posicoes_vazias = [
        indice
        for indice, nome in enumerate(cabecalho, start=1)
        if nome.strip() == ""
    ]
    if posicoes_vazias:
        raise ValueError(
            f"cabeçalho com nome vazio nas posições {posicoes_vazias}"
        )

    repetidos = sorted({
        nome for nome in cabecalho if cabecalho.count(nome) > 1
    })
    if repetidos:
        raise ValueError(
            f"cabeçalho com nomes repetidos: {repetidos}"
        )

    recebidas = set(cabecalho)
    ausentes = sorted(COLUNAS_ESPERADAS - recebidas)
    inesperadas = sorted(recebidas - COLUNAS_ESPERADAS)

    if ausentes or inesperadas:
        detalhes = []
        if ausentes:
            detalhes.append(f"colunas ausentes: {ausentes}")
        if inesperadas:
            detalhes.append(f"colunas inesperadas: {inesperadas}")
        raise ValueError("cabeçalho incompatível: " + "; ".join(detalhes))


with open("cadastro.csv", encoding="utf-8", newline="") as arquivo:
    reader = csv.DictReader(arquivo, delimiter=";")
    validar_cabecalho(reader)

    for registro in reader:
        print(registro)

# produto;quantidade;observacao

# Caderno;5;
{
    "produto": "Caderno",
    "quantidade": "5",
    "observacao": "",
}

# Lápis;10
{
    "produto": "Lápis",
    "quantidade": "10",
    "observacao": None,
}

# Borracha;3;Branca;Escolar
{
    "produto": "Borracha",
    "quantidade": "3",
    "observacao": "Branca",
    None: ["Escolar"],
}

colunas = ["produto", "quantidade", "observacao"]

for numero_registro, registro in enumerate(reader, start=1):
    linha_fisica_final = reader.line_num

    if None in registro:
        excedentes = registro[None]
        raise ValueError(
            f"Registro {numero_registro} tem campos excedentes: "
            f"{excedentes!r}. Última linha física consumida: "
            f"{linha_fisica_final}."
        )

    ausentes = [
        coluna
        for coluna in colunas
        if registro[coluna] is None
    ]

    if ausentes:
        raise ValueError(
            f"Registro {numero_registro} não contém os campos: "
            f"{ausentes!r}. Última linha física consumida: "
            f"{linha_fisica_final}."
        )

    # Somente agora é seguro acessar e validar os conteúdos.

def converter_registro(registro, numero_registro):
    produto = registro["produto"]
    quantidade_texto = registro["quantidade"]
    observacao = registro["observacao"]

    if not produto.strip():
        raise ValueError(
            f"Registro {numero_registro}, campo produto: "
            "deve conter algum caractere diferente de espaço"
        )

    try:
        quantidade = int(quantidade_texto)
    except ValueError:
        raise ValueError(
            f"Registro {numero_registro}, campo quantidade: "
            f"{quantidade_texto!r} não representa um número inteiro"
        ) from None

    if quantidade < 0:
        raise ValueError(
            f"Registro {numero_registro}, campo quantidade: "
            "deve ser maior ou igual a zero"
        )

    return {
        "produto": produto,
        "quantidade": quantidade,
        "observacao": observacao,
    }

import csv
from pathlib import Path

colunas = ["produto", "quantidade", "observacao"]

registros = [
    {
        "observacao": "pacote; 500 g",
        "quantidade": 12,
        "produto": "Café",
    },
    {
        "produto": "Caneca",
        "observacao": 'Ela disse "frágil".',
        "quantidade": 3,
    },
    {
        "quantidade": 5,
        "observacao": "capa\nazul",
        "produto": "Caderno",
    },
]

caminho_saida = Path("cadastro_exportado.csv")

with caminho_saida.open(
    "w", encoding="utf-8", newline=""
) as arquivo:
    writer = csv.DictWriter(
        arquivo,
        fieldnames=colunas,
        delimiter=";",
    )
    writer.writeheader()
    writer.writerows(registros)

print(f"Arquivo gravado: {caminho_saida}")

registros_relidos = []

with caminho_saida.open(
    "r", encoding="utf-8", newline=""
) as arquivo:
    reader = csv.DictReader(arquivo, delimiter=";")

    for registro in reader:
        registros_relidos.append(
            {
                "produto": registro["produto"],
                "quantidade": int(registro["quantidade"]),
                "observacao": registro["observacao"],
            }
        )

print(registros_relidos == registros)
# Resultado esperado: True

import csv

COLUNAS = ["produto", "quantidade", "observacao"]


def importar(caminho):
    registros = []

    with open(caminho, "r", encoding="utf-8", newline="") as arquivo:
        reader = csv.DictReader(
            arquivo,
            delimiter=";",
            strict=True,
        )

        cabecalho = reader.fieldnames
        if cabecalho is None:
            raise ValueError("cabeçalho ausente")
        if "" in cabecalho:
            raise ValueError("nome de coluna vazio")
        if len(cabecalho) != len(set(cabecalho)):
            raise ValueError("nome de coluna repetido")
        if set(cabecalho) != set(COLUNAS):
            raise ValueError("colunas incompatíveis")

        for numero, registro in enumerate(reader, start=1):
            if None in registro:
                raise ValueError(f"registro {numero}: campos excedentes")
            if any(valor is None for valor in registro.values()):
                raise ValueError(f"registro {numero}: campos ausentes")

            try:
                quantidade = int(registro["quantidade"])
            except ValueError as erro:
                raise ValueError(
                    f"registro {numero}, campo quantidade: inteiro inválido"
                ) from erro

            if quantidade < 0:
                raise ValueError(
                    f"registro {numero}, campo quantidade: valor negativo"
                )

            registros.append({
                "produto": registro["produto"],
                "quantidade": quantidade,
                "observacao": registro["observacao"],
            })

    return registros


def exportar(caminho, registros):
    with open(caminho, "w", encoding="utf-8", newline="") as arquivo:
        writer = csv.DictWriter(
            arquivo,
            fieldnames=COLUNAS,
            delimiter=";",
        )
        writer.writeheader()
        writer.writerows(registros)


entrada = "cadastro.csv"
saida = "cadastro_validado.csv"

try:
    dados = importar(entrada)
except csv.Error as erro:
    print(f"Formato CSV inválido em {entrada}: {erro}")
except UnicodeDecodeError as erro:
    print(f"Não foi possível decodificar {entrada}: {erro}")
except OSError as erro:
    print(f"Falha de acesso a {entrada}: {erro}")
except ValueError as erro:
    print(f"Conteúdo inválido em {entrada}: {erro}")
else:
    try:
        exportar(saida, dados)
    except UnicodeEncodeError as erro:
        print(f"Não foi possível codificar {saida}: {erro}")
    except OSError as erro:
        print(f"Falha ao gravar {saida}: {erro}")
    else:
        print(f"Dados exportados para {saida}")

produto;quantidade;observacao
Caderno;12;"Capa azul; 96 folhas"
Caneta;3;"Modelo ""premium"""
Agenda;1;"Entrega em duas
etapas"

import csv

COLUNAS = ["produto", "quantidade", "observacao"]
ENTRADA = "cadastro_entrada.csv"
SAIDA = "cadastro_saida.csv"


def validar_cabecalho(nomes):
    if nomes is None:
        raise ValueError("arquivo vazio ou cabeçalho ausente")

    if any(nome == "" for nome in nomes):
        raise ValueError("o cabeçalho contém um nome vazio")

    repetidos = []
    for nome in nomes:
        if nomes.count(nome) > 1 and nome not in repetidos:
            repetidos.append(nome)

    if repetidos:
        raise ValueError(
            f"colunas repetidas no cabeçalho: {repetidos}"
        )

    esperadas = set(COLUNAS)
    recebidas = set(nomes)
    faltantes = sorted(esperadas - recebidas)
    inesperadas = sorted(recebidas - esperadas)

    if faltantes:
        raise ValueError(f"colunas obrigatórias ausentes: {faltantes}")
    if inesperadas:
        raise ValueError(f"colunas inesperadas: {inesperadas}")


def validar_e_converter(linha, numero_registro, linha_fisica):
    extras = linha.get(None)
    if extras is not None:
        raise ValueError(
            f"registro {numero_registro}: campos excedentes {extras}; "
            f"última linha física consumida: {linha_fisica}"
        )

    ausentes = [
        coluna for coluna in COLUNAS if linha[coluna] is None
    ]
    if ausentes:
        raise ValueError(
            f"registro {numero_registro}: campos ausentes {ausentes}; "
            f"última linha física consumida: {linha_fisica}"
        )

    produto = linha["produto"]
    observacao = linha["observacao"]

    if produto.strip() == "":
        raise ValueError(
            f"registro {numero_registro}, campo produto: valor obrigatório"
        )

    try:
        quantidade = int(linha["quantidade"])
    except ValueError:
        raise ValueError(
            f"registro {numero_registro}, campo quantidade: "
            f"{linha['quantidade']!r} não é um inteiro"
        )

    if quantidade < 0:
        raise ValueError(
            f"registro {numero_registro}, campo quantidade: "
            "deve ser maior ou igual a zero"
        )

    return {
        "produto": produto,
        "quantidade": quantidade,
        "observacao": observacao,
    }


def importar_csv(caminho):
    registros = []

    with open(caminho, "r", encoding="utf-8", newline="") as arquivo:
        leitor = csv.DictReader(
            arquivo,
            delimiter=";",
            strict=True,
        )
        validar_cabecalho(leitor.fieldnames)

        for numero, linha in enumerate(leitor, start=1):
            registro = validar_e_converter(
                linha,
                numero_registro=numero,
                linha_fisica=leitor.line_num,
            )
            registros.append(registro)

    return registros


def exportar_csv(caminho, registros):
    with open(caminho, "w", encoding="utf-8", newline="") as arquivo:
        escritor = csv.DictWriter(
            arquivo,
            fieldnames=COLUNAS,
            delimiter=";",
        )
        escritor.writeheader()
        escritor.writerows(registros)


def main():
    try:
        registros = importar_csv(ENTRADA)
    except csv.Error as erro:
        print(f"Falha de formato CSV na importação: {erro}")
    except ValueError as erro:
        print(f"Falha de conteúdo na importação: {erro}")
    except UnicodeDecodeError as erro:
        print(f"Falha de codificação na importação: {erro}")
    except OSError as erro:
        print(f"Falha de acesso à entrada {ENTRADA!r}: {erro}")
    else:
        print(f"Importados: {registros}")

        try:
            exportar_csv(SAIDA, registros)
            relidos = importar_csv(SAIDA)

            if relidos != registros:
                raise ValueError("a releitura produziu valores diferentes")
        except csv.Error as erro:
            print(f"Falha de formato na exportação ou releitura: {erro}")
        except (UnicodeDecodeError, UnicodeEncodeError) as erro:
            print(f"Falha de codificação na exportação ou releitura: {erro}")
        except ValueError as erro:
            print(f"Falha na verificação da saída: {erro}")
        except OSError as erro:
            print(f"Falha de acesso à saída {SAIDA!r}: {erro}")
        else:
            print(f"Exportação concluída: {SAIDA}")
            print(f"Relidos: {relidos}")
            print(f"Ida e volta preservada: {relidos == registros}")


if __name__ == "__main__":
    main()

Exportação concluída: cadastro_saida.csv
Relidos: [{'produto': 'Caderno', 'quantidade': 12, 'observacao': 'Capa azul; 96 folhas'}, {'produto': 'Caneta', 'quantidade': 3, 'observacao': 'Modelo "premium"'}, {'produto': 'Agenda', 'quantidade': 1, 'observacao': 'Entrega em duas\netapas'}]
Ida e volta preservada: True

produto;quantidade;observacao
Caderno;12;"Capa azul; 96 folhas"
Caneta;x;"Modelo ""premium"""
Agenda;1;"Entrega em duas
etapas"