uniformizar terminologia: loop->laço

Author: ramalho

guia-de-estilo.adoc

@@ -166,6 +166,7 @@ Termo em inglês adotado::
 |❗ _in place_        | ✅ internamente, interno | 🔎  no mesmo lugar
 |❗ _keyword argument_ | ✅ argumento nomeado | 🔎 argumento de palavra-chave
 |❗ _lock_             | ✅ trava  |
+|❗ _loop_             | ✅ laço  | ex: laço `for`, laço de eventos, laço infinito
 |❗ _match_ (s.m.)     | ✅ casamento | substantivo; aplica-se a `match/case` e `re.match`
 |❗ _match_ (v.)       | ✅ casar | verbo; aplica-se a `match/case` e `re.match`
 |✅ MRO (s.m.)  | Ordem de Resolução de Métodos (_Method Resolution Order_)

links/FPY.LI.htaccess

@@ -1370,6 +1370,7 @@ RedirectTemp /93	https://pythonfluente.com/2/#ex_strkeydict
 RedirectTemp /94	https://pythonfluente.com/2/#ex_tcp_mojifinder_main
 RedirectTemp /95	https://pythonfluente.com/2/#ex_checked_class_top
 RedirectTemp /96	https://pythonfluente.com/2/#ex_primes_procs_top
+
 # cap 17: appended 2026-01-09 15:15:31
 RedirectTemp /97	https://docs.python.org/pt-br/3.10/library/functions.html#iter
 RedirectTemp /98	https://github.com/python/python-docs-pt-br/issues/290
@@ -1387,6 +1388,7 @@ RedirectTemp /9k	https://github.com/fluentpython/language-creators
 RedirectTemp /9m	https://docs.python.org/pt-br/3/library/exceptions.html#StopIteration
 RedirectTemp /9n	https://docs.python.org/pt-br/3/reference/expressions.html#yield-expressions
 RedirectTemp /9p	https://docs.python.org/pt-br/3/reference/index.html
+
 # cap18: appended 2026-01-09 15:36:28
 RedirectTemp /9q	https://docs.python.org/pt-br/3/library/threading.html#using-locks-conditions-and-semaphores-in-the-with-statement
 RedirectTemp /9r	https://docs.python.org/pt-br/3/library/decimal.html#decimal.localcontext
@@ -1400,6 +1402,7 @@ RedirectTemp /9z	https://docs.python.org/pt-br/3/library/stdtypes.html#typeconte
 RedirectTemp /a2	https://pt.wikipedia.org/wiki/Recursividade_(ci%C3%AAncia_da_computa%C3%A7%C3%A3o)#Fun%C3%A7%C3%B5es_recursivas_em_cauda
 RedirectTemp /a3	https://docs.python.org/3/library/sqlite3.html#using-the-connection-as-a-context-manager
 RedirectTemp /a4	https://docs.python.org/pt-br/3/reference/datamodel.html#with-statement-context-managers
+
 # cap19: appended 2026-01-09 15:48:37
 RedirectTemp /a5	https://docs.python.org/pt-br/3/library/sys.html#sys.getswitchinterval
 RedirectTemp /a6	https://pt.wikipedia.org/wiki/Chamada_de_sistema
@@ -1459,6 +1462,7 @@ RedirectTemp /bq	https://pt.wikipedia.org/wiki/Mutex_recursivo
 RedirectTemp /br	https://docs.python.org/pt-br/3/reference/datamodel.html#customizing-attribute-access
 RedirectTemp /bs	https://docs.python.org/pt-br/3/reference/datamodel.html#special-method-lookup
 RedirectTemp /bt	https://docs.python.org/pt-br/3/library/stdtypes.html#special-attributes
+
 # cap23: appended 2026-01-09 16:32:34
 RedirectTemp /bv	https://docs.python.org/pt-br/3/howto/descriptor.html
 RedirectTemp /bw	https://docs.python.org/pt-br/3/howto/

online/cap02.adoc

@@ -204,7 +204,7 @@ Qualquer um que saiba um pouco de Python consegue ler o <<ex_build_list>>.
 Entretanto, após aprender sobre as listcomps, acho o <<ex_listcomp0>> mais legível,
 porque deixa sua intenção explícita.
 
-Um loop `for` pode ser usado para muitas coisas diferentes:
+Um laço `for` pode ser usado para muitas coisas diferentes:
 percorrer uma sequência para contar ou encontrar itens, computar valores agregados (somas, médias),
 ou inúmeras outras tarefas.
 O código no <<ex_build_list>> está criando uma lista.
