formatação

Author: ramalho

vol1/.gitignore

@@ -1 +1 @@
-*.pdf
+vol1.pdf

vol1/cap03.adoc

@@ -438,7 +438,7 @@ A <<mapping_methods_tbl>> mostra os métodos implementados por `dict` e pelas va
 |       `d.pop(k, [default])` |  ●   |      ●      |      ●      | Remove e devolve valor em `k`, ou `default` ou `None`, se `k` não existir
 |               `d.popitem()` |  ●   |      ●      |      ●      | Remove e devolve, na forma `(chave, valor)`, o último item inseridofootnote:[`OrderedDict.popitem(last=False)` remove o primeiro item inserido (FIFO). O argumento nomeado `last` não é suportado por `dict` ou `defaultdict`, pelo menos até Python 3.10b3.]
 |          `+d.__reversed__()+` |  ●   |      ●      |      ●      | Suporte a `reverse(d)`—devolve um iterador de chaves, da última para a primeira a serem inseridas
-|          `+d.__ror__(other)+` |  ●   |      ●      |      ●      | Suporte a `other \| dd`—operador de união reverso (Python ≥ 3.9)footnote:[Operadores reversos são tratados no «Capítulo 16» [.small]#&#91;vol.2, fpy.li/4r&#93;.&#93;#
+|          `+d.__ror__(other)+` |  ●   |      ●      |      ●      | Suporte a `other \| dd`—operador de união reverso (Python ≥ 3.9)footnote:[Operadores reversos são tratados no «Capítulo 16» [.small]#&#91;vol.2, fpy.li/4r&#93;.&#93;#]
 |`d.setdefault(k, [default])` |  ●   |      ●      |      ●      | Se `k in d`, devolve `d[k]`; senão, atribui `d[k] = default` e devolve isso
 |       `+d.__setitem__(k, v)+` |  ●   |      ●      |      ●      | `d[k] = v`—coloca `v` em `k`
 |   `d.update(m, [**kwargs])` |  ●   |      ●      |      ●      | Atualiza `d` com itens de um mapeamento ou iterável de pares `(chave, valor)`
@@ -916,7 +916,7 @@ A principal razão pela qual é melhor criar uma subclasse de `UserDict` em vez
 que o tipo embutido tem alguns atalhos de implementação,
 que acabam nos obrigando a sobrescrever métodos que poderíamos apenas herdar de `UserDict`
 sem maiores problemas.footnote:[O problema exato de se criar subclasses de `dict` e de outros tipos embutidos
-é tratado na «Seção 14.3» [.small]#&#91;vol.2, fpy.li/4z&#93;.&#93;#
+é tratado na «Seção 14.3» [.small]#&#91;vol.2, fpy.li/4z&#93;.&#93;#.]
 
 Observe que `UserDict` não herda de `dict`, mas usa uma composição:
 a classe tem uma instância interna de `dict`, chamada `data`, que mantém os itens propriamente ditos.

vol1/cap06.adoc

@@ -69,7 +69,7 @@ Em 1997, ((("object references", "variables as labels versus boxes", id="ORvar06
 "as labels versus boxes", secondary-sortas="labels versus boxes", id="Vlabel06")))
 fiz um curso de verão sobre Java no MIT.
 A professora Lynn Steinfootnote:[Lynn Andrea Stein é uma aclamada educadora de ciências da computação.
-Ela «atualmente leciona na Olin College of Engineering (EN)» [.small]#[fpy.li/6-1]#.]
+Ela atualmente leciona no «Olin College of Engineering» [.small]#[fpy.li/6-1]#.]
 explicou que a metáfora comum, de “variáveis como caixas”,
 na verdade atrapalha o entendimento de variáveis de
 referência em linguagens orientadas a objetos.
@@ -258,6 +258,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, 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()`
@@ -276,7 +277,7 @@ diferentes--pode não ser viável usar `is`.
 
 
 [[choosing_eq_v_is_sec]]
-==== Escolhendo Entre == e is
+==== Escolhendo entre == e is
 
 O operador ((("is operator"))) `==` compara os valores de objetos (os dados que eles contêm),
 enquanto `is` compara suas identidades.
@@ -435,14 +436,15 @@ Mas se existirem itens mutáveis, isso pode gerar surpresas desagradáveis.
 Em <<ex_shallow_copy>> criamos uma lista contendo outra lista e uma tupla,
 e então fazemos algumas mudanças para ver como isso afeta os objetos referenciados.
 
+<<<
 [TIP]
 ====
-Se você tem um computador conectado à internet disponível,
-recomendo fortemente que você assista à animação interativa do
-<<ex_shallow_copy>> em «Online Python Tutor» [.small]#&#91;fpy.li/6-3&#93;#.
+Se você está conectado à internet,
+recomendo que assista à animação interativa do
+<<ex_shallow_copy>> no «_Online Python Tutor_» [.small]#&#91;fpy.li/6-3&#93;#.
 No momento em que escrevo, o link direto para um exemplo pronto no _pythontutor.com_
-não estava funcionando de forma estável.
-Mas a ferramenta é ótima, então vale a pena gastar seu tempo copiando e colando o código.
+não funciona sempre.
+Mas a ferramenta é ótima, então vale a pena investir o tempo copiando e colando o código.
 ====
 
 
@@ -463,7 +465,7 @@ print('l1:', l1)
 print('l2:', l2)
 ----
 ====
-<1> `l2` é uma cópia rasa de `l1`. Este estado está representado em <<shallow_copy1>>.
+<1> `l2` é uma cópia rasa de `l1`. Este estado está representado na <<shallow_copy1>>.
 <2> Concatenar `100` a `l1` não tem qualquer efeito sobre `l2`.
 <3> Aqui removemos `55` da lista interna `l1[1]`. Isso afeta `l2`,
 pois `l2[1]` está associado à mesma lista em `l1[1]`.
@@ -476,15 +478,15 @@ Isso é equivalente a fazer `l2[2] = l2[2] + (10, 11)`.
 Agora as tuplas na última posição de `l1` e `l2` não são mais o mesmo objeto.
 Veja <<shallow_copy2>>.
 
+A saída do <<ex_shallow_copy>> está no <<ex_shallow_copy_out>>,
+e o estado final dos objetos está representado na <<shallow_copy2>>.
+
 [[shallow_copy1]]
 .Estado do programa imediatamente após a atribuição `l2 = list(l1)` em <<ex_shallow_copy>>. `l1` e `l2` se referem a listas diferentes, mas as listas compartilham referências para os mesmos objetos internos, a lista `[66, 55, 44]` e para a tupla `(7, 8, 9)`. (Diagrama gerado pelo Online Python Tutor)
-image::../images/flpy_0603.png[References diagram]
-
-A saída de <<ex_shallow_copy>> é <<ex_shallow_copy_out>>,
-e o estado final dos objetos está representado em <<shallow_copy2>>.
+image::../images/flpy_0603.png[align="left",pdfwidth=8cm]
 
 [[ex_shallow_copy_out]]
-.Saída de <<ex_shallow_copy>>
+.Saída do <<ex_shallow_copy>>
 ====
 [source, python]
 ----
@@ -497,7 +499,7 @@ l2: [3, [66, 44, 33, 22], (7, 8, 9, 10, 11)]
 
 [[shallow_copy2]]
 .Estado final de `l1` e `l2`: elas ainda compartilham referências para o mesmo objeto lista, que agora contém `[66, 44, 33, 22]`, mas a operação `l2[2] += (10, 11)` criou uma nova tupla com conteúdo `(7, 8, 9, 10, 11)`, sem relação com a tupla `(7, 8, 9)` referenciada por `l1[2]`. (Diagrama gerado pelo Online Python Tutor.)
-image::../images/flpy_0604.png[References diagram]
+image::../images/flpy_0604.png[align="left",pdfwidth=10cm]
 
 Já deve estar claro que cópias rasas são fáceis de criar,
 mas podem ou não ser o que você quer.
@@ -726,8 +728,8 @@ True
 <7> O problema: `bus2.passengers` e `bus3.passengers` se referem à mesma lista.
 <8> Mas `bus1.passengers` é uma lista diferente.
 
-O problema é que instâncias de `HauntedBus` que não recebem uma lista de passageiros
-inicial acabam todas compartilhando a mesma lista de passageiros entre si.
+O problema é que objetos `HauntedBus` que não recebem uma lista de passageiros
+inicial compartilham a mesma lista de passageiros entre si.
 
 Este tipo de bug pode ser muito sutil.
 Como o <<demo_haunted_bus>> demonstra,
@@ -740,9 +742,9 @@ quando o módulo é carregado—e os valores default se tornam atributos do obje
 Assim, se o valor default é um objeto mutável e você o altera,
 a alteração vai afetar todas as futuras chamadas da função.
 
-Após executar as linhas do <<demo_haunted_bus>>,
-você pode inspecionar o objeto `+HauntedBus.__init__+`
-e ver os estudantes fantasma assombrando o atributo `+__defaults__+`:
+Depois de rodar o <<demo_haunted_bus>>,
+podemos inspecionar o objeto `+HauntedBus.__init__+`
+e ver fantasmas de estudantes assombrando o atributo `+__defaults__+`:
 
 [source, python]
 ----
@@ -805,16 +807,17 @@ perspectiva de um cliente daquela classe, em <<demo_twilight_bus>>.
 <3> O `bus` deixa uma estudante, depois outra.
 <4> As passageiras desembarcadas desapareceram do time de basquete!
 
+<<<
 `TwilightBus` viola o "Princípio da Menor Surpresa", uma boa prática do design de
-interfaces.footnote:[Ver «_Principle of least astonishment_» [.small]#&#91;fpy.li/6-5&#93;# (EN).]
-Com certeza, é surpreendente que quando o ônibus deixa uma estudante,
-seu nome seja removido da escalação do time de basquete.
+interfaces.footnote:[Ver «_Principle of least astonishment_» [.small]#&#91;fpy.li/6-5&#93;#.]
+Com certeza, é surpreendente: quando o ônibus deixa uma estudante,
+o nome dela é removido da escalação do time de basquete.
 
 
 <<ex_twilight_bus>> é a implementação de `TwilightBus` e uma explicação do problema.
 
 [[ex_twilight_bus]]
-.Uma classe simples mostrando os perigos de mudar argumentos recebidos
+.Classe simples mostrando o perigo de mudar argumentos recebidos
 ====
 [source, py]
 ----
@@ -833,8 +836,9 @@ O problema aqui é que o ônibus está apelidando a lista passada para o constru
 Ao invés disso, ele deveria manter sua própria lista de passageiros.
 A solução é simples: em `+__init__+`, quando o parâmetro `passengers` é fornecido,
 `self.passengers` deveria ser inicializado com uma cópia daquela lista,
-como fizemos, de forma correta, em <<ex_bus1>>:
+como fizemos, de forma correta, no <<ex_bus1>>:
 
+<<<
 [source, python]
 ----
     def __init__(self, passengers=None):
@@ -936,7 +940,7 @@ Outras implementações de Python têm coletores de lixo mais sofisticados,
 que não se baseiam na contagem de referências,
 o que significa que o método `+__del__+` pode não ser chamado
 imediatamente quando não existem mais referências ao objeto.
-Veja «PyPy, Garbage Collection, and a Deadlock» [.small]#&#91;fpy.li/6-7&#93;# (EN)
+Veja «_PyPy, Garbage Collection, and a Deadlock_» [.small]#&#91;fpy.li/6-7&#93;#
 de A. Jesse Jiryu Davis para uma discussão sobre os usos próprios e impróprios de `+__del__+`.
 
 Para demonstrar o fim da vida de um objeto, <<ex_finalize>> usa `weakref.finalize`
@@ -995,18 +999,18 @@ por terem uma referência no cache.((("", startref="ORdel06")))((("", startref="
 Referências fracas são um tópico muito especializado,
 então decidi retirá-lo dessa segunda edição.
 Em vez disso, publiquei a nota
-«"Weak References" em _fluentpython.com_» [.small]#&#91;fpy.li/weakref&#93;#.
+«_Weak References_ em _fluentpython.com_» [.small]#&#91;fpy.li/weakref&#93;#.
 ====
 
 === Peças que Python prega com imutáveis
 
 [NOTE]
 ====
-Esta((("object references", "immutability and"))) seção opcional discute alguns detalhes que,
-na verdade, não são muito importantes para _usuários_ de Python,
+Esta((("object references", "immutability and"))) seção opcional discute detalhes que
+não são muito importantes para _usuários_ de Python,
 e que podem não se aplicar a outras implementações da linguagem ou mesmo a futuras versões de CPython.
-Entretanto, já vi muita gente tropeçar nesses casos laterais e daí passar a usar o((("is operator")))
-operador `is` de forma incorreta, então acho que vale a pena mencionar esses detalhes.
+Mas já vi pessoas tropeçarem nesses casos obscuros e passarem a usar o((("is operator")))
+operador `is` incorretamente, então decidi abordar esses detalhes.
 ====
 
 Fiquei((("tuples", "immutability and"))) surpreso ao descobrir que, dada uma tupla `t`,
@@ -1017,7 +1021,7 @@ Digite `help(tuple)` no console de Python e leia:
 "Se o argumento é uma tupla, o valor de retorno é o mesmo objeto."
 Pensei que sabia tudo sobre tuplas antes de escrever esse livro.]
 
-<<ex_same_tuple>> demonstra esse fato.
+O <<ex_same_tuple>> demonstra esse fato.
 
 [[ex_same_tuple]]
 .Uma tupla construída a partir de outra é, na verdade, exatamente a mesma tupla.
@@ -1148,29 +1152,29 @@ Isso pode ser feito com referências fracas,
 um mecanismo de baixo nível encontrado nas coleções `WeakValueDictionary`,
 `WeakKeyDictionary`, `WeakSet`, e na função `finalize` do módulo `weakref`.
 
-Leia «"Weak References" em _fluentpython.com_» [.small]#&#91;fpy.li/weakref&#93;# (EN)
-para aprender mais sobre `weakref`.
-
+Leia «_Weak References_» [.small]#&#91;fpy.li/weakref&#93;#
+para aprender mais sobre `weakref` no _fluentpython.com_.
 
+<<<
 === Para saber mais
 
-O((("object references", "further reading on")))
-«capítulo "Modelo de Dados"» [.small]#&#91;fpy.li/2j&#93;# de _A Referência da Linguagem Python_
+O((("object references", "further reading on"))) capítulo
+«Modelo de Dados» [.small]#&#91;fpy.li/2j&#93;# de _A Referência da Linguagem Python_
 inicia com uma explicação bastante clara sobre identidades e valores de objetos.
 
 Wesley Chun, autor da série _Core Python_,
-apresentou «Understanding Python's Memory Model, Mutability, and Methods» [.small]#&#91;fpy.li/6-8&#93;#
-(EN) na EuroPython 2011, discutindo não apenas o tema desse capítulo como também o uso de métodos especiais.
+apresentou «_Understanding Python's Memory Model, Mutability, and Methods_» [.small]#&#91;fpy.li/6-8&#93;#
+na EuroPython 2011, discutindo não apenas o tema desse capítulo como também o uso de métodos especiais.
 
-Doug Hellmann escreveu os posts «copy — Duplicate Objects» [.small]#&#91;fpy.li/6-9&#93;# (EN) e
-«weakref — Garbage-Collectable References to Objects» [.small]#&#91;fpy.li/6-10&#93;# (EN),
+Doug Hellmann escreveu os posts «_copy—Duplicate Objects_» [.small]#&#91;fpy.li/6-9&#93;# e
+«weakref—Garbage-Collectable References to Objects» [.small]#&#91;fpy.li/6-10&#93;#,
 cobrindo alguns dos tópicos que acabamos de tratar.
 
 Você pode encontrar mais informações sobre o coletor de lixo geracional do CPython em
-«gc — Interface para o coletor de lixo» [.small]#&#91;fpy.li/3y&#93;#,
+«gc—Interface para o coletor de lixo» [.small]#&#91;fpy.li/3y&#93;#,
 que começa com a frase "Este módulo fornece uma interface para o coletor de lixo opcional."
-O adjetivo "opcional" aqui pode ser surpreendente,
-mas o «capítulo "Modelo de Dados"» [.small]#&#91;fpy.li/2j&#93;# também afirma:
+O adjetivo "opcional" pode ser surpreendente,
+mas o capítulo «Modelo de Dados» [.small]#&#91;fpy.li/2j&#93;# também afirma:
 
 [quote]
 ____
@@ -1180,17 +1184,17 @@ desde que nenhum objeto que ainda esteja acessível seja coletado.
 ____
 
 Pablo Galindo escreveu um texto mais aprofundado sobre o Coletor de Lixo em Python, em
-«Design of CPython’s Garbage Collector» [.small]#&#91;fpy.li/6-12&#93;# (EN)
+«_Design of CPython’s Garbage Collector_» [.small]#&#91;fpy.li/6-12&#93;#
 no «_Python Developer’s Guide_» [.small]#&#91;fpy.li/6-13&#93;#,
 voltado para contribuidores novos e experientes da implementação CPython.
 
 O CPython 3.4 aperfeiçoou o tratamento de objetos que implementam `+__del__+`,
-como descrito em «PEP 442--Safe object finalization» [.small]#&#91;fpy.li/6-14&#93;# (EN).
+como descrito em «PEP 442--Safe object finalization» [.small]#&#91;fpy.li/6-14&#93;#.
 
-A Wikipedia tem um artigo sobre «string interning» [.small]#&#91;fpy.li/6-15&#93;# (EN),
+A Wikipedia tem um artigo sobre «string interning» [.small]#&#91;fpy.li/6-15&#93;#,
 que menciona o uso desta técnica em várias linguagens, incluindo Python.
 
-A Wikipedia também tem um artigo sobre «Haddocks' Eyes» [.small]#&#91;fpy.li/6-16&#93;#,
+A Wikipedia também tem um artigo sobre «_Haddocks' Eyes_» [.small]#&#91;fpy.li/6-16&#93;#,
 a canção de Lewis Carroll que mencionei no início deste capítulo.
 Os editores da Wikipedia escreveram que a letra é usada em trabalhos de lógica e filosofia
 "para elaborar o status simbólico do conceito de 'nome':
@@ -1312,10 +1316,10 @@ with open('test.txt', 'wt', encoding='utf-8') as fp:
     fp.write('1, 2, 3')
 ----
 
-Se você tiver interesse no assunto de coletores de lixo,
-você talvez queira ler o artigo de Thomas Perl,
-«Python Garbage Collector Implementations: CPython, PyPy and GaS» [.small]#&#91;fpy.li/6-17&#93;#
-(EN), onde eu aprendi esses detalhes sobre a segurança de `open().write()` em CPython.
+Se tiver interesse no assunto de coletores de lixo,
+talvez queira ler o artigo de Thomas Perl,
+«_Python Garbage Collector Implementations: CPython, PyPy and GaS_» [.small]#&#91;fpy.li/6-17&#93;#,
+onde aprendi esses detalhes sobre a segurança de `open().write()` em CPython.
 
 [role="soapbox-title"]
 *Passagem de parâmetros: chamada por compartilhamento*