vol2: cap 9 e 10: paginação

Author: ramalho

code/10-dp-1class-func/strategy.py

@@ -33,7 +33,6 @@
 from decimal import Decimal
 from typing import Optional, Callable, NamedTuple
 
-
 class Customer(NamedTuple):
     name: str
     fidelity: int
@@ -46,6 +45,7 @@ class LineItem(NamedTuple):
 
     def total(self):
         return self.price * self.quantity
+    
 
 @dataclass(frozen=True)
 class Order:  # the Context
@@ -67,10 +67,8 @@ def due(self) -> Decimal:
     def __repr__(self):
         return f'<Order total: {self.total():.2f} due: {self.due():.2f}>'
 
-
 # <3>
 
-
 def fidelity_promo(order: Order) -> Decimal:  # <4>
     """5% discount for customers with 1000 or more fidelity points"""
     if order.customer.fidelity >= 1000:
@@ -86,13 +84,10 @@ def bulk_item_promo(order: Order) -> Decimal:
             discount += item.total() * Decimal('0.1')
     return discount
 
-
 def large_order_promo(order: Order) -> Decimal:
     """7% discount for orders with 10 or more distinct items"""
     distinct_items = {item.product for item in order.cart}
     if len(distinct_items) >= 10:
         return order.total() * Decimal('0.07')
     return Decimal(0)
-
-
 # end::STRATEGY[]

code/10-dp-1class-func/strategy_best4.py

@@ -45,17 +45,14 @@
 from strategy import Order
 
 # tag::STRATEGY_BEST4[]
-
 Promotion = Callable[[Order], Decimal]
 
 promos: list[Promotion] = []  # <1>
 
-
 def promotion(promo: Promotion) -> Promotion:  # <2>
     promos.append(promo)
     return promo
 
-
 def best_promo(order: Order) -> Decimal:
     """Compute the best discount available"""
     return max(promo(order) for promo in promos)  # <3>
@@ -68,7 +65,6 @@ def fidelity(order: Order) -> Decimal:
         return order.total() * Decimal('0.05')
     return Decimal(0)
 
-
 @promotion
 def bulk_item(order: Order) -> Decimal:
     """10% discount for each LineItem with 20 or more units"""
@@ -78,13 +74,11 @@ def bulk_item(order: Order) -> Decimal:
             discount += item.total() * Decimal('0.1')
     return discount
 
-
 @promotion
 def large_order(order: Order) -> Decimal:
     """7% discount for orders with 10 or more distinct items"""
     distinct_items = {item.product for item in order.cart}
     if len(distinct_items) >= 10:
         return order.total() * Decimal('0.07')
     return Decimal(0)
-
 # end::STRATEGY_BEST4[]

online/cap10.adoc

@@ -256,9 +256,8 @@ include::../code/10-dp-1class-func/strategy.py[tags=STRATEGY_TESTS]
 <3> Uma função de promoção diferente é usada aqui e no teste seguinte.
 
 
-Observe os textos explicativos do <<ex_strategy_tests>>: não há necessidade
-de instanciar um novo objeto `promotion` com cada novo pedido:
-as funções já estão prontas para usar.
+Note que não precisamos criar uma nova instância de `promotion` a
+cada novo pedido: as funções já estão prontas para usar.
 
 É interessante notar que no _Padrões de Projetos_, os autores sugerem que:
 "Objetos Estratégia muitas vezes são bons "peso mosca"
@@ -418,7 +417,7 @@ startref="FDPrefactor10")))((("", startref="RSfind10")))
 
 
 [[decorated_strategy_sec]]
