Ciência de dados para Search Engine Marketing (SEM)

Como usuária(o) assídua(o) do DataCamp há dois anos, aprendi muita coisa. Meu principal trabalho é em marketing digital, e as habilidades de ciência de dados que desenvolvi fizeram toda a diferença. Hoje consigo gerenciar campanhas muito maiores e mais complexas e mantê-las com eficiência. Como já estou bem familiarizada(o) com o conteúdo, os diferentes tópicos e os pacotes em R e Python, pensei em como eu poderia criar campanhas de busca para o DataCamp, só como um exercício.

Neste tutorial, você vai passar pelos seguintes tópicos:

• Primeiro, vai entender melhor o que é Search Engine Marketing (SEM) e como funcionam as campanhas de busca;
• Depois, vai analisar mais de perto o caso de negócio deste tutorial;
• Em seguida, vai gerar palavras-chave para instrutores, tecnologias, cursos e temas do DataCamp.
• Com as palavras-chave em mãos, você começa a gerar seus anúncios. Primeiro definimos uma estratégia e, depois, criamos os modelos de anúncios.

Search Engine Marketing (SEM) e campanhas

O que é SEM?

SEM é uma das maneiras mais eficazes de fazer seu negócio crescer em um mercado cada vez mais competitivo. É o processo de ganhar tráfego para o site por meio da compra de anúncios em mecanismos de busca. O Google AdWords é uma das formas mais populares de publicidade online: você disputa lances para exibir anúncios nos links patrocinados do buscador para palavras-chave relacionadas ao seu negócio e paga uma taxa por clique.

Pagar por clique pode ficar caro, então é essencial planejar e agrupar bem suas palavras‑chave e anúncios, de um jeito que permita controlar os custos e, de preferência, ter campanhas lucrativas.

Embora o processo exato de determinar o preço por clique seja um segredo bem guardado e dependa de muitos fatores, a ideia principal é: quanto mais relevantes forem seus anúncios, menor tende a ser seu custo por clique.

Como configurar uma campanha de busca

Antes de criar uma campanha, normalmente você define um orçamento, escolhe palavras‑chave e analisa a concorrência. Também garante que sua landing page esteja redonda. Aí sim dá para configurar sua campanha: escrever o primeiro anúncio, ajustar os detalhes e configurar o acompanhamento de conversões. Este tutorial vai focar principalmente no processo de gerar um grande volume de palavras‑chave e anúncios, com base nas diferentes landing pages que temos.

Mas, antes de começar, vamos ver o que exatamente são essas campanhas de busca!

Grupos de anúncios

Para iniciar uma campanha de busca, você primeiro precisa elaborar um plano para seus grupos de anúncios. Esse é o núcleo da organização, onde você faz o mapeamento entre palavras‑chave, anúncios e landing pages. Mas o que são exatamente esses três componentes?

1. Palavras‑chave: a intenção do usuário, o que ele está procurando.
2. Anúncios: sua promessa para aquela intenção.
3. Landing pages: a entrega da promessa.

Fazer esse mapeamento direito é 70–80% do trabalho. Acertando aqui, a manutenção e as mudanças ficam muito mais fáceis.

Isso significa que, para ser específico e relevante para o usuário, você precisa promover o produto que tem e, principalmente, focar em levar a pessoa certa para a página certa, com a mensagem ou expectativa certa. Uma boa estrutura de campanha reflete e acompanha a estrutura do site, que essencialmente espelha a estratégia do negócio.

Observação: todo grupo de anúncios precisa fazer parte de uma campanha. No nível da campanha, você encontra configurações que regem todos os grupos, como segmentação por idioma, localização, dispositivos, horário do dia etc.

Campanha de busca, passo a passo

No trecho anterior, você viu as campanhas de busca de um nível mais alto: palavras‑chave, anúncios e landing pages fazem parte de um grupo de anúncios, e você precisa planejar esse núcleo organizacional de uma forma que reflita sua estratégia de negócio. Agora, vamos aprofundar no que fazer para configurar uma campanha, focando nas etapas que você vai percorrer neste tutorial.

Como mostrado acima, esse é o mapeamento que você quer atingir. No fim, você quer ter dois DataFrames principais: um de palavras‑chave e outro de anúncios. Veja abaixo um exemplo de como isso fica.

