Ошибка SyntaxError: unexpected EOF while parsing Solution в Python
В Python простой, но строгий синтаксис. Если забыть закрыть блок кода, то возникнет ошибка «SyntaxError: unexpected EOF while parsing». Это происходит часто, например, когда вы забыли добавить как минимум одну строку в цикл for.
В этом материале разберемся с этой ошибкой, и по каким еще причинам она возникает. Разберем несколько примеров, чтобы понять, как с ней справляться.
Ошибка «SyntaxError: unexpected EOF while parsing» возникает в том случае, когда программа добирается до конца файла, но не весь код еще выполнен. Это может быть вызвано ошибкой в структуре или синтаксисе кода.
EOF значит End of File. Представляет собой последний символ в Python-программе.
Python достигает конца файла до выполнения всех блоков в таких случаях:
- Если забыть заключить код в специальную инструкцию, такую как, циклы for или while, или функцию.
- Не закрыть все скобки на строке.
Разберем эти ошибки на примерах построчно.
Пример №1: незавершенные блоки кода
Циклы for и while, инструкции if и функции требуют как минимум одной строки кода в теле. Если их не добавить, результатом будет ошибка EOF.
Рассмотрим такой пример цикла for, который выводит все элементы рецепта:
Исключения¶
Исключения возникают тогда, когда в программе возникает некоторая исключительная ситуация. Например, к чему приведёт попытка чтения несуществующего файла? Или если файл был случайно удалён, пока программа работала? Такие ситуации обрабатываются при помощи исключений.
Это касается и программ, содержащих недействительные команды. В этом случае Python поднимает руки и сообщает, что обнаружил ошибку.
Ошибки¶
Рассмотрим простой вызов функции print . Что, если мы ошибочно напишем print как Print ? Обратите внимание на заглавную букву. В этом случае Python поднимает синтаксическую ошибку.
>>> Print('Привет, Мир!') Traceback (most recent call last): File "", line 1, in Print('Привет, Мир!') NameError: name 'Print' is not defined >>> print('Привет, Мир!') Привет, Мир!
Обратите внимание, что была поднята ошибка NameError , а также указано место, где была обнаружена ошибка. Так в данном случае действует обработчик ошибок.
Исключения¶
Попытаемся считать что-либо от пользователя. Нажмите Сtrl-D (или Ctrl+Z в Windows) и посмотрите, что произойдёт.
>>> s = input('Введите что-нибудь --> ') Введите что-нибудь --> Traceback (most recent call last): File "", line 1, in s = input('Введите что-нибудь --> ') EOFError: EOF when reading a line
Python поднимает ошибку с именем EOFError , что означает, что он обнаружил символ конца файла (который вводится при помощи Ctrl-D ) там, где не ожидал.
Обработка исключений¶
Обрабатывать исключения можно при помощи оператора try..except [1]. При этом все обычные команды помещаются внутрь try-блока, а все обработчики исключений – в except-блок.
Пример: (сохраните как try_except.py )
try: text = input('Введите что-нибудь --> ') except EOFError: print('Ну зачем вы сделали мне EOF?') except KeyboardInterrupt: print('Вы отменили операцию.') else: print('Вы ввели '.format(text))
Вывод:
$ python3 try_except.py Введите что-нибудь --> # Нажмите ctrl-d Ну зачем вы сделали мне EOF? $ python3 try_except.py Введите что-нибудь --> # Нажмите ctrl-c Вы отменили операцию. $ python3 try_except.py Введите что-нибудь --> без ошибок Вы ввели без ошибок
Как это работает:
Здесь мы поместили все команды, которые могут вызвать исключения/ошибки, внутрь блока try , а затем поместили обработчики соответствующих ошибок/исключений в блок except . Выражение except может обрабатывать как одиночную ошибку или исключение, так и список ошибок/исключений в скобках. Если не указано имя ошибки или исключения, обрабатываться будут все ошибки и исключения.
Помните, что для каждого выражения try должно быть хотя бы одно соответствующее выражение except . Иначе какой смысл был бы в блоке try ?
Если ошибка или исключение не обработано, будет вызван обработчик Python по умолчанию, который останавливает выполнение программы и выводит на экран сообщение об ошибке. Выше мы уже видели это в действии.
Можно также добавить пункт else к соответствующему блоку try..except . Этот пункт будет выполнен тогда, когда исключений не возникает.
В следующем примере мы увидим, как можно получить объект исключения для дальнейшей работы с ним.
Вызов исключения¶
Исключение можно поднять при помощи оператора raise [2], передав ему имя ошибки/исключения, а также объект исключения, который нужно выбросить.
Вызываемая ошибка или исключение должна быть классом, который прямо или непрямо является производным от класса Exception .
Пример: (сохраните как raising.py )
class ShortInputException(Exception): '''Пользовательский класс исключения.''' def __init__(self, length, atleast): Exception.__init__(self) self.length = length self.atleast = atleast try: text = input('Введите что-нибудь --> ') if len(text) 3: raise ShortInputException(len(text), 3) # Здесь может происходить обычная работа except EOFError: print('Ну зачем вы сделали мне EOF?') except ShortInputException as ex: print('ShortInputException: Длина введённой строки -- ; \ ожидалось, как минимум, '.format(ex.length, ex.atleast)) else: print('Не было исключений.')
Вывод:
$ python3 raising.py Введите что-нибудь --> а ShortInputException: Длина введённой строки -- 1; ожидалось, как минимум, 3 $ python3 raising.py Введите что-нибудь --> абв Не было исключений.
Как это работает:
Здесь мы создаём наш собственный тип исключения. Этот новый тип исключения называется ShortInputException . Он содержит два поля: length , хранящее длину введённого текста, и atleast , указывающее, какую минимальную длину текста ожидала программа.
В пункте except мы указываем класс ошибки ShortInputException , который будет сохранён как[3] переменная ex , содержащая соответствующий объект ошибки/исключения. Это аналогично параметрам и аргументам при вызове функции. Внутри этого пункта except мы используем поля length и atleast объекта исключения для вывода необходимых сообщений пользователю.
Try .. Finally¶
Представим, что в программе происходит чтение файла и необходимо убедиться, что объект файла был корректно закрыт и что не возникло никакого исключения. Этого можно достичь с применением блока finally .
Сохраните как finally.py :
import time try: f = open('poem.txt') while True: # наш обычный способ читать файлы line = f.readline() if len(line) == 0: break print(line, end='') time.sleep(2) # Пусть подождёт некоторое время except KeyboardInterrupt: print('!! Вы отменили чтение файла.') finally: f.close() print('(Очистка: Закрытие файла)')
Вывод:
$ python3 finally.py Программировать весело Если работа скучна, Чтобы придать ей весёлый тон - !! Вы отменили чтение файла. (Очистка: Закрытие файла)
Как это работает:
Здесь мы производим обычные операции чтения из файла, но в данном случае добавляем двухсекундный сон после вывода каждой строки при помощи функции time.sleep , чтобы программа выполнялась медленно (ведь Python очень быстр от природы). Во время выполнения программы нажмите ctrl-c , чтобы прервать/отменить выполнение программы.
Пронаблюдайте, как при этом выдаётся исключение KeyboardInterrupt , и программа выходит. Однако, прежде чем программа выйдет, выполняется пункт finally , и файловый объект будет всегда закрыт.
Оператор with¶
Типичной схемой является запрос некоторого ресурса в блоке try с последующим освобождением этого ресурса в блоке finally . Для того, чтобы сделать это более “чисто”, существует оператор with [4]:
Сохраните как using_with.py :
with open("poem.txt") as f: for line in f: print(line, end='')
Как это работает:
Вывод должен быть таким же, как и в предыдущем примере. Разница лишь в том, что здесь мы используем функцию open с оператором with – этим мы оставляем автоматическое закрытие файла под ответственность with open .
За кулисами происходит следующее. Существует некий протокол, используемый оператором with . Он считывает объект, возвращаемый оператором open . Назовём его в данном случае “thefile”.
Перед запуском блока кода, содержащегося в нём, оператор with всегда вызывает функцию thefile.__enter__ , а также всегда вызывает thefile.__exit__ после завершения выполнения этого блока кода.
Так что код, который мы бы написали в блоке finally , будет автоматически обработан методом __exit__ . Это избавляет нас от необходимости повторно в явном виде указывать операторы try..finally .
Более обширное рассмотрение этой темы выходит за рамки настоящей книги, поэтому для более исчерпывающего объяснения см. PEP 343.
Резюме¶
Мы обсудили использование операторов try..except и try..finally . Мы также увидели, как создавать наши собственные типы исключений и как их вызывать.
Далее мы ознакомимся со стандартной библиотекой Python.
Примечания¶
| [1] | try – англ. “пытаться” (прим.перев.) |
| [2] | raise – англ. “поднимать” (прим.перев.) |
EOF — это не символ
Недавно я читал книгу «Компьютерные системы: архитектура и программирование. Взгляд программиста». Там, в главе про систему ввода-вывода Unix, авторы упомянули о том, что в конце файла нет особого символа EOF .
Если вы читали о системе ввода-вывода Unix/Linux, или экспериментировали с ней, если писали программы на C, которые читают данные из файлов, то это заявление вам, вероятно, покажется совершенно очевидным. Но давайте поближе присмотримся к следующим двум утверждениям, относящимся к тому, что я нашёл в книге:
- EOF — это не символ.
- В конце файлов нет некоего особого символа.
EOF — это не символ
Почему кто-то говорит или думает, что EOF — это символ? Полагаю, это может быть так из-за того, что в некоторых программах, написанных на C, можно найти код, в котором используется явная проверка на EOF с использованием функций getchar() и getc() .
Это может выглядеть так:
#include . while ((c = getchar()) != EOF) putchar(c);
FILE *fp; int c; . while ((c = getc(fp)) != EOF) putc(c, stdout);
Если заглянуть в справку по getchar() или getc() , можно узнать, что обе функции считывают следующий символ из потока ввода. Вероятно — именно это является причиной возникновения заблуждения о природе EOF . Но это — лишь мои предположения. Вернёмся к мысли о том, что EOF — это не символ.
А что такое, вообще, символ? Символ — это самый маленький компонент текста. «A», «a», «B», «b» — всё это — разные символы. У символа есть числовой код, который в стандарте Unicode называют кодовой точкой. Например — латинская буква «A» имеет, в десятичном представлении, код 65. Это можно быстро проверить, воспользовавшись командной строкой интерпретатора Python:
$python >>> ord('A') 65 >>> chr(65) 'A' Или можно взглянуть на таблицу ASCII в Unix/Linux:
$ man ascii 
Выясним, какой код соответствует EOF , написав небольшую программу на C. В ANSI C константа EOF определена в stdio.h , она является частью стандартной библиотеки. Обычно в эту константу записано -1 . Можете сохранить следующий код в файле printeof.c , скомпилировать его и запустить:
#include int main(int argc, char *argv[])
Скомпилируем и запустим программу:
$ gcc -o printeof printeof.c $ ./printeof EOF value on my system: -1 У меня эта программа, проверенная на Mac OS и на Ubuntu, сообщает о том, что EOF равняется -1 . Есть ли какой-нибудь символ с таким кодом? Тут, опять же, можно проверить коды символов в таблице ASCII, можно взглянуть на таблицу Unicode и узнать о том, в каком диапазоне могут находиться коды символов. Мы же поступим иначе: запустим интерпретатор Python и воспользуемся стандартной функцией chr() для того, чтобы она дала бы нам символ, соответствующий коду -1 :
$ python >>> chr(-1) Traceback (most recent call last): File "", line 1, in ValueError: chr() arg not in range(0x110000) Как и ожидалось, символа с кодом -1 не существует. Значит, в итоге, EOF , и правда, символом не является. Переходим теперь ко второму рассматриваемому утверждению.
В конце файлов нет некоего особого символа
Может, EOF — это особенный символ, который можно обнаружить в конце файла? Полагаю, сейчас вы уже знаете ответ. Но давайте тщательно проверим наше предположение.
Возьмём простой текстовый файл, helloworld.txt, и выведем его содержимое в шестнадцатеричном представлении. Для этого можно воспользоваться командой xxd :
$ cat helloworld.txt Hello world! $ xxd helloworld.txt 00000000: 4865 6c6c 6f20 776f 726c 6421 0a Hello world!. Как видите, последний символ файла имеет код 0a . Из таблицы ASCII можно узнать о том, что этот код соответствует символу nl , то есть — символу новой строки. Это можно выяснить и воспользовавшись Python:
$ python >>> chr(0x0a) '\n' Так. EOF — это не символ, а в конце файлов нет некоего особого символа. Что же такое EOF ?
Что такое EOF?
EOF (end-of-file) — это состояние, которое может быть обнаружено приложением в ситуации, когда операция чтения файла доходит до его конца.
Взглянем на то, как можно обнаруживать состояние EOF в разных языках программирования при чтении текстового файла с использованием высокоуровневых средств ввода-вывода, предоставляемых этими языками. Для этого напишем очень простую версию cat , которая будет называться mcat . Она побайтно (посимвольно) читает ASCII-текст и в явном виде выполняет проверку на EOF . Программу напишем на следующих языках:
- ANSI C
- Python 3
- Go
- JavaScript (Node.js)
ANSI C
Начнём с почтенного C. Представленная здесь программа является модифицированной версией cat из книги «Язык программирования C».
/* mcat.c */ #include int main(int argc, char *argv[]) < FILE *fp; int c; if ((fp = fopen(*++argv, "r")) == NULL) < printf("mcat: can't open %s\n", *argv); return 1; >while ((c = getc(fp)) != EOF) putc(c, stdout); fclose(fp); return 0; > $ gcc -o mcat mcat.c $ ./mcat helloworld.txt Hello world! Вот некоторые пояснения, касающиеся вышеприведённого кода:
- Программа открывает файл, переданный ей в виде аргумента командной строки.
- В цикле while осуществляется копирование данных из файла в стандартный поток вывода. Данные копируются побайтово, происходит это до тех пор, пока не будет достигнут конец файла.
- Когда программа доходит до EOF , она закрывает файл и завершает работу.
Python 3
В Python нет механизма явной проверки на EOF , похожего на тот, который имеется в ANSI C. Но если посимвольно читать файл, то можно выявить состояние EOF в том случае, если в переменной, хранящей очередной прочитанный символ, будет пусто:
# mcat.py import sys with open(sys.argv[1]) as fin: while True: c = fin.read(1) # читаем максимум 1 символ if c == '': # EOF break print(c, end='') Запустим программу и взглянём на возвращаемые ей результаты:
$ python mcat.py helloworld.txt Hello world! Вот более короткая версия этого же примера, написанная на Python 3.8+. Здесь используется оператор := (его называют «оператор walrus» или «моржовый оператор»):
# mcat38.py import sys with open(sys.argv[1]) as fin: while (c := fin.read(1)) != '': # читаем максимум 1 символ до достижения EOF print(c, end='') Запустим этот код:
$ python3.8 mcat38.py helloworld.txt Hello world! Go
В Go можно явным образом проверить ошибку, возвращённую Read(), на предмет того, не указывает ли она на то, что мы добрались до конца файла:
// mcat.go package main import ( "fmt" "os" "io" ) func main() < file, err := os.Open(os.Args[1]) if err != nil < fmt.Fprintf(os.Stderr, "mcat: %v\n", err) os.Exit(1) >buffer := make([]byte, 1) // 1-byte buffer for < bytesread, err := file.Read(buffer) if err == io.EOF < break >fmt.Print(string(buffer[:bytesread])) > file.Close() > $ go run mcat.go helloworld.txt Hello world! JavaScript (Node.js)
В среде Node.js нет механизма для явной проверки на EOF . Но, когда при достижении конца файла делается попытка ещё что-то прочитать, вызывается событие потока end.
/* mcat.js */ const fs = require('fs'); const process = require('process'); const fileName = process.argv[2]; var readable = fs.createReadStream(fileName, < encoding: 'utf8', fd: null, >); readable.on('readable', function() < var chunk; while ((chunk = readable.read(1)) !== null) < process.stdout.write(chunk); /* chunk is one byte */ >>); readable.on('end', () => < console.log('\nEOF: There will be no more data.'); >); $ node mcat.js helloworld.txt Hello world! EOF: There will be no more data. Низкоуровневые системные механизмы
Как высокоуровневые механизмы ввода-вывода, использованные в вышеприведённых примерах, определяют достижение конца файла? В Linux эти механизмы прямо или косвенно используют системный вызов read(), предоставляемый ядром. Функция (или макрос) getc() из C, например, использует системный вызов read() и возвращает EOF в том случае, если read() указывает на возникновение состояния достижения конца файла. В этом случае read() возвращает 0 . Если изобразить всё это в виде схемы, то получится следующее:
Получается, что функция getc() основана на read() .
Напишем версию cat , названную syscat , используя только системные вызовы Unix. Сделаем мы это не только из интереса, но и из-за того, что это вполне может принести нам какую-то пользу.
Вот эта программа, написанная на C:
/* syscat.c */ #include #include #include #include int main(int argc, char *argv[])
$ gcc -o syscat syscat.c $ ./syscat helloworld.txt Hello world! В этом коде используется тот факт, что функция read() , указывая на достижение конца файла, возвращает 0 .
Вот та же программа, написанная на Python 3:
# syscat.py import sys import os fd = os.open(sys.argv[1], os.O_RDONLY) while True: c = os.read(fd, 1) if not c: # EOF break os.write(sys.stdout.fileno(), c) $ python syscat.py helloworld.txt Hello world! Вот — то же самое, написанное на Python 3.8+:
# syscat38.py import sys import os fd = os.open(sys.argv[1], os.O_RDONLY) while c := os.read(fd, 1): os.write(sys.stdout.fileno(), c) Запустим и этот код:
$ python3.8 syscat38.py helloworld.txt Hello world! Итоги
- EOF — это не символ.
- В конце файлов нет некоего особого символа.
- EOF — это состояние, о котором сообщает ядро, и которое может быть обнаружено приложением в том случае, когда операция чтения данных доходит до конца файла.
- В ANSI C EOF — это, опять же, не символ. Это — константа, определённая в stdio.h , в которую обычно записано значение -1.
- «Символ» EOF нельзя найти в таблице ASCII или в Unicode.
Как исправить ошибку SyntaxError: unexpected EOF while parsing
Есть данный код:
fam = input(«Назовите вашу фамилию: «)
nam = input(«Ваше имя: «)
otc = input(«Ваше отчество:»)
print(«\n»)
res = fam + nam + otc
while res != «ПариевОлегЕвгеньевич»:
try:
if res == «ПариевОлегЕвгеньевич»:
print(«Личность установленна. \n»)
print(«Добропожаловать, «, fam, nam, otc)
else:
print(«Личность не установленна. «)
print(«Попробуйте войти снова.»)
Помогите пожалуйста найти в нём ошибку типа: SyntaxError: unexpected EOF while parsing
Дополнен 5 лет назад
Хорошо. Тогда у меня к вам другой вопрос. Как всю программу заставить идти сначала, если будет выполняться:
else:
print(«Личность не установленна. «)
print(«Попробуйте войти снова.»)
Лучший ответ
А что, теперь разрешено писать try без except? У тебя же в коде первая половина оператора написана, а вторая отсутствует. Вот Python и ругается, что текст программы уже закончился, а синтаксический разбор кода ещё не завершён.
Олег ПариевЗнаток (274) 5 лет назад
Хорошо. Тогда у меня к вам другой вопрос. Как всю программу заставить идти сначала, если будет выполняться:
else:
print(«Личность не установленна. «)
print(«Попробуйте войти снова.»)
Андрей Высший разум (419041) Например, обернуть весь код в бесконечный цикл и после print(«Добропожаловать, «, fam, nam, otc) добавить break
Олег ПариевЗнаток (274) 5 лет назад
Огромное спасибо!
Остальные ответы
Думаю, надо удалить строку
try:
После этого программа может будет выполняться, но неправильно. Это не единственная ошибка.
Олег ПариевЗнаток (274) 5 лет назад
Хорошо. Тогда у меня к вам другой вопрос. Как всю программу заставить идти сначала, если будет выполняться:
else:
print(«Личность не установленна. «)
print(«Попробуйте войти снова.»)
Голова Робота Просветленный (36328) Надо сделать цикл. Но этот код уже находится в цикле. Возможно, тут второй цикл просто не нужен.