Exemplos de instruções de parsing

Veja exemplos práticos de instruções de análise para o Custom Parser: manipule objetos aninhados, listas, erros e matrizes de matrizes.

O seguinte trecho de HTML é analisado usando instruções de parsing de exemplo nas próximas seções.

HTML de exemplo

<body>
    <div id="products">
        <div class="product" id="shoes">
            <div class="title">Sapatos</div>
            <div class="price">223.12</div>
            <div class="description">
                <ul>
                    <li class="description-item">Super</li>
                </ul>
            </div>
        </div>
        <div class="product" id="pants">
            <div class="title">Calças</div>
            <div class="price">60.12</div>
            <div class="description">
                <ul>
                    <li class="description-item">Incrível</li>
                    <li class="description-item">Qualidade</li>
                </ul>
            </div>
        </div>
        <div class="product" id="socks">
            <div class="title">Meias</div>
            <div class="price">123.12</div>
            <div class="description">
                <ul>
                    <li class="description-item">Muito</li>
                    <li class="description-item">Bom</li>
                    <li class="description-item">Meias</li>
                </ul>
            </div>
        </div>
    </div>
</body>

Mínimo indispensável

Caso de uso: você quer extrair o texto de todos os sapatos descrição itens.

Exemplo 1. Seleção dos itens de descrição dos sapatos usando XPath.

{
    "shoes_description": {
        "_fns": [
            {
                "_fn": "xpath",
                "_args": [
                    ".//div[@id='shoes']//li[@class='description-item']/text()"
                ]
            }
        ]
    }
}

A xpath a função encontrará um único item e o colocará em uma lista como uma string:

{
    "shoes_description": [
        "Super"
    ]
}

O exato xpath comportamento da função é descrito aqui.

Instruções de parsing aninhadas

Caso de uso: você quer analisar todas as informações relacionadas aos sapatos. Além disso, o resultado analisado deve representar a estrutura do documento do HTML fornecido.

Você está direcionando esta parte do HTML de exemplo:

<div class="product" id="shoes">
    <div class="title">Sapatos</div>
    <div class="price">223.12</div>
    <div class="description">
        <ul>
            <li class="description-item">Super</li>
        </ul>
    </div>
</div>

E você gostaria que o resultado analisado tivesse a seguinte estrutura:

{
    "shoes": {
        "title": "Sapatos",
        "price": "223.12",
        "description": [
            "Super"
        ]
    }
}

As instruções de parsing teriam a seguinte aparência.

Exemplo 2. As instruções de parsing são usadas para analisar sapatos informações.

{
    "shoes": {
        "title": {
            "_fns": [
                {
                    "_fn": "xpath_one",
                    "_args": ["//div[@id='shoes']/div[@class='title']/text()"]
                }
            ]
        },
        "price": {
            "_fns": [
                {
                    "_fn": "xpath_one",
                    "_args": ["//div[@id='shoes']/div[@class='price']/text()"]
                }
            ]
        },
        "description": {
            "_fns": [
                {
                    "_fn": "xpath",
                    "_args": ["//div[@id='shoes']//li[@class='description-item']/text()"]
                }
            ]
        }
    }
}

xpath_one funciona de forma semelhante a xpath, mas em vez de retornar uma lista de todas as correspondências, retorna o primeiro item correspondente.

No exemplo acima, a sapatos propriedade é a única propriedade definida no escopo mais externo das instruções. A sapatos propriedade contém instruções de parsing aninhadas.

A sapatos o escopo das instruções não tem um pipeline definido (_fns propriedade está ausente). Isso significa que os pipelines definidos em title, price, e descrição os escopos usarão o documento em análise como entrada do pipeline.

No Exemplo 2, você pode ver uma repetição de //div[@id='shoes'] nas expressões XPath. A repetição pode ser evitada definindo um pipeline em sapatos escopo:

Exemplo 3. Definindo um pipeline nas instruções de escopo sapatos para evitar a repetição da expressão XPath.

{
    "shoes": {
        "_fns": [
            {
                "_fn": "xpath_one",
                "_args": ["//div[@id='shoes']"]
            }
        ],
        "title": {
            "_fns": [
                {
                    "_fn": "xpath_one",
                    "_args": ["./div[@class='title']/text()"]
                }
            ]
        },
        "price": {
            "_fns": [
                {
                    "_fn": "xpath_one",
                    "_args": ["./div[@class='price']/text()"]
                }
            ]
        },
        "description": {
            "_fns": [
                {
                    "_fn": "xpath",
                    "_args": [".//li[@class='description-item']/text()"]
                }
            ]
        }
    }
}

