[ad_1]

Untuk profesional SEO, pembaruan utama Google adalah cara hidup. Mereka terjadi setidaknya sekali – jika tidak lebih sering – setiap tahun.

Ada pemenang dan pecundang secara alami.

Jadi, meskipun Google tidak menentukan sebagian besar langkah di balik pembaruan algoritme, ada beberapa hal yang dapat kami lakukan untuk lebih memahami apa yang sedang terjadi.

  • Konten situs mana yang terpengaruh.
  • Situs yang bekerja di mesin pencari Anda.
  • Jenis hasil.

Batasnya adalah imajinasi Anda, pertanyaan Anda (berdasarkan pengetahuan SEO Anda) dan, tentu saja, data Anda.

Kode ini mencakup integrasi pada peringkat halaman hasil mesin pencari (SERP) (perbandingan kategori antar situs) dan prinsip yang sama dapat diterapkan pada tampilan pembaruan utama seperti jenis hasil (pertimbangkan puncak dan tampilan lain yang disebutkan di atas).

Menggunakan Python untuk membandingkan SERP

Aturan umum adalah membandingkan SERP sebelum dan sesudah perbaikan besar, yang memberi Anda petunjuk tentang apa yang sedang terjadi.

Mulailah dengan mengimpor perpustakaan Python kami

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

Ketika kami menjelaskan beberapa variabel, kami akan fokus pada ON24.com, yang dikalahkan oleh peningkatan besar.

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

Dengan membaca informasinya, kami menggunakan GetSTAT Export, yang memiliki laporan berguna yang memungkinkan Anda membandingkan SERP untuk kata kunci Anda sebelum dan sesudah.

Laporan SERP ini tersedia dari penyedia peringkat lainnya. Tampilan SEO Dan Peringkat Web Tingkat Lanjut – Tidak ada pilihan atau dukungan di pihak saya!

getstat_ba_urls = pd.read_csv('data/webinars_top_20.csv', encoding = 'UTF-16', sep = 't')
getstat_raw.head()
Melacak SERPTangkapan Layar Penulis, Januari 2022
getstat_ba_urls = getstat_raw

Gabungkan protokol dan string URL dan buat URL untuk mendapatkan URL level penuh sebelum dan sesudah pembaruan.

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'])


Untuk menemukan domain URL peringkat, kami membuat salinan URL di kolom baru, menghapus deskripsi jika subdomain termasuk dalam pemahaman terperinci.

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), '')

Rincian daftar diulang untuk menghapus domain setelah pembaruan.

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
Sebelum dan sesudah URLTangkapan Layar Penulis, Januari 2022

Hilangkan URL multi-level

Langkah selanjutnya adalah menghapus beberapa URL peringkat dari kata kunci SERP di domain yang sama. Kami membagi data menjadi dua set sebelum dan sesudah.

Kemudian kami mengumpulkan kata kunci dan melakukan perkalian

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
Pelacakan kata kunciTangkapan Layar Penulis, Januari 2022

Proses ini diulang setelah pengumpulan data.

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'
                                        ]]

Kelas Situs SERP

Ketika datang ke pembaruan besar, sebagian besar jawabannya ada di SERP. Di sinilah kita dapat melihat situs apa yang menang dan apa yang dimenangkan orang lain.

Pengumpulan data dibagi dan dipisahkan, kami menciptakan pesaing yang sama sehingga kami mulai membaginya secara manual yang membantu kami memvisualisasikan dampak pembaruan.

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')

Kosongkan kolom nilai NAN No No Number menggunakan fungsi np.where(), yang setara dengan rumus Panda untuk Excel.

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'])


Beberapa metrik yang dihitung menunjukkan perbedaan peringkat berikutnya, dan apakah URL telah berubah.

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
Perbedaan level sebelum vs sesudahTangkapan Layar Penulis, Januari 2022

Gabungkan situs pemenang

Setelah data dibersihkan, sekarang kita dapat berkumpul untuk melihat situs mana yang paling relevan.

Untuk melakukan ini, kami menjelaskan fungsi yang menghitung bobot rata-rata berdasarkan volume pencarian.

