desatando "nós"

Author: ramalho

capitulos/cap05.adoc

@@ -39,7 +39,7 @@ Entretanto, `TypedDict` não cria classes concretas que possam ser instanciadas.
 Ela é apenas a sintaxe para escrever dicas de tipo para parâmetros de função e
 variáveis que aceitarão valores de mapeamentos como registros,
 enquanto suas chaves serão os nomes dos campos.
-Nós veremos mais sobre isso na <<typeddict_sec>> do <<ch_more_types>>.
+Veremos mais sobre isso na <<typeddict_sec>> do <<ch_more_types>>.
 ====
 
 

capitulos/cap06.adoc

@@ -256,7 +256,7 @@ mas outro interpretador Python pode retornar algo diferente.
 O ponto fundamental é que o ID será sempre um valor numérico único,
 e ele nunca mudará durante a vida do objeto.
 
-Na prática, nós raramente usamos a função `id()` quando programamos.
+Na prática, raramente usamos a função `id()` quando programamos.
 A verificação de identidade é feita, na maior parte das vezes, com o operador `is`,
 que compara os IDs dos objetos, então nosso código não precisa chamar `id()`
 explicitamente.
@@ -818,7 +818,7 @@ include::code/06-obj-ref/twilight_bus.py[tags=TWILIGHT_BUS_CLASS]
 ----
 ====
 [role="pagebreak-before less_space"]
-<1> Aqui nós cuidadosamente criamos uma lista vazia quando `passengers` é `None`.
+<1> Aqui cuidadosamente criamos uma lista vazia quando `passengers` é `None`.
 <2> Entretanto, esta atribuição transforma `self.passengers` em um apelido para `passengers`,
 que por sua vez é um apelido para o argumento passado para `+__init__+`
 (i.e. `basketball_team` em <<demo_twilight_bus>>).

capitulos/cap08.adoc

@@ -449,7 +449,7 @@ Por exemplo, não é possível, usando dicas de tipo,
 definir `Quantity` como um número inteiro entre 1 e 10000,
 ou `AirportCode` como uma sequência de 3 letras.
 O NumPy oferece `uint8`, `int16`, e outros tipos numéricos ligados à arquitetura do hardware,
-mas na biblioteca padrão de Python nós encontramos apenas
+mas na biblioteca padrão de Python encontramos apenas
 tipos com conjuntos muitos pequenos de valores (`NoneType`, `bool`)
 ou conjuntos muito grandes (`float`, `int`, `str`, todas as tuplas possíveis, etc.).]
 
@@ -876,20 +876,27 @@ Todo sistema de tipagem gradual precisa de um tipo coringa como `Any`
 O verbo "inferir" é um sinônimo bonito para "adivinhar", quando usado no contexto da análise de tipos.
 Verificadores de tipo modernos, em Python e outras linguagens,
 não precisam de anotações de tipo em todo lugar porque conseguem inferir o tipo de muitas expressões.
-Por exemplo, se eu escrever `x = len(s) * 10`, o verificador não precisa de uma declaração local explícita para saber que `x` é um `int`, desde que consiga encontrar dicas de tipo para `len` em algum lugar.
+Por exemplo, se eu escrever `x = len(s) * 10`,
+o verificador não precisa de uma declaração local explícita para saber que `x` é um `int`,
+desde que consiga encontrar dicas de tipo para `len` em algum lugar.
 ====
 
-Agora podemos explorar o restante dos tipos usados em anotações.((("", startref="GTSsub08")))((("", startref="dynamic08")))((("", startref="anytype08")))
+Agora podemos explorar o restante dos tipos usados em anotações.
+((("", startref="GTSsub08")))((("", startref="dynamic08")))((("", startref="anytype08")))
 
 ==== Tipos simples e classes
 
-Tipos simples((("gradual type system", "simple types and classes"))) como `int`, `float`, `str`, e `bytes` podem ser usados diretamente em dicas de tipo.
-Classes concretas da biblioteca padrão, de pacotes externos ou definidas pelo usuário — `FrenchDeck`, `Vector2d`, e `Duck` - também podem ser usadas em dicas de tipo.
+Tipos simples((("gradual type system", "simple types and classes")))
+como `int`, `float`, `str`, e `bytes` podem ser usados diretamente em dicas de tipo.
+Classes concretas da biblioteca padrão,
+de pacotes externos ou definidas pelo usuário (ex. `FrenchDeck`, `Vector2d`, e `Duck`)
+também podem ser usadas em dicas de tipo.
 
 Classes base abstratas também são úteis aqui.
 Voltaremos a elas quando formos estudar os tipos coleção, e em <<type_hint_abc_sec>>.
 