Com isso pronto, você já pode fazer o upload em formato CSV (Comma-separated Values) para o Google AdWords ou outras plataformas que funcionam do mesmo jeito. O Google AdWords é, de longe, a plataforma paga de busca mais usada por profissionais de marketing, além de Bing Ads, Yandex, Baidu e outras.

Observação: se você quiser importar seus dados em outras plataformas que não o Google Adwords ou o Bing Ads, talvez seja preciso fazer pequenos ajustes!

O caso de negócio: DataCamp

Como você leu na introdução, vamos criar campanhas de busca para o DataCamp. Considerando as diferentes formas de alguém demonstrar interesse no produto que a empresa oferece, ou seja, educação em ciência de dados, dá para montar facilmente uma lista inicial dessas formas:

1. Instrutores: "curso do Hadley Wickham", "cursos do Garrett Grolemund" etc.
2. Tecnologias: "curso de python", "cursos de r", "curso de sql para data science" etc.
3. Cursos: nomes de cursos específicos; "unsupervised learning in python", "deep learning in python" etc.
4. Tópicos: "cursos de machine learning", "curso de visualização de dados" etc.
5. Pacotes/bibliotecas: "aprender ggplot", "tutorial matplotlib" etc.

Neste tutorial, não faremos a fase tradicional de pesquisa de palavras‑chave, porque você tem o poder da linguagem de programação para gerar todas as combinações possíveis e agrupá‑las nas respectivas campanhas e grupos de anúncios.

Para isso, você precisa basicamente de duas coisas:

• Conhecimento do produto: saber quais cursos e tópicos o DataCamp oferece, como estão organizados no site e como são agrupados. Você descobre isso navegando — e, com conhecimento interno, dá para ter insights ainda melhores (principalmente se houver mudanças planejadas!).
• Palavras‑chave relevantes: todos os jeitos possíveis de alguém expressar interesse no que você oferece. No caso do DataCamp: "curso", "aprender", "educação", "tutorial" etc. Você pode chegar a essa lista fazendo brainstorming, usando ferramentas de palavras‑chave e outros métodos.

Geração de palavras‑chave para sua campanha de SEM

Vamos começar gerando as palavras‑chave!

1. Gerar palavras‑chave de instrutores

Esta campanha vai mirar pessoas que buscam cursos de quaisquer instrutores do DataCamp.

Você pode restringir as palavras‑chave para "curso do <nome do instrutor>" ou optar por um conjunto mais amplo mirando apenas o nome do instrutor. No início, é melhor segmentar os nomes com "curso" ou "cursos" e ver o desempenho.

Também vale checar se algum dos nomes coincide com outra pessoa famosa ou é muito comum; nesse caso, será preciso restringir as palavras‑chave para aquele instrutor.

Comece obtendo os nomes dos instrutores e as URLs de cada um:

import requests
from bs4 import BeautifulSoup


instructors_page = 'https://www.datacamp.com/instructors?all=true'
instructor_link_selector = '.instructor-block__description .instructor-block__link' # CSS class of the link
instructor_name_selector = '.mb-sm'  # CSS class of the name

instructor_resp = requests.get(instructors_page)
soup = BeautifulSoup(instructor_resp.text, 'lxml')

instructor_urls = [url['href'] for url in soup.select(instructor_link_selector)]
instructor_names = [name.text.strip() for name in soup.select(instructor_name_selector)]
instructor_urls = ['https://www.datacamp.com' + url for url in instructor_urls]

Coloque tudo em um DataFrame para usar depois. As URLs serão usadas mais adiante para gerar anúncios.

instructor_df = pd.DataFrame({
    'name': instructor_names,
    'url': instructor_urls
})
print(instructor_df.shape)
instructor_df.head()

(72, 2)

Agora que você tem os nomes dos instrutores, vamos usar um template que combina cada nome com um conjunto de palavras‑chave relacionadas ao seu tema — principalmente cursos do instrutor.

Variáveis usadas no código abaixo:

col_names: lista com os nomes das colunas do arquivo que vamos enviar ao Google AdWords.
words: palavras que serão combinadas com os nomes dos instrutores para gerar as palavras‑chave/frases completas.
match_types: há mais detalhes no Central de Ajuda do AdWords, mas aqui vai o básico.
[data science course], "data science course" e data science course são, tecnicamente, três palavras‑chave diferentes.

