uniformizar termos

Author: ramalho

capitulos/cap01.adoc

@@ -347,7 +347,7 @@ structfootnote:[Uma struct do C é um tipo de registro com campos nomeados.]
 chamada `PyVarObject`, com um campo `ob_size` que registra a quantidade de itens na coleção.
 Então, se `my_object` é uma instância de algum daqueles tipos embutidos,
 `len(my_object)` devolve diretamente valor do campo `ob_size`,
-e isso é muito mais rápido que chamar um método.
+e isso é mais rápido que chamar um método.
 
 Na maior parte das vezes, a chamada a um método especial é implícita.
 Por exemplo, o comando `for i in x:` na verdade gera uma invocação de `iter(x)`,
@@ -356,7 +356,7 @@ ou usar `+x.__getitem__()+`, como no exemplo do `FrenchDeck`.
 
 Em condições normais, seu código não deveria conter muitas chamadas diretas a métodos especiais.
 A menos que você esteja fazendo muita metaprogramação,
-implementar métodos especiais deve ser muito mais frequente que invocá-los explicitamente.
+implementar métodos especiais deve ser mais frequente que invocá-los explicitamente.
 O((("__init__")))
 único método especial que é chamado frequentemente pelo seu código é `+__init__+`,
 para invocar a inicialização da superclasse na implementação do seu próprio `+__init__+`.
@@ -460,7 +460,7 @@ 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 <<ch_op_overload>>.
+Vou falar mais sobre esse tópico no <<ch_op_overload>>.
 
 [WARNING]
 ====
@@ -829,7 +829,7 @@ daí sua sintaxe para `for/range` estar limitada a suportar cinco tipos "mágico
 incluindo arrays, strings e mapas.
 
 Talvez, no futuro, os projetistas de Go melhorem seu protocolo de metaobjetos.
-Em 2021, ele ainda é muito mais limitado do que Python, Ruby, e JavaScript oferecem.
+Em 2021, ele ainda é mais limitado do que Python, Ruby, e JavaScript oferecem.
 
 
 [role="soapbox-title"]

capitulos/cap02.adoc

@@ -101,7 +101,7 @@ O objeto Python mais simples, um `float`, tem um campo de valor e dois campos de
 * `ob_fval`: um `double` de C mantendo o valor do `float`
 
 No Python 64-bits, cada um desses campos ocupa 8 bytes.
-Por isso um array de números de ponto flutuante é muito mais compacto que uma tupla de números de ponto flutuante:
+Por isso um array de números de ponto flutuante é mais compacto que uma tupla de números de ponto flutuante:
 o array é um único objeto contendo apenas o valor dos números,
 enquanto a tupla consiste de vários objetos—a própria tupla e cada objeto `float` que ela contém.
 ====
