cap21: revisão de estilo WIP

Author: ramalho

code/20-executors/getflags/flags_asyncio.py

@@ -43,5 +43,5 @@ async def supervisor(cc_list: list[str]) -> int:
     return len(res)                              # <6>
 
 if __name__ == '__main__':
-    main(download_many)
+    main(download_many)                          # <7>
 # end::FLAGS_ASYNCIO_START[]

images/flpy_2101.png

@@ -67,7 +67,7 @@ Escrevi uma nova seção de abertura, tratando especificamente da função embut
 profundamente a forma como `super()` suporta a herança múltipla cooperativa.
 
 A <<mixin_classes_sec>> também é nova. Reorganizei a <<multi_real_world_sec>>,
-apresentando exemplos mais simples de _mixin_ na bilbioteca
+apresentando exemplos mais simples de _mixin_ na biblioteca
 padrão, antes de apresentar o exemplos com o Django e a 
 hierarquia complicada do Tkinter.
 
@@ -1012,7 +1012,7 @@ Text, Widget, BaseWidget, Misc, Pack, Place, Grid, XView, YView, object
 ====
 
 Pelos padrões atuais, a hierarquia de classes do Tkinter é profunda demais.
-Poucas partes da bilbioteca padrão de Python tem mais que três ou quatro níveis
+Poucas partes da biblioteca padrão de Python tem mais que três ou quatro níveis
 de classes concretas, e o mesmo pode ser dito da biblioteca de classes de Java.
 Entretanto, é interessante observar que algumas das hierarquias mais profundas
 da biblioteca de classes de Java são precisamente os pacotes relacionados à

online/cap14.adoc

@@ -1158,7 +1158,7 @@ Dada a instabilidade da situação atual, se você precisar ler anotações dura
 
 * Evite ler `+__annotations__+` diretamente; em vez disso, use `inspect.get_annotations` (desde o Python 3.10) ou `typing.get_type_hints` (desde o Python 3.5).
 * Escreva uma função customizada própria, como um invólucro para