• correspondência exata (entre colchetes) só aciona os anúncios se o usuário buscar exatamente aquela palavra‑chave, por exemplo, "data science course" escrito exatamente assim.
• correspondência de frase (entre aspas) aciona seus anúncios se o usuário buscar a sequência exata acompanhada de qualquer coisa antes ou depois. Então "best data science course" ou "data science course online" acionariam nossos anúncios.
• correspondência ampla (sem pontuação) acionaria nossos anúncios se alguém buscar algo semelhante ou relacionado a "data science course". Isso fica a cargo dos algoritmos do Google, então é preciso cautela, pois pode acionar para buscas como "data science platform", que não é bem o que queremos promover. Eu prefiro usar a ampla modificada, pois restringe um pouco mais a segmentação. Basicamente, aciona os anúncios se alguém buscar qualquer derivação da palavra, não apenas sinônimos. É indicada com um sinal de "+" no início da palavra. Assim, "+game" acionaria por "gaming", "gamers", mas não por "play".

col_names = ['Campaign', 'Ad Group', 'Keyword', 'Criterion Type']
instructor_keywords = []

words = ['course', 'courses', 'learn', 'data science', 'data camp', 'datacamp']
match_types = ['Exact', 'Phrase', 'Broad']
for instructor in instructor_df['name']:
    for word in words:
        for match in match_types:
            if match == 'Broad':
                keyword = '+' + ' +'.join([instructor.replace(' ', ' +').lower(), word])  # modified broach match
            else:
                keyword = instructor.lower() + ' ' + word
            row = ['SEM_Instructors',  # campaign name
                   instructor,  # ad group name
                   keyword, # instructor <keyword>
                   match]  # keyword match type
            instructor_keywords.append(row)

# do the same by having the keywords come before the instructor name
for instructor in instructor_df['name']:
    for word in words:
        for match in match_types:
            if match == 'Broad':
                keyword = '+' + ' +'.join([word, instructor.replace(' ', ' +').lower()])
            else:
                keyword = word + ' ' + instructor.lower() 
            row = ['SEM_Instructors',  # campaign name
                   instructor,  # ad group name
                   keyword, # <keyword> instructor 
                   match]  # keyword match type
            instructor_keywords.append(row)


instructor_keywords_df = pd.DataFrame.from_records(instructor_keywords, 
                                                   columns=col_names)
print('total keywords:', instructor_keywords_df.shape[0])
instructor_keywords_df.head()

total keywords: 2592

Basicamente, estamos percorrendo os nomes dos instrutores, todas as palavras e todos os tipos de correspondência, para gerar todas as combinações possíveis. Fazemos isso duas vezes: uma com o template "nome do instrutor palavra‑chave" e outra com "palavra‑chave nome do instrutor".

Agora é só repetir o mesmo para todos os segmentos, com pequenas mudanças nas palavras‑chave e na forma de extrair os dados.

Uma boa regra que aprendi no R for Data Science é: se você vai copiar e colar mais de duas vezes, é hora de escrever uma função!

def generate_keywords(topics, keywords, match_types=['Exact', 'Phrase', 'Broad'],
                     campaign='SEM_Campaign'):
    col_names = ['Campaign', 'Ad Group', 'Keyword', 'Criterion Type']
    campaign_keywords = []

    for topic in topics:
        for word in keywords:
            for match in match_types:
                if match == 'Broad':
                    keyword = '+' + ' +'.join([topic.lower().replace(' ', ' +'), word.replace(' ', ' +')])
                else:
                    keyword = topic.lower() + ' ' + word
                row = [campaign,  # campaign name
                       topic,  # ad group name
                       keyword, # instructor <keyword>
                       match]  # keyword match type
                campaign_keywords.append(row)

    # I said more than twice! :)             
    for topic in topics:
        for word in keywords:
            for match in match_types:
                if match == 'Broad':
                    keyword = '+' + ' +'.join([word.replace(' ', ' +'), topic.lower().replace(' ', ' +')])
                else:
                    keyword = word + ' ' + topic.lower()
                row = [campaign,  # campaign name
                       topic,  # ad group name
                       keyword, # <keyword> instructor
                       match]  # keyword match type
                campaign_keywords.append(row)

    return pd.DataFrame.from_records(campaign_keywords, columns=col_names)

