prefixo ch_ nas ancoras de capitulo

Author: ramalho

Prefacio.adoc

@@ -76,7 +76,7 @@ pela comunidade Python brasileira.
 
 === Como ler este livro
 
-Recomendo((("Python", "approach to learning", id="Papproach00"))) que todos leiam o <<data_model>>.
+Recomendo((("Python", "approach to learning", id="Papproach00"))) que todos leiam o <<ch_data_model>>.
 Após a leitura do capítulo "O modelo de dados de Python",
 o público principal deste livro não terá problema em
 pular diretamente para qualquer outra parte,
@@ -85,7 +85,7 @@ Pense nas partes <<data_structures_part>> até a <<metaprog_part>> como cinco li
 
 Tentei enfatizar o uso de classes e módulos que já existem antes de discutir como criar seus próprios.
 Por exemplo, na <<data_structures_part>>,
-o <<sequences>> trata dos tipos de sequências que estão prontas para serem usadas,
+o <<ch_sequences>> trata dos tipos de sequências que estão prontas para serem usadas,
 incluindo algumas que não recebem muita atenção, como `collections.deque`.
 Criar sequências definidas pelo usuário só é discutido na <<classes_protocols_part>>, onde também vemos como usar as classes base abstratas (ABCs) de `collections.abc`.
 Criar suas próprias ABCs é discutido ainda mais tarde, na <<classes_protocols_part>>, pois acredito na importância de estar confortável usando uma ABC antes de escrever uma.
@@ -104,18 +104,18 @@ Acredito que isso é mais fácil de tolerar agora que você sabe porque escolhi
 Aqui estão os principais tópicos de cada parte do livro:
 
 <<data_structures_part>>::
-O <<data_model>> introduz o Modelo de Dados de Python e explica porque os métodos especiais (por exemplo, `+__repr__+`) são a chave do comportamento consistente de objetos de todos os tipos. Os métodos especiais são tratados em maiores detalhes ao longo do livro. Os((("data structures"))) capítulos restantes dessa parte cobrem o uso de tipos coleção: sequências, mapeamentos e conjuntos, bem como a separação de `str` e `bytes`--causa de muitas celebrações entre usuários de Python 3, e de muita dor para usuários de Python 2 obrigados a migrar suas bases de código. Também são abordadas as fábricas de classe de alto nível na biblioteca padrão: fábricas de tuplas nomeadas e o decorador `@dataclass`. _Pattern matching_ ("casamento de padrões")—novidade no Python 3.10—é tratada em seções do <<sequences>>,
-do <<dicts-a-to-z>> e
-do <<data_class_ch>>,
+O <<ch_data_model>> introduz o Modelo de Dados de Python e explica porque os métodos especiais (por exemplo, `+__repr__+`) são a chave do comportamento consistente de objetos de todos os tipos. Os métodos especiais são tratados em maiores detalhes ao longo do livro. Os((("data structures"))) capítulos restantes dessa parte cobrem o uso de tipos coleção: sequências, mapeamentos e conjuntos, bem como a separação de `str` e `bytes`--causa de muitas celebrações entre usuários de Python 3, e de muita dor para usuários de Python 2 obrigados a migrar suas bases de código. Também são abordadas as fábricas de classe de alto nível na biblioteca padrão: fábricas de tuplas nomeadas e o decorador `@dataclass`. _Pattern matching_ ("casamento de padrões")—novidade no Python 3.10—é tratada em seções do <<ch_sequences>>,
+do <<ch_dicts_sets>> e
+do <<ch_dataclass>>,
 que discutem padrões para sequências, padrões para mapeamentos e padrões para instâncias de classes.
 O último capítulo na <<data_structures_part>> versa sobre o ciclo de vida dos objetos: referências, mutabilidade e coleta de lixo (_garbage collection_).
 
-<<function_objects_part>>:: Aqui((("functions, as first-class objects", "topics covered"))) falamos sobre funções como objetos de primeira classe na linguagem: o significado disso, como isso afeta alguns padrões de projetos populares e como aproveitar as clausuras para implementar decoradores de função. Também são vistos aqui o conceito geral de invocáveis no Python, atributos de função, introspecção, anotação de parâmetros e a nova declaração `nonlocal` no Python 3. O <<type_hints_in_def_ch>> introduz um novo tópico importante, dicas de tipo em assinaturas de função.
+<<function_objects_part>>:: Aqui((("functions, as first-class objects", "topics covered"))) falamos sobre funções como objetos de primeira classe na linguagem: o significado disso, como isso afeta alguns padrões de projetos populares e como aproveitar as clausuras para implementar decoradores de função. Também são vistos aqui o conceito geral de invocáveis no Python, atributos de função, introspecção, anotação de parâmetros e a nova declaração `nonlocal` no Python 3. O <<ch_type_hints_def>> introduz um novo tópico importante, dicas de tipo em assinaturas de função.
 
