errata #111

Author: ramalho

online/cap02.adoc

@@ -378,7 +378,7 @@ ordenada por naipe e então por valor:
                                         for rank in self.ranks]
 ----
 
-Listcomps são mágicas de truque só: elas criam listas.
+Listcomps são mágicas de um truque só: elas criam listas.
 Para gerar dados para outros tipos de sequências, uma genexp é o caminho.
 A próxima seção é uma pequena incursão às genexps, no contexto de criação de sequências que não são
 listas.((("", startref="cartprod02")))
@@ -610,17 +610,17 @@ True
 False
 ----
 
-Vamos aprofundar essa questão em <<tuple-relative-immutable>>.
+Vamos aprofundar essa questão na <<tuple_relative_immutable_sec>>.
 
 Apesar dessa ressalva, as tuplas são frequentemente usadas como listas imutáveis.
-Elas oferecem algumas vantagens de desempenho, explicadas por uma dos desenvolvedores principais de Python,
+Elas oferecem algumas vantagens de desempenho, explicadas por um dosdesenvolvedores principais de Python,
 Raymond Hettinger, em uma resposta à questão
 https://fpy.li/2-3["Are tuples more efficient than lists in Python?" (_As tuplas são mais eficientes que as listas no Python?_)]
 no StackOverflow.
 Em resumo, Hettinger escreveu:
 
-* Para avaliar uma tupla literal, o compilador Python gera bytecode para uma constante tupla em uma operação;
-mas para um literal lista, o bytecode gerado insere cada elemento como uma constante separada na pilha,
+* Para avaliar uma tupla literal como `(1, 2, 3)`, o compilador Python gera bytecode para uma constante tupla em uma operação;
+mas para um literal lista, `[1, 2, 3]`, o bytecode gerado insere cada elemento como uma constante separada na pilha,
 e então cria a lista.
 * Dada a tupla `t`, `tuple(t)` simplesmente devolve uma referência para a mesma `t`. Não há necessidade de cópia.
 Por outro lado, dada uma lista `l`, o construtor `list(l)` precisa criar uma nova cópia de `l`.
@@ -929,15 +929,15 @@ O sujeito contém os dados que Python vai comparar aos padrões em cada instruç
 O primeiro item deve ser a string `BEEPER`.
 O segundo e o terceiro itens podem ser qualquer coisa, e serão vinculados às variáveis `frequency` e `times`, nessa ordem.
 <3> Isso casa com qualquer sujeito com dois itens, se o primeiro for `'NECK'`.
-<4> Isso vai casar com uma sujeito de três itens começando com `LED`.
+<4> Isso vai casar com um sujeito de três itens começando com `LED`.
 Se o número de itens não for correspondente, Python segue para o próximo `case`.
 <5> Outro padrão de sequência começando com `'LED'`, agora com cinco itens—incluindo a constante `'LED'`.
 <6> Esse é o `case` default.
 Vai casar com qualquer sujeito que não tenha sido capturado por um dos padrões precedentes.
 A variável `_` é especial, como logo veremos.
 
 Olhando((("pattern matching", "destructuring"))) superficialmente,
