vol2, cap09: revisão de estilo

Author: ramalho

code/09-closure-deco/clock/clockdeco_param.py

@@ -12,25 +12,25 @@
 # tag::CLOCKDECO_PARAM[]
 import time
 
-DEFAULT_FMT = '[{elapsed:0.8f}s] {name}({args}) -> {result}'
+DEFAULT_FMT = '[{elapsed:0.8f}s] {name}({args}) -> {result}'  # <1>
 
-def clock(fmt=DEFAULT_FMT):  # <1>
-    def decorate(func):      # <2>
-        def clocked(*_args): # <3>
+def clock(fmt=DEFAULT_FMT):  # <2>
+    def decorate(func):      # <3>
+        def clocked(*_args): # <4>
             t0 = time.perf_counter()
-            _result = func(*_args)  # <4>
+            _result = func(*_args)  # <5>
             elapsed = time.perf_counter() - t0
             name = func.__name__
-            args = ', '.join(repr(arg) for arg in _args)  # <5>
-            result = repr(_result)  # <6>
-            print(fmt.format(**locals()))  # <7>
-            return _result  # <8>
-        return clocked  # <9>
-    return decorate  # <10>
+            args = ', '.join(repr(arg) for arg in _args)  # <6>
+            result = repr(_result)  # <7>
+            print(fmt.format(**locals()))  # <8>
+            return _result  # <9>
+        return clocked  # <10>
+    return decorate  # <11>
 
 if __name__ == '__main__':
 
-    @clock()  # <11>
+    @clock()  # <12>
     def snooze(seconds):
         time.sleep(seconds)
 

guia-de-estilo.adoc

@@ -135,6 +135,7 @@ Termo em inglês adotado::
 |✅ _hashable_ (adj.)  |❓            |
 |✅ _hook_ (s.m.)      |❗gancho      |
 |❗ _I/O bound_        | ✅ limitado por E/S |
+|❗ _import time_      | ✅ momento da importação | 🔎  tempo de importação
 |❗ _in place_        | ✅ internamente, interno | 🔎  no mesmo lugar
 |❗ _keyword argument_ | ✅ argumento nomeado | 🔎 argumento de palavra-chave
 |❗ _lock_             | ✅ trava  |

images/diagrama9-1.odg

@@ -419,7 +419,7 @@ startref="FDPrefactor10")))((("", startref="RSfind10")))
 
 
 [[decorated_strategy]]
