Cada lenguaje tiene un conjunto de reglas que definen cómo formar correctamente construcciones válidas; esto se conoce como la sintaxis del lenguaje. Cuando estás empezando a aprender a programar, experimentar errores de sintaxis es parte del proceso. Los principiantes suelen tener dificultades para entender las reglas de sintaxis y con frecuencia se topan con errores tipográficos y símbolos fuera de lugar.
Los errores de sintaxis son una parte común del proceso de programación de todo el mundo, pero cuanto antes comprendas por qué ocurren, antes podrás corregirlos.
En este artículo, aprenderás sobre los diferentes errores de sintaxis en Python y cómo evitarlos.
Errores de sintaxis en Python
En cualquier lenguaje de programación, lo más probable es que no se sigan las reglas de sintaxis y el código no pueda ejecutarse.
En Python, el Python Interpreter lee y ejecuta tu código Python, actuando como traductor entre Python de alto nivel y el lenguaje de máquina de bajo nivel que entiende tu ordenador. Si tu código no sigue las reglas de sintaxis de Python, el intérprete no puede procesar el código.
Cuando el intérprete de Python encuentra un error de sintaxis, se detiene y muestra un mensaje de error. Este mensaje incluye un rastreo de la línea de código que provocó el error, junto con un indicador que apunta al punto más antiguo de la línea en el que se detectó el error.
El intérprete intenta proporcionarte la mayor cantidad de información relevante posible para ayudarte a diagnosticar y solucionar el problema, así que asegúrate de leer los mensajes de error detenidamente.
Los errores de sintaxis en Python tienen que ver con la estructura: se producen cuando un comando infringe las reglas gramaticales del lenguaje. Por ejemplo, en inglés, una oración siempre debe comenzar con una letra mayúscula y terminar con un signo de puntuación. Del mismo modo, en Python, una sentencia siempre debe terminar con una nueva línea y bloques de código (como los de las sentencias o bucles if) que deben tener la sangría adecuada.
Si estás familiarizado con los errores de ejecución, puede que te preguntes en qué se diferencian de los errores de sintaxis. Los errores de sintaxis impiden la ejecución de un programa. Los errores de ejecución se producen después de que el programa haya comenzado a ejecutarse.
Exploración de diferentes tipos de errores de sintaxis
Como Python tiene muchas reglas sintácticas, también pueden producirse muchos errores de sintaxis. En esta sección, conocerás varios errores comunes y sus soluciones.
Puntuación que está mal colocada, que falta o que no coincide
Python usa varios signos de puntuación para entender la estructura del código. Debes asegurarte de que cada uno de estos signos de puntuación esté colocado correctamente y coincida con la puntuación correspondiente para evitar errores de sintaxis.
Por ejemplo, siempre debes usar paréntesis (()), corchetes ([]) y llaves ({}) en pares coincidentes. Esto significa que, si abres uno, debes cerrarlo.
En el ejemplo siguiente, se usa una llave para definir un objeto, pero no está cerrada:
# Incorrect
proxies = {
'http': proxy_url,
'https': proxy_url
Si intentas ejecutar el código, el intérprete devuelve un SyntaxError:
File "python-syntax-errors.py", line 2
proxies = {
^
SyntaxError: '{' was never closed
Como se mencionó anteriormente, el intérprete de Python normalmente proporciona un mensaje de error descriptivo. Aquí, se te indica el nombre del archivo donde sucedió el error, el número de línea en el que se produjo y una flecha que indica en qué parte del código se detectó el error. También se te transmite que la llave ({) nunca se cerró.
Con toda esta información, puedes descifrar fácilmente que necesitas cerrar la llave para solucionar el problema:
# Correct
proxies = {
'http': proxy_url,
'https': proxy_url
} # Closed a curly bracket
Otro signo de puntuación que suele causar problemas son las comillas (‘ o “). Python, como muchos otros lenguajes de programación, usa comillas para definir cadenas. Debes usar el mismo tipo de comillas para abrir y cerrar una cadena:
# Incorrect
host = "brd.superproxy.io'
La combinación de comillas simples y dobles produce un error de sintaxis:
File "python-syntax-errors.py", line 2
host = "brd.superproxy.io'
^
SyntaxError: unterminated string literal (detected at line 2)
Aquí, el intérprete te transmite que no has terminado el literal de la cadena en la segunda línea:
# Correct
host = "brd.superproxy.io"
Puedes usar un par de comillas simples para obtener el mismo resultado.
En algunos casos, es posible que tengas que usar comillas simples y dobles en una cadena. En ese caso, puedes usar comillas triples como esta:
quote = """He said, "It's the best proxy service you can find!", and showed me this provider."""
En Python, las comas se utilizan para separar los elementos de una lista, una tupla o un argumento de una función. La falta de una coma puede generar 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"}
]
La ejecución de este código produce el siguiente mensaje de error:
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?
Si bien los mensajes de error son lo más útiles posible, puede que no siempre sugieran soluciones perfectas. Este fragmento omite cuatro comas, pero el mensaje de error solo selecciona la primera instancia. Para solucionarlo, consulta el código que aparece junto al mensaje de error y busca otros lugares en los que es posible que te hayas olvidado de colocar una coma:
# 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"}
]
A diferencia de las comas, los dos puntos se utilizan para iniciar un nuevo bloque de código (como en una sentencia if o un bucle 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)
)
Si se olvidan dos puntos, se produce el siguiente error de sintaxis:
if response.status_code == 200
^
SyntaxError: expected ':'
A partir de este mensaje de error, es fácil determinar que faltan dos puntos y puedes añadirlos en el lugar sugerido para solucionar el 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)
Palabras clave de Python que están mal escritas, mal colocadas o que faltan
Las palabras clave de Python son palabras especiales reservadas para significados y usos específicos, y no puedes usarlas como nombres de variables. Si escribes mal, colocas mal o te olvidas de usar una palabra clave, el intérprete generará un error.
Por ejemplo, si estás intentando importar los módulos requests y pprint a tu proyecto de raspado web, es posible que escribas mal accidentalmente la palabra clave import:
# Incorrect
improt requests
import pprint
Este error ortográfico hace que el intérprete genere el siguiente error de sintaxis no válida:
File "python-syntax-errors.py", line 2
improt requests
^^^^^^^^
SyntaxError: invalid syntax
Lamentablemente, este mensaje de error es impreciso, por lo que tienes que esforzarte un poco para descubrir qué ha fallado. Puedes ver que las flechas del mensaje de error apuntan a requests; ahí es donde el intérprete detectó por primera vez un error de sintaxis. Dado que escribir mal el nombre de un módulo no genera un error de sintaxis, la única otra opción es escribir mal la palabra clave import.
Una simple corrección de la palabra import corrige el error:
# Correct
import requests
import pprint
También es posible equivocarse con la sentencia from ... import … de la siguiente manera:
import BeautifulSoup from bs4
Aunque parece correcto, al ejecutar el código anterior se produce un error porque la palabra clave from debe ir antes de import:
File "python-syntax-errors.py", line 2
import BeautifulSoup from bs4
^^^^
SyntaxError: invalid syntax
Cambiar from e import soluciona el problema:
from bs4 import BeautifulSoup
Que falte una palabra clave es otro problema al que probablemente te enfrentarás al programar en Python. Este tipo de error es un poco más sutil que los otros mencionados porque la ausencia de una palabra clave en Python puede generar diferentes errores.
Si olvidas incluir la palabra clave return en una función que se supone que devuelve un valor, la función no se comporta como se esperaba:
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()
Esto no produce ningún error de sintaxis, pero la función devuelve None en lugar del resultado esperado. Al añadir la palabra clave return, se corrige el 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()
Si olvidas la palabra clave def al definir una función, se produce un error de sintaxis:
# 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()
El código anterior genera un error de sintaxis porque el intérprete espera una palabra clave antes del nombre de la función:
File "python-syntax-errors.py", line 1
fetch_data():
^
SyntaxError: invalid syntax
Al añadir la palabra clave def, se resuelve el error:
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()
Si olvidas la palabra clave if en una sentencia condicional, el intérprete genera un error porque espera una palabra clave antes de la condición:
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
Solo tienes que incluir la palabra clave if para solucionar este 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)
Ten en cuenta que estos son solo algunos ejemplos de palabras clave ausentes en Python. La falta de palabras clave también puede generar otros tipos de errores, así que ten mucho cuidado.
Uso incorrecto del operador de asignación
En Python, el símbolo = se usa para asignaciones, y == se usa para comparaciones. La mezcla de estos dos símbolos puede provocar un error de sintaxis:
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")
En el código anterior, el intérprete detecta correctamente la causa del problema:
File "python-syntax-errors.py", line 5
if response = requests.get('https://example.com/data', proxies=proxies)
^^^^^^
En este caso, estás intentando verificar que tu respuesta es la misma que la respuesta al método request.get(). Esto significa que debes reemplazar el operador de asignación en la sentencia if por el operador de comparación:
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")
Errores de sangría
Python usa la sangría para definir bloques de código. Si el código no tiene la sangría adecuada, el intérprete no puede distinguir el contenido del bloque de código y genera un IndentationError:
# Incorrect
async with async_playwright() as playwright:
await run(playwright)
Como puedes ver en el código anterior, no hay ninguna sangría después de la definición de un bloque (dos puntos), por lo que, cuando lo ejecutas, aparece el siguiente mensaje de error:
File "python-syntax-errors.py", line 2
await run(playwright)
^
IndentationError: expected an indented block after the with statement on line 1
Para solucionar este problema, sigue las reglas de sintaxis de Python y aplica la sangría adecuada al bloque de código:
# Correct
async with async_playwright() as playwright:
await run(playwright)
Problemas con las declaraciones de variables
Los nombres de variables en Python deben empezar con una letra o un guión bajo, y solo pueden contener letras, números y guiones bajos. Además, Python distingue entre mayúsculas y minúsculas, por lo que myvariable, myVariabley MYVARIABLE son variables diferentes.
Los nombres de tus variables solo pueden empezar por una letra o un guión bajo. El siguiente nombre de variable empieza por 1, lo que no cumple con las reglas de sintaxis de Python:
# Incorrect
1st_port = 22225
Al ejecutar el código anterior, el intérprete genera un SyntaxError:
File "python-syntax-errors.py", line 2
1st_port = 1
^
SyntaxError: invalid decimal literal
Para solucionar este problema, debes empezar el nombre de la variable con una letra o un guión bajo. Serviría cualquiera de las siguientes opciones:
# Correct
first_port = 22225
port_no_1 = 22225
Errores de definición de funciones y llamadas
Al definir una función, debes usar la palabra clave def seguida del nombre de la función, paréntesis y dos puntos. Al llamar a una función, debes usar su nombre seguido de paréntesis. Si olvidas alguno de estos elementos, se produce un error de sintaxis:
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
Aquí faltan tres elementos y cada uno de ellos provoca un error de sintaxis diferente. Para corregir estos errores, debes añadir paréntesis y dos puntos después del nombre de la función fetch_data. También necesitas añadir paréntesis después de la llamada a la función en la última línea del bloque de código, de la siguiente manera:
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()
Ten en cuenta que la falta de paréntesis y dos puntos en la definición de la función siempre provoca un error de sintaxis. Sin embargo, el intérprete no detecta si olvidaste los paréntesis al llamar a una función (fetch_data()). En ese caso, no produce necesariamente una excepción, lo que puede provocar un comportamiento inesperado.
Mejores prácticas para ayudarte a evitar errores de sintaxis
Escribir código sin errores es una habilidad que se adquiere con la práctica. Comprender e implementar las siguientes prácticas recomendadas puede ayudarte a evitar errores de sintaxis comunes.
Estrategias proactivas
La mejor manera de lidiar con los errores de sintaxis es intentar evitarlos de antemano.
Antes de empezar a trabajar en un proyecto, debes familiarizarte con las reglas de sintaxis más comunes del lenguaje en el que estás codificando.
Utiliza un editor de código con resaltado de sintaxis y comprobación de sangría
Un buen editor de código es un gran aliado a la hora de evitar errores de sintaxis. La mayoría de los editores de código modernos ofrecen funciones como el resaltado de sintaxis y la comprobación de sangría, que pueden ayudarte a detectar errores antes de ejecutar el código.
Por ejemplo, en la siguiente ilustración, hay una marca roja al final de la línea if response.status_code == 200 que sugiere que hay un error porque no hay dos puntos:
Sigue unas pautas de estilo de codificación coherentes
Como ocurre con la mayoría de las cosas, la coherencia es clave cuando se trata de escribir un código limpio y sin errores. Intenta seguir un estilo de codificación coherente. Esto hace que el código sea más fácil de leer y entender, lo que, a su vez, facilita la detección y la corrección de errores.
En Python, la Guía de estilo PEP 8 es ampliamente aceptada como el estándar para el estilo de codificación. Proporciona unas pautas para aspectos como la denominación de variables, la sangría y el uso de espacios en blanco.
Escribe código en funciones pequeñas y bien definidas
Dividir el código en funciones pequeñas y bien definidas puede facilitar la gestión y la depuración.
Cada función debe tener un propósito único y claro. Si una función hace demasiadas cosas, puede resultar difícil entenderla y depurarla. Por ejemplo, echa un vistazo a la siguiente función 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())
En este ejemplo, sería más fácil dividir esta función en varias más pequeñas, cada una de las cuales ejecutando una porción de código más pequeña y manejable:
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))
Estrategias reactivas
No importa cuánto te esfuerces por evitar errores, ya que siempre habrá algunos que se cuelen. Las siguientes estrategias se centran en lidiar con estos errores.
Lee los mensajes de error con atención
Como se mencionó anteriormente, Python normalmente muestra un mensaje de error que incluye información sobre la naturaleza del error y su ubicación.
Leer detenidamente estos mensajes de error puede darte pistas valiosas sobre lo que salió mal y cómo solucionarlo.
Usa las sentencias print() de manera estratégica
El uso de sentencias print() es una forma rápida y eficaz de depurar proyectos pequeños o problemas sencillos en los que es necesario rastrear el flujo de ejecución o inspeccionar los valores de las variables en puntos específicos. Es particularmente útil para un desarrollo rápido y cuando tienes una buena comprensión de dónde podría estar el problema.
La depuración de print() puede ser menos intrusiva y rápida de implementar, lo que la convierte en un método de referencia para corregir errores rápidos y sencillos. Sin embargo, ten siempre en cuenta que es solo para uso temporal y asegúrate de no usarlo en el código de producción, ya que la impresión de los datos que se muestran a los usuarios finales puede provocar filtraciones de datos catastróficas y problemas de rendimiento.
Si tienes problemas más complejos, tienes bases de código más grandes o necesitas inspeccionar el estado del programa con más profundidad (como los estados de las variables en varias llamadas a funciones o iteraciones), es más apropiado usar un depurador. Los depuradores permiten establecer puntos de interrupción, revisar el código línea por línea e inspeccionar el estado de la solicitud en cualquier momento, lo que proporciona un entorno de depuración más controlado y completo.
Aprovecha los recursos y las comunidades en línea
Si no consigues solucionar un error especialmente complicado, no dudes en buscar ayuda. En Internet hay numerosos recursos (Python Docs y Real Python) y comunidades (comunidades de Reddit como r/Python y r/LearnPython, Stack Overflowy Python Forum) donde puedes encontrar respuestas y soluciones a tus problemas.
Conclusión
En este artículo, has explorado el mundo de los errores de sintaxis de Python. Has aprendido sobre algunos tipos de errores de sintaxis, incluidos dónde pueden ocurrir y cómo identificarlos y corregirlos.
También has aprendido sobre algunas estrategias proactivas y reactivas que te ayudarán a prevenir errores de sintaxis o a corregirlos cuando se produzcan.
Bright Data es un proveedor líder de herramientas de raspado web. Ya sea que necesites proxies fiables, una recopilación automatizada de datos, conjuntos de datos listos para usar o la automatización de las tareas de raspado web, Bright Data ofrece soluciones que pueden hacer que tus proyectos de raspado web sean más eficientes y productivos.
Regístrate ahora para encontrar el producto que mejor se adapte a tus necesidades y ¡empieza una prueba gratuita hoy mismo!
No se requiere tarjeta de crédito
