ValorFinal
Entrar

Glossário do Curso de Python Avançado

Todos os termos do curso em um só lugar, com definições simples. Use a busca para achar rápido.

__cause__
Atributo de uma exceção que aponta para a exceção original que a provocou, quando se usa raise ... from .... Faz o rastreamento mostrar a mensagem A causa direta da exceção acima foi.
Ver na aula →
__context__
Atributo preenchido automaticamente quando uma exceção ocorre dentro do tratamento de outra, mesmo sem from. O rastreamento mostra Durante o tratamento da exceção acima, ocorreu outra exceção.
Ver na aula →
__enter__
O método chamado quando o fluxo entra no bloco with. Ele prepara ou adquire o recurso e devolve o objeto que será atribuído à variável depois do as. É o começo do ciclo de vida do context manager.
Ver na aula →
__exit__
O método chamado quando o fluxo sai do bloco with, por saída normal ou por exceção. É onde a limpeza acontece. Recebe informações sobre a exceção que eventualmente ocorreu no bloco.
Ver na aula →
__getattr__
Método chamado apenas quando o atributo procurado não é encontrado pelo caminho normal. Ideal para valores dinâmicos e proxies, sem interferir nos atributos que já existem no objeto.
Ver na aula →
__getattribute__
Método chamado em todo acesso a atributo, exista ele ou não. Muito poderoso e igualmente perigoso: mal escrito, causa recursão infinita. Raramente é necessário sobrescrevê-lo.
Ver na aula →
__init_subclass__
Método de classe chamado automaticamente sempre que uma subclasse da classe que o define é criada. Resolve, de forma simples, muitos casos que antes exigiam uma metaclass.
Ver na aula →
__new__ da metaclass
O método que efetivamente cria o objeto-classe, recebendo o nome, as bases e o dicionário de atributos. Executa antes de a classe existir, e é onde se pode inspecionar ou modificar a definição.
Ver na aula →
__post_init__
Um método especial chamado automaticamente logo após o __init__ gerado. É o lugar para validar campos ou calcular valores derivados, garantindo que o objeto nasça consistente.
Ver na aula →
__set_name__
Método chamado automaticamente quando o descritor é atribuído a um atributo de classe, recebendo a classe e o nome do atributo. Serve para o descritor saber sob qual nome ele foi definido.
Ver na aula →
__slots__
Uma declaração que fixa quais atributos uma instância pode ter, dispensando o dicionário interno que cada objeto normalmente carrega. Economiza memória de forma significativa em classes com muitas instâncias, ao custo de não aceitar atributos novos fora da lista.
Ver na aula →
@contextlib.contextmanager
Um decorador da biblioteca padrão que transforma uma função geradora (com um único yield) em um context manager. Ele cuida de chamar __enter__ e __exit__ nos bastidores, deixando você escrever só a lógica.
Ver na aula →
Any
Um tipo especial que aceita qualquer valor e desliga a verificação naquele ponto. Usá-lo demais anula a vantagem dos tipos; reserve para casos em que o tipo é genuinamente desconhecido.
Ver na aula →
Arquitetura
As decisões de alto nível sobre a forma do software: quais são as partes, o que cada uma faz e como elas se conectam. Definir a arquitetura antes de codar evita retrabalho e bagunça.
Ver na aula →
Assinatura de função
A primeira linha da função, com nome, parâmetros e, no avançado, os tipos: def media(notas: list[float]) -> float. Resume o contrato do que entra e do que sai.
Ver na aula →
async with
A versão assíncrona do gerenciador de contexto: entra e sai de um recurso com etapas que podem aguardar com await, como abrir e fechar uma conexão de rede sem bloquear o event loop.
Ver na aula →
asyncio.gather
Uma função que recebe várias corrotinas, agenda todas para rodar ao mesmo tempo no event loop e espera todas terminarem, devolvendo os resultados em uma lista na mesma ordem das corrotinas passadas.
Ver na aula →
asyncio.run
A função que inicia o event loop, executa a corrotina principal passada a ela e, ao terminar, fecha o loop de forma organizada. É a maneira recomendada de entrar no mundo assíncrono a partir de código comum.
Ver na aula →
Avaliação preguiçosa
Calcular um valor apenas quando ele é realmente necessário, em vez de calcular tudo de antemão. Geradores são preguiçosos: produzem o próximo item só quando alguém o pede com next ou em um for.
Ver na aula →
await
A palavra-chave que espera uma operação assíncrona terminar, cedendo o controle ao event loop enquanto isso. Só pode aparecer dentro de uma função async, e é ali que outra tarefa ganha a chance de avançar.
Ver na aula →
Biblioteca
Um conjunto de código reutilizável, empacotado para ser importado por outros programas. Diferente de um aplicativo, uma biblioteca não roda sozinha; ela oferece funções e classes para quem a usa.
Ver na aula →
Bloquear o loop
Executar, dentro de uma corrotina, uma operação demorada que não cede o controle ao event loop, como um time.sleep ou um cálculo pesado. Enquanto ela roda, nenhuma outra corrotina avança, e a vantagem do async se perde.
Ver na aula →
Callable
O tipo de algo que se pode chamar como função. Callable[[int, int], int] descreve uma função que recebe dois inteiros e devolve um inteiro.
Ver na aula →
Campo
Cada atributo de dados declarado no corpo de uma dataclass, na forma nome: tipo. É a partir dos campos que o decorador gera o __init__ e os demais métodos.
Ver na aula →
classmethod
Um método decorado com @classmethod que recebe a própria classe como primeiro parâmetro, por convenção chamado cls, em vez de uma instância. É a forma idiomática de escrever construtores alternativos que devolvem novos objetos da classe.
Ver na aula →
Closure
Uma função interna que lembra as variáveis do escopo onde foi criada, mesmo depois que esse escopo terminou. É o que faz o wrapper enxergar os argumentos da fábrica e da função original ao mesmo tempo.
Ver na aula →
Cobertura de testes
A medida de quanto do código foi executado pela suíte de testes, em geral por linha. Uma ferramenta como o coverage roda os testes e informa quais linhas nunca foram exercitadas, revelando pontos cegos.
Ver na aula →
Código bloqueante
Uma chamada que segura o thread até terminar, sem oferecer um ponto de await. Bibliotecas síncronas de rede e banco são bloqueantes; usadas dentro de async sem cuidado, elas travam o event loop inteiro.
Ver na aula →
Complexidade O(n)
Uma forma de descrever como o tempo de uma operação cresce conforme o tamanho da entrada. O(1) não muda com o tamanho; O(n) cresce em linha reta; O(n ao quadrado) explode quando a entrada aumenta.
Ver na aula →
Composição
Construir uma classe a partir de outras como componentes internos, guardando-as como atributos, em vez de herdar delas. Modela a relação tem um: um Carro tem um Motor, em vez de um Carro ser um Motor.
Ver na aula →
Compreensão de lista
Uma forma concisa de criar uma lista transformando ou filtrando outra, escrita entre colchetes. Costuma ser a alternativa mais legível a map e filter no Python.
Ver na aula →
Context manager
Um objeto que sabe preparar um recurso ao entrar em um bloco with e limpá-lo ao sair, mesmo que uma exceção ocorra. É o mecanismo que o with usa por baixo dos panos.
Ver na aula →
contextlib.ExitStack
Um context manager que empilha vários outros gerenciadores de contexto e garante a limpeza de todos ao sair, na ordem inversa. Serve quando o número de recursos só é conhecido em tempo de execução.
Ver na aula →
contextlib.suppress
Um context manager que ignora, sem erro, exceções dos tipos que você indicar dentro do seu bloco. Substitui um try, except que só passa (pass), deixando a intenção explícita e o código mais curto.
Ver na aula →
Contrato de código
A promessa que uma função ou classe faz sobre o que recebe e o que devolve. No avançado esse contrato deixa de ser só um comentário e vira algo verificável, com type hints e testes.
Ver na aula →
Corrotina
Uma função que pode pausar e retomar, trocando dados nos dois sentidos com quem a chama. Geradores com send são corrotinas clássicas; a sintaxe moderna async e await é a evolução dessa ideia.
Ver na aula →
cProfile
Profiler determinístico da biblioteca padrão. Ele acompanha cada chamada de função durante a execução e registra quantas vezes cada uma foi chamada e quanto tempo consumiu.
Ver na aula →
cumtime
Tempo cumulativo: o total gasto dentro de uma função somado ao de tudo que ela chama. Contrasta com tottime, o tempo gasto apenas no corpo da própria função, sem contar as chamadas internas.
Ver na aula →
dataclass
Uma classe decorada com @dataclass, cujos métodos comuns de uma classe de dados (construtor, representação e comparação) são gerados automaticamente a partir dos campos declarados.
Ver na aula →
Decorador de classe
Um decorador aplicado a uma definição de classe. Ele recebe o objeto classe, pode modificá-lo (adicionar métodos, atributos, registrá-lo) e devolve a classe, que passa a valer no lugar da original.
Ver na aula →
default_factory
Um parâmetro de field que recebe uma função sem argumentos, chamada a cada nova instância para produzir o valor padrão do campo. É como se garante um valor mutável novo para cada objeto.
Ver na aula →
Delegação
Passar uma responsabilidade para outro objeto. No caso do yield from, o gerador externo delega ao gerador interno a tarefa de produzir os próximos valores, apenas repassando-os para quem consome.
Ver na aula →
deque
Estrutura de fila de duas pontas em collections. Adicionar e remover no início ou no fim custa O(1), ao contrário da lista, onde mexer no início é O(n) por deslocar todos os itens.
Ver na aula →
Descritor
Um objeto, atribuído a um atributo de classe, que define pelo menos um dos métodos __get__, __set__ ou __delete__. Ele intercepta o acesso ao atributo nas instâncias, permitindo validação, cálculo e controle.
Ver na aula →
DRY
Sigla de Don't Repeat Yourself, não se repita. O princípio de que cada pedaço de conhecimento deve ter uma única representação no código, para que uma mudança aconteça em um lugar só.
Ver na aula →
EAFP
Easier to Ask Forgiveness than Permission. O estilo pythônico de tentar a operação e tratar a exceção se ela falhar, em vez de checar todas as condições antes. Costuma ser mais limpo e evita corridas.
Ver na aula →
Efeito colateral
Qualquer alteração que uma função faz além de devolver um valor: mudar uma variável global, escrever num arquivo, modificar uma lista recebida. Funções puras não têm efeitos colaterais.
Ver na aula →
Empacotar
Transformar o projeto num pacote instalável, com metadados e estrutura corretos, para que outras pessoas possam instalá-lo e importá-lo. O pyproject.toml guia esse processo.
Ver na aula →
Empilhamento de decoradores
Aplicar mais de um decorador à mesma função, escrevendo um por linha, um em cima do outro. Cada decorador embrulha o resultado do decorador abaixo dele, formando camadas.
Ver na aula →
Encapsulamento
O princípio de controlar o acesso ao estado interno de um objeto, expondo uma interface e escondendo os detalhes. A property é a ferramenta pythônica para encapsular sem obrigar quem usa a chamar métodos get e set.
Ver na aula →
Engenharia de software
A disciplina de construir programas de forma sistemática: não basta funcionar, ele precisa ser correto, testado, sustentável e eficiente. No avançado você troca o improviso por decisões de projeto com justificativa.
Ver na aula →
Enum
Uma enumeração: um conjunto de constantes nomeadas ligadas a valores. Cada membro tem um nome legível e um valor associado, substituindo números e textos soltos por identificadores com significado.
Ver na aula →
Estrutura de dados
A forma de organizar dados na memória: tupla, lista, dicionário, dataclass, namedtuple. Cada uma tem forças e fraquezas; escolher a certa é uma decisão de projeto.
Ver na aula →
Event loop
O laço central do asyncio que fica de olho nas tarefas: enquanto uma espera por I/O, ele passa a vez para outra que esteja pronta. É o maestro que coordena todas as corrotinas em um único thread.
Ver na aula →
Exceção base do domínio
Uma classe de exceção própria, geralmente herdando de Exception, da qual todas as outras exceções do seu módulo ou aplicação descendem. Permite capturar qualquer erro do domínio com um único except.
Ver na aula →
Fábrica de decoradores
Uma função que recebe parâmetros de configuração e devolve um decorador. É o padrão que permite escrever @repetir(vezes=3): a chamada com parênteses cria o decorador de fato, que então envolve a função.
Ver na aula →
Falhar rápido
A prática de interromper a execução assim que um problema é detectado, perto da causa, em vez de deixar dados inválidos se espalharem e causarem um erro distante e confuso mais tarde.
Ver na aula →
Fixture
Uma função decorada com @pytest.fixture que prepara e entrega um cenário para os testes: um objeto, um dado, um recurso. O teste recebe a fixture como parâmetro, e o pytest a executa e injeta automaticamente.
Ver na aula →
frozen
Uma opção do decorador (@dataclass(frozen=True)) que torna as instâncias imutáveis: depois de criado, o objeto não permite alterar seus campos. Tentar mudar um campo levanta erro.
Ver na aula →
Função pura
Uma função cujo resultado depende só dos argumentos e que não causa efeitos colaterais. Dados os mesmos argumentos, sempre devolve o mesmo valor e não altera nada fora dela.
Ver na aula →
functools.wraps
Um decorador da biblioteca padrão que se aplica ao wrapper interno e copia os metadados da função original (__name__, __doc__, __module__ e outros) para ele. Sem wraps, a função decorada perde a própria identidade.
Ver na aula →
Future
Um objeto que representa o resultado de uma tarefa que ainda pode não ter terminado. Você guarda o future ao enviar a tarefa e, mais tarde, chama result nele para obter o valor, esperando se necessário.
Ver na aula →
Gargalo
A parte do programa que consome a maior fatia do tempo total. Otimizar fora do gargalo quase não muda o resultado; achar o gargalo é o primeiro passo de qualquer otimização séria.
Ver na aula →
Generator expression
Uma expressão parecida com uma list comprehension, mas escrita entre parênteses, que produz um gerador em vez de uma lista. Ela calcula cada valor sob demanda, sem construir tudo de uma vez na memória.
Ver na aula →
Gerador
Uma função que usa yield para produzir valores um a um, sob demanda, sem construir tudo na memória. É a base para os geradores avançados e a programação assíncrona que você vê aqui.
Ver na aula →
GIL (Global Interpreter Lock)
Uma trava interna do interpretador CPython que permite apenas uma thread executar bytecode Python por vez. Ela simplifica o interpretador e protege a memória, mas impede que duas threads rodem código Python puro em paralelo real.
Ver na aula →
Gradual typing
A abordagem do Python de permitir tipos onde você quiser, misturando código tipado e não tipado. Você começa sem tipos e vai anotando as partes que mais se beneficiam disso.
Ver na aula →
groupby
Uma ferramenta do itertools que agrupa itens consecutivos iguais por uma chave. Agrupa apenas vizinhos, então os dados normalmente precisam estar ordenados por essa chave antes.
Ver na aula →
Handler
O componente que decide o destino das mensagens de log: o console, um arquivo, a rede. Um mesmo logger pode ter vários handlers, cada um com seu nível e formato próprios.
Ver na aula →
heap
Uma organização de dados em que o menor elemento fica sempre acessível no topo. O módulo heapq mantém uma lista comum como heap, permitindo pegar o menor e inserir novos em tempo eficiente.
Ver na aula →
Herança
O mecanismo pelo qual uma classe (filha) reaproveita e estende outra (base), herdando seus atributos e métodos. Vista no Intermediário, é a base para os temas avançados de orientação a objetos deste curso.
Ver na aula →
Hierarquia de exceções
A árvore de classes de erro em que exceções específicas herdam de uma base comum. Capturar a base pega tudo; capturar uma folha pega só aquele caso, dando controle fino ao código que trata o erro.
Ver na aula →
I/O bound
Uma tarefa cujo tempo é gasto esperando entrada e saída, como rede, disco ou banco de dados, e não calculando. Nesse caso a CPU fica ociosa esperando, e é justamente aí que threads ajudam.
Ver na aula →
Import absoluto
Importação que nomeia o caminho completo a partir da raiz do pacote, como from financas.juros import juros_simples. É explícito e não depende de onde o arquivo está sendo executado.
Ver na aula →
Invariante
Uma condição que deveria ser sempre verdadeira em certo ponto do código se a lógica estiver correta. Verificada com assert, serve para pegar bugs do próprio programa, não para validar entrada externa.
Ver na aula →
Iterador
Um objeto que sabe entregar o próximo valor da sequência, por meio do método __next__, e sinaliza o fim levantando StopIteration. Todo iterador também é iterável, devolvendo a si mesmo no __iter__.
Ver na aula →
Iterador preguiçoso
Um objeto que produz itens um a um, sob demanda, sem calcular tudo de antemão. O itertools trabalha com iteradores preguiçosos, o que economiza memória e permite até sequências infinitas.
Ver na aula →
Iterável
Um objeto que sabe produzir um iterador quando você pede, por meio do método __iter__. Listas, tuplas, strings e dicionários são iteráveis. É o que você pode usar em um for.
Ver na aula →
itertools.islice
Uma função do módulo itertools que pega uma fatia de um iterável, como o fatiamento de listas, mas funcionando sob demanda. É a forma segura de consumir só os primeiros N itens de um gerador, inclusive de um gerador infinito.
Ver na aula →
join()
O método que faz a thread que chama esperar até a outra terminar. Sem join, o programa principal pode seguir e até encerrar antes de a thread concluir o trabalho.
Ver na aula →
lambda
Uma função anônima de uma linha, escrita com a palavra lambda. Serve para funções curtas e descartáveis, muito usadas como argumento de map, filter e sorted.
Ver na aula →
LBYL
Look Before You Leap. O estilo de verificar todas as pré-condições antes de agir, com uma sequência de if. Comum em outras linguagens; em Python, às vezes leva a checagens redundantes e a condições de corrida.
Ver na aula →
Linter
Ferramenta que analisa o código sem executá-lo e aponta problemas de estilo, possíveis bugs e más práticas. O ruff é um linter rápido e muito usado no ecossistema Python atual.
Ver na aula →
Lock (bloqueio)
Um mecanismo que garante que apenas uma thread por vez execute um trecho crítico de código. Precisa ser liberado depois do uso; se não for, outras threads ficam presas esperando para sempre.
Ver na aula →
Logger
O objeto pelo qual você registra mensagens, obtido com logging.getLogger(__name__). Cada mensagem tem um nível de severidade, e o logger decide, conforme sua configuração, o que passa e para onde vai.
Ver na aula →
logging
Módulo padrão para registrar eventos de um programa com níveis de severidade. Substitui o print de diagnóstico, permitindo controlar o que aparece e para onde vai, sem alterar o código.
Ver na aula →
lru_cache
Um decorador do functools que aplica memoização automaticamente. LRU quer dizer least recently used: quando o cache enche, ele descarta os resultados usados há mais tempo.
Ver na aula →
Memoização
A técnica de guardar o resultado de uma função para certos argumentos, de modo que chamadas repetidas com os mesmos argumentos devolvam o valor guardado em vez de recalcular.
Ver na aula →
Metaclass
Uma classe cujas instâncias são outras classes. Na prática, uma subclasse de type que personaliza como as classes são criadas. Padrão em Python é type; você troca por outra com o argumento metaclass=.
Ver na aula →
Método dunder
Um método com dois sublinhados no começo e no fim do nome, como __init__ ou __eq__. O nome vem de double underscore. O Python os chama automaticamente em situações específicas, o que permite integrar suas classes à sintaxe da linguagem.
Ver na aula →
Mixin
Uma classe pequena, feita para ser combinada com outras por herança múltipla, que acrescenta um comportamento específico sem representar uma entidade completa por si só. É o uso mais saudável e comum de herança múltipla.
Ver na aula →
Mock
Um objeto dublê, do módulo unittest.mock, que substitui uma dependência real no teste. Ele registra como foi chamado e devolve o que você mandar, permitindo verificar o comportamento sem executar a dependência de verdade.
Ver na aula →
Módulo
Um único arquivo .py com código Python. Qualquer arquivo que você pode importar é um módulo. É a menor unidade de organização acima da função e da classe.
Ver na aula →
monkeypatch
Uma fixture do pytest que troca atributos, métodos e variáveis de ambiente só durante o teste, desfazendo a troca automaticamente no fim. Serve para substituir dependências de forma segura e temporária.
Ver na aula →
MRO (Method Resolution Order)
A ordem em que o Python procura um método nas classes de uma hierarquia. Com herança múltipla, ela define qual versão de um método vale. Você a consulta em Classe.__mro__ ou Classe.mro().
Ver na aula →
Multitarefa cooperativa
Um modelo em que cada tarefa decide quando ceder a vez, marcando pontos de espera com await. O async usa esse modelo: o controle só troca de tarefa nos pontos de await, nunca no meio de um trecho sem espera.
Ver na aula →
mypy
Uma ferramenta que lê os type hints do seu código e avisa, antes de rodar, quando um tipo não bate, por exemplo passar um texto onde se esperava um número. É o verificador de tipos estáticos mais usado no Python.
Ver na aula →
namedtuple
Uma tupla com campos nomeados, criada com collections.namedtuple. É imutável e leve, acessada tanto por posição quanto por nome, boa para agrupamentos pequenos e fixos de dados.
Ver na aula →
Objeto de primeira classe
Algo que pode ser guardado em variável, passado como argumento e devolvido por uma função. Em Python, funções e classes são objetos de primeira classe, o que abre caminho para metaprogramação.
Ver na aula →
Optional
Uma forma de dizer que um valor pode ser do tipo indicado ou None. Optional[int] é o mesmo que int | None: aceita um inteiro ou a ausência de valor.
Ver na aula →
Ordem de aplicação
A sequência em que os decoradores embrulham a função: de baixo para cima. O decorador mais próximo do def envolve a função primeiro; o de cima envolve o resultado disso.
Ver na aula →
Pacote
Uma pasta que agrupa módulos relacionados e pode ser importada como um todo. Historicamente marcada por um arquivo __init__.py, ela dá nome e namespace ao conjunto.
Ver na aula →
Padrão estratégia
Um padrão de projeto em que o algoritmo a usar é escolhido em tempo de execução. Em Python, como funções são valores, uma estratégia pode ser apenas uma função passada como argumento, sem precisar de classes.
Ver na aula →
parametrize
Um marcador do pytest, @pytest.mark.parametrize, que roda a mesma função de teste várias vezes, com conjuntos de entradas e resultados esperados diferentes. Cada conjunto vira um caso de teste independente.
Ver na aula →
partial
Uma função do functools que cria uma nova função com alguns argumentos já fixados. É a aplicação parcial: você congela parte dos parâmetros e obtém uma versão especializada.
Ver na aula →
PEP 8
O guia de estilo oficial do código Python. Define convenções de indentação, nomes, espaçamento e organização para que o código da comunidade tenha uma aparência consistente e previsível.
Ver na aula →
Pipeline de geradores
Uma sequência de geradores encadeados em que a saída de um alimenta a entrada do próximo. Como cada etapa é preguiçosa, os dados fluem item a item pelo pipeline, sem que nenhuma etapa inteira seja armazenada.
Ver na aula →
Ponto de yield
A linha com yield dentro da função decorada. Ela marca a fronteira: tudo antes roda na entrada do with, o valor cedido vai para o as, e tudo depois roda na saída do with.
Ver na aula →
Pool de threads
Um grupo de threads reutilizáveis mantido pronto para receber tarefas. Em vez de criar e destruir uma thread por tarefa, o pool reaproveita as mesmas threads, reduzindo o custo e limitando quantas rodam ao mesmo tempo.
Ver na aula →
property
Um recurso que transforma métodos em atributos aparentes: ao ler ou escrever obj.valor, o Python chama funções que você definiu, permitindo validar ou calcular sem mudar a forma de acesso. Cria-se com o decorador @property.
Ver na aula →
Protocol
Uma classe base que descreve os métodos que um objeto precisa ter, sem exigir herança. Qualquer objeto com esses métodos satisfaz o Protocol: é o duck typing verificado pelo mypy.
Ver na aula →
Protocolo
Um conjunto de métodos dunder que, quando presentes, fazem o objeto se comportar de certa forma. Implementar __len__ e __getitem__, por exemplo, faz o objeto seguir o protocolo de sequência, respondendo a len e a indexação.
Ver na aula →
pyproject.toml
Arquivo de configuração padronizado de projetos Python. Reúne metadados (nome, versão, dependências) e a configuração de ferramentas como o empacotador, o formatador e o verificador de tipos, num único lugar.
Ver na aula →
pytest
O framework de testes mais popular do Python. Deixa escrever testes com funções simples e o comando assert, e traz recursos como fixtures e parametrização. É a estrela do módulo 13.
Ver na aula →
pytest.raises
Um gerenciador de contexto do pytest usado com with para afirmar que o bloco levanta uma exceção específica. Se a exceção esperada não ocorre, o teste falha.
Ver na aula →
queue.Queue
Uma fila do módulo queue projetada para uso entre threads. Ela é thread-safe: várias threads podem inserir e retirar itens ao mesmo tempo sem race condition, porque a própria fila cuida da sincronização interna.
Ver na aula →
Race condition
Um defeito que surge quando o resultado do programa depende da ordem imprevisível em que threads acessam um dado compartilhado. O mesmo código pode acertar às vezes e errar outras, o que torna o bug difícil de reproduzir.
Ver na aula →
Recurso
Algo que o programa adquire e precisa devolver depois de usar: um arquivo aberto, uma conexão de rede, um bloqueio (lock), uma transação de banco. Deixar um recurso aberto sem fechar causa vazamentos e comportamentos imprevisíveis.
Ver na aula →
reduce
Uma função do functools que aplica uma operação de dois argumentos de forma acumulada ao longo de um iterável, reduzindo-o a um único valor, como uma soma ou um produto de todos os itens.
Ver na aula →
Registro (registry)
Uma coleção, geralmente um dicionário, onde classes ou funções se cadastram automaticamente ao serem definidas. Um decorador de classe é uma forma limpa de fazer esse cadastro sem código repetido.
Ver na aula →
Responsabilidade única
O primeiro princípio de SOLID: uma classe deve ter um, e apenas um, motivo para mudar. Ou seja, deve concentrar uma única responsabilidade, não misturar assuntos diferentes.
Ver na aula →
Rollback
Desfazer as alterações feitas em uma transação de banco de dados quando algo dá errado, voltando ao estado anterior. O oposto é o commit, que confirma as alterações. Um bom gerenciador escolhe entre os dois conforme haja erro ou não.
Ver na aula →
Seção crítica
O trecho de código que mexe em um recurso compartilhado e que só pode ser executado por uma thread por vez para manter a consistência. Protege-se a seção crítica com uma trava, como o Lock.
Ver na aula →
send
Um método do gerador que retoma sua execução e, ao mesmo tempo, envia um valor que vira o resultado da expressão yield onde ele estava pausado. É o que permite mandar dados para dentro de um gerador, não só recebê-los.
Ver na aula →
Sentinela
Um valor especial colocado na fila para avisar o consumidor de que não há mais trabalho e ele pode encerrar. É uma convenção; costuma-se usar None ou um objeto único combinado entre produtor e consumidor.
Ver na aula →
SOLID
Sigla de cinco princípios de design orientado a objetos: responsabilidade única, aberto-fechado, substituição de Liskov, segregação de interfaces e inversão de dependência. Juntos, guiam código flexível e fácil de manter.
Ver na aula →
start()
O método que efetivamente dispara a thread, agendando a função alvo para rodar em paralelo lógico. Chamar a função diretamente executaria no fluxo principal; é o start que cria a nova linha de execução.
Ver na aula →
staticmethod
Um método decorado com @staticmethod que não recebe nem a instância nem a classe. É apenas uma função comum agrupada dentro da classe por relação lógica, sem acesso ao estado do objeto ou da classe.
Ver na aula →
Suíte de testes
O conjunto de todos os testes de um projeto. Rodada de uma vez, ela confirma que o código se comporta como esperado e alerta quando uma mudança quebra algo que funcionava.
Ver na aula →
Tabela de dispersão
A estrutura por trás de set e dict. Ela usa um cálculo sobre o valor (o hash) para ir quase direto ao lugar certo, o que torna a busca praticamente instantânea, sem varrer item por item.
Ver na aula →
Task
Uma corrotina agendada para rodar no event loop de forma concorrente com outras. Diferente de apenas aguardar uma corrotina em sequência, uma task começa a avançar sozinha assim que o loop tem uma folga.
Ver na aula →
TDD
Test-Driven Development, ou desenvolvimento guiado por testes. Escreve-se o teste antes do código, no ciclo red (teste falha), green (código faz passar) e refactor (melhora com a rede de segurança dos testes).
Ver na aula →
Teardown
A limpeza que acontece depois do teste: fechar arquivos, apagar dados temporários, restaurar estado. Numa fixture com yield, o teardown é o código escrito depois do yield, executado quando o teste termina.
Ver na aula →
timeit
Módulo da biblioteca padrão para medir o tempo de execução de trechos curtos de código. Ele roda o trecho muitas vezes e reporta o melhor tempo, reduzindo o ruído do sistema operacional.
Ver na aula →
type
A classe embutida que cria todas as outras classes em Python. Chamada com um argumento, revela o tipo de um objeto; chamada com três, fabrica uma classe nova em tempo de execução.
Ver na aula →
Type hint
Uma anotação de tipo escrita no código, como nome: str ou -> int, que declara qual tipo se espera para um parâmetro, variável ou retorno. O Python a trata como documentação; ferramentas como o mypy a verificam.
Ver na aula →
TypeVar
Uma variável de tipo. Ao declarar T = TypeVar('T'), você cria um espaço reservado que representa um tipo qualquer, mas o mesmo em toda a assinatura, ligando entrada e saída.
Ver na aula →
Union
Uma forma de dizer que um valor pode ser de mais de um tipo. Union[int, str] aceita inteiro ou texto; a escrita moderna equivalente é int | str.
Ver na aula →
Valor mágico
Um número ou texto solto no código cujo significado não é óbvio, como o 1 que quer dizer ativo. Enums eliminam esses valores mágicos ao dar-lhes um nome.
Ver na aula →
Valor mutável compartilhado
O bug em que várias instâncias acabam usando o mesmo objeto mutável, como uma lista, porque ele foi criado uma vez só. Alterar em uma instância afeta as outras.
Ver na aula →
Verificação estática
Análise do código sem executá-lo. O mypy lê os type hints e o corpo das funções e aponta incoerências de tipo antes de rodar, ao contrário de um erro que só aparece em tempo de execução.
Ver na aula →
wrapper
A função interna que o decorador define para envolver a função original. É ela que roda no lugar da função decorada, executando o comportamento extra antes ou depois de chamar a original.
Ver na aula →
yield from
Uma expressão que, dentro de um gerador, produz todos os valores de outro iterável ou gerador, um a um, sem precisar de um laço explícito. Ela delega a iteração ao objeto interno.
Ver na aula →