-=== Padrão Estratégia aperfeiçoado com um decorador
+=== Padrão Estratégia melhorado com decorador
 
 Lembre-se((("functions, design patterns with first-class", "decorator-enhanced
 strategy pattern", id="FDPdecorator10")))((("refactoring strategies",

images/diagrama9-1.png

@@ -31,7 +31,7 @@ Essa mudança foi replicada para as implementações seguintes de `Vector` aqui
 
 Vamos começar.
 
-=== Vector: Um tipo sequência definido pelo usuário
+=== Vector: tipo sequência definido pelo usuário
 
 Nossa((("sequences, special methods for", "Vector implementation strategy")))((("Vector class, multidimensional", "implementation strategy"))) estratégia na implementação de `Vector` será usar composição, não herança. Vamos armazenar os componentes em um array de números de ponto flutuante, e implementar os métodos necessários para que nossa classe `Vector` se comporte como uma sequência plana imutável.
 
@@ -153,7 +153,7 @@ Vamos agora implementar o protocolo sequência em `Vector`, primeiro sem suporte
 
 
 [[sliceable_sequence_sec]]
-=== Vector versão #2: Uma sequência fatiável
+=== Vector versão #2: sequência fatiável
 
 Como((("Vector class, multidimensional", "sliceable sequences", id="VCMslice12")))((("sequences, special methods for", "sliceable sequences", id="SSMslice12")))((("slicing", "sliceable sequences", id="Sslseq12")))((("__len__", id="len12")))((("__getitem__", id="getitem12"))) vimos no exemplo da classe `FrenchDeck`, suportar o protocolo de sequência é muito fácil se você puder delegar para um atributo sequência em seu objeto, como nosso array `self._components`. Esses `+__len__+` e `+__getitem__+` de uma linha são um bom começo:
 
@@ -320,7 +320,7 @@ include::../code/12-seq-hacking/vector_v2.py[tags=VECTOR_V2_DEMO]
 <4> `Vector` não suporta indexação multidimensional, então tuplas de índices ou de fatias geram um erro.((("", startref="getitem12")))((("", startref="len12")))((("", startref="Sslseq12")))((("", startref="SSMslice12")))((("", startref="VCMslice12")))
 
 [[vector_dynamic_attrs_sec]]
-=== Vector versão #3: acesso dinâmico a atributos
+=== Vector versão #3: atributos dinâmicos
 
 Ao((("Vector class, multidimensional", "dynamic attribute access", id="VCMdyn12")))((("sequences, special methods for", "dynamic attribute access", id="SSMdyn12")))((("&#x005F;&#x005F;getattr&#x005F;&#x005F;", id="getattr12")))((("attributes", "dynamic attribute access", id="Adyn12"))) evoluir `Vector2d` para `Vector`, perdemos a habilidade de acessar os componentes do vetor por nome (por exemplo, `v.x`, `v.y`). Agora estamos trabalhando com vetores que podem ter um número grande de componentes. Ainda assim, pode ser conveniente acessar os primeiros componentes usando letras como atalhos, algo como `x`, `y`, `z` em vez de `v[0]`, `v[1]`, and `v[2]`.
 

images/flpy_0901-EN.png

@@ -516,17 +516,22 @@ Para fazer metaprogramação de classes, precisamos saber quando o interpretador
 [[import_v_runtime_sec]]
 === O que acontece quando: importação versus execução
 
-Programadores Python((("class metaprogramming", "import time versus runtime", id="CMimport24")))((("import time versus runtime"))) falam de "importação" (_import time_) versus "execução" (_runtime_), mas estes termos não têm definições precisas e há uma zona cinzenta entre eles.
+Programadores Python((("class metaprogramming", "import time versus runtime", id="CMimport24")))((("import time versus runtime"))) falam de "momento da importação" (_import time_) versus "momento de execução" (_run time_), mas estes termos não têm definições precisas e há uma zona cinzenta entre eles.
 
-Na importação, o interpretador:
+No momento da importação, o interpretador:
 
-. Analisa o código-fonte de módulo _.py_ em uma passagem, de cima até embaixo. É aqui que um `SyntaxError` pode ocorrer.
+. Analisa o código-fonte de módulo _.py_ em uma passagem, da primeira até a última linha. É aqui que um `SyntaxError` pode ocorrer.
 . Compila o _bytecode_ a ser executado.
 . Executa o código no nível superior do módulo compilado.
 
-Se existir um arquivo _.pyc_ atualizado no `+__pycache__+` local, a análise e a compilação são omitidas, pois o _bytecode_ está pronto para ser executado.
+Se existir um arquivo _.pyc_ atualizado no `+__pycache__+` local,
+a análise e a compilação são omitidas, pois o _bytecode_ está pronto para ser executado.
 
-Apesar da análise e a compilação serem definitivamente atividades de "importação", outras coisas podem acontecer durante o processo, pois quase todos os comandos ou instruções no Python são executáveis, no sentido de poderem potencialmente rodar código do usuário e modificar o estado do programa do usuário.
+Apesar da análise e a compilação serem definitivamente atividades de "importação",
+outras coisas podem acontecer durante este processo,
+pois quase todos os comandos ou instruções no Python são executáveis,
+no sentido de poderem potencialmente rodar código do usuário
+e modificar o estado do programa do usuário.
 
 Em especial, a instrução `import` não é meramente uma declaraçãofootnote:[Compare com a instrução `import` em Java, que é apenas uma declaração para informar o compilador que determinados pacotes são necessários.], pois na verdade ela executa todo o código no nível superior de um módulo, quando este é importado para o processo pela primeira vez. Importações posteriores do mesmo módulo usarão um _cache_, e então o único efeito será a vinculação dos objetos importados a nomes no módulo cliente. Aquele código no primeiro nível pode fazer qualquer coisa, incluindo ações típicas da "execução", como escrever em um arquivo de log ou conectar-se a um banco de dados.footnote:[Não estou dizendo que é uma boa ideia abrir uma conexão com um banco de dados só porque o módulo foi importado, apenas apontando que isso pode ser feito.]
 Por isso a fronteira entre a "importação" e a "execução" é difusa: `import` pode acionar todo tipo de comportamento de "execução", porque a instrução `import` e a função embutida

online/cap09.adoc

@@ -24,7 +24,7 @@ _Python Fluente_, o livro definitivo sobre Python.
 
 image::fpy.li-pf2q.png[]
 
-
+ 
 # Texto para orelha da contra-capa (espiral)
 
 ## Python Fluente, 2ª edição