links curtos para capítulos

Author: ramalho

replacer.ipynb

@@ -0,0 +1,159 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "eb57d79f-c9cd-45a6-bc29-8a4cbd9dc87e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def to_int(s):\n",
+    "    try:\n",
+    "        n = int(s)\n",
+    "    except ValueError:\n",
+    "        n = int(s[0]) * 10 + ord(s[1])\n",
+    "    return n\n",
+    "\n",
+    "def get_id(s):\n",
+    "    return s[s.index('#ch_')+1:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "2ec7ea76-776f-48f7-b84b-d172d41cb004",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/4q /13 ch_ifaces_prot_abc\n",
+      "/4r /16 ch_op_overload\n",
+      "/4s /17 ch_generators\n",
+      "/4t /12 ch_seq_methods\n",
+      "/53 /24 ch_class_metaprog\n",
+      "/54 /15 ch_more_types\n",
+      "/55 /23 ch_descriptors\n",
+      "/56 /14 ch_inheritance\n",
+      "/57 /21 ch_async\n",
+      "/5c /9 ch_closure_decorator\n",
+      "/5d /10 ch_design_patterns\n",
+      "{'/4q': '/13',\n",
+      " '/4r': '/16',\n",
+      " '/4s': '/17',\n",
+      " '/4t': '/12',\n",
+      " '/53': '/24',\n",
+      " '/54': '/15',\n",
+      " '/55': '/23',\n",
+      " '/56': '/14',\n",
+      " '/57': '/21',\n",
+      " '/5c': '/9',\n",
+      " '/5d': '/10'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open('links/FPY.LI.htaccess') as fp:\n",
+    "    lines = fp.readlines()\n",
+    "\n",
+    "PRE = 'https://pythonfluente.com/2/#ch_'\n",
+    "\n",
+    "id2n = {}\n",
+    "subs = {}\n",
+    "\n",
+    "for line in lines:\n",
+    "    try:\n",
+    "        _, short, long = line.strip().split()\n",
+    "    except ValueError:\n",
+    "        continue\n",
+    "    if not long.startswith(PRE):\n",
+    "        continue\n",
+    "    n = to_int(short[1:])\n",
+    "    id = get_id(long)\n",
+    "    if n in range(1, 25):\n",
+    "        id2n[id] = n\n",
+    "    else:\n",
+    "        print(f'{short} /{id2n[id]} {id}')\n",
+    "        subs[short] = f'/{id2n[id]}'\n",
+    "\n",
+    "from pprint import pprint\n",
+    "pprint(subs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "d4efc774-3fae-4dd2-91c9-284985f3bddc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "vol1/cap03.adoc\n",
+      "vol1/Copyright-pb.adoc\n",
+      "vol1/cap02.adoc\n",
+      "vol1/cap05.adoc\n",
+      "vol1/cap04.adoc\n",
+      "vol1/cap08.adoc\n",
+      "vol1/Copyright-cor.adoc\n",
+      "vol1/cap07.adoc\n",
+      "vol1/cap06.adoc\n",
+      "vol1/titulos-vol1.adoc\n",
+      "vol1/vol1-pb.adoc\n",
+      "vol1/vol1-cor.adoc\n",
+      "vol1/cap01.adoc\n",
+      "vol1/Prefacio.adoc\n"
+     ]
+    }
+   ],
+   "source": [
+    "from glob import glob\n",
+    "\n",
+    "link = 'fpy.li{}&'\n",
+    "\n",
+    "for name in glob('vol1/*.adoc'):\n",
+    "    print(name)\n",
+    "    with open(name) as fp:\n",
+    "        adoc = fp.read()\n",
+    "    for old, new in subs.items():\n",
+    "        old, new = link.format(old), link.format(new)\n",
+    "        adoc = adoc.replace(old, new)\n",
+    "    with open(name, 'w', encoding='utf8') as fp:\n",
+    "        fp.write(adoc)\n",
+    "\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e801a363-bb8c-4db9-ae1b-216fc1dbb27c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.14.0rc1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

vol1/cap01.adoc

@@ -321,7 +321,7 @@ startref="len01")))((("", startref="pycard01")))((("", startref="SMgetitem01")))
 Como foi implementado até aqui, um `FrenchDeck` não pode ser embaralhado,
 porque as cartas e suas posições não podem ser alteradas,
 exceto violando o encapsulamento e manipulando o atributo `_cards` diretamente.
