Discussão prática de como Python realiza tratamento e registro de exceções

[Antevisão da transmissão ao vivo] Os modelos grandes substituirão os programadores? "

Este artigo foi compartilhado da comunidade Huawei Cloud " Manipulação e registro de exceções em Python para construir aplicativos robustos e confiáveis " por Lemony Hug.

O tratamento de exceções e o registro em log são componentes vitais para escrever aplicativos de software confiáveis e de fácil manutenção. Python fornece um mecanismo poderoso de tratamento de exceções e funções de registro flexíveis, tornando mais fácil para os desenvolvedores gerenciar erros no código e rastrear o processo de execução do aplicativo. Neste artigo, exploraremos as práticas recomendadas para tratamento de exceções e registro em log em Python, bem como alguns códigos de caso para ilustrar esses conceitos.

A importância do tratamento de exceções

O tratamento de exceções refere-se ao processo de tratamento de erros ou situações anormais que podem ocorrer durante a execução do programa. Um bom tratamento de exceções pode nos ajudar:

Melhorar a estabilidade do programa: Ao capturar e tratar exceções, podemos evitar travamentos inesperados do programa e melhorar a estabilidade do aplicativo.
Melhorar a experiência do usuário: quando ocorre um erro no programa, avisos e tratamentos amigáveis de erros podem melhorar a experiência do usuário e evitar a má impressão dos usuários sobre o programa.
Depuração e manutenção mais fáceis: um bom tratamento de exceções pode nos ajudar a localizar e resolver problemas no programa com mais facilidade e melhorar a capacidade de manutenção do código.

Tratamento de exceções em Python

Em Python, o tratamento de exceções é implementado por meio da instrução try-except. Aqui está um exemplo simples de tratamento de exceção:

tentar:
    # Tentativa de executar código que pode lançar uma exceção
    resultado = 10/0
exceto ZeroDivisionError:
    # Lidar com tipos específicos de exceções
    print("Ocorreu um erro de divisão por zero!")

Neste exemplo, tentamos calcular 10 dividido por 0, o que gera uma exceção ZeroDivisionError. Em seguida, usamos a cláusula exceto para capturar essa exceção e gerar a mensagem de erro. Além de capturar tipos específicos de exceções, também podemos usar excepta cláusula para capturar todos os tipos de exceções para tratamento genérico de erros.

Além de capturar exceções, também podemos usar elsecláusulas para executar código específico quando nenhuma exceção ocorre no bloco try e finallycláusulas para executar código de limpeza específico, independentemente de ocorrer ou não uma exceção.

A importância do registro

Logging é uma técnica que registra informações importantes durante a execução de uma aplicação. Um bom registro nos ajuda:

Rastreie o processo de execução do aplicativo: Ao registrar os principais eventos e informações de status, podemos rastrear o processo de execução do aplicativo e nos ajudar a entender o comportamento do programa.
Diagnóstico e depuração: quando ocorre um problema no programa, o registro pode fornecer informações úteis de depuração para nos ajudar a localizar e resolver rapidamente o problema.
Monitoramento e análise: Ao analisar os dados de log, podemos entender o desempenho e a utilização da aplicação, ajudando-nos a otimizar e melhorar o programa.

Fazendo login em Python

Os módulos da biblioteca padrão do Python loggingfornecem recursos de registro poderosos e flexíveis. Podemos usar este módulo para criar um logger, definir o nível do log, definir o formato do log, etc. Aqui está um exemplo simples de registro:

registro de importação

#Criar registrador
registrador = logging.getLogger(__name__)
logger.setLevel(logging.INFO)

#Criar manipulador de arquivos
file_handler = logging.FileHandler('app.log')
file_handler.setLevel(logging.INFO)

#Criar formato de registro
formatador = logging.Formatter('%(asctime)s - %(nome)s - %(nomedonível)s - %(mensagem)s')
file_handler.setFormatter(formatador)

# Adiciona manipulador ao logger
logger.addHandler(file_handler)