Jika Anda peduli dengan kata kunci yang mendapatkan banyak pencarian, tidak semua kata kunci akan membuat analisis lebih bermakna.

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()
Hitung peringkat rata-rata yang diukur berdasarkan volume pencarianTangkapan Layar Penulis, Januari 2022

Peringkat rata-rata memang penting, begitu pula jangkauan web karena memberi tahu kita ukuran halaman di Google, jumlah kata kunci.

Aksesibilitas membantu kami memprioritaskan situs yang ingin kami sertakan di kelas kami.

Partisi dibuat menggunakan fungsi np.select, yang merupakan excel seperti ekstracellate.

Pertama, kami membuat daftar kondisi kami.

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', 
                                       ])
]

Kami kemudian membuat daftar nilai yang ingin kami tetapkan untuk setiap situasi.

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

Kemudian buat kolom baru dan gunakan np.select untuk mengklasifikasikan nilai kita sebagai argumen.

commonstats_df['segment'] = np.select(domain_conds, segment_values, default="other")
commonstats_df = commonstats_df[['before_site', 'segment', 'reach', 'wavg_rank']]
commonstats_df
Kolom baru untuk menggunakan np.selectTangkapan Layar Penulis, Januari 2022

Domain sekarang dibagi, yang berarti kami akan mulai menikmati penambahan untuk melihat jenis situs mana yang mendapat manfaat dari pembaruan.

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


Kami sekarang menggabungkan informasi khusus pra-SERP ke dalam tabel segmen SERP untuk membagi URL peringkat menggunakan fungsi penggabungan.

Fungsi integrasi yang menggunakan parameter ‘eft’ setara dengan fungsi Excel Velocator atau fungsi Index Match.

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
Gabungkan informasi unik sebelum SERP dengan tabel kelas SERPTangkapan Layar Penulis, Januari 2022

Menggabungkan SERP sebelumnya

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
Menggabungkan SERP sebelumnya.Tangkapan Layar Penulis, Januari 2022

Ulangi proses setelah SERPs.

# 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
Ulangi proses setelah SERPsTangkapan Layar Penulis, Januari 2022

Kami dapat menggabungkan dan membandingkannya dengan kedua SERP.

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
Bandingkan peringkat sebelum dan sesudah kata kunciTangkapan Layar Penulis, Januari 2022

Meskipun situs web penerbit tampaknya paling diuntungkan dari kata kunci tambahan yang ditetapkan, menggambar tentu saja berbicara 1000 kata lebih banyak di dek PowerPoint.

Kami mencoba melakukan ini dengan memformat paket grafis Pythian ke dalam format panjang favorit Anda.

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
peringkat GoogleTangkapan Layar Penulis, Januari 2022

Dan itu menunjukkan kepada kita bagaimana sebagian besar jenis situs mendapat peringkat. Tampilan pertama kita adalah setengah dari cerita.

Mari kita lihat 20 teratas.

Desktop dengan smartphoneTangkapan Layar Penulis, Januari 2022

Mengabaikan bagian ‘lainnya’, kami melihat bahwa pemenang utama adalah Martec dan penerbit, memperluas akses ke kata kunci mereka.

Ringkasan

Dibutuhkan sedikit kode untuk membuat satu tabel yang perlu dibersihkan dan dikumpulkan.

Namun, prinsip-prinsip tersebut dapat diterapkan untuk mencapai pandangan win-win yang diperluas seperti

  • tingkat domain.
  • Konten situs internal.
  • Jenis hasil.
  • Hasil buruk.
  • Peringkat jenis konten URL (blog, penawaran halaman, dll.).

Sebagian besar laporan SERP memiliki data untuk melakukan tampilan yang diperluas di atas.

Meskipun tidak secara eksplisit menyatakan peringkat utama, tampilan dapat memberi tahu Anda banyak hal tentang apa yang sedang terjadi, menjelaskan pembaruan utama kepada kolega Anda, dan menghasilkan hipotesis untuk menguji apakah Anda salah satu yang beruntung. Untuk memulihkan.

Lebih banyak sumber daya


Pengambilan gambar unggulan Pixels Hunter / shutterstock



[ad_2]

Penting dibaca: Tool Artikel Terbaik dan Keyword Allintitle serta Tips SEO Pageone

By admin

Tinggalkan Balasan

Alamat email Anda tidak akan dipublikasikan. Ruas yang wajib ditandai *