Usando as instruções de parsing fornecidas no Exemplo 3, Custom Parser irá:

Começar processando shoes._fns pipeline, que produzirá o sapatos elemento HTML;
Pegar a saída do shoes._fns pipeline e usá-la como entrada para os pipelines definidos em title, price, e descrição escopos;
Processar title, price, e descrição pipelines para produzir os valores finais.

O resultado será igual ao resultado do Exemplo 2:

{
    "shoes": {
        "title": "Sapatos",
        "price": "223.12",
        "description": [
            "Super"
        ]
    }
}

A principal diferença entre o Exemplo 2 e o Exemplo 3 é que, no Exemplo 3, o pipeline é definido no sapatos escopo. Esse pipeline adicional seleciona o elemento dos sapatos e o passa adiante para outros pipelines encontrados mais profundamente na hierarquia de instruções.

Lista de objetos aninhados

Caso de uso: Anteriormente, você queria analisar apenas sapatos informações. Agora você quer analisar as informações de todos os produtos no HTML.

A HTML de exemplo é usado novamente como o documento em análise.

Se você quiser que o resultado analisado se pareça com isto:

{
    "products": [
        {
            "title": "Sapatos",
            "price": "223.12",
            "description": [
                "Super"
            ]
        },
        {
            "title": "Calças",
            "price": "60.12",
            "description": [
                "Incrível",
                "Qualidade"
            ]
        },
        {
            "title": "Meias",
            "price": "123.12",
            "description": [
                "Muito",
                "Bonito",
                "Meias"
            ]
        }
    ]
}

As instruções de parsing teriam a seguinte aparência:

Exemplo 4. Analisando todos os produtos encontrados no documento HTML.

{
    "products": {
        "_fns": [
            {
                "_fn": "xpath",
                "_args": ["//div[@class='product']"]
            }
        ],
        "_items": {
            "title": {
                "_fns": [
                    {
                        "_fn": "xpath_one",
                        "_args": ["./div[@class='title']/text()"]
                    }
                ]
            },
            "price": {
                "_fns": [
                    {
                        "_fn": "xpath_one",
                        "_args": ["./div[@class='price']/text()"]
                    }
                ]
            },
            "description": {
                "_fns": [
                    {
                        "_fn": "xpath",
                        "_args": [".//li[@class='description-item']/text()"]
                    }
                ]
            }
        }
    }
}

A estrutura da instrução de parsing parece semelhante à do Exemplo 3. No entanto, há duas exceções principais:

xpath é usado em vez de xpath_one em products._fns pipeline. products._fns o pipeline agora produzirá uma lista de todos os elementos que correspondem à expressão XPath fornecida (uma lista de elementos de produto).
_items a propriedade reservada é usada para indicar que você quer formar uma lista iterando por cada item da saída do products._fns pipeline e passando/processando cada item da lista separadamente para o escopo do pipeline.

Se _items a propriedade reservada não fosse usada nas instruções de parsing do Exemplo 4, o resultado analisado teria a seguinte aparência:

{
    "products": {
        "title": [
            "Sapatos",
            "Calças",
            "Meias"
        ],
        "price": [
            "223.12",
            "60.12",
            "123.12"
        ],
        "description": [
            [
                "Super"
            ],
            [
                "Incrível",
                "Qualidade"
            ],
            [
                "Muito",
                "Bonito",
                "Meias"
            ]
        ]
    }
}

_items é usado para especificar que o Custom Parser deve passar itens separados da lista em vez da lista inteira para baixo nas instruções de parsing.

Selecione o enésimo elemento de uma lista

Esta seção demonstra a flexibilidade dos pipelines. O mesmo problema pode ser abordado de maneiras diferentes.

Múltiplas opções podem ser usadas para selecionar o enésimo elemento de uma lista de qualquer valor.

Caso de uso: você quer selecionar o segundo preço do produto na página.

A HTML de exemplo é usado novamente como exemplo. Você tem várias opções para selecionar o 2º produto.

Opção 1

Você pode utilizar o seletor XPath [] e definir a seleção na expressão XPath.

Exemplo 5. Selecione o 2º preço usando o seletor XPath [].

{
    "second_price": {
        "_fns": [
            {
                "_fn": "xpath",
                "_args": [
                    "(//div[@class='price'])[2]/text()"
                ]
            }
        ]
    }
}

Resultado:

{
    "second_price": [
        "60.12"
    ]
}

Opção 2

Você também pode usar a xpath função para encontrar todos os preços e encaminhá-la para a função select_nth, que seleciona o enésimo elemento da lista extraída de preços.

