Google Core -päivityksen voittajien ja häviäjien visualisointi Pythonilla

SEO-asiantuntijoille Googlen ydinpäivitykset ovat elämäntapa. Niitä tapahtuu vähintään kerran – ellei useita kertoja – vuodessa.

Luonnollisesti on voittajia ja häviäjiä.

Joten vaikka Google ei paljasta suurinta osaa ranking tekijät Algoritmipäivitysten takana on asioita, joita voimme tehdä saadaksemme paremman käsityksen siitä, mitä tapahtuu.

• Minkä sivuston sisältö vaikuttaa.
• Hakutilassasi toimivat sivustot.
• Tulostyypit.

Rajana on mielikuvituksesi, kysymyksesi (seo-tietojesi perusteella) ja tietysti tietosi.

Tämä koodi kattaa aggregaatit hakukoneen tulossivun (SERP) tasolla (sivustojen välinen luokkien vertailu), ja samoja periaatteita voidaan soveltaa muihin ydinpäivityksen näkymiin, kuten tulostyyppeihin (ajattele katkelmia ja muut edellä mainitut näkemykset).

Pythonin käyttäminen SERP:iden vertailuun

Yleinen periaate on verrata SERP:itä ennen ydinpäivitystä ja sen jälkeen, mikä antaa meille vihjeitä siitä, mitä tapahtuu.

Aloitamme tuomalla Python-kirjastomme:

import re
import time
import random
import pandas as pd
import numpy as np
import datetime
from datetime import timedelta
from plotnine import *
import matplotlib.pyplot as plt
from pandas.api.types import is_string_dtype
from pandas.api.types import is_numeric_dtype
import uritools  
pd.set_option('display.max_colwidth', None)
%matplotlib inline

Joitakin muuttujia määriteltäessä keskitymme ON24.comiin, koska se hävisi ydinpäivitykselle.

root_domain = 'on24.com'
hostdomain = 'www.on24.com'
hostname="on24"
full_domain = 'https://www.on24.com'
site_name="ON24"

Lukeessamme tietoja käytämme GetSTATin vientiä, jossa on hyödyllinen raportti, jonka avulla voit verrata avainsanojesi SERP-arvoja ennen ja jälkeen.

Tämä SERPs-raportti on saatavilla muilta sijoitusseurantapalveluntarjoajilta, kuten SEO-näyttö ja Advanced Web Ranking – ei mieltymyksiä tai suosituksia puolellani!

getstat_ba_urls = pd.read_csv('data/webinars_top_20.csv', encoding = 'UTF-16', sep = 't')
getstat_raw.head()

getstat_ba_urls = getstat_raw

Luo URL-osoitteet yhdistämällä protokolla ja URL-merkkijono saadaksesi täydellisen sijoituksen URL-osoitteen sekä ennen päivitystä että sen jälkeen.

getstat_ba_urls['before_url'] = getstat_ba_urls['Protocol for Nov 19, 2020'] + '://' + getstat_ba_urls['Ranking URL on Nov 19, 2020']
getstat_ba_urls['after_url'] = getstat_ba_urls['Protocol for Dec 17, 2020'] + '://' + getstat_ba_urls['Ranking URL on Dec 17, 2020']
getstat_ba_urls['before_url'] = np.where(getstat_ba_urls['before_url'].isnull(), '', getstat_ba_urls['before_url'])
getstat_ba_urls['after_url'] = np.where(getstat_ba_urls['after_url'].isnull(), '', getstat_ba_urls['after_url'])

Saadaksemme sijoittuvien URL-osoitteiden verkkotunnukset luomme URL-osoitteesta kopion uuteen sarakkeeseen, poistamme aliverkkotunnukset käyttämällä if-lausetta, joka on upotettu luettelon ymmärtämiseen:

getstat_ba_urls['before_site'] = [uritools.urisplit(x).authority if uritools.isuri(x) else x for x in getstat_ba_urls['before_url']]
stop_sites = ['hub.', 'blog.', 'www.', 'impact.', 'harvard.', 'its.', 'is.', 'support.']
getstat_ba_urls['before_site'] = getstat_ba_urls['before_site'].str.replace('|'.join(stop_sites), '')

Luettelon ymmärtäminen toistetaan verkkotunnusten purkamiseksi päivityksen jälkeen.

getstat_ba_urls['after_site'] = [uritools.urisplit(x).authority if uritools.isuri(x) else x for x in getstat_ba_urls['after_url']]
getstat_ba_urls['after_site'] = getstat_ba_urls['after_site'].str.replace('|'.join(stop_sites), '')
getstat_ba_urls.columns = [x.lower() for x in getstat_ba_urls.columns]
getstat_ba_urls = getstat_ba_urls.rename(columns = {'global monthly search volume': 'search_volume'
                                                   })
getstat_ba_urls

Poista useita ranking-URL-osoitteita

Seuraava vaihe on poistaa useita URL-osoitteita samalla verkkotunnuksella avainsanaa kohden SERP. Jaamme tiedot kahteen ryhmään, ennen ja jälkeen.

Sitten ryhmittelemme avainsanan mukaan ja suoritamme duplikoinnin:

getstat_bef_unique = getstat_ba_urls[['keyword', 'market', 'location', 'device', 'search_volume', 'rank',
       'result types for nov 19, 2020', 'protocol for nov 19, 2020',
       'ranking url on nov 19, 2020', 'before_url', 'before_site']]
getstat_bef_unique = getstat_bef_unique.sort_values('rank').groupby(['before_site', 'device', 'keyword']).first()
getstat_bef_unique = getstat_bef_unique.reset_index()
getstat_bef_unique = getstat_bef_unique[getstat_bef_unique['before_site'] != '']
getstat_bef_unique = getstat_bef_unique.sort_values(['keyword', 'device', 'rank'])
getstat_bef_unique = getstat_bef_unique.rename(columns = {'rank': 'before_rank', 
                                                          'result types for nov 19, 2020': 'before_snippets'})
getstat_bef_unique = getstat_bef_unique[['keyword', 'market', 'device', 'before_snippets', 'search_volume', 
                                         'before_url', 'before_site', 'before_rank'
                                        ]]
getstat_bef_unique

Toimenpide toistetaan jälki-tietojoukolle.

getstat_aft_unique = getstat_ba_urls[['keyword', 'market', 'location', 'device', 'search_volume', 'rank',
       'result types for dec 17, 2020', 'protocol for dec 17, 2020',
       'ranking url on dec 17, 2020', 'after_url', 'after_site']]
getstat_aft_unique = getstat_aft_unique.sort_values('rank').groupby(['after_site', 'device', 'keyword']).first()
getstat_aft_unique = getstat_aft_unique.reset_index()
getstat_aft_unique = getstat_aft_unique[getstat_aft_unique['after_site'] != '']
getstat_aft_unique = getstat_aft_unique.sort_values(['keyword', 'device', 'rank'])
getstat_aft_unique = getstat_aft_unique.rename(columns = {'rank': 'after_rank', 
                                                          'result types for dec 17, 2020': 'after_snippets'})
getstat_aft_unique = getstat_aft_unique[['keyword', 'market', 'device', 'after_snippets', 'search_volume', 
                                         'after_url', 'after_site', 'after_rank'
                                        ]]

Segmentoi SERP-sivustot

Kun on kyse ydinpäivitykset, useimmat vastaukset ovat yleensä SERP:issä. Tästä voimme nähdä, mitkä sivustot palkitaan ja muut, jotka häviävät.

Kun tietojoukot on poistettu ja erotettu, selvitämme yleiset kilpailijat, jotta voimme alkaa segmentoida niitä manuaalisesti, mikä auttaa meitä visualisoimaan päivityksen vaikutuksen.