@@ -537,7 +537,7 @@ O((("tuples", "tuple unpacking"))) termo "desempacotamento de tuplas" (_tuple un
 e está ganhando popularidade, como no título da
 https://fpy.li/2-2[PEP 3132 -- Extended Iterable Unpacking (_Desempacotamento Estendido de Iteráveis_)].
 
-A <<iterable_unpacking_sec>> fala muito mais sobre desempacotamento,
+A <<iterable_unpacking_sec>> fala mais sobre desempacotamento,
 não apenas de tuplas, mas também de sequências e iteráveis em geral.
 ====
 
@@ -1271,7 +1271,7 @@ mas deve ser uma sequência começando com um `Symbol` na sintaxe de `define` pa
 
 Agora pense em quanto trabalho teríamos para adicionar o suporte a essa segunda sintaxe de `define`
 sem a ajuda do _pattern matching_ no <<ex_norvigs_eval>>.
-A instrução `match` faz muito mais que o `switch` das linguagens similares ao C.
+A instrução `match` faz mais que o `switch` das linguagens similares ao C.
 
 O _pattern matching_ é um exemplo de programação declarativa:
 o código descreve "o que" você quer casar,

capitulos/cap03.adoc

@@ -937,7 +937,7 @@ include::code/03-dict-set/strkeydict.py[tags=STRKEYDICT]
 <3> `+__contains__+` é mais simples: podemos assumir que todas as chaves armazenadas são `str`,
 e podemos operar sobre `self.data` em vez de invocar `self.keys()`, como fizemos em `StrKeyDict0`.
 <4> `+__setitem__+` converte qualquer `key` para uma `str`.
-Esse método é mais fácil de sobrepor quando podemos delegar para o atributo `self.data`.
+Esse método é mais fácil de  sobrescrever quando podemos delegar para o atributo `self.data`.
 
 Como `UserDict` estende `abc.MutableMapping`, o restante dos métodos que fazem de `StrKeyDict`
 um mapeamento completo são herdados de `UserDict`, `MutableMapping`, ou `Mapping`.

capitulos/cap04.adoc

@@ -903,7 +903,7 @@ No((("\N{} (Unicode literals escape notation)")))((("Unicod
 escrevendo o nome oficial do caractere dentro do `\N{}`.
 Isso é bastante prolixo, mas explícito e seguro:
 Python gera um `SyntaxError` se o nome não existir—bem melhor que escrever um número hexadecimal que pode estar errado,
-mas isso só será descoberto muito mais tarde.
+mas isso só será descoberto mais tarde.
 De qualquer forma, você provavelmente vai querer escrever um comentário explicando os códigos numéricos dos caracteres,
 então a verbosidade do `\N{}` é fácil de aceitar.
 ====
@@ -995,7 +995,7 @@ então a E/S entende e exibe todos os caracteres Unicode.
 No Windows, não apenas codificações diferentes são usadas no mesmo sistema,
 elas também são, normalmente, páginas de código como `'cp850'` ou `'cp1252'`, que suportam só o ASCII
 com 127 caracteres adicionais (que por sua vez são diferentes de uma codificação para a outra).
-Assim, usuários de Windows tem muito mais chances de encontrar erros de codificação.
+Assim, usuários de Windows tem mais chances de encontrar erros de codificação.
 ====
 
 Resumindo, a configuração de codificação mais importante devolvida por `locale.getpreferredencoding()`
@@ -1270,7 +1270,7 @@ https://en.wikipedia.org/wiki/S%C3%A3o_Paulo
 ----
 
 O trecho `%C3%A3` é a renderização em UTF-8 de uma única letra,
-o "ã" ("a" com til). A forma a seguir é muito mais fácil de reconhecer, mesmo com a ortografia incorreta:
+o "ã" ("a" com til). A forma a seguir é mais fácil de reconhecer, mesmo com a ortografia incorreta:
 
 ----
 https://en.wikipedia.org/wiki/Sao_Paulo

capitulos/cap05.adoc

@@ -159,7 +159,7 @@ tipos como `**fields_and_types`.
 Desde Python 3.6, `typing.NamedTuple` pode também ser usada em uma instrução `class`,
 com as anotações de tipo escritas como descrito na
 https://fpy.li/pep526[PEP 526—Syntax for Variable Annotations (_Sintaxe para Anotações de Variáveis_)] (EN).
-É muito mais legível, e torna fácil sobrepor métodos ou acrescentar métodos novos.
+É mais legível, e torna fácil  sobrescrever métodos ou acrescentar métodos novos.
 O <<coord_tuple_ex>> é a mesma classe `Coordinate`, com um par de atributos `float`
 e um `+__str__+` personalziado, para mostrar a coordenada no formato 55.8°N, 37.6°E.
 //  as shown in <<coord_tuple_ex>>.
@@ -1810,7 +1810,7 @@ Se existissem atributos de classe, eles estariam na terceira linha.
 
 Python sempre teve uma forma fácil de declarar um atributo de classe,
 se ele tiver um valor inicial.
-Mas atributos de instância são muito mais comuns,
+Mas atributos de instância são mais comuns,
 e os programadores Python tem sido obrigados a olhar dentro do método `+__init__+` para encontrá-los,
 sempre temerosos que podem existir atributos de instância sendo criados
 em outro lugar na classe—ou mesmo por funções e métodos de outras classes.

capitulos/cap06.adoc

@@ -111,7 +111,7 @@ Por exemplo, quando discutia sobre um objeto representando uma gangorra em uma s
 ela dizia:
 “A variável g foi atribuída à gangorra”, mas nunca “A gangorra foi atribuída à variável g”.
 Com variáveis de referência,
-faz muito mais sentido dizer que a variável é atribuída a um objeto, não o contrário.
+faz mais sentido dizer que a variável é atribuída a um objeto, não o contrário.
 Afinal, o objeto é criado antes da atribuição.
 <<ex_var_assign_after>> prova que o lado direito de uma atribuição é processado primeiro.
 
@@ -1198,7 +1198,7 @@ Aprendi((("object references", "Soapbox discussion")))((("Soapbox sidebars",
 "equality (&#x3D;&#x3D;) operator")))((("&#x3D;&#x3D; (equality) operator")))((("equality (&#x3D;&#x3D;) operator")))
 Java antes de conhecer Python.
 O operador `==` em Java sempre me pareceu equivocado.
-É muito mais comum que programadores estejam preocupados com a igualdade que com a identidade.
+É mais comum que programadores estejam preocupados com a igualdade que com a identidade.
 Mas para objetos (não tipos primitivos), o `==` em Java compara referências, não valores dos objetos.
 Mesmo para algo tão básico quanto comparar strings,
 Java obriga você a usar o método `.equals`.

capitulos/cap07.adoc

@@ -4,7 +4,7 @@
 [quote, Guido van Rossum, BDFL de Python]
 ____
 Nunca achei que Python tenha sido fortemente influenciado por linguagens funcionais, independente do que outros digam ou pensem.
-Eu estava muito mais familiarizado com linguagens imperativas, como o C e o Algol e, apesar de ter tornado as funções objetos de primeira classe, não via Python como uma linguagem funcional.footnote:[https://fpy.li/7-1["Origins of Python's 'Functional' Features" (_As origens dos recursos 'funcionais' de Python_—EN)], do blog The History of Python (A História de Python) do próprio Guido.]footnote:["Benevolent Dictator For Life." - Ditador Benevolente Vitalício. Veja Guido van van Rossum em https://fpy.li/bdfl["Origin of BDFL" (_A Origem do BDFL_)] (EN).]
+Eu estava mais familiarizado com linguagens imperativas, como o C e o Algol e, apesar de ter tornado as funções objetos de primeira classe, não via Python como uma linguagem funcional.footnote:[https://fpy.li/7-1["Origins of Python's 'Functional' Features" (_As origens dos recursos 'funcionais' de Python_—EN)], do blog The History of Python (A História de Python) do próprio Guido.]footnote:["Benevolent Dictator For Life." - Ditador Benevolente Vitalício. Veja Guido van van Rossum em https://fpy.li/bdfl["Origin of BDFL" (_A Origem do BDFL_)] (EN).]
 ____
 
 No Python, funções((("objects", "first-class")))((("first-class objects")))((("functions, as first-class objects", "definition of term"))) são objetos de primeira classe. Estudiosos de linguagens de programação definem um "objeto de primeira classe" como uma entidade programática que pode ser:

capitulos/cap11.adoc

@@ -107,7 +107,7 @@ include::code/11-pythonic-obj/vector2d_v0.py[tags=VECTOR2D_V0]
 ====
 <1> `typecode` é um atributo de classe, usado na conversão de instâncias de `Vector2d` de/para `bytes`.
 <2> Converter `x` e `y` para `float` em `+__init__+` captura erros mais rápido, algo útil quando `Vector2d` é chamado com argumentos inadequados.
-<3> `+__iter__+` torna um `Vector2d` iterável; é isso que faz o desempacotamento funcionar (por exemplo, `x, y = my_vector`). Vamos implementá-lo aqui usando uma expressão geradora para produzir os componentes, um após outro.footnote:[Essa linha também poderia ser escrita assim: `yield self.x; yield.self.y`. Terei muito mais a dizer sobre o método especial `+__iter__+`, sobre expressões geradoras e sobre a palavra reservada `yield` no <<ch_generators>>.]
+<3> `+__iter__+` torna um `Vector2d` iterável; é isso que faz o desempacotamento funcionar (por exemplo, `x, y = my_vector`). Vamos implementá-lo aqui usando uma expressão geradora para produzir os componentes, um após outro.footnote:[Essa linha também poderia ser escrita assim: `yield self.x; yield.self.y`. Terei mais a dizer sobre o método especial `+__iter__+`, sobre expressões geradoras e sobre a palavra reservada `yield` no <<ch_generators>>.]
 <4> O `+__repr__+` cria uma string interpolando os componentes com `{!r}`, para obter seus `repr`; como `Vector2d` é iterável, `*self` alimenta `format` com os componentes `x` e `y`.
 <5> Dado um iterável `Vector2d`, é fácil criar uma `tuple` para exibição como um par ordenado.
 <6> Para gerar `bytes`, convertemos o typecode para `bytes` e concatenamos...
@@ -306,7 +306,7 @@ onde `r` é a magnitute e θ (theta) é o ângulo em radianos. O restante do esp
 
 [TIP]
 ====
-Ao escolher a letra para um código personalizado de formato, evitei sobrepor códigos usados por outros tipos. Na https://docs.python.org/pt-br/3/library/string.html#formatspec[Mini-Linguagem de Especificação de Formato] vemos que inteiros usam os códigos `'bcdoxXn'`, `floats` usam `'eEfFgGn%'` e strings usam `'s'`. Então escolhi `'p'` para coordenadas polares. Como cada classe interpreta esses códigos de forma independente, reutilizar uma letra em um formato personalizado para um novo tipo não é um erro, mas pode ser confuso para os usuários.
+Ao escolher a letra para um código personalizado de formato, evitei  sobrescrever códigos usados por outros tipos. Na https://docs.python.org/pt-br/3/library/string.html#formatspec[Mini-Linguagem de Especificação de Formato] vemos que inteiros usam os códigos `'bcdoxXn'`, `floats` usam `'eEfFgGn%'` e strings usam `'s'`. Então escolhi `'p'` para coordenadas polares. Como cada classe interpreta esses códigos de forma independente, reutilizar uma letra em um formato personalizado para um novo tipo não é um erro, mas pode ser confuso para os usuários.
 ====
 
 Para gerar coordenadas polares, já temos o método `+__abs__+` para a magnitude. Vamos então escrever um método `angle` simples, usando a função `math.atan2()`, para obter o ângulo. Eis o código:
@@ -805,7 +805,7 @@ ShortVector2d(0.09090909090909091, 0.037037037037037035)  # <3>
 9
 ----
 ====
-<1> Cria `ShortVector2d` como uma subclasse de `Vector2d` apenas para sobrepor o atributo de classe `typecode`.
+<1> Cria `ShortVector2d` como uma subclasse de `Vector2d` apenas para  sobrescrever o atributo de classe `typecode`.
 <2> Cria `sv`, uma instância de `ShortVector2d`, para demonstração.
 <3> Verifica o `repr` de `sv`.
 <4> Verifica que a quantidade de bytes exportados é 9, e não 17 como antes.

capitulos/cap12.adoc

@@ -749,7 +749,7 @@ O último aperfeiçoamento a `Vector` foi reimplementar o método `+__format__+`
 
 Como fizemos no <<ch_pythonic_obj>>, muitas vezes aqui olhamos como os objetos padrão de Python se comportam, para emulá-los e dar a `Vector` uma aparência "pythônica".
 
-No <<ch_op_overload>> vamos implemenar vários operadores infixos em `Vector`. A matemática será muito mais simples que aquela no método `angle()` daqui, mas explorar como os operadores infixos funcionam no Python é uma grande lição sobre design orientado a objetos. Mas antes de chegar à sobrecarga de operadores, vamos parar um pouco de trabalhar com uma única classe e olhar para a organização de múltiplas classes com interfaces e herança, os assuntos dos capítulos pass:[<a data-type="xref" href="#ch_ifaces_prot_abc" data-xrefstyle="select: labelnumber">#ch_ifaces_prot_abc</a>] e pass:[<a data-type="xref" href="ch_inheritance" data-xrefstyle="select: labelnumber">ch_inheritance</a>].
+No <<ch_op_overload>> vamos implemenar vários operadores infixos em `Vector`. A matemática será mais simples que aquela no método `angle()` daqui, mas explorar como os operadores infixos funcionam no Python é uma grande lição sobre design orientado a objetos. Mas antes de chegar à sobrecarga de operadores, vamos parar um pouco de trabalhar com uma única classe e olhar para a organização de múltiplas classes com interfaces e herança, os assuntos dos capítulos pass:[<a data-type="xref" href="#ch_ifaces_prot_abc" data-xrefstyle="select: labelnumber">#ch_ifaces_prot_abc</a>] e pass:[<a data-type="xref" href="ch_inheritance" data-xrefstyle="select: labelnumber">ch_inheritance</a>].
 
 
 === Leitura complementar