-No «Capítulo 13» [.small]#[vol.2, fpy.li/4q]#
+No «Capítulo 13» [.small]#[vol.2, fpy.li/13]#
 vamos corrigir isso acrescentando um método `+__setitem__+` de uma linha.
 Você consegue imaginar como ele seria implementado?
 =====================================================================
@@ -374,7 +374,7 @@ determinar o valor booleano de um objeto, e implementar coleções.
 Vários((("special methods", "emulating numeric types", id="SMnumeric01")))((("numeric types",
 "emulating using special methods", id="NTemul01")))
 métodos especiais permitem que objetos criados pelo usuário respondam a operadores como `+`.
-Vamos tratar disso com mais detalhes no «Capítulo 16» [.small]#[vol.2, fpy.li/4r]#.
+Vamos tratar disso com mais detalhes no «Capítulo 16» [.small]#[vol.2, fpy.li/16]#.
 Aqui nosso objetivo é continuar ilustrando o uso dos métodos especiais, através de outro exemplo simples.
 
 Vamos((("vectors", "representing two-dimensional", id="Vtwo01"))) implementar uma classe para representar
@@ -385,7 +385,7 @@ vetores bidimensionais—isto é, vetores euclidianos como aqueles usados em mat
 ======
 O tipo embutido `complex` pode ser usado para representar vetores bidimensionais,
 mas nossa classe pode ser estendida para representar vetores N-dimensionais.
-Faremos isso no «Capítulo 17» [.small]#[vol.3, fpy.li/4s]#.
+Faremos isso no «Capítulo 17» [.small]#[vol.3, fpy.li/17]#.
 ======
 
 [[vectors_fig]]
@@ -454,14 +454,14 @@ para demonstrar o uso básico de `+__add__+` e `+__mul__+`.
 Nos dois casos, os métodos criam e devolvem uma nova instância de `Vector`,
 e não modificam nenhum dos operandos: `self` e `other` são apenas lidos.
 Esse é o comportamento esperado de operadores infixos: criar novos objetos e não tocar em seus operandos.
-Vou falar mais sobre esse tópico no «Capítulo 16» [.small]#[vol.2, fpy.li/4r]#.
+Vou falar mais sobre esse tópico no «Capítulo 16» [.small]#[vol.2, fpy.li/16]#.
 
 [WARNING]
 ====
 Da forma como está implementado, o <<ex_vector2d>> permite multiplicar um `Vector` por um número,
 mas não um número por um `Vector`,
 violando a propriedade comutativa da multiplicação escalar.
-Vamos consertar isso com o método especial `+__rmul__+` no «Capítulo 16» [.small]#&#91;vol.2, fpy.li/4r&#93;#.
+Vamos consertar isso com o método especial `+__rmul__+` no «Capítulo 16» [.small]#&#91;vol.2, fpy.li/16&#93;#.
 ====
 
 Nas seções seguintes vamos discutir os outros métodos especiais em