-=== Estratégia melhorado com decorador
+=== Estratégia com decorador de registro
 
 Lembre-se((("functions, design patterns with first-class", "decorator-enhanced
 strategy pattern", id="FDPdecorator10")))((("refactoring strategies",

online/cap14.adoc

@@ -1239,7 +1239,7 @@ Se você precisar usar subclasses para reutilização de código, então o códi
 ser reutilizado deve estar em métodos mixin de ABCs, ou em classes mixin
 explicitamente nomeadas.
 
-Vamos agora analisar o Tkinter do ponto de vista dessas recomendações
+Vamos agora analisar o Tkinter do ponto de vista destas recomendações.
 
 ==== Tkinter: o bom, o mau e o feio
 

vol2/README.md

@@ -2,10 +2,10 @@
 
 ## Progresso
 
-As primeiras tarefas acontecem nos arquivos `/online/cap??.adoc`.
+Faço as primeiras tarefas nos arquivos `/online/cap??.adoc`.
 
-Depois cada arquivo é copiado para `/vol?/cap??.adoc`
-e as tarefas são feitas nesta cópia para impressão.
+Depois copio cada arquivo para `/vol2/cap??.adoc`
+e faço as demais tarefas nestas cópias especiais para impressão.
 
 | 9 | 10| 11| 12| 13| 14| 15| 16| local | tarefa |
 |:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|-------|-------|
@@ -14,6 +14,6 @@ e as tarefas são feitas nesta cópia para impressão.
 |✅ |✅ |✅ |✅ |✅ |✅ |✅ |✅ |`/online`|revisar ortografia e gramática|
 |✅ |✅ |✅ |✅ |✅ |✅ |✅ |✅ |`/vol2`| refazer referências entre volumes|
 |✅ |✅ |✅ |✅ |✅ |✅ |✅ |✅ |`/vol2`| encurtar links entre volumes |
-|   |   |   |   |   |   |   |   |`/vol2`| exibir capítulo alvo em xrefs para exemplos de outros capítulos |
-|   |   |   |   |   |   |   |   |`/vol2`| rever paginação   |
+|✅ |✅ |✅ |✅ |✅ |✅ |✅ |✅ |`/vol2`| exibir capítulo alvo em xrefs para exemplos de outros capítulos |
+|✅ |✅ |   |   |   |   |   |   |`/vol2`| rever paginação   |
 

vol2/cap09.adoc

@@ -72,10 +72,8 @@ apresento o decorador de _caching_ `functools.cache` do Python
 3.9 antes do `functools.lru_cache`, que é mais antigo.
 A <<lru_cache_sec>> apresenta também o uso de `lru_cache`
 sem argumentos, uma novidade do Python 3.8.
-
 Expandi a <<generic_functions_sec>> para incluir dicas de tipo, a sintaxe
 recomendada para usar `functools.singledispatch` desde o Python 3.7.
-
 A <<parameterized_dec_sec>> agora inclui o <<clockdeco_param_cls_ex>>,
 que usa uma classe e não uma clausura para implementar um decorador.
 
@@ -92,7 +90,6 @@ devolver a mesma função ou substituí-la por outra função ou objeto invocáv
 você substituir "função" por "classe" na sentença anterior, o resultado é uma
 descrição resumida do papel de um decorador de classe, assunto que veremos no
 https://fpy.li/24[«Capítulo 24»] (vol.3).]
-
 Em outras palavras, supondo a existência de uma função decoradora
 chamada `decorate`, este código:
 
@@ -206,6 +203,7 @@ Observe que `register` roda (duas vezes) antes de qualquer outra função no
 módulo. Quando `register` é chamada, ela recebe o objeto função a ser decorado
 como argumento—por exemplo, `<function f1 at 0x100631bf8>`.
 
+<<<
 Após o carregamento do módulo, a lista `registry` contém referências para as
 duas funções decoradas: `f1` e `f2`. Essas funções, bem como `f3`, são executadas
 apenas quando chamadas explicitamente por `main`.
@@ -250,7 +248,7 @@ argumento. Na prática, a maior parte dos decoradores define e devolve uma funç
 interna.
 
 Apesar do decorador `register` no <<registration_ex>> devolver a função decorada
-inalterada, esta técnica não é inútil. Decoradores parecidos são usados por muitos
+inalterada, ele não é inútil. Decoradores parecidos são usados por muitos
 frameworks Python para adicionar funções a um registro central—por exemplo, um
 registro mapeando padrões de URLs para funções que geram respostas HTTP. Tais
 decoradores de registro podem ou não modificar as funções decoradas.
@@ -302,6 +300,7 @@ atribuirmos um valor a um `b` global e então chamarmos `f1`, funciona:
 
 Agora vamos ver um exemplo que pode ser surpreendente.
 
+<<<
 Leia com atenção a função `f2`, no <<ex_local_unbound>>. As primeiras duas linhas
 são as mesmas da `f1` do <<ex_global_undef>>, e então ela faz uma atribuição a
 `b`. Mas para com um erro no segundo `print`, antes da atribuição ser executada.
@@ -391,6 +390,7 @@ Leia no <<#ex_f1_dis>> e no <<#ex_f2_dis>> os
 bytecodes de `f1` e `f2`, do <<#ex_global_undef>> e do <<#ex_local_unbound>>,
 respectivamente.
 
+<<<
 [[ex_f1_dis]]
 .Bytecode da função `f1` do <<ex_global_undef>>
 ====
@@ -477,6 +477,7 @@ cresce continuamente; por exemplo, o preço diário de um produto
 ao longo de toda a sua história. A cada dia, um novo preço é acrescentado,
 e a média é computada levando em conta todos os preços até então.
 
+<<<
 Começando do zero, `avg` poderia ser usada assim:
 
 [source, python]
@@ -683,7 +684,6 @@ e isso a torna uma variável local. O mesmo problema afeta a variável `total`.
 Não tivemos esse problema no <<ex_average_fn>>, porque nunca atribuimos nada ao
 nome `series`; apenas chamamos `series.append` e invocamos `sum` e `len` nele.
 Nos valemos, então, do fato de listas serem mutáveis.
-
 Mas com tipos imutáveis, como números, strings, tuplas, etc., só é possível ler,
 nunca atualizar. Se você reatribuir, como em `count += 1`,
 estará implicitamente criando uma variável local `count`. Ela não será mais uma
@@ -746,7 +746,7 @@ decorada e exibe o tempo decorrido, os argumentos passados, e o resultado da
 chamada.
 
 [[ex_clockdeco0]]
-._clockdeco0.py_: decorador simples que mostra o tempo de execução de funções
+._clockdeco0.py_: decorador que exibe o tempo de execução da função
 ====
 [source, python]
 ----
@@ -817,7 +817,6 @@ dos panos). De fato, se você importar o módulo `clockdeco_demo` e verificar o
 >>> import clockdeco_demo
 >>> clockdeco_demo.factorial.__name__
 'clocked'
->>>
 ----
 
 O nome `factorial` agora é uma referência para a função `clocked`. Daqui por
@@ -847,10 +846,13 @@ No _<<closures_soapbox>>_ escrevi mais sobre esse assunto.
 
 O decorador `clock` implementado no <<ex_clockdeco0>> tem alguns defeitos: ele
 não aceita argumentos nomeados, e encobre o `+__name__+` e o `+__doc__+` da
-função decorada. O <<ex_clockdeco2>> usa o decorador `functools.wraps` para
+função decorada.
+
+O <<ex_clockdeco2>> usa o decorador `functools.wraps` para
 copiar os atributos relevantes de `func` para `clocked`.
 Nesta nova versão, os argumentos nomeados também são tratados corretamente.
 
+<<<
 [[ex_clockdeco2]]
 ._clockdeco.py_: um decorador `clock` melhorado
 ====
@@ -952,7 +954,6 @@ Veja a <<lru_cache_sec>> para uma alternativa que suporta versões anteriores de
 `@cache` é aplicado à função devolvida por `@clock`.
 
 [[stacked_decorators_tip]]
-.Decoradores empilhados
 [TIP]
 ====
 Para((("stacked decorators"))) entender os decoradores empilhados (_stacked decorators_),
@@ -1385,6 +1386,8 @@ revisitar o decorador `clock`, acrescentando um recurso: os usuários podem
 passar uma string para formatar o relatório sobre a função cronometrada.
 Veja o <<clockdeco_param_ex>>.
 
+
+<<<
 [NOTE]
 ====
 
@@ -1451,6 +1454,7 @@ include::../code/09-closure-deco/clock/clockdeco_param_demo1.py[]
 ----
 ====
 
+<<<
 Saída do <<ex_clockdecoparam_demo1>>:
 
 [source]
@@ -1494,7 +1498,7 @@ de Graham Dumpleton e o módulo `wrapt`.
 
 ====
 
-A próxima seção traz um exemplo no estilo recomendado por Regebro e Dumpleton.((("", startref="CDparam09")))
+Agora veremos um exemplo no estilo recomendado por Regebro e Dumpleton.((("", startref="CDparam09")))
 
 ==== Um decorador de cronometragem em forma de classe
 
@@ -1560,7 +1564,7 @@ baseada em classes pode ser mais fácil de ler e manter.
 Como exemplos de decoradores parametrizados na biblioteca padrão, visitamos os
 poderosos `@cache` e `@singledispatch`, do módulo `functools`.
 
-
+<<<
 [[decorator_further]]
 === Para saber mais
 
@@ -1604,6 +1608,7 @@ ela ainda é uma excelente fonte de inspiração.
 https://fpy.li/9-11[_Closures in Python_] é um post curto de Fredrik Lundh,
 explicando a terminologia das clausuras.
 
+<<<
 A https://fpy.li/9-12[_PEP 3104—Access to Names in Outer Scopes_] (Acesso a Nomes
 em Escopos Externos) descreve a introdução da declaração `nonlocal`.
 Ela também inclui uma excelente revisão de como essa questão foi resolvida
@@ -1651,6 +1656,8 @@ do ambiente onde a função é invocada.
 Se Python tivesse escopo dinâmico e não tivesse clausuras, poderíamos improvisar
 `avg` (similar ao <<ex_average_fn>>) desta forma:
 
+<<<
+
 [source, python]
 ----
 >>> ### esta não é uma sessão real de Python! ###
@@ -1726,7 +1733,10 @@ Isso foi resolvido no Python 2.2 (de dezembro de 2001), mas a blogosfera nunca p
 Desde então, `lambda` é triste apenas devido à sua sintaxe
 limitada.((("", startref="Scynamic09")))((("", startref="SSdynamic09")))
 
-[role="soapbox-title"]
+****
+<<<
+
+****
 **Os decoradores de Python e o padrão de projeto Decorator**
 
 Os decoradores de função((("Soapbox sidebars", "Python decorators and decorator
@@ -1737,7 +1747,6 @@ criação de subclasses para estender funcionalidade."
 
 Ao nível da implementação, os decoradores de Python não lembram o padrão de
 projeto decorador clássico, mas é possível fazer uma analogia.
-
 No padrão de projeto, `Decorador` e `Componente` são classes abstratas. Uma
 instância de um decorador concreto envolve uma instância de um componente
 concreto para adicionar comportamentos a ela. Citando _Padrões de Projeto_:
@@ -1753,19 +1762,22 @@ de forma recursiva, possibilitando assim um número ilimitado de
 responsabilidades adicionais. (p. 175 da edição em inglês)
 ____
 
+
 No Python, a função decoradora faz o papel de uma subclasse concreta de
 `Decorador`, e a função interna que ela devolve é uma instância do decorador. A
 função devolvida envolve a função a ser decorada, que é análoga ao componente no
 padrão de projeto. A função devolvida é transparente, pois se adapta à interface
-do componente (ao aceitar os mesmos argumentos). Pegando emprestado da citação
-anterior, podemos adaptar a última frase para dizer que "A transparência permite
+do componente (ao aceitar os mesmos argumentos). Adaptando a última frase
+da citação: "A transparência permite
 empilhar decoradores, possibilitando assim um número ilimitado de comportamentos
 adicionais".
 
 Veja que não estou sugerindo que decoradores de função devam ser usados para
-implementar o padrão decorador em programas Python. Pode até ser possível em
+implementar o padrão decorador em programas Python. Pode até ser feito em
 situações específicas, mas em geral o padrão decorador é melhor implementado
 com classes representando o decorador e os componentes que ela vai envolver.((("",
 startref="DACsoap09")))
 
 ****
+
+<<<