El tamaño y la varianza del vocabulario son conceptos semánticos y lingüísticos para la lingüística matemática y cualitativa.

Por poner un ejemplo, la ley de Heaps establece que la longitud del objeto y el tamaño del vocabulario son correlativos. No obstante, pasado cierto umbral, prosiguen mostrándose exactamente las mismas expresiones sin prosperar el tamaño del vocabulario.

Word2Vec emplea la bolsa continua de expresiones (CBOW) y Skip-gram para entender las expresiones importantes a nivel local y la distancia que las divide. Al tiempo, GloVe procura emplear la factorización de matrices con ventanas de contexto.

La ley de Zipf es una teoría complementaria a la ley de Heaps. Establece que las expresiones mucho más usuales y la segunda palabra mucho más recurrente tienen una diferencia porcentual regular entre ellas.

Hay otras semánticas distributivas y teorías lingüísticas en el procesamiento estadístico del lenguaje natural.

Pero la «comparación léxica» es una metodología primordial a fin de que los buscadores entiendan «diferencias de actualidad», «tema primordial del archivo» o «rivalidad general del archivo».

Paul Haahr de Google plus mencionó que equipara el «vocabulario de solicitud» con el «vocabulario de documentos».

David C. Taylor y sus proyectos de dominio de contexto implican algunos vectores de expresiones en la búsqueda de vectores para poder ver qué archivo y qué subsección del archivo son mucho más sobre qué, tal es así que un motor de búsqueda logre clasificar y reclasificar documentos según los cambios en las consultas de búsqueda.

La comparación de las diferencias de vocabulario entre las clasificaciones de webs en la página de desenlaces del motor de búsqueda (SERP) asiste para los expertos de SEO a conocer qué contextos, expresiones en rivalidad y cercanía de expresiones están suprimiendo con relación a sus contendientes.

Es útil ver las diferencias de contexto en los documentos.

En esta guía, se emplea el lenguaje de programación Python para buscar en Google plus y tomar elementos SERP (extractos) para seguir su contenido, tokenizar y cotejar su vocabulario entre sí.

Compare las diferencias de vocabulario entre la clasificación de páginas web SERP con Python

¿De qué forma equiparar el vocabulario de clasificación de documentos web con Python?

Para cotejar los vocabularios de clasificación de documentos web (con Python), las bibliotecas usadas y los packs del lenguaje de programación Python se cuentan ahora.

  • Googlesearch es un bulto de Python para efectuar una búsqueda en Google plus con una solicitud, zona, idioma, número de desenlaces, continuidad de peticiones o filtros de búsqueda seguros.
  • URLlib es una biblioteca de Python para investigar dirección de Internet en netloc, patrón o ruta.
  • Las peticiones (opcional) se usan para recobrar títulos, especificaciones y links de productos SERP (extractos).
  • Fake_useragent es un bulto de Python para emplear programas de usuario falsos y al azar para eludir códigos de estado 429.
  • Advertools se usa para seguir dirección de Internet de los resultados de la búsqueda de consultas de Google plus para recobrar su artículo para la limpieza y el procesamiento de artículo.
  • Pandas regula y añade datos para un mayor análisis de la semántica distributiva de los documentos SERP.
  • El grupo Natural LanguageTool se emplea para tokenizar el contenido del archivo y utilizar expresiones poco relevantes en inglés para remover expresiones poco relevantes.
  • Compilaciones para utilizar el procedimiento «Contador» para contar ocurrencias de expresiones.
  • String es un módulo de Python que llama a todos y cada uno de los signos de puntuación en una lista de limpieza de puntuación.

¿Cuáles son los pasos para cotejar vocabulario y tamaño de contenido entre páginas?

