Jak automatycznie monitorować trendy wyszukiwań na całym świecie za pomocą Pythona

W dzisiejszym cyfrowym świecie, zrozumienie trendów wyszukiwań może być kluczowe dla sukcesu wielu działań marketingowych. Dzięki narzędziom takim jak Google Trends i bibliotekom Python możemy zautomatyzować proces zbierania i analizowania danych na temat popularnych wyszukiwań w różnych krajach. W tym artykule opiszę działanie skryptu, który pozwoli monitorować te trendy automatycznie.

Skrypt pozwala na automatyczne zbieranie danych o trendach wyszukiwań dla wybranych słów kluczowych w różnych krajach i językach, co pozwala lepiej zrozumieć globalne zainteresowania użytkowników. Wykorzystuje on bibliotekę pytrends do komunikacji z Google Trends, googletrans do tłumaczenia słów kluczowych, oraz ThreadPoolExecutor do równoległego przetwarzania zapytań, co przyspiesza jego pracę. Skrypt jest elastyczny i łatwy do dostosowania, co czyni go idealnym narzędziem dla marketerów czy analityków danych.

Jest to skrypt dla osób, które znajdą trochę Pythona i wiedzą, jak go uruchomić. Dla osób początkujących planuję napisanie artykułu odnośnie do instalacji i konfiguracji.

Zalety i zastosowanie skryptu zapytań z Google Trends

Wykorzystanie skryptu zapytań z Google Trends może stać się strategicznym narzędziem w rękach marketerów, analityków i menedżerów, pozwalając na lepsze zrozumienie rynku i bardziej efektywne działania biznesowe.

1. Zrozumienie preferencji konsumentów:
   • Pozwala firmom zrozumieć, czego szukają konsumenci w różnych regionach.
   • Umożliwia identyfikację różnic w preferencjach i potrzebach między krajami i kulturami.
2. Monitorowanie zmian rynkowych:
   • Trendy wyszukiwań mogą wskazywać na zmiany w zachowaniach konsumenckich i nowe trendy rynkowe.
   • Pomaga firmom być na bieżąco z dynamicznie zmieniającymi się preferencjami klientów.
3. Optymalizacja SEO:
   • Informacje o popularnych słowach kluczowych mogą być używane do optymalizacji stron internetowych pod kątem wyszukiwarek (SEO).
   • Słowa kluczowe „rising” mogą znacząco zwiększyć ruch na stronie dzięki mniej znanym tematom i słowom kluczowym, które nie są powszechnie używane przez konkurencję.
   • Zwiększa to widoczność strony internetowej w wynikach wyszukiwania w różnych regionach.
4. Zrozumienie trendów wyszukiwań może pomóc w planowaniu kampanii w mediach społecznościowych i tworzeniu angażujących treści.
5. Lepsze targetowanie reklam:
   • Dane o trendach wyszukiwań pomagają w tworzeniu bardziej precyzyjnych kampanii reklamowych.
   • Możliwość dostosowania treści reklam do lokalnych preferencji językowych i kulturowych.
6. Planowanie asortymentu i produktów:
   • Zrozumienie, które produkty są najbardziej poszukiwane w różnych krajach, pozwala na lepsze dostosowanie oferty.
   • Pomaga w identyfikacji nowych rynków i segmentów do ekspansji.
7. Personalizacja oferty:
   • Dane o wyszukiwaniach mogą być wykorzystane do personalizacji oferty produktowej lub usługowej dla konkretnych rynków.
   • Zwiększa to szanse na przyciągnięcie i zatrzymanie klientów.

Krok po kroku: Jak działa skrypt?

Importowanie potrzebnych bibliotek: Importujemy potrzebne biblioteki time, pandas, pytrends, googletrans, pytrends.exceptions, oraz concurrent.futures.

Inicjalizacja translatora: UżywamTranslator z googletrans, aby automatycznie tłumaczyć słowa kluczowe na języki różnych krajów.

• translator = Translator()

Definicja słów kluczowych i tłumaczeń ręcznych: Określamy słowa kluczowe, które chcemy monitorować w języku polskim.

keywords = ["słowo 1", "słowo 2"]

