В каждом языке есть набор правил, определяющих, как правильно формировать допустимые конструкции; это называется синтаксисом языка. Когда вы только учитесь кодировать, синтаксические ошибки являются частью процесса. Во многих случаях новичкам трудно понять правила синтаксиса, и они часто сталкиваются с опечатками и неправильно расположенными символами.
Синтаксические ошибки — обычная часть процесса кодирования, но чем раньше вы поймете, почему они возникают, тем быстрее сможете их исправить.
В этой статье вы узнаете о различных синтаксических ошибках в Python и о том, как их избежать.
Синтаксические ошибки в Python
В любом языке программирования несоблюдение правил синтаксиса, скорее всего, приведет к синтаксической ошибке, и ваш код не сможет работать.
В Python интерпретатор Python читает и выполняет ваш код Python, выступая в качестве переводчика между высокоуровневым языком Python и низкоуровневым машинным языком, понятным вашему компьютеру. Если ваш код не соответствует синтаксическим правилам Python, интерпретатор не сможет его обработать.
Когда интерпретатор Python обнаруживает синтаксическую ошибку, он останавливается и отображает сообщение об ошибке. Это сообщение содержит трассировку строки кода, вызвавшей ошибку, а также индикатор, указывающий на самую раннюю точку в строке, где была обнаружена ошибка.
Интерпретатор старается предоставить вам как можно больше релевантной информации, которая поможет диагностировать и устранить проблему, поэтому внимательно читайте сообщения об ошибках.
Синтаксические ошибки в Python связаны со структурой — они возникают, когда команда нарушает грамматические правила языка. Например, в английском языке предложение всегда должно начинаться с заглавной буквы и заканчиваться знаком препинания. Точно так же в Python оператор всегда должен заканчиваться новой строкой и блоками кода (например, в операторах или циклах if ), которые должны иметь правильный отступ.
Если вы знакомы с ошибками выполнения, возможно, вам интересно, чем они отличаются от синтаксических ошибок. Синтаксические ошибки препятствуют запуску программы. Ошибки выполнения возникают после начала работы программы.
Изучение различных типов синтаксических ошибок
Поскольку в Python много синтаксических правил, также может возникать множество синтаксических ошибок. В этом разделе вы узнаете о нескольких распространенных ошибках и способах их устранения.
Неправильная, отсутствующая или несовпадающая пунктуация
Python использует различные знаки препинания для понимания структуры кода. Чтобы избежать синтаксических ошибок, необходимо убедиться, что каждый из этих знаков препинания расставлен правильно и совпадает с соответствующей пунктуацией.
Например, всегда следует использовать круглые скобки (()), квадратные скобки ([]) и фигурные скобки ({}) в соответствующих парах. Это означает, что если вы открываете скобку, вы должны закрыть ее.
В следующем примере фигурная скобка используется для определения объекта, но она не закрывается:
# Incorrect
proxies = {
'http': proxy_url,
'https': proxy_url
Если вы попытаетесь запустить эту строку кода, интерпретатор выдаст ошибку SyntaxError:
File "python-syntax-errors.py", line 2
proxies = {
^
SyntaxError: '{' was never closed
Как упоминалось ранее, интерпретатор Python обычно предоставляет описательное сообщение об ошибке. В нем содержатся имя файла, в котором произошла ошибка, номер строки, в которой она произошла, и стрелка, указывающая место в коде, где была обнаружена ошибка. Вам также сообщают, что фигурная скобка '{' не была закрыта.
Имея всю эту информацию, можно легко понять, что для решения проблемы необходимо закрыть фигурную скобку:
# Correct
proxies = {
'http': proxy_url,
'https': proxy_url
} # Closed a curly bracket
Еще один знак препинания, который часто вызывает проблемы, — кавычки (‘или “). Python, как и многие другие языки программирования, использует кавычки для определения строк. Для открытия и закрытия строки необходимо использовать один и тот же тип кавычек:
# Incorrect
host = "brd.superproxy.io'
Смешивание одинарных и двойных кавычек приводит к синтаксической ошибке:
File "python-syntax-errors.py", line 2
host = "brd.superproxy.io'
^
SyntaxError: unterminated string literal (detected at line 2)
Здесь интерпретатор сообщает вам, что вы не завершили строковый литерал во второй строке:
# Correct
host = "brd.superproxy.io"
Для получения того же результата можно использовать пару одинарных кавычек.
В некоторых сценариях может потребоваться использовать одинарные и двойные кавычки в строке. В этом случае вы можете использовать тройные кавычки следующим образом:
quote = """He said, "It's the best proxy service you can find!", and showed me this provider."""
В Python запятые используются для разделения элементов в списке, кортеже или аргументе функции. Отсутствие запятой может привести к неожиданным результатам:
# 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"}
]
Выполнение этого кода приводит к появлению следующего сообщения об ошибке:
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?
Хотя сообщения об ошибках сделаны максимально полезными, они не всегда предлагают идеальные решения. В этом фрагменте пропущены четыре запятых, но сообщение об ошибке указывает только на первый случай. Чтобы исправить это, посмотрите код вокруг сообщения об ошибке и найдите другие места, где вы, возможно, забыли поставить запятую:
# 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"}
]
В отличие от запятых, двоеточие используется для начала нового блока кода (например, в операторе if или для цикла ):
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)
)
Если пропустить двоеточие, возникнет следующая синтаксическая ошибка:
if response.status_code == 200
^
SyntaxError: expected ':'
Из этого сообщения об ошибке легко определить, что отсутствует двоеточие, и вы можете добавить его в предложенное место, чтобы решить проблему:
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)
Написанные с ошибками, неправильно размещенные или отсутствующие ключевые слова Python
Ключевые слова Python — это специальные слова, зарезервированные для определенных значений и вариантов использования, и их нельзя использовать в качестве имен переменных. Если вы ошиблись в написании, неправильно разместили или забыли указать ключевое слово, интерпретатор выдаст сообщение об ошибке.
Например, если вы пытаетесь импортировать модули requests и pprint в свой проект по веб-скрейпингу, вы можете случайно неправильно написать ключевое слово import :
# Incorrect
improt requests
import pprint
Из-за этой орфографической ошибки интерпретатор выдает следующую ошибку неправильного синтаксиса :
File "python-syntax-errors.py", line 2
improt requests
^^^^^^^^
SyntaxError: invalid syntax
К сожалению, это сообщение об ошибке расплывчато, поэтому вам придется приложить немного усилий, чтобы выяснить, что пошло не так. Вы можете видеть, что стрелки в сообщении об ошибке указывают на requests; именно здесь интерпретатор впервые обнаружил синтаксическую ошибку. Поскольку неправильное написание имени модуля не приводит к синтаксической ошибке, единственным вариантом является неправильное написание ключевого слова import .
Простое исправление слова import исправляет ошибку:
# Correct
import requests
import pprint
Также можно испортить оператор from... import... следующим образом:
import BeautifulSoup from bs4
Хотя все выглядит нормально, выполнение предыдущего кода приводит к ошибке, поскольку ключевое слово from должно быть использовано перед словом import:
File "python-syntax-errors.py", line 2
import BeautifulSoup from bs4
^^^^
SyntaxError: invalid syntax
Для устранения проблемы следует поменять местами from и import :
from bs4 import BeautifulSoup
Отсутствие ключевого слова — еще одна проблема, с которой вы, вероятно, столкнетесь при написании кода на Python. Этот тип ошибок немного более коварен, чем другие упомянутые ошибки, поскольку отсутствие ключевого слова в Python может приводить к возникновению различных ошибок.
Если вы забудете включить ключевое слово return в функцию, которая должна возвращать значение, функция будет вести себя не так, как ожидалось:
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()
Это не приводит к синтаксической ошибке, но вместо ожидаемого результата функция возвращает None . Добавление ключевого слова return исправляет предыдущий код:
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()
Если вы забудете ключевое слово def при определении функции, вы столкнетесь с синтаксической ошибкой:
# 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()
В предыдущем коде возникает синтаксическая ошибка, поскольку интерпретатор ожидает ключевое слово перед именем функции:
File "python-syntax-errors.py", line 1
fetch_data():
^
SyntaxError: invalid syntax
Добавление ключевого слова def устраняет ошибку:
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()
Если вы забудете ключевое слово if в условном операторе, интерпретатор выдает ошибку, потому что интерпретатор ожидает ключевое слово перед условием:
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
Чтобы решить эту проблему, нужно просто включить ключевое слово if :
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)
Обратите внимание, что это всего лишь несколько примеров пропущенных ключевых слов в Python. Пропущенные ключевые слова могут привести и к другим ошибкам, поэтому будьте особенно осторожны.
Неправильное использование оператора присваивания
В Python символ = используется для присваивания значений, а символ == используется для сравнений . Смешение этих двух символов может привести к синтаксической ошибке:
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")
В предыдущем коде интерпретатор правильно определяет причину проблемы:
File "python-syntax-errors.py", line 5
if response = requests.get('https://example.com/data', proxies=proxies)
^^^^^^
В данном случае вы пытаетесь проверить, совпадает ли ваш ответ с ответом на метод request.get () . Это означает, что вам необходимо заменить оператор присваивания в выражении if оператором сравнения:
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")
Ошибки отступа
Python использует отступы для определения блоков кода. Если в коде используется неправильный отступ, интерпретатор не может различить содержимое блока кода и выдает ошибку IndentationError:
# Incorrect
async with async_playwright() as playwright:
await run(playwright)
Как видно из предыдущего кода, после определения блока (двоеточия) нет отступа, поэтому при запуске появляется следующее сообщение об ошибке:
File "python-syntax-errors.py", line 2
await run(playwright)
^
IndentationError: expected an indented block after the with statement on line 1
Чтобы решить эту проблему, следуйте синтаксическим правилам Python и сделайте правильный отступ в блоке кода:
# Correct
async with async_playwright() as playwright:
await run(playwright)
Проблемы с объявлениями переменных
Имена переменных в Python должны начинаться с буквы или символа подчеркивания и могут содержать только буквы, цифры и символы подчеркивания. Кроме того, Python чувствителен к регистру символов, поэтому myvariable, myVariableи MYVARIABLE — это разные переменные.
Имена переменных не могут начинаться ни с чего, кроме буквы или символа подчеркивания. Следующее имя переменной начинается с 1, что не соответствует правилам синтаксиса Python:
# Incorrect
1st_port = 22225
При запуске предыдущего кода интерпретатор выдает ошибку SyntaxError:
File "python-syntax-errors.py", line 2
1st_port = 1
^
SyntaxError: invalid decimal literal
Чтобы исправить эту ошибку, следует начать имя переменной с буквы или символа подчеркивания. Может сработать любой из следующих вариантов:
# Correct
first_port = 22225
port_no_1 = 22225
Определение и ошибки вызова функции
При определении функции необходимо использовать ключевое слово def , а затем имя функции, круглые скобки и двоеточие. При вызове функции необходимо использовать ее имя, за которым следуют круглые скобки. Если пропустить любой из этих элементов, возникнет следующая синтаксическая ошибка:
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
Здесь отсутствуют три элемента, и каждый из них вызывает отдельную синтаксическую ошибку. Чтобы исправить эти ошибки, необходимо добавить круглые скобки и двоеточие после имени функции fetch_data. Необходимо также добавить круглые скобки после вызова функции в последней строке блока кода, например:
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()
Обратите внимание, что отсутствие круглых скобок и двоеточий в определении функции всегда приводит к синтаксической ошибке. Однако интерпретатор не поймет, забыли ли вы круглые скобки при вызове функции (fetch_data ()). В данном случае это не обязательно вызывает исключение, которое может привести к неожиданному поведению.
Рекомендации по предотвращению синтаксических ошибок
Написание безошибочного кода — навык, который приходит с практикой. Понимание и применение следующих передовых методов поможет избежать распространенных синтаксических ошибок.
Проактивные стратегии
Лучший способ справиться с синтаксическими ошибками — сначала попытаться предотвратить их.
Прежде чем приступить к работе над проектом, вы должны ознакомиться с наиболее распространенными синтаксическими правилами языка, на котором вы пишете код.
Используйте редактор кода с подсветкой синтаксиса и проверкой отступов
Хороший редактор кода — отличный помощник, когда речь идет о предотвращении синтаксических ошибок. Большинство современных редакторов кода предлагают такие функции, как выделение синтаксиса и проверка отступов, которые помогают выявлять ошибки еще до запуска кода.
Например, на следующем рисунке в конце строки if response.status_code == 200 есть красная метка, указывающая на ошибку из-за отсутствия двоеточия:
Следуйте рекомендациям по единому стилю кодирования
Как и в большинстве случаев, согласованность играет ключевую роль при написании чистого и безошибочного кода. Старайтесь следовать единому стилю кодирования. Это упрощает чтение и понимание кода, что, в свою очередь, облегчает обнаружение и исправление ошибок.
В Python в качестве стандарта стиля кодирования широко принято руководство по стилю PEP 8 . В нем содержатся рекомендации по таким вопросам, как присвоение имен переменным, отступы и использование пробелов.
Пишите код с помощью небольших, четко определенных функций
Разбиение кода на небольшие, четко определенные функции упростит управление и отладку.
Каждая функция должна иметь единую четкую цель. Если функция выполняет слишком много действий, ее может быть трудно понять и отладить. Например, рассмотрим следующую функцию 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())
В этом примере было бы удобнее разбить эту функцию на несколько небольших функций, каждая из которых будет выполнять меньшую и более удобную для управления часть кода:
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))
Реактивные стратегии
Как бы вы ни старались предотвратить ошибки, некоторые из них всегда могут проскользнуть. Следующие стратегии направлены на устранение этих ошибок.
Внимательно читайте сообщения об ошибках
Как упоминалось ранее, Python обычно выдает сообщение об ошибке, содержащее информацию о характере ошибки и ее местонахождении.
Внимательное чтение сообщений об ошибках может дать вам ценные сведения о том, что пошло не так и как это исправить.
Стратегически используйте оператор Print
Использование оператора print () — это быстрый и эффективный способ отладки небольших проектов или простых задач, когда необходимо отслеживать ход выполнения или проверять значения переменных в определенных точках. Это особенно полезно для быстрой разработки и когда вы хорошо понимаете, в чем может заключаться проблема.
Отладка с помощью оператора Print может быть менее докучливой и более быстрой в реализации, что делает ее популярным методом быстрого исправления и устранения простых ошибок. Однако всегда имейте в виду, что она предназначена только для временного использования, и не используйте ее в производственном коде, поскольку печать данных, демонстрируемых конечным пользователям, может привести к катастрофическим утечкам данных и проблемам с производительностью.
Если у вас есть более сложные проблемы, большая кодовая база или вам нужно глубже изучить состояние программы (например, состояния переменных при нескольких вызовах функций или итерациях), лучше использовать отладчик. Отладчики позволяют устанавливать точки останова, пошагово просматривать код и проверять состояние приложения в любой момент, обеспечивая более контролируемую и комплексную среду отладки.
Используйте онлайн-ресурсы и сообщества
Если вы столкнулись с особенно сложной ошибкой, не стесняйтесь обращаться за помощью. Существует множество онлайн-ресурсов (Python Docs и Real Python) и сообществ (r/Python и r/LearnPython , Stack Overflowи Python Forum), где можно найти ответы и решения своих проблем.
Заключение
В этой статье вы познакомились с миром синтаксических ошибок Python. Вы узнали о нескольких типах синтаксических ошибок, в том числе о том, где они могут возникать, а также как их выявлять и исправлять.
Вы также узнали о нескольких проактивных и реактивных стратегиях, которые помогут предотвратить синтаксические ошибки или исправить их в случае их возникновения.
Bright Data является ведущим поставщиком инструментов для веб-скрейпинга. Если вам нужны надежные прокси-серверы, автоматический сбор данных, готовые к использованию наборы данныхили автоматизация задач по веб-скрейпингу, Bright Data предлагает решения, которые могут сделать ваши проекты по веб-скрейпингу более эффективными и продуктивными.
Зарегистрируйтесь сейчас, чтобы найти продукт, соответствующий вашим потребностям, и начните бесплатное опробование уже сегодня!
Кредитная карта не требуется