# Registrar informações de registro
logger.info('Este é um registro de informações')
logger.warning('Este é um log de aviso')
logger.error('Este é um log de erros')

Neste exemplo, primeiro criamos um criador de logs loggere definimos o nível de log como INFO. Em seguida, criamos um manipulador de arquivo file_handler, definimos seu nível como INFO também e definimos o formato do log. Por fim, adicionamos o processador de arquivos ao logger e usamos métodos logger.info()como logger.warning()e logger.error()para registrar diferentes níveis de informações de log.

Exemplos de melhores práticas

Aqui está um exemplo de práticas recomendadas que combinam tratamento de exceções e registro em log:

registro de importação

#Criar registrador
registrador = logging.getLogger(__name__)
logger.setLevel(logging.INFO)

#Criar manipulador de arquivos
file_handler = logging.FileHandler('app.log')
file_handler.setLevel(logging.INFO)

#Criar formato de registro
formatador = logging.Formatter('%(asctime)s - %(nome)s - %(nomedonível)s - %(mensagem)s')
file_handler.setFormatter(formatador)

# Adiciona manipulador ao logger
logger.addHandler(file_handler)

def dividir(x, y):
    tentar:
        resultado = x / y
    exceto ZeroDivisionError como e:
        logger.error(f"dividir por zero erro: {e}")
    exceto Exceção como e:
        logger.error(f"Ocorreu exceção: {e}")
    outro:
        logger.info(f"Resultado: {resultado}")
    finalmente:
        logger.info("Operação encerrada")

# Função de teste
dividir(10, 2)
dividir(10, 0)

Neste exemplo, definimos uma divide()função chamada que calcula o quociente de dois números. Dentro da função, usamos uma instrução try-except para capturar possíveis erros de divisão por zero e usamos um logger para registrar informações de exceção. Ao final da execução da função, utilizamos finallyuma cláusula para registrar informações sobre o final da operação.

Para entender melhor como usar Python para tratamento e registro de exceções e aplicar essas práticas recomendadas em projetos reais. No desenvolvimento real, além do tratamento e registro de exceções básicos, configurações e otimizações mais complexas também podem ser realizadas com base nas características e necessidades do projeto, como:

Use classes de exceção personalizadas : além dos tipos de exceção integrados ao Python, também podemos definir nossas próprias classes de exceção para organizar e gerenciar melhor as informações de exceção.
Uso flexível de níveis de log : De acordo com diferentes partes e necessidades do aplicativo, o nível do logger pode ser ajustado de forma flexível para depuração e monitoramento em diferentes ambientes.
Registro hierárquico de logs : além de usar diferentes níveis de métodos de registro, os logs também podem ser gravados em diferentes arquivos ou fontes de dados com base na importância e no tipo de mensagens de log para análise e processamento subsequentes.
Integrar serviços de log de terceiros : Para grandes projetos ou sistemas distribuídos, você pode considerar a integração de serviços de log de terceiros (como ELK Stack, Splunk, etc.) para obter funções mais avançadas de gerenciamento e monitoramento de log.

Resumindo, o tratamento de exceções e o registro em log são componentes indispensáveis e importantes no desenvolvimento de aplicativos Python. Ao fazer uso razoável do mecanismo de tratamento de exceções e das funções de registro fornecidas pelo Python, e configurar e otimizar de forma flexível de acordo com a situação real do projeto, podemos escrever aplicativos de software mais robustos e confiáveis, melhorar a experiência do usuário e reduzir o custo de falhas. ocorrência e processamento, fornecendo forte suporte para a entrega, operação e manutenção bem-sucedidas do projeto.

Em projetos reais, aqui estão algumas dicas adicionais e práticas recomendadas que podem melhorar ainda mais a eficiência e a facilidade de manutenção do tratamento e registro de exceções:

Usando gerenciadores de contexto

O gerenciador de contexto é uma ferramenta elegante de gerenciamento de recursos em Python que garante a correta alocação e liberação de recursos. Ao combinar gerenciadores de contexto e tratamento de exceções, podemos gerenciar melhor os recursos e evitar vazamentos de recursos e erros inesperados. Por exemplo, você pode usar withinstruções para gerenciar operações de arquivo:

tentar:
    com open('file.txt', 'r') como f:
        conteúdo = f.read()
exceto FileNotFoundError:
    logger.error('Arquivo não existe')
exceto Exceção como e:
    logger.error(f'Ocorreu uma exceção: {e}')

Usando Decoradores

Decoradores são um recurso poderoso em Python que pode ser usado para adicionar lógica adicional antes e depois da execução da função. Ao personalizar decoradores, podemos implementar lógica unificada de tratamento de exceções e registro e evitar escrever repetidamente código semelhante em cada função. Por exemplo, você pode escrever um decorador para registrar o tempo de execução da função e informações de exceção:

hora de importação

def log_exceptions(func):
    def wrapper(*args, **kwargs):
        tentar:
            hora_início = hora.time()
            resultado = func(*args, **kwargs)
            hora_final = hora.time()
            logger.info(f"{func.__name__} tempo de execução: {end_time - start_time} segundos")
            resultado de retorno
        exceto Exceção como e:
            logger.error(f"Ocorreu exceção na função {func.__name__}: {e}")
    invólucro de devolução

@log_exceptions
def alguma_função():
    # Lógica de função
    passar

Combinado com códigos de erro

Em aplicações complexas, os códigos de erro podem ser usados para identificar diferentes tipos de erros para melhor organizar e gerenciar informações de exceção. Ao definir um conjunto de códigos de erro e mensagens de erro correspondentes, você pode tornar seu código mais legível e de fácil manutenção. Por exemplo:

ERRO_CODE_DIVIDE_BY_ZERO = 1001
ERROR_CODE_FILE_NOT_FOUND = 1002

def dividir(x, y):
    tentar:
        resultado = x / y
    exceto ZeroDivisionError:
        logger.error(f"erro de divisão por zero: {e}", extra={'error_code': ERROR_CODE_DIVIDE_BY_ZERO})
    exceto FileNotFoundError:
        logger.error(f"Arquivo não encontrado: {e}", extra={'error_code': ERROR_CODE_FILE_NOT_FOUND})

Use biblioteca de registro de terceiros

Além do módulo de registro na biblioteca padrão do Python, existem muitas bibliotecas de registro de terceiros excelentes para você escolher, como Loguru, structlog, etc. Essas bibliotecas fornecem funções mais ricas e APIs mais amigáveis, e você pode escolher a biblioteca apropriada para registro de acordo com as necessidades reais.

Defina políticas claras em nível de log

Ao projetar um sistema de registro, uma política clara em nível de registro deve ser definida para garantir a precisão e a legibilidade das informações de registro. Geralmente, diferentes níveis de log podem ser definidos com base na importância e urgência da mensagem de log, como DEBUG, INFO, WARNING, ERROR e CRITICAL. No desenvolvimento diário, níveis de log apropriados devem ser usados de acordo com situações específicas para garantir que as informações de log não sejam muito detalhadas nem que informações críticas sejam perdidas.

Considere as necessidades de internacionalização e localização

Para aplicações destinadas a usuários globais, os requisitos de internacionalização e localização devem ser considerados, e texto internacionalizado padrão e métodos de formatação devem ser usados em registros de log para garantir a legibilidade e consistência das informações de log em ambientes de diferentes idiomas. Ao mesmo tempo, os formatos de hora e os hábitos de diferentes fusos horários e regiões também devem ser considerados para melhor compreender e analisar as informações de registo.

Implementar rotação e arquivamento de logs

Em aplicativos de longa execução, os arquivos de log podem crescer continuamente e ocupar grandes quantidades de espaço em disco. Para evitar essa situação, você pode implementar funções de rotação e arquivamento de log e limpar e compactar regularmente arquivos de log antigos para economizar espaço de armazenamento e garantir a acessibilidade das informações de log. Você pode usar bibliotecas de terceiros em Python (como LogRotate) para implementar rotação de log e funções de arquivamento ou implementá-las você mesmo de acordo com as necessidades do projeto.

