Python: Script A Google Autosuggest Extract of Trends for Your Niche Search Keywords

Python-skript for å fange autoforslag på trender

Alle liker Google Trends, men det er litt vanskelig når det gjelder Long Tail Keywords. Vi liker alle tjenestemannen google trendservice for å få innsikt i søkeoppførselen. To ting hindrer imidlertid mange i å bruke den til solid arbeid;

  1. Når du trenger å finne nye nisje nøkkelordDet er ikke nok data på Google Trends 
  2. Mangel på offisiell API for å komme med forespørsler til google-trender: Når vi bruker moduler som pytrender, så må vi bruke proxy-servere, ellers blir vi blokkert. 

I denne artikkelen vil jeg dele et Python-skript vi har skrevet for å eksportere populære søkeord via Google Autosuggest.

Hent og lagre autoforslagsresultater over tid 

Anta at vi har 1,000 frø-søkeord som skal sendes til Google Autosuggest. Til gjengjeld får vi sannsynligvis rundt 200,000 XNUMX longtail søkeord. Deretter må vi gjøre det samme en uke senere og sammenligne disse datasettene for å svare på to spørsmål:

  • Hvilke spørsmål er nye søkeord sammenlignet med forrige gang? Dette er sannsynligvis tilfelle vi trenger. Google mener at disse spørsmålene blir mer betydningsfulle - ved å gjøre det kan vi lage vår egen Google Autosuggest-løsning! 
  • Hvilke spørsmål er nøkkelord ikke lenger trender?

Skriptet er ganske enkelt, og det meste av koden jeg delte her.. Den oppdaterte koden lagrer dataene fra tidligere kjøringer og sammenligner forslagene over tid. Vi unngikk filbaserte databaser som SQLite for å gjøre det enkelt - så all datalagring bruker CSV-filer nedenfor. Dette lar deg importere filen i Excel og utforske nisje søkeordtrender for din virksomhet.

Å bruke dette Python-skriptet

  1. Skriv inn settet ditt for nøkkelord som skal sendes til autofullfør: keywords.csv
  2. Juster skriptinnstillingene etter behov:
    • SPRÅK: standard “no”
    • LAND: standard “oss”
  3. Planlegg at skriptet skal kjøres en gang i uken. Du kan også kjøre den manuelt som du vil.
  4. Bruk keyword_suggestions.csv for videre analyse:
    • først sett: dette er datoen der spørringen dukket opp for første gang i autosuggest
    • sist sett: datoen der søket ble sett for siste gang
    • er ny: hvis first_seen == last_seen setter vi dette til ekte - Bare filtrer på denne verdien for å få de nye populære søkene i Googles autoforslag.

Her er Python-koden

# Pemavor.com Autocomplete Trends
# Author: Stefan Neefischer (stefan.neefischer@gmail.com)
import concurrent.futures
from datetime import date
from datetime import datetime
import pandas as pd
import itertools
import requests
import string
import json
import time

charList = " " + string.ascii_lowercase + string.digits

def makeGoogleRequest(query):
    # If you make requests too quickly, you may be blocked by google 
    time.sleep(WAIT_TIME)
    URL="http://suggestqueries.google.com/complete/search"
    PARAMS = {"client":"opera",
            "hl":LANGUAGE,
            "q":query,
            "gl":COUNTRY}
    response = requests.get(URL, params=PARAMS)
    if response.status_code == 200:
        try:
            suggestedSearches = json.loads(response.content.decode('utf-8'))[1]
        except:
            suggestedSearches = json.loads(response.content.decode('latin-1'))[1]
        return suggestedSearches
    else:
        return "ERR"

def getGoogleSuggests(keyword):
    # err_count1 = 0
    queryList = [keyword + " " + char for char in charList]
    suggestions = []
    for query in queryList:
        suggestion = makeGoogleRequest(query)
        if suggestion != 'ERR':
            suggestions.append(suggestion)

    # Remove empty suggestions
    suggestions = set(itertools.chain(*suggestions))
    if "" in suggestions:
        suggestions.remove("")
    return suggestions

