"Se um trabalhador quiser fazer bem o seu trabalho, ele deve primeiro afiar suas ferramentas." - Confúcio, "Os Analectos de Confúcio. Lu Linggong"
Primeira página > Programação > Práticas recomendadas de Python: escrevendo código limpo, eficiente e sustentável

Práticas recomendadas de Python: escrevendo código limpo, eficiente e sustentável

Publicado em 2024-11-06
Navegar:738

Python Best Practices: Writing Clean, Efficient, and Maintainable Code

Python é uma das linguagens de programação mais populares devido à sua simplicidade, legibilidade e versatilidade.

Seja você um desenvolvedor experiente ou iniciante, seguir as práticas recomendadas em Python é crucial para escrever um código limpo, eficiente e de fácil manutenção.

Nesta postagem do blog, exploraremos algumas das principais práticas recomendadas a serem lembradas ao escrever código Python.


1 - Siga as Diretrizes PEP 8

PEP 8 é o guia de estilo para código Python, fornecendo convenções para formatação e estruturação de seu código.

Alguns pontos-chave do PEP 8 incluem:

  • Recuo: use 4 espaços por nível de recuo.
  • Comprimento da linha: limite todas as linhas a um máximo de 79 caracteres.
  • Linhas em branco: separe as definições de funções e classes de nível superior com duas linhas em branco e as definições de métodos dentro de uma classe com uma linha em branco.
  • Importações: coloque as importações na parte superior do arquivo, agrupadas na seguinte ordem: importações de biblioteca padrão, importações de terceiros relacionadas e importações específicas de aplicativos/bibliotecas locais.

Aderir ao PEP 8 torna seu código mais legível e consistente com outras bases de código Python.


2 - Escreva nomes de variáveis ​​descritivos e concisos

Escolha nomes de variáveis ​​que sejam descritivos, mas concisos.

Evite variáveis ​​de uma única letra, exceto em casos como contadores de loop.
Por exemplo:

# Bad
a = 10

# Good
number_of_users = 10

Nomes descritivos de variáveis ​​tornam seu código autoexplicativo, reduzindo a necessidade de comentários extensos e facilitando a compreensão de outras pessoas (e de você mesmo no futuro).


3 - Use compreensões de lista e expressões geradoras

As compreensões de lista e as expressões geradoras fornecem uma maneira concisa de criar listas e geradores.

Eles são mais legíveis e geralmente mais rápidos do que usar loops.

# List comprehension
squares = [x**2 for x in range(10)]

# Generator expression
squares_gen = (x**2 for x in range(10))

A compreensão da lista é melhor quando a lista resultante é pequena o suficiente para caber na memória.

Use expressões geradoras para conjuntos de dados maiores para economizar memória.


4 - Aproveite as funções e bibliotecas integradas do Python

A biblioteca padrão do Python é vasta e geralmente é melhor usar funções integradas em vez de escrever código personalizado.

Por exemplo, em vez de escrever sua própria função para encontrar o máximo de uma lista, use a função max() integrada do Python.

# Bad
def find_max(lst):
    max_val = lst[0]
    for num in lst:
        if num > max_val:
            max_val = num
    return max_val

# Good
max_val = max(lst)


O uso de funções e bibliotecas integradas pode economizar tempo e reduzir a probabilidade de erros.


5 – Siga o princípio DRY (não se repita)

Evite duplicar código.

Se você estiver escrevendo o mesmo código mais de uma vez, considere refatorá-lo em uma função ou classe.

Isso não apenas reduz o tamanho da sua base de código, mas também facilita sua manutenção.

# Bad
def print_user_details(name, age):
    print(f"Name: {name}")
    print(f"Age: {age}")

def print_product_details(product, price):
    print(f"Product: {product}")
    print(f"Price: {price}")

# Good
def print_details(label, value):
    print(f"{label}: {value}")

O princípio DRY leva a um código mais modular e reutilizável.


6 – Utilize Ambientes Virtuais

Ao trabalhar em um projeto Python, especialmente com dependências, é melhor usar ambientes virtuais.

Os ambientes virtuais permitem gerenciar dependências por projeto, evitando conflitos entre pacotes usados ​​em projetos diferentes.

# 
Create a virtual environment
python -m venv myenv

# Activate the virtual environment
source myenv/bin/activate  # On Windows: myenv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

O uso de ambientes virtuais garante que as dependências do seu projeto sejam isoladas e facilmente reproduzíveis.


7 - Escreva testes unitários

Escrever testes é crucial para garantir que seu código funcione conforme o esperado e para evitar regressões ao fazer alterações.

O módulo unittest do Python é um ótimo ponto de partida para escrever testes.

import unittest

def add(a, b):
    return a   b

class TestMathFunctions(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)
        self.assertEqual(add(-1, 1), 0)

if __name__ == '__main__':
    unittest.main()

A execução regular de testes durante o desenvolvimento garante que seu código permaneça robusto e livre de bugs.


8 - Use comentários e doutrinas significativas

Embora o código limpo deva ser autoexplicativo, comentários e docstrings ainda são importantes para explicar lógicas, suposições e decisões complexas.

Use os comentários com moderação e concentre-se no motivo pelo qual você fez algo, e não no que fez.

def calculate_discount(price, discount):
    """
    Calculate the price after applying the discount.

    Args:
    price (float): Original price
    discount (float): Discount percentage (0-100)

    Returns:
    float: Final price after discount
    """
    return price * (1 - discount / 100)

Bons comentários e docstrings melhoram a capacidade de manutenção e usabilidade do seu código.


9 – Lidar com exceções com elegância

Python fornece recursos poderosos de tratamento de exceções que devem ser usados ​​para gerenciar erros normalmente.

Em vez de deixar seu programa travar, use os blocos try e except para lidar com possíveis erros.

try:
    with open('data.txt', 'r') as file:
        data = file.read()
except FileNotFoundError:
    print("File not found. Please check the file path.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

O tratamento adequado de exceções garante que seu programa possa lidar com situações inesperadas sem travar.


10 – Mantenha seu código modular

O código modular é mais fácil de entender, testar e manter.

Divida seu código em funções e classes menores e reutilizáveis.

Cada função ou classe deve ter uma única responsabilidade.

# Bad
def process_data(data):
    # Load data
    # Clean data
    # Analyze data
    # Save results

# Good
def load_data(path):
    pass

def clean_data(data):
    pass

def analyze_data(data):
    pass

def save_results(results):
    pass

A modularidade aumenta a clareza e a reutilização do código, facilitando a depuração e a extensão.


Conclusão

Seguindo essas práticas recomendadas do Python, você pode escrever um código limpo, eficiente e de fácil manutenção.

Esteja você escrevendo um script pequeno ou desenvolvendo um aplicativo grande, esses princípios o ajudarão a criar um código Python melhor e mais profissional.

Lembre-se de que programar não é apenas fazer as coisas funcionarem; trata-se de fazê-los funcionar bem, agora e no futuro.

Declaração de lançamento Este artigo foi reproduzido em: https://dev.to/devasservice/python-best-practices-writing-clean-efficient-and-maintainable-code-34bj?1 Se houver alguma violação, entre em contato com [email protected] para excluí-lo
Tutorial mais recente Mais>

Isenção de responsabilidade: Todos os recursos fornecidos são parcialmente provenientes da Internet. Se houver qualquer violação de seus direitos autorais ou outros direitos e interesses, explique os motivos detalhados e forneça prova de direitos autorais ou direitos e interesses e envie-a para o e-mail: [email protected]. Nós cuidaremos disso para você o mais rápido possível.

Copyright© 2022 湘ICP备2022001581号-3