-<<classes_protocols_part>>:: Agora((("classes", "topics covered"))) o foco se volta para a criação "manual" de classes—em contraste com o uso de fábricas de classe vistas no <<data_class_ch>>.
-Como qualquer linguagem orientada a objetos, Python tem seu conjunto particular de recursos que podem ou não estar presentes na linguagem na qual você ou eu aprendemos programação baseada em classes. Os capítulos explicam como criar suas próprias coleções, classes base abstratas (ABCs) e protocolos, bem como as formas de lidar com herança múltipla e como implementar a sobrecarga de operadores, quando fizer sentido.O <<more_types_ch>> continua a conversa sobre dicas de tipo.
+<<classes_protocols_part>>:: Agora((("classes", "topics covered"))) o foco se volta para a criação "manual" de classes—em contraste com o uso de fábricas de classe vistas no <<ch_dataclass>>.
+Como qualquer linguagem orientada a objetos, Python tem seu conjunto particular de recursos que podem ou não estar presentes na linguagem na qual você ou eu aprendemos programação baseada em classes. Os capítulos explicam como criar suas próprias coleções, classes base abstratas (ABCs) e protocolos, bem como as formas de lidar com herança múltipla e como implementar a sobrecarga de operadores, quando fizer sentido. O <<ch_more_types>> continua a conversa sobre dicas de tipo.
 
-<<control_flow_part>>:: Nesta((("control flow"))) parte são tratados os mecanismos da linguagem e as bibliotecas que vão além do controle de fluxo tradicional, com condicionais, laços e sub-rotinas. Começamos com os geradores, visitamos a seguir os gerenciadores de contexto e as corrotinas, incluindo a desafiadora mas poderosa sintaxe do `yield from`. O <<with_match_ch>> inclui um exemplo significativo, usando _pattern matching_ em um interpretador de linguagem simples mas funcional. O <<concurrency_models_ch>> é novo, apresentando uma visão geral das alternativas para processamento concorrente e paralelo no Python, suas limitações, e como a arquitetura de software permite ao Python operar na escala da Web. Reescrevi o capítulo sobre _programação assíncrona_, para enfatizar os recursos centrais da linguagem—por exemplo, `await`, `async def`, `async for` e `async with`, e mostrar como eles são usados com _asyncio_ e outros frameworks.
+<<control_flow_part>>:: Nesta((("control flow"))) parte são tratados os mecanismos da linguagem e as bibliotecas que vão além do controle de fluxo tradicional, com condicionais, laços e sub-rotinas. Começamos com os geradores, visitamos a seguir os gerenciadores de contexto e as corrotinas, incluindo a desafiadora mas poderosa sintaxe do `yield from`. O <<ch_with_match>> inclui um exemplo significativo, usando _pattern matching_ em um interpretador de linguagem simples mas funcional. O <<ch_concurrency_models>> é novo, apresentando uma visão geral das alternativas para processamento concorrente e paralelo no Python, suas limitações, e como a arquitetura de software permite ao Python operar na escala da Web. Reescrevi o capítulo sobre _programação assíncrona_, para enfatizar os recursos centrais da linguagem—por exemplo, `await`, `async def`, `async for` e `async with`, e mostrar como eles são usados com _asyncio_ e outros frameworks.
 
 <<metaprog_part>>:: Essa((("metaprogramming"))) parte começa com uma revisão de técnicas para criação de classes com atributos criados dinamicamente para lidar com dados semi-estruturados, tal como conjuntos de dados JSON. A seguir tratamos do mecanismo familiar das propriedades, antes de mergulhar no funcionamento do acesso a atributos de objetos no Python em um nível mais baixo, usando descritores. A relação entre funções, métodos e descritores é explicada. Por toda a <<metaprog_part>>, a implementação passo a passo de uma biblioteca de validação de campos revela questões sutis, levando às ferramentas avançadas do capítulo final: decoradores de classes e metaclasses.
 
@@ -291,7 +291,7 @@ Alex Martelli e Anna Ravenscroft foram os primeiros a verem o esquema desse livr
 Seus livros me ensinaram Python idiomático e são modelos de clareza, precisão e profundidade em escrita técnica.
 Os https://fpy.li/p-7[6,200+ posts de Alex no Stack Overflow] (EN) são uma fonte de boas ideias sobre a linguagem e seu uso apropriado.
 