@@ -216,7 +216,7 @@ Já vi código Python usando listcomps apenas para repetir um bloco de código p
 Se você não vai fazer alguma coisa com a lista criada, não deveria usar essa sintaxe.
 Além disso, tente manter o código curto.
 Se uma compreensão ocupa mais de duas linhas,
-provavelmente seria melhor quebrá-la ou reescrevê-la como um bom e velho loop `for`.
+provavelmente seria melhor quebrá-la ou reescrevê-la como um bom e velho laço `for`.
 Avalie qual o melhor caminho: em Python, como em português, não existem regras absolutas para se escrever bem.
 
 
@@ -361,7 +361,7 @@ O resultado tem seis itens.
 ----
 ====
 <1> Isso gera uma lista de tuplas ordenadas por cor, depois por tamanho.
-<2> Observe que a lista resultante é ordenada como se os loops `for`
+<2> Observe que a lista resultante é ordenada como se os laços `for`
 estivessem aninhados na mesma ordem que eles aparecem na listcomp.
 <3> Para ter os itens ordenados por tamanho e então por cor, apenas rearranje as cláusulas `for`;
 quebrar a listcomp em duas linhas torna mais fácil ver como o resultado será ordenado.
@@ -421,10 +421,10 @@ O <<ex_genexp_cartesian>> usa uma genexp com um produto cartesiano para
 gerar uma relação de camisetas de duas cores em três tamanhos.
 Diferente do <<ex_listcomp_cartesian>>,
 aquela lista de camisetas com seis itens nunca é criada na memória:
-a expressão geradora alimenta o loop `for` produzindo um item por vez.
+a expressão geradora alimenta o laço `for` produzindo um item por vez.
 Se as duas listas usadas no produto cartesiano tivessem mil itens cada uma,
 usar uma função geradora evitaria o custo de construir uma lista
-com um milhão de itens apenas para passar ao loop `for`.
+com um milhão de itens apenas para passar ao laço `for`.
 
 [[ex_genexp_cartesian]]
 .Produto cartesiano em uma expressão geradora
@@ -1390,7 +1390,7 @@ porque eles permitem que você atribua nomes às fatias, da mesma forma que plan
 
 Suponha que você precise analisar um arquivo de dados como a fatura mostrada na <<flat_file_invoice>>.
 Em vez de encher seu código de fatias explícitas fixas, você pode nomeá-las.
-Veja como isso torna legível o loop `for` no final do exemplo.
+Veja como isso torna legível o laço `for` no final do exemplo.
 
 [[flat_file_invoice]]
 .Itens de um arquivo tabular de fatura
@@ -1681,7 +1681,7 @@ Veja uma demonstração de `*=` com uma sequência mutável e depois com uma seq
 A concatenação repetida de sequências imutáveis é ineficiente, pois ao invés de apenas acrescentar novos itens,
 o interpretador tem que copiar toda a sequência alvo para criar um novo objeto com os novos itens
 concatenados.footnote:[`str` é uma exceção a essa descrição.
-Como criar strings com `+=` em loops é tão comum em bases de código reais,
+Como criar strings com `+=` em laços é tão comum em bases de código reais,
 o CPython foi otimizado para esse caso de uso.
 Instâncias de `str` são alocadas na memória com espaço extra,
 então a concatenação não exige a cópia da string inteira a cada operação.]
@@ -2548,7 +2548,7 @@ https://fpy.li/2-30[Python for Data Analysis], de Wes McKinney.
 "A Numpy é toda sobre vetorização". Essa é a frase de abertura do livro de acesso aberto
 https://fpy.li/2-31[From Python to NumPy], de Nicolas P. Rougier.
 Operações vetorizadas aplicam funções matemáticas a todos os elementos de um array
-sem um loop explícito escrito em Python.
+sem um laço explícito escrito em Python.
 Elas podem operar em paralelo, usando instruções especiais de vetor presentes em CPUs modernas,
 tirando proveito de múltiplos núcleos ou delegando para a GPU, dependendo da biblioteca.
 O primeiro exemplo no livro de Rougier mostra um aumento de velocidade de 500 vezes,

online/cap03.adoc

@@ -25,7 +25,7 @@ os conjuntos que você pode ter encontrado em outras linguagens populares.
 Em especial, os conjuntos de Python implementam todas as operações fundamentais da teoria dos conjuntos,
 como união, interseção, testes de subconjuntos, etc.
 Com eles, podemos expressar algoritmos de forma mais declarativa,