Vamos testar:

topics = ['Data Science', 'Machine Learning']
keywords = ['course', 'tutorial']
generate_keywords(topics, keywords).head(10)

Parece bom. Agora vamos gerar os tópicos e as palavras‑chave relevantes para cada segmento!

2. Palavras‑chave de tecnologia

topics = ['R', 'Python', 'SQL', 'Git', 'Shell']  # listed on the /courses page
keywords = ['data science', 'programming', 'analytics', 'data analysis', 'machine learning',
            'deep learning', 'financial analysis', 'data viz', 'visualization', 'data visualization',
            'learn', 'course', 'courses', 'education', 'data import', 'data cleaning', 
            'data manipulation', 'probability', 'stats', 'statistics', 'course', 'courses',
           'learn', 'education', 'tutorial']  # @marketing_team: this list can / should be refined or 
                                              # expanded based on the strategy and how specific the 
                                              # targeting needs to be
tech_keywords = generate_keywords(topics, keywords, campaign='SEM_Technologies')
print('total keywords:', tech_keywords.shape[0])
tech_keywords.head()

total keywords: 750

3. Gerando palavras‑chave de cursos

Este provavelmente é o segmento mais específico e, portanto, o mais relevante para atingir as pessoas certas. Se alguém busca por "data visualization with r" e o DataCamp tem esse curso, o anúncio será extremamente relevante, porque você terá a landing page certa para atender exatamente àquela necessidade.

Existe um pequeno problema, porém. Alguns nomes de cursos não correspondem ao que o usuário costuma buscar: "Machine Learning with the Experts: School Budgets", "Sentiment Analysis in R: The Tidy Way". Não são nomes ruins, mas exigem atenção para selecionar as palavras‑chave que as pessoas realmente usariam para encontrá‑los.

De novo, você pode extrair os nomes e as URLs correspondentes como fez na campanha de instrutores:

courses_page = 'https://www.datacamp.com/courses/all'
course_link_selector = '.courses__explore-list .course-block'

course_resp = requests.get(courses_page)
soup = BeautifulSoup(course_resp.text, 'lxml')

course_urls = [link.contents[1]['href'] for link in soup.select(course_link_selector)] 
course_urls = ['https://www.datacamp.com' + url for url in course_urls]
course_names = [link.h4.text for link in soup.select(course_link_selector)]

course_df = pd.DataFrame({
    'name': course_names,
    'url': course_urls
})
course_df['name_clean'] = course_df.name.str.replace('\(.*\)', '').str.strip()  # remove (part x)
print('total keywords:', course_df.shape[0])
course_df.head()

total keywords: 104

Vamos fazer o mesmo (usando a função generate_keywords()) para os cursos, mas com cuidado: é preciso revisar, porque, como dito acima, alguns nomes não são o que as pessoas procuram, e isso deve ser tratado caso a caso. O que segue já é um bom ponto de partida; depois você olha os dados e decide.

Observação: usar o caractere vazio abaixo não é erro. Os nomes dos cursos são longos e específicos o suficiente para servirem como palavras‑chave por si só, sem precisar adicionar qualificadores como "aprender" ou "curso". Então vamos usar os nomes isolados e também com qualificadores.

keywords = ['', 'learn', 'course', 'courses', 'tutorial', 'education']
course_keywords = generate_keywords(course_df['name_clean'], keywords, campaign='SEM_Courses')
print('total keywords:', course_keywords.shape[0])
course_keywords.head(10)

total keywords: 3744

4. Palavras‑chave por tópicos

São temas genéricos que as pessoas podem buscar. Eles aparecem na seção de "trilhas" (tracks), com as sub‑seções de habilidades e carreira. Para nosso objetivo, podemos agrupar tudo na mesma campanha. O processo é novamente o mesmo, como você fez nas seções anteriores!

Habilidades

skills_page = 'https://www.datacamp.com/tracks/skill'
skills_link_selector = '#all .shim'

skills_resp = requests.get(skills_page)
skill_soup = BeautifulSoup(skills_resp.text, 'lxml')