manual_translations = {
    'IT': ["Przetłumaczone słowo 1", "Przetłumaczone słowo 2"],
    'FR': None,
    'DE': None,
    'ES': None
}

Funkcja tłumaczenia słów kluczowych: translate_keywords_list automatycznie tłumaczy słowa kluczowe na wybrane języki.

def translate_keywords_list(keywords, language_code):
    try:
        translated = [translator.translate(word, dest=language_code).text for word in keywords]
        if len(translated) != len(keywords):
            raise ValueError("Liczba przetłumaczonych słów nie jest zgodna z liczbą oryginalnych słów kluczowych.")
        return translated
    except Exception as e:
        print(f"Błąd tłumaczenia słów kluczowych: {e}")
        return keywords

Tłumaczenie słów kluczowych na różne języki: Skrypt tłumaczy słowa kluczowe na języki odpowiednich krajów, korzystając z ręcznych tłumaczeń, jeśli są dostępne, lub automatycznie.

translated_keywords = {
    'IT': manual_translations['IT'] if manual_translations['IT'] is not None else translate_keywords_list(keywords, 'it'),
    'FR': manual_translations['FR'] if manual_translations['FR'] is not None else translate_keywords_list(keywords, 'fr'),
    'DE': manual_translations['DE'] if manual_translations['DE'] is not None else translate_keywords_list(keywords, 'de'),
    'ES': manual_translations['DE'] if manual_translations['ES'] is not None else translate_keywords_list(keywords, 'es')
}

Funkcja pobierania powiązanych zapytań: fetch_related_queriespobiera powiązane zapytania z Google Trends, z obsługą ponawiania prób w przypadku błędów.

def fetch_related_queries(pytrend, keywords, geo, query_type, timeframe):
    for attempt in range(5): 
        try:
            pytrend.build_payload(keywords, geo=geo, timeframe=timeframe)
            related_queries = pytrend.related_queries()
            return related_queries
        except TooManyRequestsError:
            print(f"Osiągnięto limit szybkości. Uśpienie przed ponowną próbą... (Próba {attempt + 1})")
            time.sleep(120) 
    return None

Funkcja przetwarzania danych dla kraju: process_country_data przetwarza dane dla wybranego kraju, pobierając powiązane zapytania i przechowując wyniki.

def process_country_data(country, settings, query_type, timeframe):
    pytrend = TrendReq(hl=settings['hl'], tz=settings['tz'])
    related_queries = fetch_related_queries(pytrend, settings['keywords'], country, query_type, timeframe)
    country_results = []
    if related_queries:
        for keyword in settings['keywords']:
            if keyword in related_queries:
                if query_type == 'rising' or query_type == 'both':
                    rising_queries = related_queries[keyword].get('rising', None)
                    if rising_queries is not None:
                        for query in rising_queries.itertuples():
                            country_results.append([settings['hl'], keyword, 'rising', country, query.query, query.value])
                if query_type == 'top' or query_type == 'both':
                    top_queries = related_queries[keyword].get('top', None)
                    if top_queries is not None:
                        for query in top_queries.itertuples():
                            country_results.append([settings['hl'], keyword, 'top', country, query.query, query.value])
    return country_results

Lista krajów do analizy: Definiujemy listę krajów, które chcemy analizować, wraz z odpowiednimi ustawieniami językowymi i tłumaczeniami słów kluczowych.

countries = {
    'PL': {'enabled': True, 'keywords': keywords, 'hl': 'pl-PL', 'tz': 120},
    'FR': {'enabled': True, 'keywords': translated_keywords['FR'], 'hl': 'fr-FR', 'tz': 120},
    'IT': {'enabled': True, 'keywords': translated_keywords['IT'], 'hl': 'it-IT', 'tz': 120},
    'DE': {'enabled': True, 'keywords': translated_keywords['DE'], 'hl': 'de-DE', 'tz': 120},
    'ES': {'enabled': True, 'keywords': translated_keywords['ES'], 'hl': 'es-ES', 'tz': 120},
}

Wybór typu zapytania i przedziału czasowego: Określamy, czy chcemy analizować „rising” (rosnące), „top” (najpopularniejsze) lub „both” (oba) zapytania oraz wybieramy przedział czasowy.