def autocomplete(csv_fileName):
    dateTimeObj = datetime.now().date()
    #read your csv file that contain keywords that you want to send to google autocomplete
    df = pd.read_csv(csv_fileName)
    keywords = df.iloc[:,0].tolist()
    resultList = []

    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
        futuresGoogle = {executor.submit(getGoogleSuggests, keyword): keyword for keyword in keywords}

        for future in concurrent.futures.as_completed(futuresGoogle):
            key = futuresGoogle[future]
            for suggestion in future.result():
                resultList.append([key, suggestion])

    # Convert the results to a dataframe
    suggestion_new = pd.DataFrame(resultList, columns=['Keyword','Suggestion'])
    del resultList

    #if we have old results read them
    try:
        suggestion_df=pd.read_csv("keyword_suggestions.csv")
        
    except:
        suggestion_df=pd.DataFrame(columns=['first_seen','last_seen','Keyword','Suggestion'])
    
    suggestionCommon_list=[]
    suggestionNew_list=[]
    for keyword in suggestion_new["Keyword"].unique():
        new_df=suggestion_new[suggestion_new["Keyword"]==keyword]
        old_df=suggestion_df[suggestion_df["Keyword"]==keyword]
        newSuggestion=set(new_df["Suggestion"].to_list())
        oldSuggestion=set(old_df["Suggestion"].to_list())
        commonSuggestion=list(newSuggestion & oldSuggestion)
        new_Suggestion=list(newSuggestion - oldSuggestion)
         
        for suggest in commonSuggestion:
            suggestionCommon_list.append([dateTimeObj,keyword,suggest])
        for suggest in new_Suggestion:
            suggestionNew_list.append([dateTimeObj,dateTimeObj,keyword,suggest])
    
    #new keywords
    newSuggestion_df = pd.DataFrame(suggestionNew_list, columns=['first_seen','last_seen','Keyword','Suggestion'])
    #shared keywords with date update
    commonSuggestion_df = pd.DataFrame(suggestionCommon_list, columns=['last_seen','Keyword','Suggestion'])
    merge=pd.merge(suggestion_df, commonSuggestion_df, left_on=["Suggestion"], right_on=["Suggestion"], how='left')
    merge = merge.rename(columns={'last_seen_y': 'last_seen',"Keyword_x":"Keyword"})
    merge["last_seen"].fillna(merge["last_seen_x"], inplace=True)
    del merge["last_seen_x"]
    del merge["Keyword_y"]
    
    #merge old results with new results
    frames = [merge, newSuggestion_df]
    keywords_df =  pd.concat(frames, ignore_index=True, sort=False)
    # Save dataframe as a CSV file
    keywords_df['first_seen'] = pd.to_datetime(keywords_df['first_seen'])
    keywords_df = keywords_df.sort_values(by=['first_seen','Keyword'], ascending=[False,False])   
    keywords_df['first_seen']= pd.to_datetime(keywords_df['first_seen'])
    keywords_df['last_seen']= pd.to_datetime(keywords_df['last_seen'])
    keywords_df['is_new'] = (keywords_df['first_seen']== keywords_df['last_seen'])
    keywords_df=keywords_df[['first_seen','last_seen','Keyword','Suggestion','is_new']]
    keywords_df.to_csv('keyword_suggestions.csv', index=False)

# If you use more than 50 seed keywords you should slow down your requests - otherwise google is blocking the script
# If you have thousands of seed keywords use e.g. WAIT_TIME = 1 and MAX_WORKERS = 5
WAIT_TIME = 0.2
MAX_WORKERS = 20
# set the autocomplete language
LANGUAGE = "en"
# set the autocomplete country code - DE, US, TR, GR, etc..
COUNTRY="US"
# Keyword_seed csv file name. One column csv file.
#csv_fileName="keyword_seeds.csv"
CSV_FILE_NAME="keywords.csv"
autocomplete(CSV_FILE_NAME)
#The result will save in keyword_suggestions.csv csv file

Last ned Python-skriptet

Hva tror du?

Dette nettstedet bruker Akismet for å redusere spam. Lær hvordan kommentaren din behandles.