cap13: urls curtas

Author: ramalho

online/cap13.adoc

@@ -173,7 +173,7 @@ também para permitir iteração e o operador `in`. O método especial
 `+__getitem__+` é de fato o ponto central do protocolo de sequência.
 
 Veja a seção
-https://docs.python.org/pt-br/3/c-api/sequence.html[Protocolo de Sequência]
+https://fpy.li/6k[Protocolo de Sequência]
 do Manual de referência da API Python/C:
 
 `int PySequence_Check(PyObject *o)`::
@@ -209,14 +209,13 @@ Protocolo dinâmico::
   Os((("dynamic protocols"))) protocolos informais que Python sempre teve.
   Protocolos dinâmicos são implícitos, definidos por convenção e descritos na
   documentação. Os protocolos dinâmicos mais importantes de Python são mantidos
-  pelo próprio interpretador, e documentados no
-  https://docs.python.org/pt-br/3/reference/datamodel.html[capítulo "Modelo de
-  Dados" ] em _A Referência da Linguagem Python_.
+  pelo próprio interpretador, e documentados no capítulo
+  https://fpy.li/2j[Modelo de Dados] em _A Referência da Linguagem Python_.
 
 Protocolo estático::
   Um((("static protocols", "definition of"))) protocolo como definido pela
-  https://fpy.li/pep544[PEP 544—Protocols: Structural subtyping (static duck
-  typing)], a partir de Python 3.8. Um protocolo estático tem um definição
+  https://fpy.li/pep544[PEP 544—Protocols: Structural subtyping (static duck typing)],
+  a partir de Python 3.8. Um protocolo estático tem um definição
   explícita: uma subclasse de `typing.Protocol`.
 
 Há duas diferenças fundamentais entre eles:
@@ -353,7 +352,7 @@ essencial: ela não pode ser embaralhada. Anos atrás, quando escrevi pela
 primeira vez o exemplo `FrenchDeck`, implementei um método `shuffle`. Depois
 tive um insight pythônico: se um `FrenchDeck` age como uma sequência, então ele
 não precisa de seu próprio método `shuffle`, pois já existe um `random.shuffle`,
-https://docs.python.org/pt-br/3/library/random.html#random.shuffle[documentado]
+https://fpy.li/6m[documentado]
 como "Embaralha a sequência x internamente."
 
 A função `random.shuffle` padrão é usada assim:
@@ -426,10 +425,10 @@ suit='clubs'), Card(rank='7', suit='hearts'), Card(rank='9', suit='spades')]
 <3> `deck` agora pode ser embaralhado, pois acrescentei o método necessário do
 protocolo de sequência mutável.
 
-A assinatura do método especial `+__setitem__+` está definida na _A Referência
-da Linguagem Python_ em
-https://docs.python.org/pt-br/3/reference/datamodel.html#emulating-container-types["3.3.6.
-Emulando de tipos contêineres"]. Aqui nomeei os argumentos `deck, position,
+A assinatura do método especial `+__setitem__+` está definida na
+_Referência da Linguagem Python_ em
+https://fpy.li/6n[Emulando tipos contêineres].
+Aqui nomeei os argumentos `deck, position,
 card`&#x2014;e não `self, key, value` como na referência da linguagem—para
 mostrar que todo método Python começa sua vida como uma função comum, e
 nomear o primeiro argumento `self` é só uma convenção. Isso
@@ -611,7 +610,7 @@ durante a execução—também suportado por checadores de tipos estáticos.
 
 
 O verbete
-https://docs.python.org/pt-br/3/glossary.html#term-abstract-base-class[classe base abstrata]
+https://fpy.li/6p[classe base abstrata]
 no Glossário da Documentação de Python tem uma boa explicação do
 valor dessas estruturas para linguagens que usam duck typing:
 
@@ -901,7 +900,7 @@ Por outro lado, mesmo quando `isinstance(obj, Iterable)` retorna `False`,
 o Python ainda pode ser capaz de iterar sobre `obj` usando `+__getitem__+` com índices baseados em 0,
 como vimos em <<ch_data_model>> e na  <<python_digs_seq_sec>>.
 A documentação de
-https://docs.python.org/pt-br/3/library/collections.abc.html#collections.abc.Iterable[`collections.abc.Iterable`]
+https://fpy.li/6q[`collections.abc.Iterable`]
 afirma:
 
 [quote]
@@ -990,7 +989,7 @@ Mas mesmo que tenha, as subclasses ainda são obrigadas a sobrescrevê-lo,
 mas poderão invocar o método abstrato com `super()`,
 acrescentando funcionalidade em vez de implementar do zero.
 Veja os detalhes do uso de `@abstractmethod` na