Exemplo 6. Selecione o 2º valor usando a função `select_nth`.

{
    "second_price": {
        "_fns": [
            {
                "_fn": "xpath",
                "_args": [
                    "//div[@class='price']/text()"
                ]
            },
            {
                "_fn": "select_nth",
                "_args": 1
            }
        ]
    }
}

Resultado:

{
    "second_price": "60.12"
}

Observe como a select_nth função retorna um item de uma lista, enquanto a xpath função retorna uma lista de itens, mesmo quando um único item é encontrado.

Opção 3

Você pode usar select_nth com qualquer tipo de lista, incluindo listas de elementos HTML:

Exemplo 7. Selecionando todos os elementos HTML de produto com class="product" ==> selecionando o 2º elemento de produto da lista ==> extraindo o texto do preço do elemento HTML do produto selecionado.

{
    "second_price": {
        "_fns": [
            {
                "_fn": "xpath",
                "_args": ["//div[@class='product']"]
            },
            {
                "_fn": "select_nth",
                "_args": 1
            },
            {
                "_fn": "xpath",
                "_args": ["./div[@class='price']/text()"]
            }
        ]
    }
}

Resultado:

{
    "second_price": ["60.12"]
}

Tratamento de erros

Ao receber o seguinte trecho de HTML:

<div class="product" id="shoes">
    <div class="title">Sapatos Bonitos</div>
    <div class="price">223.12</div>
    <div class="description">Super</div>
</div>

E tentar analisá-lo com as seguintes instruções de parsing:

{
    "product": {
        "_fns": [
            {
                "_fn": "xpath_one",
                "_args": ["//div[@id='shoes']"]
            }
        ],
        "price": {
            "_fns": [
                {
                    "_fn": "xpath_one",
                    "_args": ["//div[@class='price']/text()"]
                }
            ]
        },
        "title": {
            "_fns": [
                {
                    "_fn": "xpath_one",
                    "_args": ["//div[@class='title']/text()"]
                }
            ]
        },
        "description": {
            "_fns": [
                {
                    "_fn": "xpath_one",
                    "_args": ["//div[@class='description']/text()"]
                },
                {
                    "_fn": "convert_to_float"
                }
            ]
        }
    }
}

Custom Parser retornará um resultado analisado em que price e title foram analisados normalmente, mas o descrição falhou ao ser analisado devido ao convert_to_float falhar ao converter string até float:

{
    "product": {
        "price": "223.12",
        "title": "Sapatos",
        "description": null
    },
    "_warnings": [
        {
            "_fn": "convert_to_float",
            "_fn_idx": 1,
            "_msg": "Failed to process function.",
            "_path": ".product.description"
        }
    ]
}

Por padrão, todos os erros são contados como avisos e são colocados dentro da _warnings lista. Se você quiser ignorar os erros ao analisar um campo, eles podem suprimir avisos/erros com "_on_error": "suppress" parâmetro:

{
    "product": {
        ...,
        "description": {
            "_on_error": "suppress",
            "_fns": [
                {
                    "_fn": "xpath_one",
                    "_args": ["//div[@class='description']/text()"]
                },
                {
                    "_fn": "convert_to_float"
                }
            ]
        }
    }
}

O que então produzirá o seguinte resultado:

{
    "product": {
        "price": "223.12",
        "title": "Sapatos",
        "description": null
    }
}

Matriz de matrizes

Custom Parser permite matrizes N-dimensionais nos resultados analisados. Como exemplo, vamos usar o seguinte trecho de HTML:

<div class="row">
    <div class="column">1</div>
    <div class="column">2</div>
    <div class="column">3</div>
</div>
<div class="row">
    <div class="column">4</div>
    <div class="column">5</div>
    <div class="column">6</div>
</div>
<div class="row">
    <div class="column">7</div>
    <div class="column">8</div>
    <div class="column">9</div>
</div>

Digamos que você queira analisar o documento de forma que o resultado seja uma matriz 2D 3x3 de inteiros:

{
    "table": [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9],
    ]
}

Para analisar o HTML no JSON acima, você pode usar as seguintes instruções de parsing:

{
    "table": {
        "_fns": [
            {
                "_fn": "xpath",
                "_args": ["//div[@class='row']"]
            },
            {
                "_fn": "xpath",
                "_args": [".//div[@class='column']/text()"]
            },
            {
                "_fn": "convert_to_int"
            }
        ]
    }
}

AnteriorEscrevendo instruções manualmente PróximoDicas para escrever expressões XPath

Isto foi útil?