Ahora se cuentan los pasos para cotejar el tamaño del vocabulario y el contenido entre las páginas clasificadas.

  • Importe las bibliotecas y packs de Python precisos para recobrar y procesar el contenido textual de las páginas.
  • Realice una búsqueda en Google plus para localizar las dirección de Internet en los desenlaces SERP.
  • Escanee las dirección de Internet en pos de su artículo, que tiene dentro su contenido.
  • Tokenize el contenido de el sitio web para el procesamiento de artículo en metodologías NLP.
  • Suprima keywords y puntuación para un mejor análisis del artículo.
  • Contar el número de expresiones que se muestran en el contenido de el sitio web.
  • Cree un marco de datos de Pandas para un mejor y mejor análisis de artículo.
  • Escoja 2 dirección de Internet y compare la continuidad de sus expresiones.
  • Equipara el tamaño y el contenido de vocabulario de la dirección de Internet escogida.

1. Importe las bibliotecas y packs de Python precisos para recobrar y procesar el contenido textual de las páginas.

Importe las bibliotecas y los packs de Python precisos a través de los comandos y métodos «from» y también «import».

from googlesearch import search

from urllib.parse import urlparse

import requests

from fake_useragent import UserAgent

import advertools as adv

import pandas as pd

from nltk.tokenize import word_tokenize

import nltk

from collections import Counter

from nltk.corpus import stopwords

import string

nltk.download()

Use «nltk.download» solo si está empleando NLTK por vez primera. Descarga todas y cada una de las carrocerías, modelos y packs. Se va a abrir una ventana como la próxima.

descargador NLTKAtrapa de pantalla del creador, agosto de 2022

Actualice la ventana ocasionalmente; si todo está en verde, cierre la ventana a fin de que el código que se ejecuta en el editor de código se detenga y se complete.

Si no posee varios de los módulos precedentes, use el procedimiento «pip install» para descargarlos a su PC local. Si tiene un emprendimiento en un ambiente cerrado, utilice un ambiente virtual en Python.

2. Realice una búsqueda en Google plus para recobrar las dirección de Internet de los desenlaces de las páginas de desenlaces del motor de búsqueda.

Para efectuar una búsqueda en Google plus para recobrar las dirección de Internet de los elementos SERP, use un bucle for en el objeto de «búsqueda», que se deriva del bulto «Búsqueda de Google plus».

serp_item_url = []

for i in search("search engine optimization", num=10, start=1, stop=10, pause=1, lang="en", country="us"):

    serp_item_url.append(i)

    print(i)

La explicación del bloque de código previo es:

  • Cree un elemento de lista vacío como «serp_item_url».
  • Empieza un bucle for en el objeto de «búsqueda» que señala una solicitud, idioma, número de desenlaces, primer y último resultado y restricción de país.
  • Añada todos y cada uno de los desenlaces al objeto «serp_item_url», lo que supone una lista de Python.
  • Imprime todas y cada una de las dirección de Internet que hayas recuperado de Google plus SERP.

Puedes observar el resultado ahora.

Las dirección de Internet de clasificación para la solicitud de «optimización de buscadores web» se detallan arriba.

El próximo paso es investigar estas dirección de Internet para una mayor limpieza.

Pues si los desenlaces son sobre «contenido de vídeo», no va a ser viable llevar a cabo un análisis de artículo saludable si no tienen una descripción de vídeo extendida o bastantes comentarios, que es un tipo diferente de contenido.

3. Limpie las dirección de Internet de contenido de vídeo de las webs de desenlaces

Para adecentar las dirección de Internet de contenido de vídeo, use el próximo bloque de código.

parsed_urls = []


for i in range(len(serp_item_url)):

    parsed_url = urlparse(serp_item_url[i])

    i += 1

    full_url = parsed_url.scheme + '://' + parsed_url.netloc + parsed_url.path


    if ('youtube' not in full_url and 'vimeo' not in full_url and 'dailymotion' not in full_url and "dtube" not in full_url and "sproutvideo" not in full_url and "wistia" not in full_url):

        parsed_urls.append(full_url)

Los buscadores web de vídeos como YouTube, Vimeo, Dailymotion, Sproutvideo, Dtube y Wistia se suprimen de las dirección de Internet resultantes si se muestran en los desenlaces.

Puede usar exactamente la misma metodología de limpieza para los websites que piensa que tienen la posibilidad de diluir la efectividad de su análisis o revolver los desenlaces con su género de contenido.