query_type = 'rising'
timeframe = 'today 1-m'

Pobieranie danych: Skrypt wykorzystuje ThreadPoolExecutor do równoległego przetwarzania danych dla wybranych krajów, co znacząco przyspiesza cały proces.

with ThreadPoolExecutor(max_workers=5) as executor:
    futures = []
    for country, settings in countries.items():
        if settings['enabled']:
            futures.append(executor.submit(process_country_data, country, settings, query_type, timeframe))
    for future in futures:
        results.extend(future.result())

Zapis wyników do pliku Excel: Po zakończeniu przetwarzania, wyniki są zapisywane do pliku Excel.

df = pd.DataFrame(results, columns=['Język', 'Fraza', 'Typ zapytania', 'Kraj', 'Zapytanie', 'Wartość'])
df.to_excel('zapytania.xlsx', index=False)

Wyświetlanie wyników: Na końcu, skrypt wyświetla wyniki zapytań w konsoli oraz przetłumaczone słowa.

for idx, row in df.iterrows():
    print(f"{row['Typ zapytania'].capitalize()} powiązane zapytania dla {row['Kraj']} ({row['Język']}):")
    print(f"Fraza: {row['Fraza']}, Zapytanie: {row['Zapytanie']}, Wartość: {row['Wartość']}")

print("Przetłumaczone słowa kluczowe:")
for lang, words in translated_keywords.items():
    print(f"{lang}: {words}")

Jak dostosować skrypt do własnych potrzeb?

1. Dodaj lub zmień słowa kluczowe: Aby zmienić słowa kluczowe, które chcesz monitorować, edytuj listę keywords na początku skryptu.
   • keywords = ["słowo 1", "słowo 2"]
2. Dodaj własne tłumaczenia dla słów kluczowych:
   • 'IT': ["Przetłumaczone słowo 1", "Przetłumaczone słowo 2"]
3. Dodaj automatyczne tłumaczenia:
   • 'FR': None
4. Dodaj nowe kraje lub zmień istniejące: Możesz dodać nowe kraje do analizy, dodając je do słownika countries, lub edytować istniejące ustawienia.
   • 'US': {'enabled': True, 'keywords': translated_keywords['US'], 'hl': 'en-US', 'tz': -480}
5. Wyłącz kraje: Jeżeli nie chcesz za każdym razem sprawdzać trendów dla wszystkich krajów, to możesz je wyłączyć przez 'enabled': False
   • 'ES': {'enabled': False, 'keywords': translated_keywords['ES'], 'hl': 'es-ES', 'tz': 120}
6. Zmień język
7. Zmieniaj typ zapytania i przedział czasowy: Możesz zmienić zmienne query_type i timeframe, aby dostosować analizę do swoich potrzeb.
   • Przedział czasowy np.: 'now 1-d', 'now 7-d', 'today 1-m', 'today 3-m', 'today 12-m'
   • Typ zapytań: 'rising', 'top', 'both'
8. Zmień ilość ponawianych prób w przypadku błędów: W przypadku blokady przez zbyt dużą ilość żądań, skrypt odczeka X sekund przed ponowieniem próby.
   • for attempt in range(5): # Ponów próbę do 5 razy
   • time.sleep(120) # Odczekaj 120 sekund przed ponowieniem próby
9. Zmień ilość równoległego pobieraniach danych: domyślne jest ustawione na 5 wątków.
   • with ThreadPoolExecutor(max_workers=5) as executor:
10. Zmień lub dodaj zapisywanie wyników do .CSV: Jeżeli wolałbyś dodatkowo zapisywanie do .csv, lub zamienić .xlsx, to wystarczy usunąć fragment kodu i dodać nowy:
    • df.to_csv('zapytania.csv', index=False)
11. Sprawdź poprawności tłumaczeń: Nie zawsze Google translator tłumaczy poprawnie słowa kluczowe, więc możesz to zweryfikować dzięki zaimplementowanej funkcji print(f"{lang}: {words}") wyświetlającej przetłumaczone słowa w okienku terminala.

Pobierz Skrypt

Skrypt do automatycznego pobierania wyszukiwań z Google Trends.

(+7, Głosów: 7)

Loading...