Integre sistemas de monitoramento e alarme

Em um ambiente de produção, é crucial detectar e tratar exceções em tempo hábil. Portanto, os sistemas de monitoramento e alerta podem ser combinados para obter monitoramento e alerta em tempo real de informações de registro. Ao adicionar palavras-chave e identificadores aos registros de log e configurar um sistema de monitoramento para monitorá-los, situações anormais podem ser descobertas a tempo e medidas correspondentes podem ser tomadas para garantir a operação estável do aplicativo.

Faça melhorias e otimizações contínuas

O tratamento e registro de exceções é um processo de melhoria contínua, e as estratégias existentes de tratamento e registro de exceções devem ser revisadas e otimizadas regularmente para se adaptarem ao desenvolvimento e às mudanças do projeto. Os registros de log podem ser analisados e contados regularmente para descobrir possíveis problemas e otimizar o espaço, e os processos e mecanismos para tratamento de exceções e registro em log podem ser ajustados e melhorados em tempo hábil para melhorar a estabilidade e a capacidade de manutenção do aplicativo.

Por meio das dicas e práticas recomendadas acima, podemos aplicar melhor o Python para tratamento e registro de exceções e construir aplicativos de software robustos e confiáveis em projetos reais. O tratamento de exceções e o registro são elos importantes no processo de desenvolvimento de software. Eles podem não apenas nos ajudar a encontrar e resolver problemas, mas também melhorar a capacidade de manutenção e a legibilidade do código, fornecendo um forte suporte para a entrega e operação bem-sucedidas do projeto.

Resumir

O tratamento e registro de exceções são componentes essenciais e críticos no desenvolvimento de aplicativos Python. Por meio da introdução e da discussão detalhada deste artigo, nos aprofundamos nas práticas recomendadas de uso do Python para tratamento e registro de exceções e fornecemos uma variedade de códigos e técnicas de caso para ajudar os desenvolvedores a compreender e aplicar melhor esses conceitos importantes.

Em termos de tratamento de exceções, aprendemos como usar a instrução try-except para capturar e tratar exceções que podem ocorrer e discutimos como usar a cláusula else e a cláusula finalmente para realizar o trabalho de limpeza relacionado. Também exploramos como combinar técnicas avançadas, como gerenciadores de contexto e decoradores, para melhorar ainda mais a eficiência e a facilidade de manutenção do tratamento de exceções.

Em termos de registro, demos uma olhada aprofundada no módulo de registro na biblioteca padrão do Python e aprendemos como criar um registrador, definir o nível do registro e definir o formato do registro e outras operações básicas. Além disso, também discutimos como usar diferentes níveis de log e métodos de log de acordo com os requisitos do projeto e como combinar tecnologias como códigos de erro e bibliotecas de log de terceiros para obter funções de log mais flexíveis e eficientes.

Além do tratamento básico de exceções e registro em log, também exploramos uma série de dicas avançadas e práticas recomendadas, como definição de políticas claras em nível de log, consideração de necessidades de internacionalização e localização, implementação de rotação e arquivamento de log e combinação de sistema de monitoramento e alerta, etc. Essas habilidades e práticas podem ajudar os desenvolvedores a lidar melhor com requisitos complexos de projetos e situações reais, além de melhorar a qualidade e a capacidade de manutenção do código.

Em suma, aplicando adequadamente as melhores práticas de tratamento e registro de exceções, podemos escrever aplicativos Python robustos e confiáveis, melhorar a experiência do usuário, reduzir a ocorrência de falhas e os custos de processamento e fornecer um forte suporte para a entrega e operação bem-sucedidas de projetos. No trabalho de desenvolvimento futuro, devemos continuar a prestar atenção e otimizar continuamente o tratamento e o registro de exceções para garantir a estabilidade e a capacidade de manutenção do aplicativo e fornecer aos usuários melhores serviços e experiências.

Clique para seguir e conhecer as novas tecnologias da Huawei Cloud o mais rápido possível~