-Martelli e Ravenscroft foram também revisores técnicos deste livro, juntamente com Lennart Regebro e Leonardo Rochael. Todos nesta proeminente equipe de revisão técnica têm pelo menos 15 anos de experiência com Python, com muitas contribuições a projetos Python de alto impacto, em contato constante com outros desenvolvedores da comunidade. Em conjunto, eles me enviaram centenas de correções, sugestões, questões e opiniões, acrescentando imenso valor ao livro. Victor Stinner gentilmente revisou o <<async_ch>>, trazendo seu conhecimento especializado, como um dos mantenedores do `asyncio`, para a equipe de revisão técnica. Foi um grande privilégio e um prazer colaborar com eles por estes muitos meses.
+Martelli e Ravenscroft foram também revisores técnicos deste livro, juntamente com Lennart Regebro e Leonardo Rochael. Todos nesta proeminente equipe de revisão técnica têm pelo menos 15 anos de experiência com Python, com muitas contribuições a projetos Python de alto impacto, em contato constante com outros desenvolvedores da comunidade. Em conjunto, eles me enviaram centenas de correções, sugestões, questões e opiniões, acrescentando imenso valor ao livro. Victor Stinner gentilmente revisou o <<ch_async>>, trazendo seu conhecimento especializado, como um dos mantenedores do `asyncio`, para a equipe de revisão técnica. Foi um grande privilégio e um prazer colaborar com eles por estes muitos meses.
 
 A editora Meghan Blanchette foi uma fantástica mentora, e me ajudou a melhorar a organização e o fluxo do texto do livro, me mostrando que partes estavam monótonas e evitando que eu atrasasse o projeto ainda mais. Brian MacDonald editou os capítulo na <<function_objects_part>> quando Meghan estava ausente. Adorei trabalhar com eles e com todos na O'Reilly, incluindo a equipe de suporte e desenvolvimento do Atlas (Atlas é a plataforma de publicação de livros da O'Reilly, que eu tive a felicidade de usar para escrever esse livro).
 

capitulos/cap01.adoc

@@ -7,7 +7,7 @@
 :section-caption: Seção
 :chapter-caption: Capítulo
 
-[[data_model]]
+[[ch_data_model]]
 
 == O modelo de dados de Python
 
