Quando você usa o GitHub Copilot em notebooks do VS Code, as sugestões de código aparecem de forma diferente do que em arquivos de editor comuns. As células do notebook funcionam como blocos de código independentes, o que altera a forma como o Copilot lê o contexto e gera complementos. Este artigo explica as regras exatas que o Copilot segue ao sugerir código dentro de células Jupyter ou .ipynb, incluindo como ele usa a ordem das células, o escopo de variáveis e o conteúdo markdown. Você aprenderá a estruturar seu notebook para obter sugestões melhores e evitar armadilhas comuns, como complementos quebrados ou imports ausentes.
Principais Conclusões: Sugestões do Copilot em Células de Notebook do VS Code
- Contexto no nível da célula: O Copilot lê apenas a célula atual e as células anteriores na ordem de execução, não o arquivo inteiro
- Células markdown como dicas: Escrever um comentário claro ou uma descrição markdown acima de uma célula de código melhora a relevância da sugestão
- Sem contexto entre arquivos em notebooks: O Copilot não busca contexto de outros arquivos abertos ao sugerir dentro de uma célula de notebook
Como o Copilot Lê o Contexto em Células de Notebook
O Copilot em notebooks do VS Code funciona de forma diferente do seu comportamento em arquivos .py ou .js comuns. Em um arquivo normal, o Copilot vê o arquivo inteiro como um fluxo contínuo de texto. Em um notebook, cada célula é uma unidade isolada. O Copilot trata a célula atual como a principal fonte de contexto. Ele também lê o conteúdo das células que aparecem antes na ordem de execução do notebook. Isso significa que a ordem das células importa mais do que a posição visual na tela.
Quando você coloca o cursor em uma célula de código e começa a digitar, o Copilot gera sugestões com base em três fontes:
- Conteúdo da célula atual: Qualquer coisa já digitada na célula ativa, incluindo comentários e nomes de variáveis
- Células de código anteriores: Código de células acima da célula atual no notebook, mesmo que estejam recolhidas ou fora da visualização
- Células markdown imediatamente anteriores: Texto markdown diretamente acima da célula de código, que o Copilot trata como um prompt em linguagem natural
O Copilot não olha para células abaixo da célula atual. Ele também ignora células que estão ocultas ou recolhidas se aparecerem após a célula ativa. Esse modelo de contexto apenas para frente corresponde à forma como a execução flui em um notebook Jupyter.
Ordem de Execução vs Ordem Visual
Em um notebook, as células podem ser reordenadas arrastando-as. O Copilot usa a ordem visual das células conforme aparecem de cima para baixo. Se você mover uma célula para cima, o Copilot a trata como contexto anterior. Se você executar células fora de ordem, o Copilot ainda baseia as sugestões na ordem visual, não no histórico de execução em tempo real. Isso pode levar a sugestões que referenciam variáveis ainda não definidas se você pular células durante a execução.
Células Markdown como Prompts em Linguagem Natural
Células markdown acima de uma célula de código servem como instruções de alto nível para o Copilot. Por exemplo, uma célula markdown que diz “Carregue o arquivo CSV e limpe os valores ausentes” fará com que o Copilot gere código para ler um CSV e tratar valores NaN. Isso funciona melhor quando o texto markdown é conciso e usa palavras-chave que correspondem a funções comuns de bibliotecas. Evite descrições vagas como “faça algum processamento de dados” porque o Copilot gerará código genérico que pode não corresponder à sua intenção.
Passos para Obter Melhores Sugestões do Copilot em Notebooks
- Escreva uma célula markdown acima de cada célula de código
Digite uma descrição curta do que a célula de código deve realizar. Use verbos de ação como “carregar”, “filtrar”, “mesclar” ou “visualizar”. Mantenha a descrição em menos de duas frases para obter melhores resultados. - Defina todos os imports e variáveis na primeira célula de código
Coloque as declarações de import e as definições de variáveis globais na célula mais inicial. O Copilot usa esse contexto para todas as células subsequentes. Se você espalhar os imports por várias células, o Copilot pode não vê-los ao gerar sugestões em células posteriores. - Digite um comentário ou assinatura de função antes do código
Inicie a célula de código com uma linha de comentário que descreva o próximo bloco de código. Por exemplo,# Calcular a média de cada coluna. O Copilot usa esse comentário como um prompt e gera a operação pandas correspondente. - Mantenha as células focadas em uma única tarefa
Não combine carregamento de dados, transformação e plotagem em uma única célula. Uma célula longa reduz a precisão do Copilot porque ele precisa adivinhar onde uma tarefa termina e outra começa. Divida as tarefas em células separadas com suas próprias descrições markdown. - Pressione Tab ou Enter para aceitar uma sugestão
Quando o Copilot mostrar uma sugestão de texto fantasma, pressione Tab para aceitar a sugestão completa ou Ctrl+SetaDireita para aceitar uma palavra de cada vez. Pressionar Enter insere uma nova linha em vez de aceitar a sugestão. Se você quiser aceitar a sugestão e ir para a próxima linha, pressione Tab e depois Enter. - Use o chat inline do Copilot para prompts específicos de célula
Pressione Ctrl+I em uma célula de código para abrir o chat inline. Digite uma solicitação como “adicione tratamento de erro para arquivo não encontrado” e o Copilot gerará código que substitui ou complementa o conteúdo da célula atual. Isso contorna as limitações de contexto das sugestões de texto fantasma.
Problemas Comuns com o Copilot em Notebooks
O Copilot Sugere Código que Referencia Variáveis Indefinidas
Isso acontece quando a célula atual depende de uma variável definida em uma célula que aparece depois no notebook. O Copilot não vê células abaixo da atual. Para corrigir, mova a definição da variável para uma célula acima da célula atual. Alternativamente, defina a variável dentro da célula atual antes de usá-la.
O Copilot Não Sugere Nada em uma Célula
O Copilot pode permanecer em silêncio se a célula estiver completamente vazia e não houver uma célula markdown anterior. Digite um comentário ou uma linha parcial de código para acionar uma sugestão. Por exemplo, digitar import geralmente aciona uma lista de complementos de bibliotecas. Se o Copilot ainda não responder, verifique se a extensão GitHub Copilot está habilitada e se você tem uma assinatura ativa.
Sugestões Ignoram a Célula Markdown Acima
O Copilot lê células markdown apenas se elas precederem diretamente a célula de código, sem outras células de código no meio. Se houver uma célula de código em branco entre o markdown e a célula alvo, o Copilot ignora o markdown. Remova quaisquer células de código vazias entre a instrução markdown e a célula de código onde você deseja a sugestão.
O Copilot Repete a Mesma Sugestão em Várias Células
Quando as células têm descrições markdown idênticas ou código inicial idêntico, o Copilot pode gerar a mesma sugestão repetidamente. Altere a redação na célula markdown ou adicione um comentário único no topo de cada célula de código. Por exemplo, em vez de “limpar os dados” em todas as células, use “limpar valores ausentes da coluna A” em uma célula e “limpar linhas duplicadas” na próxima.
Texto Fantasma do Copilot vs Chat Inline em Notebooks
| Item | Sugestões de Texto Fantasma | Chat Inline (Ctrl+I) |
|---|---|---|
| Método de ativação | Automático ao digitar | Atalho manual ou paleta de comandos |
| Contexto usado | Célula atual e células acima | Apenas célula atual, mais o prompt fornecido pelo usuário |
| Saída | Complemento de uma ou várias linhas | Bloco de código completo que substitui o conteúdo da célula |
| Melhor para | Complementos curtos, nomes de variáveis, chamadas de função | Transformações complexas, tratamento de erros, novas funções |
| Modificação | Tab para aceitar, Ctrl+SetaDireita para aceitação parcial | Revisar e editar o código gerado antes de inserir |
O texto fantasma funciona bem para código repetitivo ou previsível. O chat inline é melhor quando você precisa reescrever completamente uma célula ou quando a célula markdown acima é muito vaga. Você pode alternar entre os dois métodos dependendo da tarefa.
Agora você entende como o Copilot lê o contexto das células, prompts markdown e ordem de execução em notebooks do VS Code. Estruture seu notebook com descrições markdown claras e células de código focadas para obter sugestões relevantes. Tente usar o chat inline com Ctrl+I quando o texto fantasma não produzir a saída correta. Para notebooks com muitas células, agrupe células relacionadas sob um único cabeçalho markdown para melhorar a consciência de contexto do Copilot.