Por poner un ejemplo, posiblemente no se precisen Pinterest u otros websites de enorme contenido visual para contrastar las diferencias de «tamaño de vocabulario» entre los documentos de la rivalidad.

Explicación del bloque de código previo:

  • Cree un elemento como «parsed_urls».
  • Crea un bucle for en el rango de longitud del número de dirección de Internet del resultado recuperado.
  • Investigar dirección de Internet con «urlparse» de «URLlib».
  • Repita incrementando el número de «i».
  • Consiga la dirección de Internet completa concatenando ‘schema’, ‘netloc’ y ‘path’.
  • Busque condicionalmente la declaración «if» con las condiciones «y también» para la limpieza del dominio.
  • Póngalos en una lista con el procedimiento «dict.fromkeys».
  • Imprime las dirección de Internet para comprobar.

Puedes observar el resultado ahora.

URL de contenido de vídeoAtrapa de pantalla del creador, agosto de 2022

4. Escanee dirección de Internet limpias para recobrar su contenido

Escanee las dirección de Internet de revisión limpias para recobrar su contenido usando herramientas de publicidad.

Asimismo puede utilizar consultas con una metodología de bucle y lista, pero Advertools es mucho más veloz para seguir y hacer el marco de datos final.

Con advertencias, recupere y mezcle de forma manual todas y cada una de las «p» y «título».

adv.crawl(examine_urls, output_file="examine_urls.jl",

          follow_links=False,

          custom_settings=)

crawled_df = pd.read_json("examine_urls.jl", lines=True)

crawled_df

Explicación del bloque de código previo:

  • Use «adv.crawl» para escanear el objeto «examine_urls».
  • Cree una ruta para los ficheros de salida con la extensión «jl», que es mucho más pequeña que otras.
  • Use «follow_links = false» para dejar de seguir solo las dirección de Internet mostradas.
  • Use configuraciones adaptadas para apuntar a un «agente de usuario aleatorio» y escanear el fichero de registro si ciertas dirección de Internet no argumentan a las peticiones de escaneo. Use una configuración de demora de escaneo para eludir la oportunidad del código de estado 429.
  • Use los pandas «read_json» con el factor «lines = True» para leer los desenlaces.
  • Llame a «crawled_df» como se expone ahora.

Puedes observar el resultado ahora.

Compare las diferencias de vocabulario entre la clasificación de páginas web SERP con PythonAtrapa de pantalla del creador, agosto de 2022

Puede ver nuestras dirección de Internet de desenlaces y sus elementos de SEO en la página, incluyendo los encabezados de contestación, los tamaños de contestación y la información de datos estructurados.

5. Tokenizar el contenido de páginas para procesamiento de artículo en metodologías NLP

La tokenización del contenido de el sitio web necesita seleccionar la columna «body_text» de la salida de escaneo de Advertools y utilizar «word_tokenize» de NLTK.

crawled_df["body_text"][0]

La línea de código previo recobra todo el contenido de entre las páginas de desenlaces como se expone ahora.

Compare las diferencias de vocabulario entre la clasificación de páginas web SERP con PythonAtrapa de pantalla del creador, agosto de 2022

Para tokenizar estas oraciones, use el bloque de código ahora.

tokenized_words = word_tokenize(crawled_df["body_text"][0])

len(tokenized_words)

Tokenizamos el contenido del primer archivo y verificamos cuántas expresiones tenía.

Compare las diferencias de vocabulario entre la clasificación de páginas web SERP con PythonAtrapa de pantalla del creador, agosto de 2022

El primer archivo que tokenizamos para la solicitud de «optimización de buscadores» tiene 11211 expresiones. Y el contenido estándar está incluido en este número.

6. Remover puntuación y dividir expresiones del corpus

Suprima la puntuación y divida las expresiones como se expone ahora.

stop_words = equipo(stopwords.words("english"))
tokenized_words = [word for word in tokenized_words if not word.lower() in stop_words and word.lower() not in string.punctuation]

len(tokenized_words)