serps_before = getstat_bef_unique
serps_after = getstat_aft_unique
serps_before_after = serps_before_after.merge(serps_after, left_on = ['keyword', 'before_site', 'device', 'market', 'search_volume'], 
                                                right_on = ['keyword', 'after_site', 'device', 'market', 'search_volume'], how = 'left')

Sijoitussarakkeiden puhdistaminen nolla-arvoista (NAN Not a Number) käyttämällä np.where()-funktiota, joka on Pandan vastine Excelin if-kaavalle.

serps_before_after['before_rank'] = np.where(serps_before_after['before_rank'].isnull(), 100, serps_before_after['before_rank'])
serps_before_after['after_rank'] = np.where(serps_before_after['after_rank'].isnull(), 100, serps_before_after['after_rank'])

Jotkut lasketut tiedot osoittavat sijoituksen eron ennen ja jälkeen sekä sen, onko URL-osoite muuttunut.

serps_before_after['rank_diff'] = serps_before_after['before_rank'] - serps_before_after['after_rank']
serps_before_after['url_change'] = np.where(serps_before_after['before_url'] == serps_before_after['after_url'], 0, 1)
serps_before_after['project'] = site_name
serps_before_after['reach'] = 1
serps_before_after

Kokoa Voittajasivustot

Kun tiedot on puhdistettu, voimme nyt koota nähdä, mitkä sivustot ovat hallitsevimpia.

Tätä varten määritämme funktion, joka laskee painotetun keskimääräisen sijoituksen hakumäärän mukaan.

Kaikki avainsanat eivät ole yhtä tärkeitä, mikä tekee analyysistä mielekkäämpää, jos välität avainsanoista, jotka saavat eniten hakuja.

def wavg_rank(x):
    names = {'wavg_rank': (x['before_rank'] * (x['search_volume'] + 0.1)).sum()/(x['search_volume'] + 0.1).sum()}
    return pd.Series(names, index=['wavg_rank']).round(1)

rank_df = serps_before_after.groupby('before_site').apply(wavg_rank).reset_index()
reach_df = serps_before_after.groupby('before_site').agg({'reach': 'sum'}).sort_values('reach', ascending = False).reset_index()

commonstats_full_df = rank_df.merge(reach_df, on = 'before_site', how = 'left').sort_values('reach', ascending = False)
commonstats_df = commonstats_full_df.sort_values('reach', ascending = False).reset_index()
commonstats_df.head()

Vaikka painotettu keskimääräinen sijoitus on tärkeä, niin on myös kattavuus, koska se kertoo meille sivuston Googlessa läsnäolon laajuuden eli avainsanojen määrän.

Kattavuus auttaa myös priorisoimaan sivustot, jotka haluamme sisällyttää segmentointiimme.

Segmentointi toimii np.select-funktiolla, joka on kuin mega sisäkkäinen Excel if -kaava.

Ensin luomme luettelon ehdoistamme.

domain_conds = [
    commonstats_df['before_site'].isin(['google.com', 'medium.com', 'forbes.com', 'en.m.wikipedia.org',
                                        'hbr.org', 'en.wikipedia.org', 'smartinsights.com', 'mckinsey.com',
                                        'techradar.com','searchenginejournal.com', 
                                        'cmswire.com']),
    commonstats_df['before_site'].isin(['on24.com', 'gotomeeting.com', 'marketo.com', 'zoom.us', 'livestorm.co',
                                        'hubspot.com', 'drift.com', 'salesforce.com', 'clickmeeting.com',
                                        'qualtrics.com', 'workcast.com', 'livewebinar.com', 'getresponse.com', 
                                        'superoffice.com', 'myownconference.com', 'info.workcast.com']),
    commonstats_df['before_site'].isin([ 'neilpatel.com', 'ventureharbour.com', 'wordstream.com', 
                                        'business.tutsplus.com', 'convinceandconvert.com']),
    commonstats_df['before_site'].isin(['trustradius.com', 'g2.com', 'capterra.com', 'softwareadvice.com', 
                                        'learn.g2.com']),
    commonstats_df['before_site'].isin(['youtube.com', 'm.youtube.com', 'facebook.com', 'linkedin.com', 
                                        'business.linkedin.com', 
                                       ])
]