-Para classes, _consistente-com_ é definido como _subtipo_de_: uma subclasse é _consistente-com_ todas as suas superclasses.
+Para classes, _consistente-com_ é definido como _subtipo_de_:
+uma subclasse é _consistente-com_ todas as suas superclasses.
 
 Entretanto, "a praticidade se sobrepõe à pureza", então há uma exceção importante, discutida em seguida.
 
@@ -901,15 +908,17 @@ Não há nenhuma relação nominal de subtipo entre os tipo nativos `int`, `floa
 Mas a PEP 484 https://fpy.li/cardxvi[declara]
 que `int` é _consistente-com_ `float`, e `float` é _consistente-com_ `complex`.
 Na prática, faz sentido:
-`int` implementa todas as operações que `float` implementa, e `int` implementa operações adicionais também - operações binárias como `&`, `|`, `<<`, etc.
+`int` implementa todas as operações que `float` implementa, e `int` implementa operações adicionais também—operações binárias como `&`, `|`, `<<`, etc.
 O resultado final é o seguinte: `int` é _consistente-com_ `complex`.
 Para `i = 3`, `i.real` é `3` e `i.imag` é `0`.
 ====
 
 
 ==== Os tipos Optional e Union
 
-Nós((("gradual type system", "Optional and Union types")))((("Union type")))((("Optional type"))) vimos o tipo especial `Optional` em <<dealing_with_none_sec>>. Ele resolve o problema de ter `None` como default, como no exemplo daquela seção:
+Vimos((("gradual type system", "Optional and Union types")))((("Union type")))((("Optional type")))
+o tipo especial `Optional` em <<dealing_with_none_sec>>.
+Ele resolve o problema de ter `None` como default, como no exemplo daquela seção:
 
 [source, py]
 ----
@@ -1730,7 +1739,7 @@ include::code/08-def-type-hints/comparable/comparable.py[]
 
 Um tipo `T` é _consistente-com_ um protocolo `P` se `T` implementa todos os métodos definido em `P`, com assinaturas de tipo correspondentes.
 
-Dado `SupportsLessThan`, nós agora podemos definir essa versão funcional de `top` no <<top_protocol_ex>>.
+Dado `SupportsLessThan`, agora podemos definir essa versão funcional de `top` no <<top_protocol_ex>>.
 
 [[top_protocol_ex]]
 ._top.py_: definição da função `top` usando uma `TypeVar` com `bound=SupportsLessThan`
@@ -2252,16 +2261,22 @@ Esse é um custo unitário.
 
 Mas há também um custo recorrente, eterno.
 
-Nós perdemos um pouco do poder expressivo de Python se insistimos que tudo precisa estar sob a checagem de tipos.
-Recursos maravilhosos como desempacotamento de argumentos — e.g., `config(**settings)`— estão além da capacidade de compreensão dos checadores de tipos.
+Perdemos parte do poder expressivo de Python se insistimos que tudo precisa estar sob a checagem de tipos.
+Recursos excelentes estão além da capacidade de compreensão dos checadores de tipos,
+por exemplo o desempacotamento de argumentos: `config(**settings)`.
 
-Se você quiser ter uma chamada como `config(**settings)` verificada quanto ao tipo, você precisa explicitar cada argumento.
+Se quiser ter uma chamada como `config(**settings)` verificada quanto ao tipo,
+precisa explicitar cada argumento.
 Isso me traz lembranças de programas em Turbo Pascal, que escrevi 35 anos atrás.
 
 Bibliotecas que usam metaprogramação são difíceis ou impossíveis de anotar.
-Claro que a metaprogramação pode ser mal usada, mas isso também é algo que torna muitos pacotes de Python divertidos [.keep-together]#de usar#.
+Claro que a metaprogramação pode ser mal usada,
+mas isso também é algo que torna muitos pacotes de Python divertidos de usar.
 
-Se dicas de tipo se tornarem obrigatórias sem exceções, por uma decisão superior em grande empresas, aposto que logo veremos pessoas usando geração de código para reduzir linhas de código padrão em programas Python - uma prática comum com linguagens menos dinâmicas.
+Se dicas de tipo se tornarem obrigatórias sem exceções,
+por uma decisão superior em grande empresas,
+aposto que logo veremos pessoas usando geração de código para reduzir a verbosidade em programas Python,
+uma prática comum com linguagens menos dinâmicas.
 
 Para alguns projetos e contextos, dicas de tipo simplesmente não fazem sentido.
 Mesmo em contextos onde elas fazer muito sentido, não fazem sentido o tempo todo.
@@ -2271,18 +2286,24 @@ Alan Kay, o recipiente do Turing Award que foi um dos pioneiros da programação
 
 [quote]
 ____
-Algumas pessoas são completamente religiosas no que diz respeito a sistemas de tipo, e como um matemático eu adoro a ideia de sistemas de tipos, mas ninguém até agora inventou um que tenha alcance o suficiente..footnote:[Fonte:
+Algumas pessoas são completamente religiosas no que diz respeito a sistemas de tipo,
+e como um matemático eu adoro a ideia de sistemas de tipos,
+mas ninguém até agora inventou um que tenha alcance o suficiente.footnote:[Fonte:
 https://fpy.li/8-54["A Conversation with Alan Kay"].]
 ____
 
 Obrigado, Guido, pela tipagem opcional.
-Vamos usá-la como foi pensada, e não tentar anotar tudo em conformidade estrita com um estilo de programação que se parece com Java 1.5.((("", startref="SStypehints08")))
+Vamos usá-la como foi pensada, e não tentar anotar tudo em conformidade estrita com
+um estilo de programação que se parece com Java 1.5.((("", startref="SStypehints08")))
 
 
 [role="soapbox-title"]
 Duck Typing FTW
 
-Duck typing((("Soapbox sidebars", "duck typing")))((("duck typing"))) encaixa bem no meu cérebro, e duck typing estático é um bom compromisso, permitindo checagem estática de tipo sem perder muito da flexibilidade que alguns sistemas de tipagem nominal só permitem ao custo de muita complexidade - isso quando permitem.
+Duck typing((("Soapbox sidebars", "duck typing")))((("duck typing")))
+encaixa bem no meu cérebro, e duck typing estático é um bom compromisso,
+permitindo checagem estática de tipo sem perder muito da flexibilidade que
+alguns sistemas de tipagem nominal só permitem ao custo de muita complexidade - isso quando permitem.
 
 Antes da PEP 544, toda essa ideia de dicas de tipo me parecia completamente não-pythônica,
 Fiquei muito feliz quando vi `typing.Protocol` surgir em Python.
@@ -2291,7 +2312,9 @@ Ele traz equilíbrio para a Força.
 [role="soapbox-title"]
 Genéricos ou Específicos?
 
-De((("Soapbox sidebars", "generic collections")))((("generic collections", "Soapbox discussion"))) uma perspectiva de Python, o uso do termo "genérico" na tipagem é um retrocesso.
+De((("Soapbox sidebars", "generic collections")))((("generic collections",
+"Soapbox discussion"))) uma perspectiva de Python,
+o uso do termo "genérico" na tipagem é um retrocesso.
 Os sentidos comuns do termo "genérico" são "aplicável integralmente a um grupo ou uma classe" ou "sem uma marca distintiva."
 
 Considere `list` versus `list[str]`. o primeiro é genérico: aceita qualquer objeto.

capitulos/cap11.adoc

@@ -852,7 +852,7 @@ Quando suportamos a conversão para `bytes`, também implementamos um construtor
 
 Vimos que a https://docs.python.org/pt-br/3/library/string.html#formatspec[Mini-Linguagem de Especificação de Formato] é extensível, ao implementarmos um método `+__format__+` que analisa uma `format_spec` fornecida à função embutida `format(obj, format_spec)` ou dentro de campos de substituição `'{:«format_spec»}'` em f-strings ou ainda strings usadas com o método `str.format()`.
 
-Para preparar a transformação de instâncias de `Vector2d` em _hashable_, fizemos um esforço para torná-las imutáveis, ao menos prevenindo modificações acidentais, programando os atributos `x` e `y` como privados, e expondo-os como propriedades apenas para leitura. Nós então implementamos
+Para preparar a transformação de instâncias de `Vector2d` em _hashable_, fizemos um esforço para torná-las imutáveis, ao menos prevenindo modificações acidentais, programando os atributos `x` e `y` como privados, e expondo-os como propriedades apenas para leitura. Então implementamos
 `+__hash__+` usando a técnica recomendada, aplicar o operador xor aos _hashes_ dos atributos da instância.
 
 Discutimos a seguir a economia de memória e as ressalvas de se declarar um atributo `+__slots__+` em `Vector2d`. Como o uso de `+__slots__+` tem efeitos colaterais, ele só faz real sentido quando é preciso processar um número muito grande de instâncias—pense em milhões de instâncias, não apenas milhares. Em muitos destes casos, usar a https://fpy.li/pandas[pandas] pode ser a melhor opção.
@@ -911,7 +911,11 @@ Nas((("attributes", "properties and up-front costs")))((("Pythonic objects", "So
 
 Quando sentimos a necessidade de evitar modificações acidentais dos atributos `x` e `y`, implementamos propriedades, mas nada mudou no restante do código ou na interface pública de `Vector2d`, como se verifica através dos doctests. Continuamos podendo acessar `my_vector.x` and `my_vector.y`.
 
-Isso mostra que podemos sempre iniciar o desenvolvimento de nossas classes da maneira mais simples possível, com atributos públicos, pois quando (ou se) nós mais tarde precisarmos impor mais controle, com _getters_ e _setters_, estes métodos podem ser implementados usando propriedades, sem mudar nada no código que já interage com nossos objetos através dos nomes que eram, inicialmente, simples atributos públicos (`x` e `y`, por exemplo).
+Isso mostra que podemos sempre iniciar o desenvolvimento de nossas classes da maneira mais simples possível,
+com atributos públicos, pois quando (ou se) for preciso impor mais depois, com _getters_ e _setters_,
+estes métodos podem ser implementados usando propriedades,
+sem mudar nada no código que já interage com nossos objetos através dos nomes que eram,
+inicialmente, simples atributos públicos (`x` e `y`, por exemplo).
 
 Essa abordagem é o oposto daquilo que é encorajado pela linguagem Java: um programador Java não pode começar com atributos públicos simples e apenas mais tarde, se necessário, implementar propriedades, porque elas não existem naquela linguagem. Portanto, escrever _getters_ e _setters_ é a regra em Java—mesmo quando esses métodos não fazem nada de útil—porque a API não pode evoluir de atributos públicos simples para _getters_ e _setters_ sem quebrar todo o código que já use aqueles atributos.
 

capitulos/cap12.adoc

@@ -436,7 +436,7 @@ Vamos((("Vector class, multidimensional", "__hash__
 Juntamente com o `+__eq__+` existente, isso tornará as instâncias de `Vector` _hashable_.
 
 O `+__hash__+` do `Vector2d` (no <<ex_vector2d_v3_hash>>) computava o _hash_ de uma `tuple` construída com os dois componentes, `self.x` and `self.y`.
-Nós agora podemos estar lidando com milhares de componentes, então criar uma `tuple` pode ser caro demais. Em vez disso, vou aplicar sucessivamente o operador `^` (xor) aos _hashes_ de todos os componentes, assim: `v[0] ^ v[1] ^ v[2]`. É para isso que serve a função `functools.reduce`. Anteriormente afirmei que `reduce` não é mais tão popular quanto antes,footnote:[`sum`, `any`, e `all` cobrem a maioria dos casos de uso comuns de `reduce`. Veja a discussão na <<map_filter_reduce>>.] mas computar o _hash_ de todos os componentes do vetor é um bom caso de uso para ela. A <<reduce_fig>> ilustra a ideia geral da((("reducing functions"))) função `reduce`.
+Agora podemos estar lidando com milhares de componentes, então criar uma `tuple` pode ser caro demais. Em vez disso, vou aplicar sucessivamente o operador `^` (xor) aos _hashes_ de todos os componentes, assim: `v[0] ^ v[1] ^ v[2]`. É para isso que serve a função `functools.reduce`. Anteriormente afirmei que `reduce` não é mais tão popular quanto antes,footnote:[`sum`, `any`, e `all` cobrem a maioria dos casos de uso comuns de `reduce`. Veja a discussão na <<map_filter_reduce>>.] mas computar o _hash_ de todos os componentes do vetor é um bom caso de uso para ela. A <<reduce_fig>> ilustra a ideia geral da((("reducing functions"))) função `reduce`.
 
 ////
 PROD: unexpected indent in first line after page break
@@ -635,7 +635,7 @@ Ter um loop `for` que itera sobre itens sem perder tempo com variáveis de índi
 ----
 ====
 <1> `zip` devolve um gerador que produz tuplas sob demanda.
-<2> Cria uma `list` apenas para exibição; nós normalmente iteramos sobre o gerador.
+<2> Cria uma `list` apenas para exibição; normalmente iteramos sobre o gerador.
 <3> `zip` para sem aviso quando um dos iteráveis é exaurido.
 <4> A função `itertools.zip_longest` se comporta de forma diferente: ela usa um `fillvalue` opcional (por default `None`) para preencher os valores ausentes, e assim consegue gerar tuplas até que o último iterável seja exaurido.