Explanation of code block above:

  • Create a equipo with the “stopwords.words(“english”)” to include all the stop words in the English language. Python sets do not include duplicate values; thus, we used a equipo rather than a list to prevent any conflict.
  • Use list comprehension with “if” and “else” statements.
  • Use the “lower” method to compare the “And” or “To” types of words properly to their lowercase versions in the stop words list.
  • Use the “string” module and include “punctuations.” A note here is that the string module might not include all the punctuations that you might need. For these situations, create your own punctuation list and replace these characters with space using the regex, and “regex.sub.”
  • Optionally, to remove the punctuations or some other non-alphabetic and numeric values, you cánido use the “isalnum” method of Python strings. But, based on the phrases, it might give different results. For example, “isalnum” would remove a word such as “keyword-related” since the “-” at the middle of the word is not alphanumeric. But, string.punctuation wouldn’t remove it since “keyword-related” is not punctuation, even if the “-” is.
  • Measure the length of the new list.

The new length of our tokenized word list is “5319”. It espectáculos that nearly half of the vocabulary of the document consists of stop words or punctuations.

It might orinan that only 54% of the words are contextual, and the rest is functional.

7. Count The Number Of Occurrences Of The Words In The Content Of The Web Pages

To count the occurrences of the words from the corpus, the “Counter” object from the “Collections” module is used as below.

counted_tokenized_words = Counter(tokenized_words)

counts_of_words_df = pd.DataFrame.from_dict(

    counted_tokenized_words, orient="index").reset_index()

counts_of_words_df.sort_values(by=0, ascending=False, inplace=True)

counts_of_words_df.head(50)

Ahora se expone una explicación del bloque de código.

  • Cree una variable como «counted_tokenized_words» para encapsular los desenlaces del procedimiento Counter.
  • Use el constructor ‘DataFrame’ en Pandas para crear un nuevo DataFrame desde los desenlaces del procedimiento Counter para el artículo tokenizado y limpio.
  • Utilice el procedimiento «from_dict» pues «Contador» devuelve un elemento de diccionario.
  • Use «sort_values» con «by = 0», lo que significa organizar por filas y «ascending = False» significa poner el valor mucho más prominente en la parte de arriba. «Inpace = True» se emplea para lograr que la novedosa versión pedida sea persistente.
  • Llame a las primeras 50 líneas con el procedimiento «head ()» de panda para contrastar el primer aspecto del marco de datos.

Puedes observar el resultado ahora.

el recuento de palabrasAtrapa de pantalla del creador, agosto de 2022

No observamos un prominente en los desenlaces, pero quedan ciertos signos de puntuación atrayentes.

Esto se origina por que ciertos websites usan distintas letras y números para exactamente los mismos objetivos, como comillas tipográficas (comillas tipográficas), comillas sencillos y comillas dobles.

Y el módulo de «funcionalidades» del módulo de cadena no los implica.

Entonces, para adecentar nuestro marco de datos, vamos a usar una función lambda adaptada como se expone ahora.

removed_curly_quotes = "’“”"

counts_of_words_df["index"] = counts_of_words_df["index"].apply(lambda x: float("NaN") if x in removed_curly_quotes else x)

counts_of_words_df.dropna(inplace=True)

counts_of_words_df.head(50)

Explicación del bloque de código:

  • Creó una variable llamada «removed_curly_quotes» para integrar comillas sencillos, dobles y sencillos.
  • Usó la función «utilizar» en pandas para contrastar todas y cada una de las columnas con esos valores probables.
  • Empleamos la función lambda con «float (» NaN «) para lograr utilizar el procedimiento «dropna» de Pandas.
  • Use «dropna» para remover cualquier valor de NaN que sustituya ediciones concretas de comillas rizadas. Añada «inplace = True» para remover de manera permanente los valores de NaN.
  • Llame a la novedosa versión del marco de datos y compruébelo.

Puedes observar el resultado ahora.

recuento de palabras dfAtrapa de pantalla del creador, agosto de 2022

Observemos las expresiones mucho más usadas en el archivo web de top relacionado con «Optimización para buscadores web».

Con la metodología de «historia» de Panda, tenemos la posibilidad de visualizarla de manera fácil como se expone ahora.

