estilo: possui->tem; irá fazer->fará

Author: ramalho

online/cap02.adoc

@@ -638,7 +638,7 @@ Quando((("tuples", "versus lists", secondary-sortas="lists")))((("lists", "versu
 usamos uma tupla como uma variante imutável de `list`, é bom saber o quão similares são suas APIs.
 Como se pode ver na <<list_x_tuple_attrs_tbl>>,
 `tuple` suporta todos os métodos de `list` que não envolvem adicionar ou remover itens,
-com uma exceção—`tuple` não possui o método `+__reversed__+`.
+com uma exceção—`tuple` não tem o método `+__reversed__+`.
 Entretanto, `reversed(my_tuple)` funciona sem esse método; ele serve apenas para otimizar.
 
 [[list_x_tuple_attrs_tbl]]

online/cap03.adoc

@@ -293,7 +293,7 @@ Na <<mappings_flexible_sec>>, vamos estudar o `defaultdict` e
 outros mapeamentos onde buscas com chaves via `+__getitem__+`
 (isto é, `d[chave]`) funcionam porque itens ausentes são criados na hora.
 No contexto do pattern matching,
-um match é bem sucedido apenas se o sujeito já possui as chaves necessárias no início do bloco `match`.
+um match é bem sucedido apenas se o sujeito já tem as chaves necessárias no início do bloco `match`.
 
 [TIP]
 ====
@@ -448,7 +448,7 @@ A <<mapping_methods_tbl>> mostra os métodos implementados por `dict` e pelas va
 
 A forma como `d.update(m)` lida com seu primeiro argumento, `m`,
 é um excelente exemplo((("duck typing"))) de _duck typing_ (_tipagem pato_):
-ele primeiro verifica se `m` possui um método `keys` e, em caso afirmativo,
+ele primeiro verifica se `m` tem um método `keys` e, em caso afirmativo,
 assume que `m` é um mapeamento.
 Caso contrário, `update()` reverte para uma iteração sobre `m`,
 presumindo que seus item são pares `(chave, valor)`.

online/cap04.adoc

@@ -215,7 +215,7 @@ causando muitas dores de cabeça nos desenvolvedores que lidam com dados binári
 A decisão está documentada na
 https://fpy.li/pep461[PEP 461--Adding % formatting to bytes and bytearray (_Acrescentando formatação com % a bytes e bytearray_)]. (EN)]
 
-As sequências binárias têm um método de classe que `str` não possui, chamado `fromhex`,
+As sequências binárias têm um método de classe que `str` não tem, chamado `fromhex`,
 que cria uma sequência binária a partir da análise de pares de dígitos hexadecimais,
 separados opcionalmente por espaços:
 

online/cap05.adoc

@@ -751,7 +751,7 @@ Vamos examinar uma instância de `DemoNTClass`:
 Para criar `nt`, precisamos passar pelo menos o argumento `a` para `DemoNTClass`.
 O construtor também aceita um argumento `b`,
 mas como este último tem um valor default (de `1.1`), ele é opcional.
-Como esperado, o objeto `nt` possui os atributos `a` e `b`;
+Como esperado, o objeto `nt` tem os atributos `a` e `b`;
 ele não tem um atributo `c`, mas Python obtém `c` da classe, como de hábito.
 
 Se você tentar atribuir valores para `nt.a`, `nt.b`, `nt.c`, ou mesmo para `nt.z`,
@@ -1790,7 +1790,7 @@ Entre outras coisas, ele diz:
 [quote]
 ____
 Diz a lenda que o atributo mais importante de Guido, além do próprio Python,
-é a máquina do tempo de Guido, um aparelho que dizem que ele possui por causa da
+é a máquina do tempo de Guido, um aparelho que dizem que ele tem por causa da
 frequência irritante com que pedidos de usuários por novos recursos
 recebem como resposta "Acabei de implementar isso noite passada..."
 ____

online/cap08.adoc

@@ -483,7 +483,7 @@ def double(x: abc.Sequence):
     return x * 2
 ----
 
-Um checador de tipos irá rejeitar esse código.
+Um checador de tipos rejeitará este código.
 Se você informar ao Mypy que `x` é do tipo `abc.Sequence`, ele vai marcar `x * 2` como erro,
 pois a https://fpy.li/8-13[`Sequence` ABC] não implementa ou herda o método `+__mul__+`.
 Durante a execução, o código vai funcionar com sequências concretas

online/cap16.adoc

@@ -552,7 +552,7 @@ reverso em sua classe.
 No espírito da tipagem pato, não vamos testar o tipo do operando `other` ou o
 tipo de seus elementos. Vamos capturar as exceções e devolver `NotImplemented`.
 Se o interpretador ainda não tiver invertido os operandos, tentará isso em seguida.
-Se a invocação do método reverso devolver `NotImplemented`, então Python irá
+Se a invocação do método reverso devolver `NotImplemented`, então Python vai
 gerar um `TypeError` com uma mensagem de erro padrão "unsupported operand
 type(s) for +: 'Vector' and 'str'” (_tipos de operandos não suportados para +:
 `Vector` e `str`_)

online/cap17.adoc

@@ -401,7 +401,7 @@ StopIteration
 <2> Obtém um iterador a partir de `s3`.
 <3> `next(it)` devolve a próxima palavra.
 <4> Não há mais palavras, então o iterador gera uma exceção `StopIteration`.
-<5> Uma vez exaurido, um itereador irá sempre gerar `StopIteration`, o que faz parecer que ele está vazio..
+<5> Uma vez exaurido, um itereador vai sempre gerar `StopIteration`, o que faz parecer que ele está vazio..
 <6> Para percorrer a sentença novamente é preciso criar um novo iterador.
 
 Como os únicos métodos exigidos de um iterador são `+__next__+` e `+__iter__+`, não há como checar se há itens restantes, exceto invocando `next()` e capturando `StopIteration`.
@@ -470,8 +470,11 @@ Iteradores implementam um método `+__next__+`, que devolve itens individuais, e
 
 Assim, iteradores também são iteráveis, mas iteráveis não são iteradores.
 
-Pode ser tentador implementar `+__next__+` além de `+__iter__+` na classe `Sentence`, tornando cada instância de `Sentence` ao mesmo tempo um iterável e um iterador de si mesma.
-Mas raramente isso é uma boa ideia. Também é um anti-padrão comum, de acordo com Alex Martelli, que possui vasta experiência revisando código no Google.
+Pode ser tentador implementar `+__next__+` além de `+__iter__+` na classe
+`Sentence`, tornando cada instância de `Sentence` ao mesmo tempo um iterável e
+um iterador de si mesma. Mas raramente isso é uma boa ideia. Também é um
+anti-padrão comum, de acordo com Alex Martelli, que tem vasta experiência
+revisando código no Google.
 
 A seção "Aplicabilidade" do padrão de projeto _Iterator_ no livro _Padrões de Projeto_ diz:
 
@@ -1589,7 +1592,7 @@ BaseException
 ----
 
 O próximo pequeno passo nos leva ao nível 1.
-A geradora `tree` irá produzir o nome da classe raiz e os nomes de cada subclasse direta.
+A geradora `tree` produzirá o nome da classe raiz e os nomes de cada subclasse direta.
 Os nomes das subclasses são indentados para explicitar a hierarquia.
 Esta é a saída que queremos:
 

online/cap19.adoc

@@ -283,7 +283,7 @@ A função `supervisor`, que aparece no <<spinner_thread_rest_ex>>, usa um `Even
 include::../code/19-concurrency/spinner_thread.py[tags=SPINNER_THREAD_REST]
 ----
 ====
-<1> `supervisor` irá retornar o resultado de `slow`.
+<1> `supervisor` retornará o resultado de `slow`.
 <2> A instância de `threading.Event` é a chave para coordenar as atividades das threads `main` e `spinner`, como explicado abaixo.
 <3> Para criar uma nova `Thread`, forneça uma função como argumento palavra-chave `target`, e argumentos posicionais para a `target` como uma tupla passada via `args`.
 <4> Mostra o objeto `spinner`. A saída é `<Thread(Thread-1, initial)>`, onde `initial`
@@ -377,7 +377,7 @@ include::../code/19-concurrency/spinner_async.py[tags=SPINNER_ASYNC_START]
 ----
 ====
 <1> `main` é a única função regular definida nesse programa—as outras são corrotinas.
-<2> A função`asyncio.run` inicia o loop de eventos para controlar a corrotina que irá em algum momento colocar as outras corrotinas em movimento.
+<2> A função`asyncio.run` inicia o loop de eventos para controlar a corrotina que em algum momento colocará as outras corrotinas em movimento.
 A função `main` ficará bloqueada até que `supervisor` retorne.
 O valor de retorno de `supervisor` será o valor de retorno de `asyncio.run`.
 <3> Corrotinas nativas são definidas com `async def`.

online/cap22.adoc

@@ -124,7 +124,7 @@ o método `keys` é um atributo do `dict` `__data`.
 
 Uma instância de  `FrozenJSON` contém um atributo de instância privado `+__data+`, armazenado sob o nome `++_FrozenJSON__data++`, como explicado na <<private_protected_sec>>.
 Tentativas de recuperar atributos por outros nomes vão disparar `+__getattr__+`.
-Esse método irá primeiro olhar se o `dict` `+self.__data+`  contém um atributo (não uma chave!) com aquele nome; isso permite que instâncias de `FrozenJSON` tratem métodos de `dict` tal como `items`, delegando para `+self.__data.items()+`. Se `+self.__data+` não contiver uma atributo como o `name` dado, `+__getattr__+` usa `name` como chave para recuperar um item de `+self.__data+`, e passa aquele item para `FrozenJSON.build`. Isso permite navegar por estruturas aninhadas nos dados JSON, já que cada mapeamento aninhado é convertido para outra instância de `FrozenJSON` pelo método de classe `build`.
+Primeiro, esse método verá se o `dict` `+self.__data+`  contém um atributo (não uma chave!) com aquele nome; isso permite que instâncias de `FrozenJSON` tratem métodos de `dict` tal como `items`, delegando para `+self.__data.items()+`. Se `+self.__data+` não contiver uma atributo como o `name` dado, `+__getattr__+` usa `name` como chave para recuperar um item de `+self.__data+`, e passa aquele item para `FrozenJSON.build`. Isso permite navegar por estruturas aninhadas nos dados JSON, já que cada mapeamento aninhado é convertido para outra instância de `FrozenJSON` pelo método de classe `build`.
 
 Observe que `FrozenJSON` não transforma ou armazena o conjunto de dados original.
 Conforme navegamos pelos dados, `+__getattr__+` cria continuamente instâncias de `FrozenJSON`.
@@ -470,16 +470,23 @@ include::../code/22-dyn-attr-prop/oscon/schedule_v3.py[tags=SCHEDULE3_SPEAKERS]
 do `+__dict__+` da instância, para evitar uma chamada recursiva à propriedade `speakers`.
 <2> Devolve uma lista de todos os registros com chaves correspondendo aos números em `spkr_serials`.
 
-Dentro do método `speakers`, tentar ler `self.speakers` irá invocar a própria propriedade, gerando rapidamente um `RecursionError`.
-Entretanto, se lemos os mesmos dados via `+self.__dict__['speakers']+`, o algoritmo normal de Python para busca e recuperação de atributos é ignorado, a propriedade não é chamada e a recursão é evitada.
-Por essa razão, ler ou escrever dados diretamente no `+__dict__+` de um objeto é um truque comum em metaprogramação no Python.
+Dentro do método `speakers`, uma tentativa de ler `self.speakers` invocará a
+mesma propriedade, gerando rapidamente um `RecursionError`. Entretanto,
+acessando via `+self.__dict__['speakers']+`, evitamos o algoritmo de Python para
+busca de atributos, a propriedade não é chamada e evitamos a recursão. Por esta
+razão, ler ou escrever dados diretamente no `+__dict__+` de um objeto é um
+truque comum em metaprogramação no Python.
 
 [WARNING]
 ====
-O interpretador avalia `+obj.my_attr+` olhando primeiro a classe de `obj`.
-Se a classe possuir uma propriedade de nome `my_attr`, aquela propriedade oculta um atributo de instância com o mesmo nome.
-Isso será demonstrado por exemplos na <<prop_override_instance>>,
-e o <<ch_descriptors>> vai revelar que uma propriedade é implementada como um descritor—uma abstração mais geral e poderosa.
+
+O interpretador avalia `+obj.my_attr+` olhando primeiro a classe de `obj`. Se a
+classe tiver uma propriedade de nome `my_attr`, aquela propriedade oculta um
+atributo de instância com o mesmo nome. Isso será demonstrado por exemplos na
+<<prop_override_instance>>, e o <<ch_descriptors>> vai revelar que uma
+propriedade é implementada como um descritor—uma abstração mais geral e
+poderosa.
+
 ====
 
 Quando programava a compreensão de lista no <<ex_schedule_v3_speakers>>, meu cérebro réptil de programador pensou: "Isso talvez seja custoso". Na verdade não é, porque os eventos no conjuntos de dados da OSCON contêm poucos palestrantes, então programar algo mais complexo seria uma otimização prematura.

vol1/cap02.adoc

@@ -640,7 +640,7 @@ Quando((("tuples", "versus lists", secondary-sortas="lists")))((("lists", "versu
 usamos uma tupla como uma variante imutável de `list`, é bom saber o quão similares são suas APIs.
 Como se pode ver na <<list_x_tuple_attrs_tbl>>,
 `tuple` suporta todos os métodos de `list` que não envolvem adicionar ou remover itens,
-com uma exceção—`tuple` não possui o método `+__reversed__+`.
+com uma exceção—`tuple` não tem o método `+__reversed__+`.
 Entretanto, `reversed(my_tuple)` funciona sem esse método; ele serve apenas para otimizar.
 
 <<<