Python: script un estratto di tendenze di Google Autosuggest per le tue parole chiave di ricerca di nicchia

Script Python per catturare le tendenze dei suggerimenti automatici

A tutti piace Google Trends, ma è un po 'complicato quando si tratta di parole chiave a coda lunga. A tutti noi piace l'ufficiale servizio google trend per ottenere informazioni sul comportamento di ricerca. Tuttavia, due cose impediscono a molti di usarlo per un lavoro solido;

  1. Quando hai bisogno di trovare nuove parole chiave di nicchia, Là non sono sufficienti dati su Google Trends 
  2. Mancanza di API ufficiali per effettuare richieste a tendenze di Google: quando utilizziamo moduli come pytrends, quindi dobbiamo utilizzare server proxy o veniamo bloccati. 

In questo articolo, condividerò uno script Python che abbiamo scritto per esportare parole chiave di tendenza tramite Google Autosuggest.

Recupera e archivia i risultati dei suggerimenti automatici nel tempo 

Supponiamo di avere 1,000 parole chiave Seed da inviare a Google Autosuggest. In cambio, probabilmente ne avremo circa 200,000 coda lunga parole chiave. Quindi, dobbiamo fare lo stesso una settimana dopo e confrontare questi set di dati per rispondere a due domande:

  • Quali sono le domande nuove parole chiave rispetto all'ultima volta? Questo è probabilmente il caso di cui abbiamo bisogno. Google pensa che queste domande stiano diventando più significative: così facendo, possiamo creare la nostra soluzione Google Autosuggest! 
  • Quali sono le domande parole chiave non più trend?

Lo script è abbastanza semplice e la maggior parte del codice l'ho condivisa qui. Il codice aggiornato salva i dati delle esecuzioni precedenti e confronta i suggerimenti nel tempo. Abbiamo evitato database basati su file come SQLite per renderlo semplice, quindi tutta l'archiviazione dei dati utilizza i file CSV di seguito. Ciò ti consente di importare il file in Excel ed esplorare le tendenze delle parole chiave di nicchia per la tua attività.

Per utilizzare questo script Python

  1. Inserisci il tuo set di parole chiave seed da inviare al completamento automatico: keywords.csv
  2. Modifica le impostazioni dello script in base alle tue necessità:
    • LINGUA: impostazione predefinita "en"
    • PAESE: predefinito "noi"
  3. Pianifica l'esecuzione dello script una volta alla settimana. Puoi anche eseguirlo manualmente come desideri.
  4. Utilizza keyword_suggestions.csv per ulteriori analisi:
    • primo_visto: questa è la data in cui la query è apparsa per la prima volta nell'autosuggest
    • ultima visualizzazione: la data in cui la query è stata visualizzata per l'ultima volta
    • è nuovo: se first_seen == last_seen lo impostiamo Vero - Filtra semplicemente questo valore per ottenere le nuove ricerche di tendenza nell'autosuggest di Google.

Ecco il codice Python

# 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

Scarica lo script Python

Cosa ne pensi?

Questo sito utilizza Akismet per ridurre lo spam. Scopri come vengono elaborati i dati dei tuoi commenti.