Sitten luomme luettelon arvoista, jotka haluamme määrittää kullekin ehdolle.

segment_values = ['publisher', 'martech', 'consulting', 'reviews', 'social_media']

Luo sitten uusi sarake ja anna sille arvot np.select-komennolla käyttämällä luettelojamme argumentteina.

commonstats_df['segment'] = np.select(domain_conds, segment_values, default="other")
commonstats_df = commonstats_df[['before_site', 'segment', 'reach', 'wavg_rank']]
commonstats_df

Verkkotunnukset on nyt segmentoitu, mikä tarkoittaa, että voimme aloittaa yhdistämisen nähdäksemme mitkä sivustotyypit hyötynyt ja huonontunut päivityksestä.

# SERPs Before and After Rank
serps_stats = commonstats_df[['before_site', 'segment']]
serps_segments = commonstats_df.segment.to_list()

Yhdistämme ainutlaatuiset ennen SERPs -tiedot välittömästi yllä luotuun SERP-segmenttitaulukkoon segmentoidaksemme sijoitus-URL-osoitteet yhdistämistoiminnolla.

Yhdistämistoiminto, joka käyttää eft-parametria, vastaa Excelin vlookup- tai index match -toimintoa.

serps_before_segmented = getstat_bef_unique.merge(serps_stats, on = 'before_site', how = 'left')
serps_before_segmented = serps_before_segmented[~serps_before_segmented.segment.isnull()]
serps_before_segmented = serps_before_segmented[['keyword', 'segment', 'device', 'search_volume', 'before_snippets', 
                             'before_rank', 'before_url', 'before_site']]
serps_before_segmented['count'] = 1
serps_queries = serps_before_segmented['keyword'].to_list()
serps_queries = list(set(serps_queries))
serps_before_segmented

Ennen SERP:ien yhdistäminen:

def wavg_rank_before(x):
    names = {'wavg_rank_before': (x['before_rank'] * x['search_volume']).sum()/(x['search_volume']).sum()}
    return pd.Series(names, index=['wavg_rank_before']).round(1)

serps_before_agg = serps_before_segmented
serps_before_wavg = serps_before_agg.groupby(['segment', 'device']).apply(wavg_rank_before).reset_index()
serps_before_sum = serps_before_agg.groupby(['segment', 'device']).agg({'count': 'sum'}).reset_index()
serps_before_stats = serps_before_wavg.merge(serps_before_sum, on = ['segment', 'device'], how = 'left')
serps_before_stats = serps_before_stats.rename(columns = {'count': 'before_n'})
serps_before_stats

Toista toimenpide jälki-SERP:ille.

# SERPs  After Rank
aft_serps_segments = commonstats_df[['before_site', 'segment']]
aft_serps_segments = aft_serps_segments.rename(columns = {'before_site': 'after_site'})
serps_after_segmented = getstat_aft_unique.merge(aft_serps_segments, on = 'after_site', how = 'left')
serps_after_segmented = serps_after_segmented[~serps_after_segmented.segment.isnull()]
serps_after_segmented = serps_after_segmented[['keyword', 'segment', 'device', 'search_volume', 'after_snippets', 
                             'after_rank', 'after_url', 'after_site']]
serps_after_segmented['count'] = 1
serps_queries = serps_after_segmented['keyword'].to_list()
serps_queries = list(set(serps_queries))

def wavg_rank_after(x):
    names = {'wavg_rank_after': (x['after_rank'] * x['search_volume']).sum()/(x['search_volume']).sum()}
    return pd.Series(names, index=['wavg_rank_after']).round(1)