counts_of_words_df.head(20).plot(kind="bar",x="index", orientation="vertical", figsize=(15,10), xlabel="Tokens", ylabel="Count", colormap="viridis", table=False, grid=True, fontsize=15, rot=35, position=1, title="Token Counts from a Website Content with Punctiation", legend=True).legend(["Tokens"], loc="lower left", prop=)

Explicación del bloque de código previo:

  • Use el procedimiento de la cabeza para poder ver los primeros valores significativos para conseguir una vista clara.
  • Use «marcar» con el atributo «tipo» para conseguir un «trazado de barras».
  • Ponga el eje «x» con las columnas que implican las expresiones.
  • Utilice el atributo de orientación para detallar la dirección del gráfico.
  • Determine el tamaño de la figura con una tupla detallando la altura y el ancho.
  • Ponga etiquetas x y también y para los nombres de los ejes x y también y.
  • Determine un mapa de colores que tenga una construcción como «viridis».
  • Establece el tamaño de la fuente, la rotación de la etiqueta, la situación de la etiqueta, el título de la textura, la presencia de la historia de historia legendaria, el título de la historia de historia legendaria, la situación de la historia de historia legendaria y el tamaño de la historia de historia legendaria.

Pandas DataFrame Plotting es un tema extenso. Si quiere usar «Plotly» como su backend de visualización de Panda, consulte la Vista de temas candentes para conseguir novedades de SEO.

Puedes observar el resultado ahora.

Gráfico de marco de datos de PandasImagen del creador, agosto de 2022

En este momento tenemos la posibilidad de seleccionar la segunda dirección de Internet para empezar a cotejar el tamaño del vocabulario y las ocurrencias de expresiones.

8. Escoja la segunda dirección de Internet para cotejar el tamaño del vocabulario y las ocurrencias de expresiones

Para equiparar el contenido de SEO previo con un archivo web de la rivalidad, usaremos la guía de SEO de SEJ. Puedes observar una versión comprimida de los pasos seguidos hasta la actualidad para el segundo producto.

def tokenize_visualize(article:int):

    stop_words = equipo(stopwords.words("english"))

    removed_curly_quotes = "’“”"

    tokenized_words = word_tokenize(crawled_df["body_text"][article])

    print("Count of tokenized words:", len(tokenized_words))

    tokenized_words = [word for word in tokenized_words if not word.lower() in stop_words and word.lower() not in string.punctuation and word.lower() not in removed_curly_quotes]

    print("Count of tokenized words after removal punctations, and stop words:", len(tokenized_words))

    counted_tokenized_words = Counter(tokenized_words)

    counts_of_words_df = pd.DataFrame.from_dict(

    counted_tokenized_words, orient="index").reset_index()

    counts_of_words_df.sort_values(by=0, ascending=False, inplace=True)

    #counts_of_words_df["index"] = counts_of_words_df["index"].apply(lambda x: float("NaN") if x in removed_curly_quotes else x)

    counts_of_words_df.dropna(inplace=True)

    counts_of_words_df.head(20).plot(kind="bar",

    x="index",

    orientation="vertical",

    figsize=(15,10),

    xlabel="Tokens",

    ylabel="Count",

    colormap="viridis",

    table=False,

    grid=True,

    fontsize=15,

    rot=35,

    position=1,

    title="Token Counts from a Website Content with Punctiation",

    legend=True).legend(["Tokens"],

    loc="lower left",

    prop=)

Reunimos todo para tokenización, anulación de supresión de expresiones, puntuación, remplazo de comillas, recuento de expresiones, construcción de marcos de datos, clasificación de marcos de datos y visualización.

Ahora puedes observar el resultado.

tokenizar los resultados de la visualizaciónAtrapa de pantalla del creador, agosto de 2022

El producto de la SEJ ocupa el octavo rincón.

tokenize_visualize(8)

El número ocho quiere decir que ocupa el octavo rincón en el contexto de datos de salida del escaneo, igual al elemento SEJ para SEO. Puedes observar el resultado ahora.