-pass:[<code>in&#x200b;spect&#x200b;.get_annotations</code>] ou `typing.get_type_hints`, e faça o restante de sua base de código chamar aquela função, de forma que mudanças futuras fiquem restritas a um único local.
+`inspect.get_annotations` ou `typing.get_type_hints`, e faça o restante de sua base de código chamar aquela função, de forma que mudanças futuras fiquem restritas a um único local.
 
 Para demonstrar esse segundo ponto, aqui estão as primeiras linhas da classe `Checked`,
 que estudaremos no <<ex_checked_class_top>> do <<ch_class_metaprog>>:
@@ -1745,7 +1745,7 @@ do <<ch_ifaces_prot_abc>>.
 O sistema de tipos de Python é um campo imenso e em rápida expansão. Este
 capítulo não é abrangente. Escolhi me concentrar em tópicos que são
 amplamente aplicáveis, ou particularmente complexos, ou conceitualmente
-importantes, e que assim provavelmente se manterão relevantes por mais
+importantes, e que provavelmente serão relevantes por mais
 tempo.
 
 ====

online/cap15.adoc

@@ -105,7 +105,7 @@ include::../code/17-it-generator/sentence.py[tags=SENTENCE_SEQ]
 <1> `.findall` devolve a lista com todos os trechos não sobrepostos
 correspondentes à expressão regular, como uma lista de strings.
 
-<2> `self.words` mantém o resultado de `.findall`, então basta devolver a
+<2> `self.words` preserva o resultado de `.findall`, então basta devolver a
 palavra em um dado índice.
 
 <3> Para completar o protocolo de sequência, implementamos `+__len__+`, apesar
@@ -630,7 +630,7 @@ ____
 
 Para "suportar travessias múltiplas", deve ser possível obter múltiplos
 iteradores independentes a partir de um mesmo objeto iterável, e cada
-iterador deve manter seu próprio estado interno. Assim, uma implementação
+iterador deve preservar seu próprio estado interno. Assim, uma implementação
 adequada do padrão exige que cada invocação de `iter(meu_iterável)` crie um novo
 iterador independente. Por isso precisamos da classe
 `SentenceIterator` neste exemplo.
@@ -2133,7 +2133,7 @@ Após esse primeiro encontro com `yield from`, vamos olhar as dicas de tipo para
 [[generic_iterable_types_sec]]
 === Tipos iteráveis genéricos
 
-A((("generators", "generic iterable types")))((("iterators", "generic iterable types"))) bilbioteca padrão de Python contém muitas funções que aceitam argumentos iteráveis.
+A((("generators", "generic iterable types")))((("iterators", "generic iterable types"))) biblioteca padrão de Python contém muitas funções que aceitam argumentos iteráveis.
 Em seu código, tais funções podem ser anotadas como a função `zip_replace`, vista no <<replacer_ex>>,
 usando `collections.abc.Iterable` (ou `typing.Iterable`, se você precisa suporta Python 3.8 ou anterior, como explicado no <<legacy_deprecated_typing_box>>). Veja o <<replacer_iterable_ex>>.
 
@@ -2317,10 +2317,19 @@ Vamos ver agora como as corrotinas clássicas funcionam.
 
 ==== Exemplo: Corrotina para computar uma média móvel
 
-Quando((("coroutines", "computing running averages", id="CRavg17")))((("running averages, computing", id="runavg17")))((("averages, computing", id="avg17"))) discutimos clausuras no <<ch_closure_decorator>>,
-estudamos objetos para computar uma média móvel.
-O <<ex_average_oo>> mostra uma classe e o <<ex_average_fixed>> apresenta uma função de ordem superior devolvendo uma função que mantem as variáveis `total` e `count` entre invocações, em uma clausura.
-O <<ex_coroaverager>> mostra como fazer o mesmo com uma corrotina.footnote:[Este exemplo foi inspirado por um trecho enviado por Jacob Holm à lista Python-ideas, em uma mensagem intitulada https://fpy.li/17-20[_Yield-From: Finalization guarantees_] (Yield-From: Garantias de finalização). Algumas variantes aparecem mais tarde na mesma thread, e Holm dá mais explicações sobre suas ideia na https://fpy.li/17-21[«mensagem 003912»].]
+Quando((("coroutines", "computing running averages", id="CRavg17")))((("running averages, computing",
+id="runavg17")))((("averages, computing", id="avg17")))
+discutimos clausuras no <<ch_closure_decorator>>, estudamos objetos para
+computar uma média móvel. O <<ex_average_oo>> mostra uma classe e o
+<<ex_average_fixed>> apresenta uma função de ordem superior devolvendo uma
+função que preserva as variáveis `total` e `count` entre invocações, em uma
+clausura. O <<ex_coroaverager>> mostra como fazer o mesmo com uma
+corrotina.footnote:[Este exemplo foi inspirado por um trecho enviado por Jacob
+Holm à lista Python-ideas, em uma mensagem intitulada
+https://fpy.li/17-20[_Yield-From: Finalization guarantees_] (Yield-From:
+Garantias de finalização). Algumas variantes aparecem mais tarde na mesma
+thread, e Holm dá mais explicações sobre suas ideia na
+https://fpy.li/17-21[«mensagem 003912»].]
 
 [[ex_coroaverager]]
 .coroaverager.py: corrotina para computar uma média móvel
@@ -2350,7 +2359,7 @@ Em uma corrotina, `total` e `count` podem ser variáveis locais:
 não precisamos usar atributos de uma instância ou uma clausura para preservar o contexto
 enquanto a corrotina está suspensa, esperando pelo próximo `.send()`.
 Por isso as corrotinas são substitutas atraentes para _callbacks_
-em programação assíncrona—elas mantêm o estado local entre ativações.
+em programação assíncrona—elas preservam o estado local entre ativações.
 
 O <<ex_coroaverager_test>> executa doctests mostrando a corrotina `averager` em operação.
 
@@ -2696,7 +2705,7 @@ lista de pagamentos ao longo do tempo. Há também a seção
 https://fpy.li/9h[_Receitas com itertools_], com funções adicionais de alto
 desempenho, usando as funções de `itertools` como base.
 
-Além da bilbioteca padrão de Python, recomendo o pacote
+Além da biblioteca padrão de Python, recomendo o pacote
 https://fpy.li/17-30[_More Itertools_], que continua a bela tradição do
 `itertools`, oferecendo geradores poderosos, acompanhadas de muitos exemplos e
 várias receitas úteis.

online/cap17.adoc

@@ -765,7 +765,7 @@ semelhante ao módulo `builtins` do Python.
 A((("lis.py interpreter", "Environment class", id="lispyenv18"))) classe
 `Environment` estende `collections.ChainMap`, acrescentando o método `change`,
 para atualizar um valor dentro de um dos dicts encadeados que as instâncias de
-`ChainMap` mantém em uma lista de mapeamentos no atributo `self.maps`. O método
+`ChainMap` guardam no atributo `self.maps`, que é lista de mapeamentos. O método
 `change` é necessário para suportar a instrução `(set! …)` do Scheme, descrita mais
 tarde.
 
@@ -1199,7 +1199,7 @@ local.
 Ambos, `nonlocal` e `(set! …)`, são necessários para atualizar o estado do
 programa mantido em variáveis dentro de uma clausura. O
 <<ex_average_fixed>> demonstrou o uso de `nonlocal` para implementar uma função
-que calcula uma média contínua, mantendo itens `count` e `total` em uma
+que calcula uma média contínua, preservando os itens `count` e `total` em uma
 clausura. Aqui está a mesma ideia, escrita no subconjunto de Scheme de _lis.py_:
 
 [source, scheme]

online/cap18.adoc

@@ -642,7 +642,7 @@ Considere a função `is_prime` no <<def_is_prime_ex>>,
 que retorna `True` se o argumento for um número primo, `False` se não for.
 
 [[def_is_prime_ex]]
-.primes.py: uma checagem de números primos fácil de entender, do exemplo em https://fpy.li/aa[pass:[<code>ProcessPool&#x200b;Executor</code>] na documentação de Python]
+.primes.py: uma checagem de números primos fácil de entender, do exemplo em https://fpy.li/aa[`ProcessPoolExecutor`] na documentação de Python]
 ====
 [source, python]
 ----
@@ -668,7 +668,7 @@ ____
 
 Antes de executar o código ou continuar lendo,
 recomendo chegar as respostas por você mesmo.
-Depois, copie e modifique os exemplos pass:[<em>spinner_*.py</em>]  como sugerido.
+Depois, copie e modifique os exemplos _spinner_ como sugerido.
 
 Agora as respostas, da mais fácil para a mais difícil.
 
@@ -901,7 +901,7 @@ include::../code/19-concurrency/primes/procs.py[tags=PRIMES_PROC_TOP]
 <1> Na tentativa de emular `threading`, `multiprocessing` fornece `multiprocessing.SimpleQueue`, mas esse é um método vinculado a uma instância pré-definida de uma classe de nível mais baixo, `BaseContext`.
 Temos que chamar essa `SimpleQueue` para criar uma fila. Mas não podemos usá-la em dicas de tipo.
 <2> `multiprocessing.queues` contém a classe `SimpleQueue` que precisamos para dicas de tipo.
-<3> `PrimeResult` inclui o número checado. Manter `n` junto com os outros campos do resultado simplifica a exibição mais tarde.
+<3> `PrimeResult` inclui o número checado. Preservar `n` com os outros campos do resultado simplifica a exibição mais tarde.
 <4> Isso é um apelido de tipo para uma `SimpleQueue` que a função `main` (<<primes_procs_main_ex>>) vai usar para enviar os números para os processos que farão a checagem.
 <5> Apelido de tipo para uma segunda `SimpleQueue` que vai coletar os resultados em `main`. Os valores na fila serão tuplas contendo o número a ser testado e uma tupla `Result`.
 <6> Isso é similar a _sequential.py_.
@@ -1728,7 +1728,7 @@ capitulo. Então temos aqui exemplos dos dois pecados descritos pelo Prof. Simon
 usar palavras diferentes para se referir à mesma coisa, e usar uma palavra para
 se referir a coisas diferentes.]
 
-* Um ator pode manter um estado interno, mas não pode compartilhar esse estado com outros atores.
+* Um ator pode ter um estado interno, mas não pode compartilhar esse estado com outros atores.
 * Atores só podem se comunicar enviando e recebendo mensagens.
 * Mensagens só contém cópias de dados, e não referências para dados mutáveis.
 * Um ator só processa uma mensagem de cada vez. Não há execução concorrente dentro de um único ator.