-https://docs.python.org/pt-br/3/library/abc.html[documentação do módulo `abc`].
+https://fpy.li/6r[documentação do módulo `abc`].
 ====
 
 O código do o método `.inspect()` é simplório, mas mostra que podemos confiar em
@@ -1108,7 +1107,7 @@ A ordem dos decoradores de função empilhados importa, e no caso de `@abstractm
 [quote]
 ____
 Quando `@abstractmethod` é aplicado em combinação com outros descritores de método,
-ele deve ser aplicado como o decorador mais interno...footnote:[O verbete https://docs.python.org/pt-br/dev/library/abc.html#abc.abstractmethod[`@abc.abstractmethod`] na https://docs.python.org/pt-br/dev/library/abc.html[documentação do módulo `abc`].]
+ele deve ser aplicado como o decorador mais interno...footnote:[O verbete https://fpy.li/6s[`@abc.abstractmethod`] na https://docs.python.org/pt-br/dev/library/abc.html[documentação do módulo `abc`].]
 ____
 
 Em outras palavras, nenhum outro decorador pode aparecer entre `@abstractmethod` e a instrução `def`.
@@ -1134,7 +1133,7 @@ include::../code/13-protocol-abc/bingo.py[tags=TOMBOLA_BINGO]
 ====
 <1> Essa classe `BingoCage` estende `Tombola` explicitamente.
 <2> Finja que vamos usar isso para um jogo online. `random.SystemRandom` implementa
-a API `random` sobre a função `os.urandom(…)`, que fornece bytes aleatórios "adequados para uso em criptografia", segundo https://docs.python.org/pt-br/3/library/os.html#os.urandom[a documentação do módulo `os`].
+a API `random` sobre a função `os.urandom(…)`, que fornece bytes aleatórios "adequados para uso em criptografia", segundo https://fpy.li/6t[a documentação do módulo `os`].
 <3> Delega o carregamento inicial para o método `.load()`
 <4> Em vez da função `random.shuffle()` normal, usamos o método `.shuffle()` de nossa instância de `SystemRandom`.
 <5> `pick` é implementado como em <<ex_bingo_callable>>.
@@ -1223,7 +1222,7 @@ include::../code/13-protocol-abc/tombolist.py[]
 <3> `TomboList` herda seu comportamento booleano de `list`, e isso retorna `True` se a lista não estiver vazia.
 <4> Nosso `pick` chama `self.pop`, herdado de `list`, passando um índice aleatório para um item.
 <5> `TomboList.load` é o mesmo que `list.extend`.
-<6> `loaded` delega para `bool`.footnote:[O truque usado com `load()` não funciona com `loaded()`, pois o tipo `list` não implementa `+__bool__+`, o método que eu teria de vincular a `loaded`. O `bool()` nativo não precisa de `+__bool__+` para funcionar, porque pode também usar `+__len__+`. Veja https://docs.python.org/pt-br/3/library/stdtypes.html#truth["4.1. Teste do Valor Verdade"] no capítulo "Tipos Embutidos" da documentação de Python.]
+<6> `loaded` delega para `bool`.footnote:[O truque usado com `load()` não funciona com `loaded()`, pois o tipo `list` não implementa `+__bool__+`, o método que eu teria de vincular a `loaded`. O `bool()` nativo não precisa de `+__bool__+` para funcionar, porque pode também usar `+__len__+`. Veja https://fpy.li/2g["4.1. Teste do Valor Verdade"] no capítulo "Tipos Embutidos" da documentação de Python.]
 <7> É sempre possível chamar `register` dessa forma, e é útil fazer assim quando você precisa registrar uma classe que você não mantém, mas que implementa a interface.
 
 Note que, por causa do registro,
@@ -1847,7 +1846,7 @@ Isso torna mais fácil criar novos tipos para chamar aquela função,
 bom para a extensibilidade e para testes com simulações ou protótipos.
 
 Ambas as práticas, protocolos estreitos e protocolos em código cliente, evitam um acoplamento muito firme, em acordo com o
-https://pt.wikipedia.org/wiki/Princ%C3%ADpio_da_segrega%C3%A7%C3%A3o_de_interface[Princípio da Segregação de Interface],
+https://fpy.li/6v[Princípio da Segregação de Interface],
 que podemos resumir como "Clientes não devem ser forçados a depender de interfaces que não usam."
 
 A página https://fpy.li/13-35["Contributing to typeshed"] (EN)