Introdução

Hey there, how’s it going everybody? In this video we’re going to be going over a handful of useful tips and tricks in Python that I believe will help you write some better code. Now these are topics that I’ve wanted to cover in other videos, but a lot of them don’t require an entire video to themselves. So instead I compiled together a list that I think you’ll find most useful. Now we do have a sponsor for this video and that is Skillshare.com. So I’d like to thank them for supporting the channel and it’ll be great if you all could check them out using our link in the description section below and support our sponsors. And I’ll talk more about their services in just a bit. So with that said, let’s go ahead and get started.

O conteúdo a seguir está organizado em dicas claras, com exemplos descritos no texto base, mantendo a fidelidade ao que foi apresentado. O objetivo é transformar o material em um artigo técnico de alto valor, com estrutura e leitura facilitadas, sem acrescentar informações que não estejam explicitamente presentes no texto original.

Tip 1: Operadores ternários (ternary conditionals)

O texto descreve como operadores ternários podem ser úteis em determinadas situações, economizando código desnecessário. A ideia é decidir o valor de uma variável com base em uma condição, em uma única linha, sem perder a legibilidade quando fizer sentido. A afirmação central é que, embora o uso de um one-liner não garanta melhoria, muitas vezes esses ternários são tão fáceis de ler quanto um if-else tradicional.

x = 1 if condition else 0
# comportamento: x será 1 quando condition for True, caso contrário 0

Exemplos de leitura rápida e o equilíbrio entre clareza e concisão são enfatizados. A ideia é reconhecer situações onde esse formato simplifica o código sem prejudicar a compreensão.

Tip 2: Facilitar a leitura de números grandes com underscores e formatação de saída

Para trabalhar com números grandes, a legibilidade pode ser aumentada através de separadores por posição. Em Python, esses separadores não afetam a execução do programa, permitindo agrupar dígitos em blocos de três, como milhar, milhão etc.

valor_grande = 10_000_000_000  # 10 bilhões
valor_grande_2 = 100_000_000

# Ao imprimir, podemos formatar com vírgulas para separar os milhares
print(f"{valor_grande:,}")           # 10,000,000,000
print(f"{valor_grande_2:,}")        # 100,000,000

Essa prática facilita a leitura de números ao manter o código legível. O uso de underscores não altera a semântica do programa, apenas a legibilidade visual durante o desenvolvimento.

Tip 3: Gerenciamento de recursos com context manager

Uma prática ruim é abrir recursos e fechá-los manualmente. O texto descreve esse comportamento como um “code smell” — algo que parece funcionar, mas pode ser gerenciado de forma mais segura e limpa com context managers.

# Estilo com manejo manual de recursos
f = open("test.txt", "r")
conteudo = f.read()
f.close()

# Estilo com context manager (recomendado)
with open("test.txt", "r") as f:
    conteudo = f.read()

O uso de with open test.txt as F abstrai o gerenciamento de recursos, garantindo que o recurso seja liberado ao sair do bloco. Além de arquivos, o conceito se aplica a threads, locks, conexões de banco de dados e outros recursos que exigem configuração e limpeza adequadas.

Há um vídeo separado sobre context managers, com link na descrição para quem quiser se aprofundar.

Tip 4: Usar enumerate quando é necessário um contador na iteração

Ao percorrer uma lista de nomes, o código comum de contagem de índice pode ficar pouco elegante. Em outras linguagens, o índice já vem embutido no laço, mas em Python há uma forma mais limpa de obter o índice junto com o valor através de enumerate.

# Forma tradicional (não recomendada)
index = 0
for name in names:
    print(index, name)
    index += 1

# Forma recomendada com enumerate
for index, name in enumerate(names):
    print(index, name)

# Start a partir de 1
for index, name in enumerate(names, start=1):
    print(index, name)

Esse recurso facilita a contagem do índice sem que o código fique poluído com variáveis auxiliares, mantendo a leitura clara e direta.

Tip 5: Usar zip para percorrer duas listas ao mesmo tempo