El número de símbolos en el contenido del sitio y signos de puntuación.Imagen del creador, agosto de 2022

Observamos que las 20 expresiones primordiales usadas entre el producto de SEO SEJ y otros productos de SEO de la rivalidad difieren.

9. Cree una función adaptada para hacer de manera automática el recuento de ocurrencia de expresiones y enseñar las diferencias de vocabulario

El paso clave para hacer de manera automática cualquier labor de SEO con Python es integrar todos y cada uno de los pasos y pretensiones en una función concreta de Python con distintas habilidades.

La función que va a ver ahora tiene una declaración condicional. Si pasa un solo elemento, se emplea una llamada de vista única; Además de esto, crea subparcelas dependiendo del número de subparcelas.

def tokenize_visualize(articles:list, article:int=None):

     if article:

          stop_words = equipo(stopwords.words("english"))

          removed_curly_quotes = "’“”"

          tokenized_words = word_tokenize(crawled_df["body_text"][article])

          print("Count of tokenized words:", len(tokenized_words))

          tokenized_words = [word for word in tokenized_words if not word.lower() in stop_words and word.lower() not in string.punctuation and word.lower() not in removed_curly_quotes]

          print("Count of tokenized words after removal punctations, and stop words:", len(tokenized_words))

          counted_tokenized_words = Counter(tokenized_words)

          counts_of_words_df = pd.DataFrame.from_dict(

          counted_tokenized_words, orient="index").reset_index()

          counts_of_words_df.sort_values(by=0, ascending=False, inplace=True)

          #counts_of_words_df["index"] = counts_of_words_df["index"].apply(lambda x: float("NaN") if x in removed_curly_quotes else x)

          counts_of_words_df.dropna(inplace=True)

          counts_of_words_df.head(20).plot(kind="bar",

          x="index",

          orientation="vertical",

          figsize=(15,10),

          xlabel="Tokens",

          ylabel="Count",

          colormap="viridis",

          table=False,

          grid=True,

          fontsize=15,

          rot=35,

          position=1,

          title="Token Counts from a Website Content with Punctiation",

          legend=True).legend(["Tokens"],

          loc="lower left",

          prop=)

     

     if articles:

          source_names = []

          for i in range(len(articles)):

               source_name = crawled_df["url"][articles[i]]

               print(source_name)

               source_name = urlparse(source_name)

               print(source_name)

               source_name = source_name.netloc

               print(source_name)

               source_names.append(source_name)

          global dfs

          dfs = []

          for i in articles:

               stop_words = equipo(stopwords.words("english"))

               removed_curly_quotes = "’“”"

               tokenized_words = word_tokenize(crawled_df["body_text"][i])

               print("Count of tokenized words:", len(tokenized_words))

               tokenized_words = [word for word in tokenized_words if not word.lower() in stop_words and word.lower() not in string.punctuation and word.lower() not in removed_curly_quotes]

               print("Count of tokenized words after removal punctations, and stop words:", len(tokenized_words))

               counted_tokenized_words = Counter(tokenized_words)

               counts_of_words_df = pd.DataFrame.from_dict(

               counted_tokenized_words, orient="index").reset_index()

               counts_of_words_df.sort_values(by=0, ascending=False, inplace=True)

               #counts_of_words_df["index"] = counts_of_words_df["index"].apply(lambda x: float("NaN") if x in removed_curly_quotes else x)

               counts_of_words_df.dropna(inplace=True)

               df_individual = counts_of_words_df

               dfs.append(df_individual)

               

          import matplotlib.pyplot as plt

          figure, axes = plt.subplots(len(articles), 1)

          for i in range(len(dfs) + 0):

               dfs[i].head(20).plot(ax = axes[i], kind="bar",

                    x="index",

                    orientation="vertical",

                    figsize=(len(articles) * 10, len(articles) * 10),

                    xlabel="Tokens",

                    ylabel="Count",

                    colormap="viridis",

                    table=False,

                    grid=True,

                    fontsize=15,

                    rot=35,

                    position=1,

                    title= f" Token Counts",

                    legend=True).legend(["Tokens"],

                    loc="lower left",

                    prop=)