skills_urls = [link['href'] for link in skill_soup.select(skills_link_selector)] 
skills_names = [skill.replace('/tracks/', '').replace('-', ' ') for skill in skills_urls]
skills_urls = ['https://www.datacamp.com' + url for url in skills_urls]

Carreiras

career_page = 'https://www.datacamp.com/tracks/career'
career_link_selector = '#all .shim'

career_resp = requests.get(career_page)
career_soup = BeautifulSoup(career_resp.text, 'lxml')

career_urls = [link['href'] for link in career_soup.select(career_link_selector)] 

career_names = [career.replace('/tracks/', '').replace('-', ' ') for career in career_urls]
career_urls = ['https://www.datacamp.com' + url for url in career_urls]

tracks_df = pd.DataFrame({
    'name': skills_names + career_names,
    'url': skills_urls + career_urls
})
tracks_df['name'] = [x.title() for x in tracks_df['name']]
tracks_df.head()

tracks_keywords = generate_keywords(tracks_df['name'], keywords, campaign='SEM_Tracks')
print('total keywords:', tracks_keywords.shape[0])
tracks_keywords.head()

total keywords: 720

Por fim, vamos concatenar todas as palavras‑chave listadas em instructor_keywords, tech_keywords, course_keywords e tracks_keywords para juntar tudo em um único DataFrame:

full_keywords_df = pd.concat([instructor_keywords_df, tech_keywords, course_keywords, tracks_keywords])
print('total keywords:', full_keywords_df.shape[0])
print('total campaigns:', len(set(full_keywords_df['Campaign'])))
print('total ad groups:', len(set(full_keywords_df['Ad Group'])))
full_keywords_df.to_csv('keywords.csv', index=False)
full_keywords_df.head()

total keywords: 7806
total campaigns: 4
total ad groups: 191

Pronto, suas palavras‑chave estão no ponto! Se quiser ver o conjunto de dados completo, baixe aqui. Agora precisamos gerar os anúncios para cada grupo de anúncios.

Vamos criar os anúncios.

Geração de anúncios e copywriting

Você tem o seguinte:

• Campanhas e nomes de grupos de anúncios corretamente mapeados no DataFrame full_keywords_df
• O nome do grupo de anúncios e a URL correspondente vindos do scraping anterior (cursos, instrutores e trilhas). Para tecnologias, vamos gerar.

Com isso em mãos, siga este plano:

1. Crie modelos de anúncios (2–3 já é um bom começo)
2. Crie uma coluna Campaign e adicione aos DataFrames ('name', 'url')
3. Una todos os DataFrames ('name', 'url') em um só

4. Gere todos os anúncios para todos os grupos; cada anúncio terá estes campos (novas colunas no mesmo DataFrame):

   • Headline 1: máximo de 30 caracteres
   • Headline 2: máximo de 30 caracteres
   • Display URL: inferida automaticamente pela URL final
   • Final URL: o caminho completo onde o usuário vai chegar (mesmo domínio da Display URL)

5. Garanta consistência com o DataFrame de keywords

6. Faça upload e lance as campanhas!

Gerar anúncios significa simplesmente substituir o nome do tema (curso, tecnologia, instrutor etc.) no lugar certo do template e criar 2–3 variações para cada grupo de anúncios.

Modelos de anúncio

Um ponto importante: apesar de inserir os nomes dos grupos de anúncios nos lugares certos ser simples, o desafio é respeitar o limite de caracteres dos campos. Como os nomes de cursos e tópicos variam bastante, precisamos lidar com isso.

Vamos ver o tamanho do problema:

%matplotlib inline
import matplotlib.pyplot as plt
adgroup_lengths = pd.Series([len(adgrp) for adgrp in full_keywords_df['Ad Group'].unique()])
long_adgroups = sum(adgroup_lengths > 30)
plt.figure(figsize=(9,6))
plt.hist(adgroup_lengths, rwidth=0.9, bins=50)
plt.vlines(x=30, ymin=0, ymax=10, colors='red')
plt.title(str(long_adgroups) + ' ad group name lenghts > 30 (don\'t fit in a headline)',  fontsize=17)
plt.xlabel('Ad Group Name Lengths', fontsize=15)
plt.ylabel('Count', fontsize=15)
plt.yticks(range(11))
plt.xticks(range(0, 51, 5))
plt.grid(alpha=0.5)
plt.show()