Quando é desejável percorrer duas listas ao mesmo tempo, a abordagem comum de indexação pode parecer pouco intuitiva. O texto sugere o uso da função zip, que permite iterar sobre pares (ou tríades) de valores simultaneamente, desembalando-os diretamente na estrutura de loop.

# Uso simples de zip
names = ["Peter Parker", "Clark Kent"]
heroes = ["Spider-Man", "Superman"]

for name, hero in zip(names, heroes):
    print(name, "-", hero)

# Adicionando uma terceira lista
universes = ["Marvel", "DC"]

for name, hero, universe in zip(names, heroes, universes):
    print(name, "is", hero, "from", universe)

O texto também comenta que, se as listas tiverem comprimentos diferentes, zip encerra ao menor comprimento. Caso seja necessário percorrer até o fim da maior lista, pode-se usar zip longest do módulo itertools (referência a um vídeo separado no canal).

Tip 6: Descompactagem de valores

O conceito de unpacking é apresentado como um recurso útil para distribuir valores de estruturas como tuplas ou listas em variáveis separadas, com possibilidades simples e avançadas. O texto oferece uma visão ampla de como lidar com diferentes cenários de desempacotamento.

# Desempacotar dois valores
a, b = (1, 2)

# Ignorar valores não utilizados
a, _, = (1, 2)

# Manter o resto em uma lista
a, b, *c = (1, 2, 3, 4, 5)

# Manter antepassando o resto entre dois valores, com último valor separado
a, b, *middle, d = (1, 2, 3, 4, 5, 6)

# Ignorar valores intermediários usando _
a, b, *_, d = (1, 2, 3, 4, 5, 6, 7)

# Exemplo com o uso de asterisco em posição final
a, b, *c, d = (1, 2, 3, 4, 5)
# a = 1, b = 2, c = [3, 4, 5], d = 5
# Observação: se houver mais valores, c se ajusta dinamicamente

O texto explica que unpacking pode ser aplicado com diferentes formatos, incluindo o uso de asterisco para coletar o resto. Além disso, menciona que underscores podem ser usados para ignorar valores não desejados. O objetivo é indicar diversas formas de manipular estruturas de dados de forma concisa e legível.

Tip 7: Atribuição dinâmica de atributos com set adder e get adder

O conteúdo aborda a possibilidade de adicionar atributos dinamicamente a objetos. Inicialmente, um objeto vazio pode receber atributos simples (por exemplo, first e last). Em seguida, é apresentado um recurso chamado set adder, capaz de usar o valor de uma variável para definir o nome do atributo, mantendo a flexibilidade ao lidar com casos dinâmicos.

# Atribuição direta de atributos
person.first = "Corey"
person.last = "Schaefer"

# Acesso aos atributos
print(person.first)
print(person.last)

Para casos em que o nome do atributo é obtido dinamicamente a partir de outra variável, o texto descreve o uso de set adder e get adder. Em vez de atribuir diretamente, é possível fazer algo como:

# Exemplo descritivo com set adder
set adder(person, "first", first_val)
set adder(person, "last", last_val)

first = get adder(person, "first")
last = get adder(person, "last")

O texto também demonstra um cenário com um dicionário de informações e a proposta de converter cada item do dicionário em atributo do objeto, utilizando as funções set adder e get adder para todo o processamento. A ideia é mostrar como essas funções ajudam a lidar com atributos provenientes de estruturas de dados dinâmicas, especialmente em loops.

Tip 8: Entrada de informações sensíveis com getpass

O texto aborda a prática de gerenciar informações sensíveis — como senhas — durante a entrada do usuário. Em vez de usar input simples, que exibe o que o usuário digita, usa-se um recurso que oculta a senha para melhorar a segurança da aplicação.

# Abordagem incorreta (exemplo no texto)
username = input("Username: ")
password = input("Password: ")

# Abordagem correta descrita no texto (getpass)
from GetPass import GetPass
password = GetPass()

# Observação: o código do texto ressalta que a exibição da senha deve ser oculta