-`match/case` se parece instrução `switch/case` da linguagem C—mas isso é só uma pequena parte da sua
+`match/case` se parece com a instrução `switch/case` da linguagem C—mas isso é só uma pequena parte da sua
 funcionalidade.footnote:[Na minha opinião, uma sucessão `if/elif/elif/.../else` funciona muito bem no lugar de `switch/case`.
 E ela não sofre dos problemas de https://fpy.li/2-8[fallthrough (_cascateamento_)] (EN) e de
 https://fpy.li/2-9[dangling else (_o `else` errante_)] (EN),

online/cap06.adoc

@@ -340,7 +340,7 @@ Para concluir essa discussão de identidade versus igualdade,
 vamos ver como o tipo notoriamente imutável `tuple` não é assim tão invariável quanto você poderia supor.
 
 
-[[tuple-relative-immutable]]
+[[tuple_relative_immutable_sec]]
 ==== A imutabilidade relativa das tuplas
 
 As tuplas, como((("tuples", "relative immutability of"))) a maioria das coleções em

online/cap07.adoc

@@ -354,7 +354,7 @@ Introduzidas no Python 3.5.
 Funções geradoras assíncronas:: Funções((("asynchronous generators"))) ou métodos definidos com `async def`, contendo `yield` em seu corpo.
 Quando chamados, devolvem um gerador assíncrono para ser usado com `async for`. Introduzidas no Python 3.6.
 
-Funções geradoras, funções de corrotinas nativas e geradoras assíncronas são diferentes de outros invocáveis: os valores devolvidos tais funções nunca são dados da aplicação, mas objetos que exigem processamento adicional, seja para produzir dados da aplicação, seja para realizar algum trabalho útil.
+Funções geradoras, funções de corrotinas nativas e geradoras assíncronas são diferentes de outros invocáveis: os valores devolvidos por tais funções nunca são dados da aplicação, mas objetos que exigem processamento adicional, seja para produzir dados da aplicação, seja para realizar algum trabalho útil.
 Funções geradoras devolvem iteradores.
 Ambos são tratados no <<ch_generators>>.
 Funções de corrotinas nativas e funções geradoras assíncronas devolvem objetos que só funcionam com a ajuda de um framework de programação assíncrona, tal como _asyncio_.

online/cap21.adoc

@@ -809,7 +809,7 @@ Veja o artigo https://pt.wikipedia.org/wiki/Listas_invertidas["Listas Invertidas
 ==== Um serviço web com FastAPI
 
 Escrevi((("FastAPI framework", id="fastapi21"))) o próximo exemplo—_web_mojifinder.py_—usando a https://fpy.li/21-28[_FastAPI_]:
-uma dos frameworks ASGI de desenvolvimento Web de Python, mencionada na <<asgi_note>>.
+um dosframeworks ASGI de desenvolvimento Web de Python, mencionada na <<asgi_note>>.
 A <<web_mojifinder_result>> é uma captura de tela da interface de usuário.
 É uma aplicação muito simples, de uma página só (SPA, Single Page Application): após o download inicial do HTML, a interface é atualizada via Javascript no cliente, em comunicação com o servidor.
 

print/1/experimento-1/cap02.adoc

@@ -608,10 +608,10 @@ True
 False
 ----
 
-Vamos aprofundar essa questão em <<tuple-relative-immutable>>.
+Vamos aprofundar essa questão na <<tuple_relative_immutable_sec>>.
 
 Apesar dessa ressalva, as tuplas são frequentemente usadas como listas imutáveis.
-Elas oferecem algumas vantagens de desempenho, explicadas por uma dos desenvolvedores principais de Python,
+Elas oferecem algumas vantagens de desempenho, explicadas por um dosdesenvolvedores principais de Python,
 Raymond Hettinger, em uma resposta à questão
 https://fpy.li/2-3["Are tuples more efficient than lists in Python?" (_As tuplas são mais eficientes que as listas no Python?_)]
 no StackOverflow. Em resumo, Hettinger escreveu:
@@ -924,7 +924,7 @@ O sujeito contém os dados que Python vai comparar aos padrões em cada instruç
 <2> Esse padrão casa com qualquer sujeito que seja uma sequência de três itens. O primeiro item deve ser a string `BEEPER`.
 O segundo e o terceiro itens podem ser qualquer coisa, e serão vinculados às variáveis `frequency` e `times`, nessa ordem.
 <3> Isso casa com qualquer sujeito com dois itens, se o primeiro for `'NECK'`.
-<4> Isso vai casar com uma sujeito de três itens começando com `LED`.
+<4> Isso vai casar com um sujeito de três itens começando com `LED`.
 Se o número de itens não for correspondente, Python segue para o próximo `case`.
 <5> Outro padrão de sequência começando com `'LED'`, agora com cinco itens—incluindo a constante `'LED'`.
 <6> Esse é o `case` default. Vai casar com qualquer sujeito que não tenha sido capturado por um dos padrões precedentes.

print/1/experimento-1/cap06.adoc

@@ -326,7 +326,7 @@ Para concluir essa discussão de identidade versus igualdade,
 vamos ver como o tipo notoriamente imutável `tuple` não é assim tão invariável quanto você poderia supor.
 
 
-[[tuple-relative-immutable]]
+[[tuple_relative_immutable_sec]]
 ==== A imutabilidade relativa das tuplas
 
 As tuplas, como((("tuples", "relative immutability of"))) a maioria das coleções em

vol1/cap02.adoc

@@ -82,7 +82,7 @@ Sequências planas::
 
 Uma((("tuples", "simplified memory diagram for")))((("arrays"))) _sequência contêiner_ mantém
 referências para os objetos que contém, que podem ser de qualquer tipo,
-enquanto uma  _sequência plana_ armazena o valor de seu conteúdo em seu próprio espaço de memória,
+enquanto uma _sequência plana_ armazena o valor de seu conteúdo em seu próprio espaço de memória,
 e não como objetos Python distintos.
 Veja a <<container_v_flat_img>>.
 
@@ -112,9 +112,11 @@ enquanto a tupla consiste de vários objetos—a própria tupla e cada objeto `f
 Outra forma de agrupar as sequências é por mutabilidade:
 
 Sequências mutáveis::
-  Por((("mutable sequences"))) exemplo, `list`, `bytearray`, `array.array` e `collections.deque`.
+  Podem((("mutable sequences"))) ter seu conteúdo modificado, reduzido ou ampliado.
+  Por exemplo, `list`, `bytearray`, `array.array` e `collections.deque`.
 Sequências imutáveis::
-  Por((("immutable sequences"))) exemplo, `tuple`, `str`, e `bytes`.
+  Uma((("immutable sequences"))) vez criadas, não podem ter seus itens removidos, trocados ou acrescentados.
+  Por((("immutable sequences"))) exemplo, `tuple`, `str`, e `bytes`.footnote:[A tupla é imutável mas pode conter itens mutáveis, o que introduz complicações que veremos em <<tuple_as_immutable_list_sec>>.]
 
 A <<sequence_uml>> ajuda a visualizar como as sequências mutáveis herdam todos os métodos
 das sequências imutáveis e implementam vários métodos adicionais.
@@ -379,7 +381,7 @@ ordenada por naipe e então por valor:
                                         for rank in self.ranks]
 ----
 
-Listcomps são mágicas de truque só: elas criam listas.
+Listcomps são mágicas de um truque só: elas criam listas.
 Para gerar dados para outros tipos de sequências, uma genexp é o caminho.
 A próxima seção é uma pequena incursão às genexps, no contexto de criação de sequências que não são
 listas.((("", startref="cartprod02")))
@@ -550,6 +552,7 @@ não apenas de tuplas, mas também de sequências e iteráveis em geral.
 Agora vamos considerar o uso da classe `tuple` como uma variante imutável da classe
 `list`.((("", startref="tuple02")))
 
+[[tuple_as_immutable_list_sec]]
 ==== Tuplas como listas imutáveis
 
 O((("tuples", "as immutable lists", secondary-sortas="immutable lists", id="Timlist02")))((("lists", "using tuples as immutable",
@@ -611,17 +614,17 @@ True
 False
 ----
 
-Vamos aprofundar essa questão em <<tuple-relative-immutable>>.
+Vamos aprofundar essa questão na <<tuple_relative_immutable_sec>>.
 
 Apesar dessa ressalva, as tuplas são frequentemente usadas como listas imutáveis.
-Elas oferecem algumas vantagens de desempenho, explicadas por uma dos desenvolvedores principais de Python,
+Elas oferecem algumas vantagens de desempenho, explicadas por um dosdesenvolvedores principais de Python,
 Raymond Hettinger, em uma resposta à questão
-«"Are tuples more efficient than lists in Python?" (_As tuplas são mais eficientes que as listas no Python?_)» [.small]#&#91;fpy.li/2-3&#93;#
+«Are tuples more efficient than lists in Python? (As tuplas são mais eficientes que as listas no Python?)» [.small]#&#91;fpy.li/2-3&#93;#
 no StackOverflow.
 Em resumo, Hettinger escreveu:
 
-* Para avaliar uma tupla literal, o compilador Python gera bytecode para uma constante tupla em uma operação;
-mas para um literal lista, o bytecode gerado insere cada elemento como uma constante separada na pilha,
+* Para avaliar uma tupla literal como `(1, 2, 3)`, o compilador Python gera bytecode para uma constante tupla em uma operação;
+mas para um literal lista, `[1, 2, 3]`, o bytecode gerado insere cada elemento como uma constante separada na pilha,
 e então cria a lista.
 * Dada a tupla `t`, `tuple(t)` simplesmente devolve uma referência para a mesma `t`. Não há necessidade de cópia.
 Por outro lado, dada uma lista `l`, o construtor `list(l)` precisa criar uma nova cópia de `l`.
@@ -930,15 +933,15 @@ O sujeito contém os dados que Python vai comparar aos padrões em cada instruç
 e o primeiro item é a string `'BEEPER'`.
 O segundo e o terceiro itens podem ser qualquer coisa, e serão vinculados às variáveis `frequency` e `times`, nessa ordem.
 <3> Isso casa com qualquer sujeito com dois itens, se o primeiro for `'NECK'`.
-<4> Isso vai casar com uma sujeito de três itens começando com `LED`.
+<4> Isso vai casar com um sujeito de três itens começando com `LED`.
 Se o número de itens não for correspondente, Python segue para o próximo `case`.
 <5> Outro padrão de sequência começando com `'LED'`, agora com cinco itens—incluindo a constante `'LED'`.
 <6> Esse é o `case` default.
 Vai casar com qualquer sujeito que não tenha sido capturado por um dos padrões precedentes.
 A variável `_` é especial, como logo veremos.
 
 Olhando((("pattern matching", "destructuring"))) superficialmente,
-`match/case` se parece instrução `switch/case` da linguagem C—mas isso é só uma pequena parte da sua
+`match/case` se parece com a instrução `switch/case` da linguagem C—mas isso é só uma pequena parte da sua
 funcionalidade.footnote:[Na minha opinião, uma sucessão `if/elif/elif/.../else` funciona muito bem no lugar de `switch/case`.
 E ela não sofre dos problemas de «fallthrough (_cascateamento_)» [.small]#&#91;fpy.li/2-8&#93;# (EN) e de
 «dangling else (_o `else` errante_)» [.small]#&#91;fpy.li/2-9&#93;# (EN),

vol1/cap06.adoc

@@ -340,7 +340,7 @@ Para concluir essa discussão de identidade versus igualdade,
 vamos ver como o tipo notoriamente imutável `tuple` não é assim tão invariável quanto você poderia supor.
 
 
-[[tuple-relative-immutable]]
+[[tuple_relative_immutable_sec]]
 ==== A imutabilidade relativa das tuplas
 
 As tuplas, como((("tuples", "relative immutability of"))) a maioria das coleções em