-evitando o excesso de loops e condicionais aninhados.
+evitando o excesso de laços e condicionais aninhados.
 
 Aqui está um breve esquema do capítulo:
 
@@ -1206,7 +1206,7 @@ Assim, dados dois conjuntos `a` e `b`, `a | b` devolve sua união,
 Quando bem utilizadas,
 as operações de conjuntos podem reduzir tanto a contagem de linhas quanto o tempo de execução de programas Python,
 ao mesmo tempo em que tornam o código mais legível e
-mais fácil de entender—pela remoção de loops e lógica condicional.
+mais fácil de entender—pela remoção de laços e lógica condicional.
 
 Por exemplo, imagine que você tem um grande conjunto de endereços de e-mail (o "palheiro"—`haystack`)
 e um conjunto menor de endereços (as "agulhas"—`needles``),
@@ -1550,7 +1550,7 @@ Por outro lado, uma view devolvida por `dict_keys` sempre pode ser usada como um
 pois todas as chaves são hashable—por definição.
 ====
 
-Usar operações de conjunto com views pode evitar a necessidade de muitos loops e ifs
+Usar operações de conjunto com views pode evitar a necessidade de muitos laços e ifs
 quando seu código precisa inspecionar o conteúdo de dicionários.
 Deixe a eficiente implementação de Python em C trabalhar para você!
 

online/cap04.adoc

@@ -1602,7 +1602,7 @@ No <<ex_cfpy>>, observe que o comando `if`, na função `find`,
 usa o método `.issubset()` para testar rapidamente se
 todas as palavras no conjunto `query` aparecem na lista de palavras criada a partir do nome do caractere.
 Graças à rica API de conjuntos de Python,
-não precisamos de um loop `for` aninhado e de outro `if` para implementar essa verificação
+não precisamos de um laço `for` aninhado e de outro `if` para implementar essa verificação
 
 [[ex_cfpy]]
 .cf.py: o utilitário de busca de caracteres

online/cap06.adoc

@@ -563,7 +563,7 @@ então seu atributo `passengers` se refere a outra lista.
 
 Em geral, criar cópias profundas não é uma questão simples.
 Objetos podem conter referências cíclicas que fariam um algoritmo
-ingênuo entrar em um loop infinito.
+ingênuo entrar em um laço infinito.
 A função `deepcopy` memoriza os objetos já copiados,
 e trata referências cíclicas corretamente.
 Isso é demonstrado no <<ex_cycle1>>.

online/cap12.adoc

@@ -715,7 +715,7 @@ Veja como `reduce` pode ser usada para computar `5!` (o fatorial de 5):
 
 Voltando a nosso problema de _hash_, o <<ex_reduce_xor>> demonstra a ideia da
 computação de um xor agregado, fazendo isso de três formas diferente: com um
-loop `for` e com dois modos diferentes de usar `reduce`.
+laço `for` e com dois modos diferentes de usar `reduce`.
 
 [[ex_reduce_xor]]
 .Três maneiras de calcular o xor acumulado de inteiros de 0 a 5
@@ -736,12 +736,12 @@ loop `for` e com dois modos diferentes de usar `reduce`.
 1
 ----
 ====
-<1> xor agregado com um loop `for` e uma variável de acumulação.
+<1> xor agregado com um laço `for` e uma variável de acumulação.
 <2> `functools.reduce` usando uma função anônima.
 <3> `functools.reduce` substituindo a `lambda` customizada por `operator.xor`.
 
 Das alternativas apresentadas no <<ex_reduce_xor>>, a última é minha favorita, e
-o loop `for` vem a seguir. Qual sua preferida?
+o laço `for` vem a seguir. Qual sua preferida?
 
 Como visto na <<operator_module_sec>>, `operator` oferece a funcionalidade de
 todos os operadores infixos de Python em formato de função, diminuindo a
@@ -796,7 +796,7 @@ Ao usar `reduce`, é uma boa prática fornecer o terceiro argumento,
 ("reduce() de uma sequência vazia sem valor inicial", uma mensagem bem escrita:
 explica o problema e diz como resolvê-lo).
 O `initializer` é o valor devolvido se a sequência for vazia e
-é usado como primeiro argumento no loop de redução,
+é usado como primeiro argumento no laço de redução,
 e portanto deve ser o elemento neutro da operação.
 Assim, o `initializer` para `{plus}`, `|`, `^` (xor) deve ser `0`,
 mas para  `*` e `&` deve ser `1`.
@@ -853,7 +853,7 @@ Mas não para grandes vetores multidimensionais. Uma forma melhor de comparar um
 `Vector` com outro `Vector` ou iterável seria o código do <<ex_eq_loop>>.
 
 [[ex_eq_loop]]
-.A implementação de `+Vector.__eq__+` usando `zip` em um loop `for`, para uma comparação mais eficiente
+.A implementação de `+Vector.__eq__+` usando `zip` em um laço `for`, para uma comparação mais eficiente
 ====
 [source, python]
 ----
@@ -895,7 +895,7 @@ um dos argumentos é consumido.
 Veja a caixa <<zip_box>> logo adiante para saber mais sobre zip.
 ====
 
-O <<ex_eq_loop>> é eficiente, mas a função `all` pode produzir a mesma computação de um agregado do loop `for` em apenas uma linha:
+O <<ex_eq_loop>> é eficiente, mas a função `all` pode produzir a mesma computação de um agregado do laço `for` em apenas uma linha:
 se todas as comparações entre componentes correspoendentes nos operandos forem `True`, o resultado é `True`.
 Assim que uma comparação é `False`, `all` devolve `False`. O <<ex_eq_all>> mostra um `+__eq__+` usando `all`.
 
@@ -922,7 +922,7 @@ startref="SSMhasheq12")))((("", startref="VCMhasheq12")))
 .O fantástico zip
 ****
 
-Ter um loop `for` que itera sobre itens sem perder tempo com variáveis de índice
+Ter um laço `for` que itera sobre itens sem perder tempo com variáveis de índice
 é muito bom e evita muitos bugs, mas exige algumas funções utilitárias
 especiais. Uma delas é a função embutida `zip`, que facilita a iteração em
 paralelo sobre dois ou mais iteráveis, devolvendo tuplas que você pode
@@ -972,7 +972,7 @@ Se você quiser entender `zip`, passe algum tempo considerando como esses
 exemplos funcionam.
 
 A função embutida `enumerate` é outra função geradora usada com frequência em
-loops `for`, para evitar manipulação direta de variáveis índice. Quem não
+laços `for`, para evitar manipulação direta de variáveis índice. Quem não
 estiver familiarizado com `enumerate` deve estudar a seção dedicada a ela na
 documentação das
 https://fpy.li/6d[Funções embutidas].
@@ -1371,7 +1371,7 @@ de David Eppstein sobre ele:
 ____
 
 Se você quer a soma de uma lista de itens, deveria escrever algo como
-"a soma de uma lista de itens", não como "faça um loop sobre
+"a soma de uma lista de itens", não como "faça um laço sobre
 esses itens, mantenha uma variável `ac`, execute uma série de somas".
 Por que temos linguagens de alto nível, senão para expressar nossas
 intenções em um nível mais alto e deixar a linguagem se preocupar

online/cap17.adoc

@@ -872,14 +872,18 @@ função geradora do módulo `re`.
 
 ==== Sentence versão #4: um gerador preguiçoso
 
-A interface `Iterator` foi projetada para ser preguiçosa: `next(my_iterator)` produz um item por vez.
-O oposto de preguiçosa é ávida: avaliação preguiçosa e ávida são termos técnicos da teoria das linguagens de programação.footnote:[NT: Os termos em inglês são _lazy_ (preguiçosa) e _eager_ (ávida). Em português essas traduções aparecem, mas a literatura usa também avaliação _estrita_ e avaliação _não estrita_. Optamos pelos termos "preguiçosa" e "ávida", que parecem mais claros.]
+A interface `Iterator` foi projetada para ser preguiçosa: `next(my_iterator)`
+produz um item por vez. O oposto de preguiçosa é ávida: avaliação preguiçosa
+(_lazy evaluation_) e ávida (_eager evaluation_) são termos técnicos da teoria
+das linguagens de programação.footnote:[NT: Em português a
+literatura usa também avaliação _estrita_ e _não estrita_.
+Optamos pelos termos "preguiçosa" e "ávida", que parecem mais claros.]
 
 ////
 parei aqui em 23/dez, 19:20
 
 TODO: trocar "loop" por "laço" ao longo do livro, começando por
-"loop `for`" -> "laço `for`"
+"laço `for`" -> "laço `for`"
 "loop infinito" -> "laço infito".
 
 ////