Pelo visto, o problema não é trivial e não há uma solução direta. Idealmente, gostaríamos que os dois títulos comportassem o nome completo do produto (curso) que estamos promovendo.

Pensei em algumas alternativas e decidi escrever um algoritmo simples que divide o nome em duas frases, cada uma com no máximo trinta caracteres.

O algoritmo não é geral e precisa de ajustes para ser universal, mas funciona bem o suficiente para este conjunto de dados:

def split_string(string, splits=2, max_len=60):
    """Split `string` into `splits` words, each shorter than `max_len` / `splits`"""
    if len(string) < max_len / splits:
        return string, ''
    str_words = string.split(' ')
    result = ''
    for i, word in enumerate(str_words):
        if len(result + ' ' + word) <= max_len / splits:
            result += word + ' '
        else:
            break
    spaces = result.strip().count(' ')
    result2 = string[string[len(result):].index(word) + len(result):]
    return result.strip(), result2

print(split_string('this is a very long course name that needs splitting', 2, 60))
print(split_string('short course name', 2, 60))

('this is a very long course', 'name that needs splitting')
('short course name', '')

Não costumo fazer isso, mas gostei da técnica e acho que vou usar em outras campanhas. É um efeito colateral bacana de escrever um tutorial!

Agora vamos pensar nos templates que queremos escrever.

O template geral que eu uso costuma ter os seguintes elementos (normalmente nessa ordem).

• Produto: se eu busco por "data science course" no Google, quero ver "data science course" nos links/anúncios.
• Benefícios: é o fator emocional/psicológico que as pessoas realmente buscam, além de só concluir o curso: "impulsione sua carreira", "destaque‑se".
• Recursos: agora que você prometeu o mundo, mostre como vai me levar até lá! "mais de 100 cursos de ciência de dados", "aprenda com grandes especialistas", "feedback instantâneo no seu código".
• Chamada para ação: beleza, você mostrou o que tem, me motivou a comprar e explicou como vou chegar lá. Estou convencida(o). O que faço agora? "faça um teste grátis", "acesse os primeiros capítulos sem custo", "economize 20% no plano anual"

Não é fácil colocar tudo isso em um anúncio do tamanho de um tweet, e alguns pontos podem se sobrepor. Mas vamos fazer o melhor possível.

• Headline 1: sempre terá o nome do curso (ou a primeira metade).
• Headline 2: a segunda metade do nome do curso, ou uma das opções abaixo:
  • Impulse sua carreira em dados
  • Destaque‑se na multidão
  • Enfrente questões complexas
• Descrição: cada grupo de anúncios terá as três variações abaixo, em rotação.
  • Aprenda direto com os maiores especialistas da área. 20% de desconto no plano anual
  • Saia na frente: domine habilidades de data science. US$ 29/mês. Cancele quando quiser
  • Escolha entre vários tópicos ensinados pelos melhores do mundo. Comece agora

Criar colunas Campaign

full_keywords_df.Campaign.unique()  # just to make sure you have consistent naming conventions

array(['SEM_Instructors', 'SEM_Technologies', 'SEM_Courses', 'SEM_Tracks'], dtype=object)

course_df['Campaign'] = 'SEM_Courses'
course_df = course_df.rename(columns={'name_clean': 'name', 'name': 'old_name'})
course_df.head()

instructor_df['Campaign'] = 'SEM_Instructors'
instructor_df.head()

tracks_df['Campaign'] = 'SEM_Tracks'
tracks_df.head()

tech_domain = 'https://www.datacamp.com/courses/tech:'
tech_domain_list = []
for tech in ['R', 'Python', 'SQL', 'Git', 'Shell']:
    tech_domain_list.append((tech, tech_domain + tech))
tech_df = pd.DataFrame.from_records(tech_domain_list, columns=['name', 'url'])
tech_df['Campaign'] = 'SEM_Technologies'
tech_df

Unir todos os DataFrames de ('name', 'url')

full_ads_df = pd.concat([course_df[['Campaign', 'name', 'url']],
                        instructor_df,
                        tracks_df,
                        tech_df], ignore_index=True)