O texto também aponta que, ao rodar scripts pela linha de comando, a prática de aceitar informações sensíveis é comum e que usar uma função para ocultar a senha é uma melhoria de segurança na experiência do usuário.

Tip 9: Executando módulos com python -m e entendendo sys.path

A explicação aborda o uso do argumento dash M ( -m ) para executar módulos diretamente, o que é comum ao trabalhar com módulos da biblioteca padrão (como venv e smtpd) e quando se quer executar um módulo específico sem referenciar um arquivo .py local. O texto descreve que o comando busca o módulo especificado em sys.path e o executa como o módulo principal, com os argumentos subsequentes servindo como parâmetros para esse módulo.

# Exemplos descritos no texto
python -m venv myenv
python -m smtpd -c debuggingServer -n localhost:1025
# Observação: erros de digitação aparecem nos exemplos no texto original ("SMTPD" vs "SMTPD")

O objetivo é esclarecer por que usamos python -m para modules específicos e como isso difere de simplesmente executar um script Python localizado no diretório atual. Também é discutido que o caminho de módulos (sys.path) é relevante para localizar o módulo desejado, e que o argumento -m facilita a execução de utilitários embutidos na linguagem ou na biblioteca padrão sem um script dedicado.

Para aprofundar ainda mais, o texto sugere entender sys.path com mais detalhes em vídeos adicionais (link na descrição). O conteúdo também destaca que, ao usar -m, é possível importar o módulo correspondente para explorar sua API com mais detalhes. A ideia é ampliar a capacidade de descobrir como usar módulos por meio de questionamentos diretos, como help e dir, conforme descrito abaixo.

Tip 10: Usando help() e dir() para explorar objetos e módulos

A última dica aborda o reforço de conhecimento por meio de funções integradas. Ao iniciar um interpretador Python, é possível importar módulos, consultar ajuda com help e inspecionar atributos e métodos com dir. Isso ajuda a entender quais atributos existem para um objeto e como utilizá-los.

# Exemplo com o módulo smtpd
import smtpd
help(smtpd)

# Exibir atributos e métodos disponíveis
dir(smtpd)

# Exemplo com datetime
from datetime import datetime
dir(datetime)
datetime.today()

O texto enfatiza que o help pode trazer explicações detalhadas, enquanto o dir fornece uma visão rápida dos atributos e métodos disponíveis. Além disso, verifica se uma função é método ou atributo ao inspecioná-la sem executar, por meio de mensagens de retorno do interpretador. Existe ainda a sugestão de, se necessário, importar o objeto para examinar mais profundamente, aproveitando o conhecimento de que quase tudo em Python pode ser descoberto com ajuda simples de built-ins.

Sponsor

Skillshare é mencionado como patrocinador do vídeo — uma plataforma de aprendizado online com mais de 25.000 classes em tecnologia, negócios, design e outros temas. A descrição ressalta a variedade de cursos, inclusive em ciência de dados, visualização de dados, introdução à programação, ciência da computação, redes neurais com Python, SQL, entre outros, além de cursos sobre como produzir conteúdos para YouTube.

O texto também informa sobre um link de inscrição e uma oferta especial para os primeiros assinantes com dois meses gratuitos de Skillshare Premium para explorar as aulas disponíveis.

Considerações finais

Este artigo mantém a fidelidade ao conteúdo original, reorganizando o material em seções com explicações claras e estruturadas. O objetivo é transformar o texto fornecido em um artigo técnico de alto valor, preservando o significado, sem adicionar novos fatos ou opiniões. As seções cobrem uma variedade de técnicas úteis em Python, mantendo a ênfase na legibilidade, na prática recomendada em situações reais e no reconhecimento de padrões de código que podem ser aprimorados com recursos da linguagem.

O leitor é convidado a trazer seus próprios insights nos comentários, sem introduzir conteúdo não presente no texto base. Caso haja interesse, há possibilidade de compor um segundo conjunto de dicas futuras com base nos aprendizados da comunidade.