@@ -581,7 +581,7 @@ id="SMcollection01")))((("Collection API", id="Cspeical01")))((("ABCs (abstract
 as interfaces dos tipos de coleções essenciais na linguagem.
 Todas as classes no diagrama são ABCs—_classes base abstratas_
 (_ABC_ é sigla para _Abstract Base Class_).
-As ABCs e o módulo `collections.abc` são tratados no «Capítulo 13» [.small]#&#91;vol.2, fpy.li/4q&#93;#.
+As ABCs e o módulo `collections.abc` são tratados no «Capítulo 13» [.small]#&#91;vol.2, fpy.li/13&#93;#.
 O objetivo dessa pequena seção é dar uma visão panorâmica das interfaces das coleções mais importantes de Python,
 mostrando como elas são criadas a partir de métodos especiais.
 
@@ -663,7 +663,7 @@ Operadores infixos e numéricos são suportados pelos métodos especiais listado
 <<special_operators_tbl>>.
 Aqui os nomes mais recentes são `+__matmul__+`, `+__rmatmul__+`, e `+__imatmul__+`,
 adicionados no Python 3.5 para suportar o uso de `@` como operador de multiplicação de matrizes,
-como veremos no «Capítulo 16» [.small]#&#91;vol.2, fpy.li/4r&#93;#.((("special methods", "special method names and symbols for operators")))
+como veremos no «Capítulo 16» [.small]#&#91;vol.2, fpy.li/16&#93;#.((("special methods", "special method names and symbols for operators")))
 
 [[special_operators_tbl]]
 .Nomes e símbolos de métodos especiais para operadores
@@ -686,7 +686,7 @@ Python invoca um método especial de operador reverso no segundo argumento
 quando o método especial correspondente não pode ser usado no primeiro operando.
 Atribuições aumentadas são um atalho combinando um operador infixo com uma atribuição de variável, por exemplo `a += b`.
 
-O «Capítulo 16» [.small]#&#91;vol.2, fpy.li/4r&#93;#
+O «Capítulo 16» [.small]#&#91;vol.2, fpy.li/16&#93;#
 explica em detalhes os operadores reversos e a atribuição aumentada.((("", startref="PDMspmtov01")))
 ====
 
@@ -736,15 +736,15 @@ uma para depuração e registro (_log_), outra para apresentar aos usuários fin
 Emular sequências, como mostrado com o exemplo do `FrenchDeck`, é um dos usos mais comuns dos métodos especiais.
 Por exemplo, bibliotecas de banco de dados frequentemente devolvem resultados de consultas na forma de coleções similares a sequências.
 Tirar o máximo proveito dos tipos de sequências existentes é o assunto do <<ch_sequences>>.
-Como implementar suas próprias sequências será visto no «Capítulo 12» [.small]#&#91;vol.2, fpy.li/4t&#93;#,
+Como implementar suas próprias sequências será visto no «Capítulo 12» [.small]#&#91;vol.2, fpy.li/12&#93;#,
 onde criaremos uma extensão multidimensional da classe `Vector`.
 
 Graças à sobrecarga de operadores, Python oferece uma rica seleção de tipos numéricos,
 desde os tipos embutidos até `decimal.Decimal` e `fractions.Fraction`,
 todos eles suportando operadores aritméticos infixos.
 A biblioteca de ciência de dados _NumPy_ suporta operadores infixos com matrizes e tensores.
 A implementação de operadores—incluindo operadores reversos e atribuição aumentada—será vista no
-«Capítulo 16» [.small]#&#91;vol.2, fpy.li/4r&#93;#,
+«Capítulo 16» [.small]#&#91;vol.2, fpy.li/16&#93;#,
 usando melhorias do exemplo `Vector`.
 
 Também veremos o uso e a implementação da maioria dos outros métodos especiais do Modelo de Dados de Python ao longo deste livro.

vol1/cap02.adoc

@@ -32,7 +32,7 @@ Tópicos específicos sobre listas, tuplas, arrays e filas também foram incluí
 mas os detalhes sobre strings Unicode e sequências de bytes são tratados no <<ch_str_bytes>>.
 Além disso, a ideia aqui é falar sobre os tipos de sequências prontas para usar.
 A criação de novos tipos de sequência é o tema do
-«Capítulo 12» [.small]#&#91;vol.2, fpy.li/4t&#93;#.
+«Capítulo 12» [.small]#&#91;vol.2, fpy.li/12&#93;#.
 
 Os((("sequences", "topics covered"))) principais tópicos cobertos neste capítulo são:
 
@@ -123,7 +123,7 @@ A <<sequence_uml>> ajuda a visualizar como as sequências mutáveis herdam todos
 das sequências imutáveis e implementam vários métodos adicionais.
 Os tipos embutidos de sequências na verdade não são subclasses das classes base abstratas (ABCs)
 `Sequence` e `MutableSequence`, mas sim _subclasses virtuais_ registradas com aquelas
-ABCs—como veremos no «Capítulo 13» [.small]#&#91;vol.2, fpy.li/4q&#93;#.
+ABCs—como veremos no «Capítulo 13» [.small]#&#91;vol.2, fpy.li/13&#93;#.
 Por serem subclasses virtuais, `tuple` e `list` passam nesses testes:
 
 [source, python]
@@ -452,7 +452,7 @@ nunca é criada neste exemplo.
 
 [NOTE]
 ====
-O «Capítulo 17» [.small]#&#91;vol.3, fpy.li/4s&#93;# explica em detalhes o funcionamento de geradoras.
+O «Capítulo 17» [.small]#&#91;vol.3, fpy.li/17&#93;# explica em detalhes o funcionamento de geradoras.
 A ideia aqui é apenas mostrar o uso de expressões geradores para inicializar sequências diferentes de listas,
 ou produzir uma saída que não precise ser mantida na memória.
 ====
@@ -667,7 +667,7 @@ Entretanto, `reversed(my_tuple)` funciona sem esse método; ele serve apenas par
 |         `+s.__len__()+` |   ●   |   ●   | `+len(s)+`—número de itens
 |        `+s.__mul__(n)+` |   ●   |   ●   | `+s * n+`—concatenação repetida
 |       `+s.__imul__(n)+` |   ●   |       | `+s *= n+`—concatenação repetida interna
-|       `+s.__rmul__(n)+` |   ●   |   ●   | `+n * s+`—concatenação repetida reversafootnote:[Operadores reversos são explicados no «Capítulo 16» [.small]#&#91;vol.2, fpy.li/4r&#93;.&#93;#]
+|       `+s.__rmul__(n)+` |   ●   |   ●   | `+n * s+`—concatenação repetida reversafootnote:[Operadores reversos são explicados no «Capítulo 16» [.small]#&#91;vol.2, fpy.li/16&#93;.&#93;#]
 |            `s.pop([p])` |   ●   |       | Remove e devolve o último item ou o item na posição opcional `p`
 |           `s.remove(e)` |   ●   |       | Remove o primeiro item de valor igual a `e`
 |           `s.reverse()` |   ●   |       | Inverte a ordem dos itens internamente
@@ -1324,7 +1324,7 @@ recurso comum a `list`, `tuple`, `str`, e a todos os tipos de sequência em Pyth
 é o suporte a operações de fatiamento, que são mais potentes do que a maioria das pessoas percebe.
 
 Nesta seção descrevemos o _uso_ dessas formas avançadas de fatiamento.
-Sua implementação em uma classe definida pelo usuário será tratada no «Capítulo 12» [.small]#&#91;vol.2, fpy.li/4t&#93;#,
+Sua implementação em uma classe definida pelo usuário será tratada no «Capítulo 12» [.small]#&#91;vol.2, fpy.li/12&#93;#,
 mantendo nossa filosofia de tratar de classes prontas para usar nessa parte do livro,
 e da criação de novas classes na
 «Parte III—Classes e protocolos» [.small]#&#91;vol.2, fpy.li/4v&#93;#.
@@ -1661,7 +1661,7 @@ Para sequências imutáveis, obviamente isso não pode acontecer.
 <<<
 O que acabei de escrever sobre `+=` também se aplica a `\*=`, que é implementado via `++__imul__++`.
 Os métodos especiais `++__iadd__++` e `++__imul__++` são tratados no
-«Capítulo 16» [.small]#&#91;vol.2, fpy.li/4r&#93;#.
+«Capítulo 16» [.small]#&#91;vol.2, fpy.li/16&#93;#.
 
 Veja uma demonstração de `*=` com uma sequência mutável e depois com uma sequência imutável:
 
@@ -1836,7 +1836,7 @@ da Wikipedia em inglês para uma descrição mais detalhada deste tópico.
 
 A função embutida `sorted`, por outro lado, cria e devolve uma nova lista.
 Ela aceita qualquer objeto iterável como um argumento, incluindo sequências imutáveis e geradores
-(veja o «Capítulo 17» [.small]#&#91;vol.3, fpy.li/4s&#93;#).
+(veja o «Capítulo 17» [.small]#&#91;vol.3, fpy.li/17&#93;#).
 Independente do tipo do iterável passado a `sorted`, ela sempre cria e devolve uma nova lista.
 
 <<<

vol1/cap03.adoc

@@ -180,7 +180,7 @@ O operador `|` cria um novo mapeamento:
 
 O tipo do novo mapeamento normalmente será o mesmo do operando da esquerda—no exemplo,
 `d1`—mas ele pode ser do tipo do segundo operando se tipos definidos pelo usuário estiverem envolvidos na operação,
-dependendo das regras de sobrecarga de operadores, que exploraremos no «Capítulo 16» [.small]#[vol.2, fpy.li/4r]#.
+dependendo das regras de sobrecarga de operadores, que exploraremos no «Capítulo 16» [.small]#[vol.2, fpy.li/16]#.
 
 Para atualizar mapeamentos existentes internamente, use `|=`.
 Retomando o exemplo anterior, ali `d1` não foi modificado.
@@ -331,7 +331,7 @@ True
 ====
 Usar `isinstance` com uma ABC é muitas vezes melhor que verificar se um argumento de função
 é do tipo concreto `dict`, porque daí tipos alternativos de mapeamentos podem ser usados.
-Vamos discutir isso em detalhes no «Capítulo 13» [.small]#[vol.2, fpy.li/4q]#.
+Vamos discutir isso em detalhes no «Capítulo 13» [.small]#[vol.2, fpy.li/13]#.
 ====
 
 [[mapping_uml]]
@@ -439,7 +439,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/16&#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)`