Ejemplos de instrucciones de análisis

Consulta ejemplos prácticos de instrucciones de análisis para Custom Parser: maneja objetos anidados, listas, errores y matrices de matrices.

El siguiente fragmento de HTML se analiza usando instrucciones de análisis de ejemplo en las secciones siguientes.

HTML de ejemplo

<body>
    <div id="products">
        <div class="product" id="shoes">
            <div class="title">Zapatos</div>
            <div class="price">223.12</div>
            <div class="description">
                <ul>
                    <li class="description-item">Súper</li>
                </ul>
            </div>
        </div>
        <div class="product" id="pants">
            <div class="title">Pantalones</div>
            <div class="price">60.12</div>
            <div class="description">
                <ul>
                    <li class="description-item">Increíble</li>
                    <li class="description-item">Calidad</li>
                </ul>
            </div>
        </div>
        <div class="product" id="socks">
            <div class="title">Calcetines</div>
            <div class="price">123.12</div>
            <div class="description">
                <ul>
                    <li class="description-item">Muy</li>
                    <li class="description-item">Bonito</li>
                    <li class="description-item">Calcetines</li>
                </ul>
            </div>
        </div>
    </div>
</body>

Mínimo indispensable

Caso de uso: quieres extraer el texto de todos los zapatos descripción elementos.

Ejemplo 1. Selección de elementos de la descripción de zapatos usando XPath.

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

La función xpath encontrará un solo elemento y lo pondrá en una lista como cadena:

{
    "shoes_description": [
        "Súper"
    ]
}

El comportamiento exacto xpath de la función se describe aquí.

Instrucciones de análisis anidadas

Caso de uso: quieres analizar toda la información relacionada con zapatos. Además, el resultado analizado debe representar la estructura del documento del HTML proporcionado.

Estás apuntando a esta parte del HTML de ejemplo:

<div class="product" id="shoes">
    <div class="title">Zapatos</div>
    <div class="price">223.12</div>
    <div class="description">
        <ul>
            <li class="description-item">Súper</li>
        </ul>
    </div>
</div>

Y te gustaría que el resultado analizado tuviera la siguiente estructura:

{
    "shoes": {
        "title": "Zapatos",
        "price": "223.12",
        "description": [
            "Súper"
        ]
    }
}

Las instrucciones de análisis serían así.

Ejemplo 2. Las instrucciones de análisis se usan para analizar zapatos información.

{
    "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 similar a xpath, pero en lugar de devolver una lista de todas las coincidencias, devuelve el primer elemento coincidente.

En el ejemplo anterior, la zapatos propiedad es la única propiedad definida en el ámbito de instrucciones más externo. La zapatos propiedad contiene instrucciones de análisis anidadas.

La función zapatos el ámbito de instrucciones no tiene una canalización definida (_fns propiedad falta). Esto significa que las canalizaciones definidas en title, price, y descripción los ámbitos usarán el documento en análisis como entrada de la canalización.

En el Ejemplo 2, puedes ver una repetición de //div[@id='shoes'] en expresiones XPath. La repetición se puede evitar definiendo una canalización en zapatos ámbito:

Ejemplo 3. Definir una canalización en zapatos instrucciones de ámbito para evitar la repetición de la expresión 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()"]
                }
            ]
        }
    }
}

Al usar las instrucciones de análisis proporcionadas en el Ejemplo 3, Custom Parser hará lo siguiente:

Empezar procesando shoes._fns la canalización, que generará el zapatos elemento HTML;
Tomar shoes._fns la salida de la canalización y usarla como entrada para las canalizaciones definidas en title, price, y descripción los ámbitos;
Procesar title, price, y descripción las canalizaciones para producir los valores finales.

El resultado se verá igual que el resultado del Ejemplo 2:

{
    "shoes": {
        "title": "Zapatos",
        "price": "223.12",
        "description": [
            "Súper"
        ]
    }
}

La diferencia principal entre el Ejemplo 2 y el Ejemplo 3 es que en el Ejemplo 3, la canalización se define en el zapatos ámbito. Esta canalización adicional selecciona el elemento de los zapatos y lo pasa a canalizaciones posteriores que se encuentran más abajo en la jerarquía de instrucciones.

Lista de objetos anidados

Caso de uso: Anteriormente, querías analizar solo zapatos información. Ahora quieres analizar la información de todos los productos del HTML.

La función HTML de ejemplo se usa de nuevo como el documento en análisis.

Si quieres que tu resultado analizado se vea así:

{
    "products": [
        {
            "title": "Zapatos",
            "price": "223.12",
            "description": [
                "Súper"
            ]
        },
        {
            "title": "Pantalones",
            "price": "60.12",
            "description": [
                "Increíble",
                "Calidad"
            ]
        },
        {
            "title": "Calcetines",
            "price": "123.12",
            "description": [
                "Muy",
                "Bonito",
                "Calcetines"
            ]
        }
    ]
}