serps_after_agg = serps_after_segmented
serps_after_wavg = serps_after_agg.groupby(['segment', 'device']).apply(wavg_rank_after).reset_index()
serps_after_sum = serps_after_agg.groupby(['segment', 'device']).agg({'count': 'sum'}).reset_index()
serps_after_stats = serps_after_wavg.merge(serps_after_sum, on = ['segment', 'device'], how = 'left')
serps_after_stats = serps_after_stats.rename(columns = {'count': 'after_n'})
serps_after_stats

Kun molemmat SERP:t on tiivistetty, voimme liittyä niihin ja alkaa tehdä vertailuja.

serps_compare_stats = serps_before_stats.merge(serps_after_stats, on = ['device', 'segment'], how = 'left')
serps_compare_stats['wavg_rank_delta'] = serps_compare_stats['wavg_rank_after'] - serps_compare_stats['wavg_rank_before']
serps_compare_stats['sites_delta'] = serps_compare_stats['after_n'] - serps_compare_stats['before_n']
serps_compare_stats

Vaikka näemmekin, että julkaisijoiden sivustot näyttivät saavan eniten voittoa useammilla hakusanoilla, kuva kertoisi varmasti 1000 sanaa enemmän PowerPoint-paketissa.

Pyrimme tekemään tämän muokkaamalla tiedot pitkäksi muotoon, jota Python-grafiikkapaketti “plotnine” suosii.

serps_compare_viz = serps_compare_stats
serps_rank_viz = serps_compare_viz[['device', 'segment', 'wavg_rank_before', 'wavg_rank_after']].reset_index()
serps_rank_viz = serps_rank_viz.rename(columns = {'wavg_rank_before': 'before', 'wavg_rank_after': 'after', })
serps_rank_viz = pd.melt(serps_rank_viz, id_vars=['device', 'segment'], value_vars=['before', 'after'],
                     var_name="phase", value_name="rank")
serps_rank_viz

serps_ba_plt = (
    ggplot(serps_rank_viz, aes(x = 'segment', y = 'rank', colour="phase",
                             fill="phase")) + 
    geom_bar(stat="identity", alpha = 0.8, position = 'dodge') +
    labs(y = 'Google Rank', x = 'phase') + 
    scale_y_reverse() + 
    theme(legend_position = 'right', axis_text_x=element_text(rotation=90, hjust=1)) + 
    facet_wrap('device')
)
serps_ba_plt

Ja meillä on ensimmäinen visualisointi, joka näyttää meille, kuinka useimmat sivustotyypit nousivat sijoituksessa, mikä on vain puolet tarinasta.

Katsotaanpa myös 20 parhaan joukkoon osallistuneiden määrää.

Jättäen huomioimatta Muut-segmentin voimme nähdä, että Martech ja Publishers olivat tärkeimmät voittajat avainsanojen kattavuuden laajentamisessa.

Yhteenveto

Kesti vähän koodia luodaksesi yhden kaavion, jossa oli kaikki puhdistus ja aggregointi.

Periaatteita voidaan kuitenkin soveltaa laajempien voittaja-häviäjä-näkemysten saavuttamiseen, kuten:

• Verkkotunnuksen taso.
• Sivuston sisäinen sisältö.
• Tulostyypit.
• Kannibalisoituja tuloksia.
• Ranking URL Sisältötyypit (blogit, tarjoussivut jne.).

Useimmissa SERP-raporteissa on tiedot yllä olevien laajennettujen näkymien suorittamiseen.

Vaikka se ei välttämättä paljasta selkeästi keskeistä sijoitustekijää, näkemykset voivat kertoa paljon siitä, mitä tapahtuu, auttaa sinua selittämään ydinpäivityksen kollegoillesi ja luomaan hypoteeseja, joiden avulla voit testata, oletko yksi vähemmän onnellisista. elpyä.

Lisää resursseja:

---

Suositeltu kuva: Pixels Hunter/Shutterstock