full_ads_df = full_ads_df.rename(columns={'name': 'Ad Group', 'url': 'Final URL'})
print('total rows:', full_ads_df.shape[0])
n_adgroups = full_ads_df.shape[0]
full_ads_df.head()

total rows: 201

Gerar anúncios

Para recapitular: agora você tem o DataFrame de anúncios com as colunas Campaign, Ad Group e Final URL devidamente mapeadas. Falta adicionar os campos Headline 1, Headline 2 e Description.

Lembre que, para cada grupo de anúncios, vamos criar três variações diferentes. Isso é uma boa prática para testes: ver no que as pessoas clicam, quais anúncios convertem mais etc. No fim, seu DataFrame terá três vezes mais linhas do que tem agora.

Vamos começar duplicando cada linha três vezes no full_ads_df:

full_ads_df = full_ads_df.iloc[[x  for x in range(n_adgroups) for i in range(3)], :] 
print('total rows:', full_ads_df.shape[0])
full_ads_df.head(9)

total rows: 603

Agora, adicione as três descrições criadas acima.

Description = [
    'Learn Directly From the Top Experts in the Field. 20% off Annual Subcriptions',
    'Be Ahead of the Curve, Master Data Science Skills. $29 / Month. Cancel Anytime',
    'Choose From a Wide Variety of Topics Tuaght by the Best in the World. Start Now'   
]
Description = [x for i in range(n_adgroups) for x in Description ]
full_ads_df['Description'] = Description
full_ads_df.head()

Em seguida, adicione Headline 1 e Headline 2 ao DataFrame. Estamos quase lá!

benefits = [
    'Boost Your Data Science Career',
    'Stand Out From the Crowd',
    'Tackle Complex Questions'    
]

Os benefícios entrarão como Headline 2 quando o comprimento do nome do grupo de anúncios for 30 ou menos. Nesses casos, teremos um campo vazio, que será preenchido com um dos benefícios.

benefits = [x for i in range(n_adgroups) for x in benefits]
headlines = [split_string(x) for x in full_ads_df['Ad Group']]
full_ads_df['Headline 1'] = [x[0] for x in headlines]
full_ads_df['Headline 2'] = [x[1] if x[1] else benefits[i] for i, x in enumerate(headlines)]
print('total ads:', full_ads_df.shape[0])
full_ads_df.head(9)

total ads: 603

Como você pode ver, "Intro to Python for Data Science" ficou longo a ponto de ocupar dois campos, então mantemos assim para preservar a clareza. Já "Introduction to R" cabe no primeiro título, então inserimos os três benefícios diferentes em Headline 2.

E pronto!

Revise os detalhes

Um check rápido para garantir que os nomes de campanhas e grupos de anúncios batem nos dois DataFrames.

ads_check = (full_ads_df[['Campaign', 'Ad Group']]
             .drop_duplicates()
             .sort_values(['Campaign', 'Ad Group'])
             .reset_index(drop=True))
keywords_check = (full_keywords_df[['Campaign', 'Ad Group']]
                  .drop_duplicates()
                  .sort_values(['Campaign', 'Ad Group'])
                  .reset_index(drop=True))

all(ads_check == keywords_check)

True

full_ads_df.to_csv('ads.csv', index=False)

Fazer upload e lançar

Como vimos, este tutorial cobriu apenas etapas específicas dentro de campanhas de SEM e, portanto, pressupõe uma compreensão básica de como o marketing em mecanismos de busca funciona. Se quiser saber mais sobre a mecânica e os detalhes do upload e do lançamento dos grupos de anúncios, confira o guia do AdWords para começar. Para acessar cursos completos em diferentes áreas, veja a Google Academy for Ads.

Ciência de dados e SEM: ainda há muito para explorar!

Com os dois arquivos CSV que você tem agora, é só fazer o upload e começar a rodar suas campanhas. Você ainda vai definir orçamentos diários, geolocalização e alguns outros parâmetros, mas, no geral, já dá para seguir em frente.

Se quiser conferir os CSVs, eles estão aqui:

• keywords
• ads

Espero que este tutorial tenha sido útil. Obrigado pela leitura e, se quiser compartilhar algum projeto de crescimento que você fez com a ajuda do Python, me chama no Twitter @eliasdabbas.