Capa do Volume 3: Engenharia e concorrência
Volume 3 de 5

Python de A a Z: Engenharia e concorrência

por Tiago Silva

Escreva Python que outras pessoas conseguem manter e que faz várias coisas ao mesmo tempo: projetos, testes, tipagem, SOLID, segurança, performance, threads, processos e asyncio.

ImpressoR$ 79,98
E-bookR$ 43,98
Comprar impresso na UICLAP E-book na Amazon: em breve
Páginas
426
Idioma
Português
Publicação
10/2026
Versão do Python
3.15
Formatos
Impresso e e-book (ePub)

Sobre este livro

Do script que funciona ao software profissional

Escrever código que roda é só o começo. Fazê-lo sobreviver a anos de manutenção, a um time inteiro e a muitos usuários é engenharia. A primeira parte deste volume cobre estrutura de projetos, dependências, logging, testes automatizados, estilo, tipagem estática, os princípios SOLID, segurança, profiling, documentação, empacotamento e design de APIs: o que um projeto Python precisa ter para ser levado a sério.

A segunda parte é de concorrência: como escolher entre threads, multiprocessamento, concurrent.futures e asyncio, o que o GIL realmente limita e o que muda com o free-threading do Python 3.15. Tudo com medições, para você decidir com números, e não por moda.

É o volume que mais se aproxima do dia a dia de uma equipe: testes, qualidade, segurança e desempenho são cobrados em vagas de desenvolvimento Python plenas e sêniores. Dominar esses assuntos é o que transforma quem programa em quem projeta sistemas, e completa o caminho para ser um especialista Python.

Por onde começar

Se você nunca programou, comece pelo Volume 1. Este volume pressupõe a base dos Volumes 1 e 2, não os livros em si: se você já escreve classes com __init__, __repr__ e herança, usa decoradores e escreve geradores, pode começar daqui. Se faltar algo, o Volume 2 cobre. Os cinco volumes formam a coleção completa, mas cada um se sustenta sozinho.

O que você vai aprender

  • Estruturar projetos, gerenciar dependências e configurar logging
  • Escrever testes automatizados e manter o estilo e a qualidade do código
  • Usar tipagem estática e aplicar os princípios SOLID em Python
  • Programar com segurança, medir a performance (profiling) e proteger segredos
  • Documentar, empacotar e publicar no PyPI, e projetar APIs que se refatoram bem
  • Escolher entre threads, multiprocessamento, concurrent.futures e asyncio
  • Decidir sobre concorrência com base em medições, incluindo o free-threading do Python 3.15

Sumário

19 capítulos. Toque em um item para ver do que ele trata.

Parte 1: Engenharia de Software
1Estrutura de Projetosp. 39
O layout src/, o pyproject.toml e a separação das regras de negócio da entrada e saída: como organizar um projeto instalável.
2Gerenciamento de Dependênciasp. 57
Declarar, resolver e travar dependências no uv.lock, para que o mesmo conjunto de pacotes rode em qualquer máquina.
3Loggingp. 77
Loggers, filtros, formatadores e handlers: registrar o que o programa faz de um jeito configurável e útil em produção.
4Testes Automatizadosp. 101
Escrever testes que dão uma rede de segurança para mudar o código sem medo.
5Estilo e Qualidade de Códigop. 125
PEP 8, formatador, linter e métricas: deixar as máquinas discutirem estilo para você discutir o que importa.
6Tipagem Estáticap. 147
Anotar o código com tipos e deixar o verificador achar os erros antes de executar.
7Princípios SOLID em Pythonp. 171
Os cinco princípios SOLID aplicados em Python, com exemplos antes e depois.
8Segurança e Programação Defensivap. 193
As falhas de segurança mais comuns em código Python e como escrever código que não confia no que recebe.
9Profiling e Performancep. 215
Medir antes de otimizar: onde o tempo e a memória realmente vão, e como achar o gargalo.
10Documentação de Código e de Projetosp. 237
Docstrings, README e guias: escrever, junto do código, o que ele não consegue dizer sozinho.
11Empacotamento e Publicação no PyPIp. 257
Gerar wheel e sdist e publicar no PyPI, para que qualquer pessoa rode pip install no seu pacote.
12Configuração e Gerenciamento de Segredosp. 279
Separar a configuração do código e guardar segredos com segurança entre desenvolvimento e produção.
13Design de APIs e Refatoraçãop. 301
Projetar interfaces fáceis de usar certo e difíceis de usar errado, e refatorar sem quebrar o que funciona.
Parte 2: Concorrência e Paralelismo
14Escolhendo o Modelo de Concorrênciap. 329
Concorrência, paralelismo e como escolher entre threads, processos, asyncio, free-threading e subinterpretadores.
15Threads e Concorrênciap. 345
Threads: ótimas para esperar E/S, e como evitar corridas e deadlocks com travas, eventos e filas.
16Multiprocessamentop. 363
Vários interpretadores, cada um com o seu GIL: usar todos os núcleos em tarefas de CPU e o preço disso.
17concurrent.futuresp. 379
Uma interface única para pools de threads, processos e subinterpretadores: troque o modelo trocando uma classe.
18Programação Assíncrona com asynciop. 393
Milhares de tarefas cooperativas em uma só thread: o laço de eventos, await e as armadilhas do código assíncrono.
19Free-Threading e Subinterpretadoresp. 411
O Python sem GIL e os subinterpretadores: paralelismo de verdade, e quando vale a pena usá-lo.

Continue a trilha

Volume 1: Fundamentos Volume 2: Domínio da linguagem Volume 4: Dados, mundo real e produção Volume 5: Padrões de projeto