Para sostener el producto conciso, no agregaré una explicación para estos. No obstante, si echa una ojeada a los manuales SEJ Python SEO precedentes que escribí, va a crear funcionalidades de envoltura afines.

Usémoslo.

tokenize_visualize (elementos =[1, 8, 4])

Deseábamos tomar los productos primero, octavo y cuarto y ver sus primeras 20 expresiones y sus ocurrencias; Puedes observar el resultado ahora.

visualización de las primeras 20 palabrasImagen del creador, agosto de 2022

10. Compare recuentos de expresiones únicas en documentos

Cotejar recuentos de expresiones únicas en documentos es bastante simple merced a pandas. Puede preguntar la función adaptada ahora.

def compare_unique_word_count(articles:list):

     source_names = []

     for i in range(len(articles)):

          source_name = crawled_df["url"][articles[i]]

          source_name = urlparse(source_name)

          source_name = source_name.netloc

          source_names.append(source_name)


     stop_words = equipo(stopwords.words("english"))

     removed_curly_quotes = "’“”"

     i = 0

     for article in articles:

          text = crawled_df["body_text"][article]

          tokenized_text = word_tokenize(text)

          tokenized_cleaned_text = [word for word in tokenized_text if not word.lower() in stop_words if not word.lower() in string.punctuation if not word.lower() in removed_curly_quotes]

          tokenized_cleanet_text_counts = Counter(tokenized_cleaned_text)

          tokenized_cleanet_text_counts_df = pd.DataFrame.from_dict(tokenized_cleanet_text_counts, orient="index").reset_index().rename(columns=).sort_values(by="Counts", ascending=False)

          i += 1

          print(tokenized_cleanet_text_counts_df, "Number of unique words: ",  tokenized_cleanet_text_counts_df.nunique(), "Total contextual word count: ", tokenized_cleanet_text_counts_df["Counts"].sum(), "Total word count: ", len(tokenized_text))

compare_unique_word_count(articles=[1, 8, 4])

El resultado es abajo.

La parte de abajo del resultado exhibe la proporción de valores únicos, que exhibe la proporción de expresiones únicas en el archivo.

www.wordstream.com Importar

16 Google plus 71

82 SEO 66

186 investigación 43

228 lugar 28

274 página 27

… … …

510 marcado / estructurado 1

1 Últimamente 1

514 fallo 1

515 abajo 1

1024 LinkedIn 1

[1025 rows x 2 columns] Número de expresiones únicas:

www.wordstream.com 1025

Cuenta 24

dtype: int64 Total de expresiones de contexto: 2399 Total de expresiones: 4918

www.searchenginejournal.com Importar

9 SEO 93

242 investigación 25

64 Asistencia 23

40 Resumen 17

13 Google plus 17

.. … …

229 Acción 1

228 Movimiento 1

227 ágil 1

226 32 1

465 novedades 1

[466 rows x 2 columns] Número de expresiones únicas:

www.searchenginejournal.com 466

Cuenta 16

dtype: int64 Contexto total Número de expresiones: 1019 Total de expresiones: 1601

blog.hubspot.com Importar

166 SEO 86

160 investigación 76

32 contenido 46

368 página 40

327 conexiones 39

… … …

695 iniciativa 1

697 charló 1

698 previo 1

699 Análisis 1

1326 Seguridad 1

[1327 rows x 2 columns] Número de expresiones únicas:

blog.hubspot.com 1327

Cuenta 31

dtype: int64 Total de expresiones de contexto: 3418 Total de expresiones: 6728

Hay 1025 expresiones únicas de 2399 expresiones contextuales sin expresiones vacías y sin puntuación. El total de expresiones es 4918.

Las cinco expresiones mucho más usadas son «Google plus», «SEO», «búsqueda», «lugar» y «página» para «Wordstream». Puedes observar otros con exactamente los mismos números.

11. Equipara las diferencias de vocabulario entre documentos en SERP

Contrastar las expresiones propias que se muestran en los documentos de la rivalidad lo contribuye a ver dónde pesa mucho más el archivo y de qué forma marca la diferencia.

