Cada linguagem tem um conjunto de regras que definem como formar adequadamente construções válidas; isso é chamado de sintaxe da linguagem. Quando você está aprendendo a programar, enfrentar erros de sintaxe faz parte do processo. Os iniciantes geralmente têm dificuldade em entender as regras de sintaxe e frequentemente encontram erros tipográficos e símbolos mal posicionados.
Erros de sintaxe são uma parte comum da jornada de programação de todos, mas quanto mais cedo você entender por que eles ocorrem, mais cedo poderá corrigi-los.
Neste artigo, você aprenderá sobre os diferentes erros de sintaxe em Python e como evitá-los.
Erros de sintaxe em Python
Em qualquer linguagem de programação, deixar de seguir as regras de sintaxe provavelmente resultará em um erro de sintaxe e seu código não poderá ser executado.
Em Python, o Python Interpreter lê e executa seu código Python, atuando como um tradutor entre o Python de alto nível e a linguagem de máquina de baixo nível que seu computador entende. Se seu código não seguir as regras de sintaxe do Python, o interpretador não poderá processar o código.
Quando o interpretador do Python encontra um erro de sintaxe, ele para e exibe uma mensagem de erro. Essa mensagem inclui um rastreamento da linha de código que causou o erro, junto com um indicador apontando para o primeiro ponto na linha em que o erro foi detectado.
O interpretador tenta fornecer o máximo de informações relevantes possível para ajudá-lo a diagnosticar e corrigir o problema, então certifique-se de ler as mensagens de erro cuidadosamente.
Os erros de sintaxe em Python têm tudo a ver com estrutura — eles ocorrem quando um comando viola as regras gramaticais da linguagem. Por exemplo, em inglês, uma frase deve sempre começar com uma letra maiúscula e terminar com um sinal de pontuação. Da mesma forma, em Python, uma instrução deve sempre terminar com uma nova linha e blocos de código (como aqueles em instruções if ou loops) que devem ser indentados corretamente.
Se você está familiarizado com runtime errors, você pode estar se perguntando como eles diferem dos erros de sintaxe. Erros de sintaxe impedem a execução de um programa. Os erros de execução (runtime errors) ocorrem após o início da execução do programa.
Explorando diferentes tipos de erros de sintaxe
Como o Python tem muitas regras de sintaxe, muitos erros de sintaxe também podem ocorrer. Nesta seção, você aprenderá sobre vários erros e soluções comuns.
Pontuação mal colocada, ausente ou incompatível
O Python usa vários sinais de pontuação para entender a estrutura do seu código. Você precisa se certificar de que cada um desses sinais de pontuação seja posicionado corretamente e combinado com a pontuação correspondente para evitar erros de sintaxe.
Por exemplo, você deve sempre usar parênteses (()), colchetes ([]) e chaves ({}) em pares correspondentes. Isso significa que se você abrir um, depois é preciso fechá-lo.
No exemplo a seguir, uma chave é usada para definir um objeto, mas não está fechada:
# Incorrect
proxies = {
'http': proxy_url,
'https': proxy_url
Se você tentar executá-lo, o interpretador lançará um SyntaxError:
File "python-syntax-errors.py", line 2
proxies = {
^
SyntaxError: '{' was never closed
Conforme mencionado anteriormente, o interpretador do Python geralmente fornece uma mensagem de erro descritiva. Aqui, você recebe o nome do arquivo em que o erro ocorreu, o número da linha em que ele ocorreu e uma seta apontando para onde o erro foi detectado no código. Você também foi informado de que '{' nunca foi fechado.
Com todas essas informações, você pode facilmente decifrar que precisa fechar a chave para resolver o problema:
# Correct
proxies = {
'http': proxy_url,
'https': proxy_url
} # Closed a curly bracket
Outro sinal de pontuação que geralmente causa problemas são as aspas (’ ou “). Python, como muitas outras linguagens de programação, usa aspas para definir strings. Você deve usar o mesmo tipo de aspas para abrir e fechar uma string:
# Incorrect
host = "brd.superproxy.io'
Misturar aspas simples e duplas resulta em um erro de sintaxe:
File "python-syntax-errors.py", line 2
host = "brd.superproxy.io'
^
SyntaxError: unterminated string literal (detected at line 2)
Aqui, o interpretador informa que você não encerrou a string literal na segunda linha:
# Correct
host = "brd.superproxy.io"
Você pode usar um par de aspas simples para obter o mesmo resultado.
Em alguns cenários, talvez seja necessário usar aspas simples e duplas em uma string. Nesse caso, você pode usar aspas triplas como esta:
quote = """He said, "It's the best proxy service you can find!", and showed me this provider."""
Em Python, vírgulas são usadas para separar itens em uma lista, tupla ou argumento de função. A falta de uma vírgula pode levar a resultados inesperados:
# Incorrect
proxies= [
{"http": "http://123.456.789.1:8080", "https": "https://123.456.789.1:8080"}
{"http": "http://98.765.432.1:3128", "https": "https://98.765.432.1:3128"}
{"http": "http://192.168.1.1:8080", "https": "https://192.168.1.1:8080"}
]
A execução desse código resulta na seguinte mensagem de erro:
File "python-syntax-errors.py", line 3
{"http": "http://123.456.789.1:8080", "https": "https://123.456.789.1:8080"}
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?
Embora as mensagens de erro sejam elaboradas para serem tão úteis quanto possível, elas nem sempre sugerem soluções perfeitas. Neste trecho faltam quatro vírgulas, mas a mensagem de erro seleciona somente a primeira instância. Para corrigir esse erro, você deve examinar o código ao redor da mensagem de erro e encontrar outros lugares onde talvez tenha esquecido de colocar uma vírgula:
# Correct
proxies = [
{"http": "http://123.456.789.1:8080", "https": "https://123.456.789.1:8080"},
{"http": "http://98.765.432.1:3128", "https": "https://98.765.432.1:3128"},
{"http": "http://192.168.1.1:8080", "https": "https://192.168.1.1:8080"}
]
Em comparação com as vírgulas, dois pontos são usados para iniciar um novo bloco de código (como em uma instrução if ou loop for):
import requests
from bs4 import BeautifulSoup
# Incorrect
response = requests.get('https://example.com')
if response.status_code == 200
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.title.text
print(title)
)
Esquecer o sinal de dois pontos resulta no seguinte erro de sintaxe:
if response.status_code == 200
^
SyntaxError: expected ':'
A partir dessa mensagem de erro, é fácil determinar que falta o sinal de dois pontos e você pode adicioná-lo no local sugerido para corrigir o problema:
import requests
from bs4 import BeautifulSoup
# Correct
response = requests.get('https://example.com')
if response.status_code == 200:
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.title.text
print(title)
Palavras-chave do Python incorretas, mal colocadas ou ausentes
As palavras-chave do Python são palavras especiais reservadas para significados e usos específicos, e você não pode usá-las como nomes de variáveis. Se você digitar errado, colocar no lugar errado ou esquecer de usar uma palavra-chave, o interpretador gerará um erro.
Por exemplo, se você estiver tentando importar os módulos requests e pprint em seu projeto de extração de dados da web, você pode acidentalmente digitar incorretamente a palavra-chave import:
# Incorrect
improt requests
import pprint
Esse erro de grafia faz com que o interpretador gere o seguinte erro de sintaxe inválida:
File "python-syntax-errors.py", line 2
improt requests
^^^^^^^^
SyntaxError: invalid syntax
Infelizmente, essa mensagem de erro é vaga, então você precisa trabalhar um pouco para descobrir o que deu errado. Você pode ver as setas na mensagem de erro apontando para requests; foi ali que o interpretador detectou pela primeira vez um erro de sintaxe. Como o erro de ortografia do nome de um módulo não gera um erro de sintaxe, a única outra opção é que você digitou incorretamente a palavra-chave import.
Uma simples correção da palavra import corrige o erro:
# Correct
import requests
import pprint
Também é possível bagunçar a instrução from... import... assim:
import BeautifulSoup from bs4
Embora pareça correto, executar o código anterior resulta em um erro porque a palavra-chave from deve ser exibida antes de import:
File "python-syntax-errors.py", line 2
import BeautifulSoup from bs4
^^^^
SyntaxError: invalid syntax
Trocar from e import corrige o problema:
from bs4 import BeautifulSoup
A falta de uma palavra-chave é outro problema que você provavelmente enfrentará ao programar em Python. Esse tipo de erro é um pouco mais sutil do que os outros erros mencionados porque a falta de uma palavra-chave em Python pode gerar erros diferentes.
Se você esquecer de incluir a palavra-chave return em uma função que deveria retornar um valor, a função não se comporta conforme o esperado:
def fetch_data():
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
# Missing a return statement here
data = fetch_data()
Isso não gera um erro de sintaxe, mas a função retorna None em vez do resultado esperado. Adicionar a palavra-chave return corrige o código anterior:
def fetch_data():
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
return data
data = fetch_data()
Se você esquecer a palavra-chave def ao definir uma função, encontrará um erro de sintaxe:
# Missing the `def` keyword
fetch_data():
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
return data
data = fetch_data()
O código anterior gera um erro de sintaxe porque o interpretador espera uma palavra-chave antes do nome da função:
File "python-syntax-errors.py", line 1
fetch_data():
^
SyntaxError: invalid syntax
Adicionar a palavra-chave def resolve o erro:
def fetch_data():
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
return data
data = fetch_data()
Se você esquecer a palavra-chave if em uma instrução condicional, o interpretador gerará um erro, pois espera uma palavra-chave antes da condição:
import requests
from bs4 import BeautifulSoup
response = requests.get('https://example.com')
# Missing the if keyword
response.status_code == 200:
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.title.text
print(title)
File "python-syntax-errors.py", line 6
response.status_code == 200:
^
SyntaxError: invalid syntax
Você só precisa incluir a palavra-chave if para corrigir esse problema:
import requests
from bs4 import BeautifulSoup
response = requests.get('https://example.com')
if response.status_code == 200:
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.title.text
print(title)
Observe que esses são apenas alguns exemplos de palavras-chave ausentes em Python. A falta de palavras-chave também pode gerar outros tipos de erros, então tenha muito cuidado.
Uso incorreto do operador de atribuição
Em Python, o símbolo = é usado para atribuiçõese == é usado para comparações. Misturar esses dois símbolos pode levar a um erro de sintaxe:
import requests
from bs4 import BeautifulSoup
# Incorrect
response = requests.get('https://example.com', proxies=proxies)
if response = requests.get('https://example.com/data', proxies=proxies):
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
for item in data:
print(item.text)
else:
print("Failed to retrieve data")
No código anterior, o interpretador detecta corretamente o que causou o problema:
File "python-syntax-errors.py", line 5
if response = requests.get('https://example.com/data', proxies=proxies)
^^^^^^
Nesse caso, você está tentando verificar se sua resposta é a mesma do método request.get(). Isso significa que você precisa substituir o operador de atribuição na instrução if pelo operador de comparação:
import requests
from bs4 import BeautifulSoup
# Correct
response = requests.get('https://example.com', proxies=proxies)
# Change in the following line
if response == requests.get('https://example.com/data', proxies=proxies):
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
for item in data:
print(item.text)
else:
print("Failed to retrieve data")
Erros de indentação
Python usa indentação para definir blocos de código. Se seu código não estiver indentado corretamente, o interpretador não conseguirá distinguir o conteúdo do bloco de código e gerará um IndentationError:
# Incorrect
async with async_playwright() as playwright:
await run(playwright)
Como você pode ver no código anterior, não há indentação após a definição de um bloco (dois pontos), então, ao executá-lo, você recebe a seguinte mensagem de erro:
File "python-syntax-errors.py", line 2
await run(playwright)
^
IndentationError: expected an indented block after the with statement on line 1
Para corrigir esse problema, siga as regras de sintaxe do Python e indente o bloco de código corretamente:
# Correct
async with async_playwright() as playwright:
await run(playwright)
Problemas com instruções de variáveis
Os nomes das variáveis em Python devem começar com uma letra ou um sublinhado e podem conter somente letras, números e sublinhados. Além disso, o Python diferencia maiúsculas de minúsculas, então myvariable, myVariablee MYVARIABLE são variáveis diferentes.
Os nomes de variáveis sempre devem começar com uma letra ou um sublinhado. O nome da variável a seguir começa com 1, o que não está em conformidade com as regras de sintaxe do Python:
# Incorrect
1st_port = 22225
Quando você executa o código anterior, o interpretador gera um SyntaxError:
File "python-syntax-errors.py", line 2
1st_port = 1
^
SyntaxError: invalid decimal literal
Para corrigi-lo, você deve iniciar o nome da variável com uma letra ou um sublinhado. Qualquer uma das seguintes opções pode funcionar:
# Correct
first_port = 22225
port_no_1 = 22225
Definição de função e erros de chamada
Ao definir uma função, você deve usar a palavra-chave def, seguida pelo nome da função, parênteses e dois pontos. Ao chamar uma função, você deve usar seu nome seguido por parênteses. Esquecer qualquer um desses elementos gera um erro de sintaxe:
import requests
from bs4 import BeautifulSoup
# Incorrect
def fetch_data
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
return data
# Incorrect
data = fetch_data
Aqui, faltam três elementos e cada um deles causa um erro de sintaxe separado. Para corrigir esses erros, você precisa adicionar parênteses e dois pontos após o nome da função fetch_data. Você também precisa adicionar parênteses após a chamada da função na última linha do bloco de código, assim:
import requests
from bs4 import BeautifulSoup
# Corrected
def fetch_data():
response = requests.get('https://example.com')
soup = BeautifulSoup(response.content, 'html.parser')
data = soup.find_all('div', class_='data')
return data
# Corrected
data = fetch_data()
Observe que a falta de parênteses e dois pontos na definição da função sempre causa um erro de sintaxe. No entanto, o interpretador não percebe se você esqueceu os parênteses ao chamar uma função (fetch_data()). Nesse caso, isso não necessariamente gera uma exceção, o que pode levar a um comportamento inesperado.
Melhores práticas para ajudar você a evitar erros de sintaxe
Escrever código sem erros é uma habilidade que vem com a prática. Compreender e implementar as seguintes melhores práticas pode ajudar você a evitar erros comuns de sintaxe.
Estratégias proativas
A melhor maneira de lidar com erros de sintaxe é, antes de tudo, tentar evitá-los.
Antes de começar a trabalhar em um projeto, você deve estar familiarizado com as regras de sintaxe mais comuns da linguagem em que está programando.
Use um editor de código com destaque de sintaxe e verificação de indentação
Um bom editor de código é um ótimo parceiro quando se trata de evitar erros de sintaxe. A maioria dos editores de código modernos oferece recursos como realce de sintaxe e verificação de indentação, que podem ajudá-lo a identificar erros antes de executar seu código.
Por exemplo, na ilustração a seguir, há uma marca vermelha no final da linha if response.status_code == 200 que sugere que há um erro, pois não há dois pontos:
Siga diretrizes consistentes de estilo de programação
Como acontece com a maioria das coisas, consistência é fundamental quando se trata de escrever um código limpo e sem erros. Procure seguir um estilo de programação consistente. Isso torna seu código mais fácil de ler e entender, o que, por sua vez, torna mais fácil identificar e corrigir erros.
Em Python, o PEP 8 Style Guide é amplamente aceito como padrão para o estilo de programação. Ele fornece diretrizes para coisas como nomenclatura de variáveis, indentação e uso de espaços em branco.
Escreva código em funções pequenas e bem definidas
Dividir seu código em funções pequenas e bem definidas pode facilitar o gerenciamento e a depuração.
Cada função deve ter um propósito único e claro. Se uma função fizer muitas coisas, ela pode se tornar difícil de entender e depurar. Por exemplo, dê uma olhada na seguinte função scrape_and_analyze():
import requests
from bs4 import BeautifulSoup
from textblob import TextBlob
def scrape_and_analyze():
url = "https://example.com/articles"
response = requests.get(url)
soup = BeautifulSoup(response.content, "html.parser")
titles = soup.find_all("h2", class_="article-title")
sentiments = []
for title in titles:
title_text = title.get_text()
blob = TextBlob(title_text)
sentiment = blob.sentiment.polarity
sentiments.append(sentiment)
return sentiments
print(scrape_and_analyze())
Neste exemplo, seria mais legível dividir essa função em várias funções menores, cada uma executando uma parte menor e mais gerenciável do código:
import requests
from bs4 import BeautifulSoup
from textblob import TextBlob
def scrape_titles(url):
"""Scrape article titles from a given URL."""
response = requests.get(url)
soup = BeautifulSoup(response.content, "html.parser")
titles = soup.find_all("h2", class_="article-title")
return [title.get_text() for title in titles]
def analyze_sentiment(text):
"""Analyze sentiment of a given text."""
blob = TextBlob(text)
return blob.sentiment.polarity
def analyze_titles_sentiment(titles):
"""Analyze sentiment of a list of titles."""
return [analyze_sentiment(title) for title in titles]
def scrape_and_analyze(url):
"""Scrape titles from a website and analyze their sentiment."""
titles = scrape_titles(url)
sentiments = analyze_titles_sentiment(titles)
return sentiments
url = "https://example.com/articles"
print(scrape_and_analyze(url))
Estratégias reativas
Não importa o quanto você tente evitar erros, alguns sempre podem passar despercebidos. As estratégias a seguir se concentram em lidar com esses erros.
Leia as mensagens de erro com cuidado
Como mencionado anteriormente, o Python geralmente fornece uma mensagem de erro que inclui informações sobre a natureza do erro e sua localização.
A leitura cuidadosa dessas mensagens de erro pode lhe dar dicas valiosas sobre o que deu errado e como corrigi-lo.
Use instruções impressas estrategicamente
Usar instruções print() é uma maneira rápida e eficaz de depurar erros em pequenos projetos ou problemas simples em que você precisa rastrear o fluxo de execução ou inspecionar valores variáveis em pontos específicos. É particularmente útil para um desenvolvimento rápido e quando você tem uma boa compreensão de onde o problema pode estar.
A depuração de impressão pode ser menos intrusiva e mais rápida de implementar, o que a torna um método ideal para correções rápidas e erros simples. No entanto, esteja sempre ciente de que é apenas para uso temporário e certifique-se de não usá-lo no código de produção, pois a impressão de dados exibidos aos usuários finais pode levar a vazamentos catastróficos de dados e problemas de desempenho.
Para quando você tem problemas mais complexos, tem bases de código maiores ou precisa inspecionar o estado do programa mais profundamente (como estados variáveis em várias chamadas de função ou iterações), usar um depurador é mais apropriado. Os depuradores permitem que você defina pontos de interrupção, percorra o código linha por linha e inspecione o estado do aplicativo a qualquer momento, fornecendo um ambiente de depuração mais controlado e abrangente.
Aproveite recursos e comunidades on-line
Se você está preso a um erro particularmente complicado, não hesite em procurar ajuda. Existem vários recursos on-line (Python Docs e Real Python) e comunidades (r/Python e r/LearnPython subreddits, Stack Overflowe Python Forum) onde você pode encontrar respostas e soluções para seus problemas.
Conclusão
Neste artigo, você explorou o mundo dos erros de sintaxe do Python. Você aprendeu sobre alguns tipos de erros de sintaxe, incluindo onde eles podem ocorrer e como identificá-los e corrigi-los.
Você também aprendeu sobre algumas estratégias proativas e reativas para ajudá-lo a evitar erros de sintaxe ou corrigi-los quando ocorrerem.
A Bright Data é uma fornecedora líder de ferramentas para extração de dados da web. Se você precisa de proxies confiáveis, coleta automatizada de dados, conjuntos de dados prontos para uso ou automação de tarefas de web scraping, a Bright Data oferece soluções que podem tornar seus projetos de extração de dados da web mais eficientes e produtivos.
Inscreva-se agora para encontrar o produto certo para suas necessidades e comece um teste gratuito hoje mesmo!
Não é necessário cartão de crédito