@@ -315,7 +315,7 @@ especificamente `self._cards`.((("", startref="PDMgetitem01")))((("", startref="
 Como foi implementado até aqui, um `FrenchDeck` não pode ser embaralhado,
 porque as cartas e suas posições não podem ser alteradas,
 exceto violando o encapsulamento e manipulando o atributo `_cards` diretamente.
-Em <<ifaces_prot_abc>> vamos corrigir isso acrescentando um método `+__setitem__+`
+Em <<ch_ifaces_prot_abc>> vamos corrigir isso acrescentando um método `+__setitem__+`
 de uma linha. Você consegue imaginar como ele seria implementado?
 =====================================================================
 
@@ -355,7 +355,7 @@ Geralmente, se você precisa invocar um método especial,
 é melhor chamar a função embutida relacionada (por exemplo, `len`, `iter`, `str`, etc.).
 Essas funções chamam o método especial correspondente,
 mas também fornecem outros serviços e—para tipos embutidos—são mais rápidas que chamadas a métodos.
-Veja, por exemplo, <<iter_closer_look>> no <<iterables2generators>>.
+Veja, por exemplo, <<iter_closer_look>> no <<ch_generators>>.
 
 Na próxima seção veremos alguns dos usos mais importantes dos métodos especiais:
 
@@ -370,7 +370,7 @@ Na próxima seção veremos alguns dos usos mais importantes dos métodos especi
 
 Vários((("special methods", "emulating numeric types", id="SMnumeric01")))((("numeric types", "emulating using special methods", id="NTemul01")))
 métodos especiais permitem que objetos criados pelo usuário respondam a operadores como `+`.
-Vamos tratar disso com mais detalhes no <<operator_overloading>>.
+Vamos tratar disso com mais detalhes no <<ch_op_overload>>.
 Aqui nosso objetivo é continuar ilustrando o uso dos métodos especiais, através de outro exemplo simples.
 
 Vamos((("vectors", "representing two-dimensional", id="Vtwo01"))) implementar uma classe para representar
@@ -381,7 +381,7 @@ vetores bi-dimensionais—isto é, vetores euclidianos como aqueles usados em ma
 ======
 O tipo embutido `complex` pode ser usado para representar vetores bi-dimensionais,
 mas nossa classe pode ser estendida para representar vetores __n__-dimensionais.
-Faremos isso em <<iterables2generators>>.
+Faremos isso em <<ch_generators>>.
 ======
 
 [[vectors_fig]]
@@ -448,14 +448,14 @@ para demonstrar o uso básico de `+__add__+` e `+__mul__+`.
 No dois casos, os métodos criam e devolvem uma nova instância de `Vector`,
 e não modificam nenhum dos operandos: `self` e `other` são apenas lidos.
 Esse é o comportamento esperado de operadores infixos: criar novos objetos e não tocar em seus operandos.
-Vou falar muito mais sobre esse tópico no <<operator_overloading>>.
+Vou falar muito mais sobre esse tópico no <<ch_op_overload>>.
 
 [WARNING]
 ====
 Da forma como está implementado, o <<ex_vector2d>> permite multiplicar um `Vector` por um número,
 mas não um número por um `Vector`,
 violando a propriedade comutativa da multiplicação escalar.
-Vamos consertar isso com o método especial `+__rmul__+` no <<operator_overloading>>.
+Vamos consertar isso com o método especial `+__rmul__+` no <<ch_op_overload>>.
 ====
 
 Nas seções seguintes vamos discutir os outros métodos especiais em
@@ -570,7 +570,7 @@ A <<collection_uml>> documenta((("special methods", "Collection API", id="SMcoll
 as interfaces dos tipos de coleções essenciais na linguagem.
 Todas as classes no diagrama são ABCs—_classes base abstratas_
 (_ABC_ é sigla para _Abstract Base Class_).
-As ABCs e o módulo `collections.abc` são tratados no <<ifaces_prot_abc>>.
+As ABCs e o módulo `collections.abc` são tratados no <<ch_ifaces_prot_abc>>.
 O objetivo dessa pequena seção é dar uma visão panorâmica das interfaces das coleções mais importantes de Python,
 mostrando como elas são criadas a partir de métodos especiais.
 
@@ -658,7 +658,7 @@ I tried to use keep-together in <<special_operators_tbl>> but it was rendering a
 Operadores infixos e numéricos são suportados pelos métodos especiais listados na
 <<special_operators_tbl>>.
 // pass:[<a data-type="xref" href="#special_operators_tbl" data-xrefstyle="select: labelnumber">#special_operators_tbl</a>].
-Aqui os nomes mais recentes são `+__matmul__+`, `+__rmatmul__+`, e `+__imatmul__+`, adicionados n Python 3.5 para suportar o uso de `@` como um operador infixo de multiplicação de matrizes, como veremos no <<operator_overloading>>.((("special methods", "special method names and symbols for operators")))
+Aqui os nomes mais recentes são `+__matmul__+`, `+__rmatmul__+`, e `+__imatmul__+`, adicionados n Python 3.5 para suportar o uso de `@` como um operador infixo de multiplicação de matrizes, como veremos no <<ch_op_overload>>.((("special methods", "special method names and symbols for operators")))
 
 [[special_operators_tbl]]
 .Nomes e símbolos de métodos especiais para operadores
@@ -680,7 +680,7 @@ Aqui os nomes mais recentes são `+__matmul__+`, `+__rmatmul__+`, e `+__imatmul_
  Python invoca um método especial de operador reverso no segundo argumento quando o método especial correspondente não pode ser usado no primeiro operando.
 Atribuições aumentadas são atalho combinando um operador infixo com uma atribuição de variável, por exemplo `a += b`.
 
-O <<operator_overloading>> explica em detalhes os operadores reversos e a atribuição aumentada.((("", startref="PDMspmtov01")))
+O <<ch_op_overload>> explica em detalhes os operadores reversos e a atribuição aumentada.((("", startref="PDMspmtov01")))
 ====
 
 
@@ -713,13 +713,13 @@ Uma exigência básica para um objeto em Python é fornecer strings representand
 
 Emular sequências, como mostrado com o exemplo do `FrenchDeck`, é um dos usos mais comuns dos métodos especiais.
 Por exemplo, bibliotecas de banco de dados frequentemente devolvem resultados de consultas na forma de coleções similares a sequências.
-Tirar o máximo proveito dos tipos de sequências existentes é o assunto do <<sequences>>.
-Como implementar suas próprias sequências será visto na <<user_defined_sequences>>,
+Tirar o máximo proveito dos tipos de sequências existentes é o assunto do <<ch_sequences>>.
+Como implementar suas próprias sequências será visto na <<ch_seq_methods>>,
 onde criaremos uma extensão multidimensional da classe `Vector`.
 
 Graças à sobrecarga de operadores, Python oferece uma rica seleção de tipos numéricos, desde os tipos embutidos até `decimal.Decimal` e `fractions.Fraction`,
 todos eles suportando operadores aritméticos infixos.
-As bibliotecas de ciência de dados _NumPy_ suportam operadores infixos com matrizes e tensores. A implementação de operadores—incluindo operadores reversos e atribuição aumentada—será vista no <<operator_overloading>>, usando melhorias do exemplo `Vector`.
+As bibliotecas de ciência de dados _NumPy_ suportam operadores infixos com matrizes e tensores. A implementação de operadores—incluindo operadores reversos e atribuição aumentada—será vista no <<ch_op_overload>>, usando melhorias do exemplo `Vector`.
 
 Também veremos o uso e a implementação da maioria dos outros métodos especiais do Modelo de Dados de Python ao longo deste livro.