La metodología es bien simple: el género de objeto «grupo» tiene un procedimiento de «diferencia» para enseñar los distintos valores entre 2 conjuntos.

def audit_vocabulary_difference(articles:list):

     stop_words = equipo(stopwords.words("english"))

     removed_curly_quotes = "’“”"

     global dfs

     global source_names

     source_names = []

     for i in range(len(articles)):

          source_name = crawled_df["url"][articles[i]]

          source_name = urlparse(source_name)

          source_name = source_name.netloc

          source_names.append(source_name)

     i = 0

     dfs = []

     for article in articles:

               text = crawled_df["body_text"][article]

               tokenized_text = word_tokenize(text)

               tokenized_cleaned_text = [word for word in tokenized_text if not word.lower() in stop_words if not word.lower() in string.punctuation if not word.lower() in removed_curly_quotes]

               tokenized_cleanet_text_counts = Counter(tokenized_cleaned_text)

               tokenized_cleanet_text_counts_df = pd.DataFrame.from_dict(tokenized_cleanet_text_counts, orient="index").reset_index().rename(columns=).sort_values(by="Counts", ascending=False)

               tokenized_cleanet_text_counts_df.dropna(inplace=True)

               i += 1

               df_individual = tokenized_cleanet_text_counts_df

               dfs.append(df_individual)

     global vocabulary_difference

     vocabulary_difference = []

     for i in dfs:

          vocabulary = equipo(i.iloc[:, 0].to_list())

          vocabulary_difference.append(vocabulary)

     print( "Words that appear on :", source_names[0], "but not on: ", source_names[1], "are below: \n", vocabulary_difference[0].difference(vocabulary_difference[1]))

Para ser conciso, no voy a explicar las líneas de función una por una, pero esencialmente tomamos expresiones particulares de múltiples productos y las equiparamos entre sí.

Puedes observar el resultado ahora.

Expresiones que se muestran en: www.techtarget.com pero no en: moz.com están ahora:

Compare las diferencias de vocabulario entre la clasificación de páginas web SERP con PythonAtrapa de pantalla del creador, agosto de 2022

Use la función adaptada ahora para poder ver con qué continuidad se emplean estas expresiones en el archivo concreto.

def unique_vocabulry_weight():

     audit_vocabulary_difference(articles=[3, 1])

vocabulary_difference_list = vocabulary_difference_df[0].to_list()

     return dfs[0][dfs[0].iloc[:, 0].isin(vocabulary_difference_list)]

unique_vocabulry_weight()

Los desenlaces están abajo.

Compare las diferencias de vocabulario entre la clasificación de páginas web SERP con PythonAtrapa de pantalla del creador, agosto de 2022

La diferencia de vocabulario entre TechTarget y Moz para la solicitud de «optimización de buscadores web» desde la perspectiva de TechTarget está arriba. Tenemos la posibilidad de revertirlo.

def unique_vocabulry_weight():

audit_vocabulary_difference(articles=[1, 3])

vocabulary_difference_list = vocabulary_difference_df[0].to_list()

return dfs[0][dfs[0].iloc[:, 0].isin(vocabulary_difference_list)]

unique_vocabulry_weight()

Cambia el orden de los números. Míralo desde otra visión.

moz cuenta los resultadosAtrapa de pantalla del creador, agosto de 2022

Puede ver que Wordstream tiene 868 expresiones únicas que no se muestran en Boosmart, y las cinco primordiales y las cinco en el final se cuentan arriba con sus ocurrencias.

La verificación de las diferencias de vocabulario se puede progresar con «continuidad ponderada» a través de la verificación de la solicitud y la información de la red.

Pero para objetivos académicos, este es ya un curso intensivo, detallado y adelantado en Python, Data Science y SEO.

Nos observamos en las próximas guías y manuales.

Mucho más elementos:


Imagen señalada: VectorMine / Shutterstock

Fuente: searchenginejournal

Hashtags: #Compare #las #diferencias #vocabulario #entre #clasificación #páginas #web #SERP #con #Python