Las instrucciones de análisis serían así:

Ejemplo 4. Análisis de todos los productos encontrados en el 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()"]
                    }
                ]
            }
        }
    }
}

La estructura de las instrucciones de análisis se parece a la del Ejemplo 3. Sin embargo, hay dos excepciones importantes:

xpath se usa en lugar de xpath_one en products._fns canalización. products._fns la canalización ahora generará una lista de todos los elementos que coinciden con la expresión XPath proporcionada (una lista de elementos de producto).
_items la propiedad reservada se usa para indicar que quieres formar una lista iterando sobre cada elemento de la products._fns salida de la canalización y pasando/procesando cada elemento de la lista por separado dentro del ámbito de la canalización.

Si _items la propiedad reservada no se usara en las instrucciones de análisis del Ejemplo 4, el resultado analizado se vería así:

{
    "products": {
        "title": [
            "Zapatos",
            "Pantalones",
            "Calcetines"
        ],
        "price": [
            "223.12",
            "60.12",
            "123.12"
        ],
        "description": [
            [
                "Súper"
            ],
            [
                "Increíble",
                "Calidad"
            ],
            [
                "Muy",
                "Bonito",
                "Calcetines"
            ]
        ]
    }
}

_items se usa para especificar que Custom Parser debe pasar elementos de lista separados en lugar de la lista completa a través de las instrucciones de análisis.

Selecciona el n-ésimo elemento de una lista

Esta sección demuestra la flexibilidad de las canalizaciones. El mismo problema puede abordarse de diferentes maneras.

Se pueden usar varias opciones para seleccionar el n-ésimo elemento de una lista de cualquier valor.

Caso de uso: quieres seleccionar el precio del segundo producto de la página.

La función HTML de ejemplo se usa de nuevo como ejemplo. Tienes varias opciones para seleccionar el 2.º producto.

Opción 1

Puedes utilizar el selector XPath [] y definir la selección en la expresión XPath.

Ejemplo 5. Selecciona el 2.º precio usando el selector XPath [].

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

Resultado:

{
    "second_price": [
        "60.12"
    ]
}

Opción 2

También puedes usar la xpath función para encontrar todos los precios y canalizarlo a la función select_nth, que selecciona el n-ésimo elemento de la lista de precios extraída.

Ejemplo 6. Selecciona el 2.º valor usando la función `select_nth`.

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

Resultado:

{
    "second_price": "60.12"
}

Observa cómo la select_nth función devuelve un elemento de una lista mientras que la xpath función devuelve una lista de elementos, incluso si se encuentra un solo elemento.

Opción 3

Puedes usar select_nth con cualquier tipo de lista, incluidas listas de elementos HTML:

Ejemplo 7. Seleccionando todos los elementos HTML de producto con class="product" ==> seleccionando el 2.º elemento de producto de la lista ==> extrayendo el texto del precio del elemento HTML de producto seleccionado.

{
    "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"]
}

Manejo de errores

Cuando se proporciona el siguiente fragmento de HTML:

<div class="product" id="shoes">
    <div class="title">Zapatos bonitos</div>
    <div class="price">223.12</div>
    <div class="description">Súper</div>
</div>

Y al intentar analizar it con las siguientes instrucciones de análisis:

{
    "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 devolverá un resultado analizado en el que price y title se analizaron normalmente, pero la descripción no se pudo analizar debido al convert_to_float fallo de la función al convertir cadena a float:

{
    "product": {
        "price": "223.12",
        "title": "Zapatos",
        "description": null
    },
    "_warnings": [
        {
            "_fn": "convert_to_float",
            "_fn_idx": 1,
            "_msg": "No se pudo procesar la función.",
            "_path": ".product.description"
        }
    ]
}

Por defecto, todos los errores se cuentan como advertencias y se colocan dentro de la _warnings lista. Si quieres ignorar los errores al analizar un campo, puedes suprimir las advertencias/errores con "_on_error": "suppress" parámetro:

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

Lo que luego producirá el siguiente resultado:

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

Matriz de matrices

Custom Parser permite matrices n-dimensionales en los resultados analizados. Como ejemplo, usemos el siguiente fragmento 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>

Supongamos que quieres analizar el documento para que el resultado sea una matriz bidimensional 3x3 de enteros:

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

Para analizar el HTML en el JSON anterior, puedes usar las siguientes instrucciones de análisis:

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

AnteriorEscritura manual de instrucciones

SiguienteConsejos para escribir expresiones XPath

Última actualización hace 2 días

¿Te fue útil?