Пока не конец файла python

Обновлено: 03.07.2024

До теперь мы работали только с объектами, сохраненными в оперативной памяти компьютера. То есть после завершения работы программы все наши действия удалялись. Сегодня мы научимся работать с файлами в Python, то есть сохранять состояние программы в файле на жестком диске.

Открытие и закрытие файла в Python.

Перед тем как прочесть и записать что-либо в файл, его следует открыть. Чтобы открыть файл в Python используется встроенная функция open(). При вызове, эта функция создает объект типа файл, с которым в дальнейшем можно работать.

Синтаксис функции open() в Python.

my_file = open(имя_файла [, режим_доступа][, буферизация])

имя_файла: строка, содержащая имя файла с расширением. Например, "my_file.txt".

режим_доступа: строка, которой мы указываем для чего открывается файл: для чтения, записи, добавления информации, и т.д. Например, "w". По умолчанию файл открывается для чтения - "r".

буферизация: Целое число. Если значение аргумента указано 0 - файл открывается без буферизации, 1 с построчной буферизацией, больше одного процесс буферизации выполняется с указанным размером буфера. Отрицательное число - разер буфера будет равен системному.

Список режимов доступа к файлу в Python.

Атрибуты файлового объекта в Python.

Как только файл был открыт и у вас появился файловый объект, вы можете получить следующую информацию о нем:

Закрытие файла в Python. Метод close().

Метод файлового объекта close() автоматически закрывает файл, при этом теряется любая несохраненная информация. Работать с файлом (читать, записывать) после этого нельзя.

Python автоматически закрывает файл если файловый объект к которому он привязан присваивается другому файлу. Однако, хорошей практикой будет вручную закрывать файл командой close().

Чтение и запись файлов в Python

Для файлового объекта доступен целый набор методов, чтобы облегчить нашу работу с файлом.

Запись в файл в Python. Метод write().

Метод write() записывает любую строку в открытый файл. Важно помнить, что строки в Python могут содержать двоичные данные, а не только текст.

Метод write() не добавляет символ переноса строки ('\n') в конец файла.

Синтаксис метода write().

Вышеприведенный код создаст файл some.txt и запишет в него указанную строку.

Чтение из файла в Python. Метод read().

Метод read() читает строку из открытого файла.

Синтаксис метода read().

Необязательный параметр count - это количество байт, которые следует прочитать из открытого файла. Этот метод читает информацию с начала файла и, если параметр count не указан, до конца файла.

Например, прочтем созданный нами файл some.txt:

Как узнать позицию указателя в файле в Python.

После того как вы вызвали метод read() на файловом объекте, если вы повторно вызовете read(), то увидите лишь пустую строку. Это происходит потому, что после первого прочтения указатель находится в конце файла. Для того чтобы узнать позицию указателя можно использовать метод tell().

Говоря проще, метод tell() сообщает в скольких байтах от начала файла мы сейчас находимся.

Чтобы перейти на нужную нам позицию, следует использовать другой метод - seek().

Синтаксис метода seek().

Аргумент offset указывает на сколько байт перейти. опциональный аргумент from означает позицию, с которой начинается движение. 0 - означает начало файла, 1 нынешняя позиция, 2 - конец файла.

The seek(offset[, from]) method changes the current file position. The offset argument indicates the number of bytes to be moved. The from argument specifies the reference position from where the bytes are to be moved.

Добавление в файл. Метод write()

Если вы хотите не перезаписать файл полностью (что делает метод write в случае открытия файла в режиме 'w'), а только добавить какой-либо текст, то файл следует открывать в режиме 'a' - appending. После чего использовать все тот же метод write.

Расширенная работа с файлами в Python.

Для доступа к более широкому функционалу в работе с файлами в Python, как то удаление файлов, создание директорий и т.д. Следует подключить библиотеку os. Скоро выйдут статьи с примерами.

Приложение-пример работы с файлами в Python.

В качестве приложения примера мы напишем программу сохранения результата игрока. Программе задается имя игрока и его результат, а она добавляет эту запись в отсортированный список. Рейтинг результатов.

чтобы прочитать какой-то текстовый файл, в C или Pascal, я всегда использую следующие фрагменты для чтения данных до EOF:

таким образом, мне интересно, как я могу сделать это просто и быстро в Python?

цикл по файлу для чтения строк:

файловые объекты являются итерационными и дают строки до EOF. Использование объекта file в качестве итерируемого использует буфер для обеспечения выполнения чтения.

вы можете сделать то же самое с stdin (нет необходимости использовать raw_input() :

чтобы завершить картину, двоичные чтения можно сделать с помощью:

здесь chunk будет содержать до 1024 байт за раз из файла.

вы можете имитировать идиому C в Python.

для чтения буфера до max_size количество байт, вы можете сделать это:

или текстовый файл строка за строкой:

вы должны использовать while True / break построить так как там нет теста eof в Python, кроме отсутствия байтов, возвращенных из чтения.

в C, вы могли бы иметь:

однако, вы не можете иметь это в Питон:

, потому что назначения не допускаются в выражениях в Python.

это точно больше идиоматический в Python, чтобы сделать это:

идиома Python для открытия файла и чтения его строка за строкой:

файл будет автоматически закрыт в конце выше код ( with строительство заботится об этом).

наконец, стоит отметить, что line сохранить пустую строку. Это можно легко удалить с помощью:

хотя есть предложения выше для "делать это на python way", если кто-то хочет действительно иметь логику, основанную на EOF, то я полагаю, что использование обработки исключений-это способ сделать это --

пример:

или Ctrl-Z на raw_input() подсказка (Windows, Ctrl-Z Linux)

вы можете использовать ниже код, чтобы читать построчно до конца файла

вы можете использовать следующий фрагмент кода. readlines() считывает весь файл сразу и разбивает его на строки.

Чтобы работать с сохранёнными данными, каждому программисту на Python необходимо знать про обработку файлов. Начиная с самого раннего выпуска, запись и чтение файлов встроены в Python. Если сравнить с другими языками типа С или Java, это довольно просто и требует немного строк кода. Более того, для этого не нужно загружать никаких дополнительных модулей.

Основы работы с файлами в Python

Общие методы для работы с файлами: open() , чтобы открыть файл, seek() , чтобы установить текущую позицию файла на заданное смещение, и close() , чтобы закрыть файловый объект, когда вы закончите его использовать. Метод open() возвращает ссылку на файл, представляющий файловый объект, чтобы получить доступ к чтению, записи или добавлению.

Как только вы открыли файл, метод open() вернёт вам файловый объект. Эти файловые объекты содержат методы наподобие read() , readline() , write() , tell() и seek() . Хотя сами они (или подобные объекты) имеют больше методов, чем указано здесь, эти встречаются наиболее часто. Не каждый файловый объект нуждаются в имплементации всех методов работы с файлами.

Примеры

В этой статье мы будем объяснять, как читать файлы с помощью Python, через примеры. Некоторые из них включают построчное чтение, кусками (определённое количество строк за раз) и чтение в один заход. Также мы вам покажем способ прочесть отдельную строку из файла без поиска по всему файлу.

Построчное чтение файла

Первый пример вдохновлён двумя языками программирования: C и C++. Он довольно простой: открываем файл с помощью метода open() , читаем файл построчно, используя метод readline() , и выводим строку сразу же после чтения. Здесь применяется цикл while , который непрерывно читает из файла, пока метод readline() продолжает возвращать данные. В случае конца файла (EOF) цикл while останавливается, и файловый объект закрывается, освобождая ресурсы для других программ.

Как вы могли заметить, в листинге 1 мы явно открыли и закрыли файл (строки 5 и 14 соответственно). Хотя интерпретатор Python закрывает открытые файлы автоматически в конце исполнения программы, явно закрывать файл через close() есть хороший стиль программирования, и это не следует забывать.

В качестве улучшения в языке Python 2.3 был введён удобный протокол итераторов. Это позволяет вам упростить цикл readline следующим образом:

Здесть применяется цикл for в комбинации с итератором in . Файл открывается в строке 4 листинга 2. Текущая строка определяется с помощью итератора in , считывается из файла, и её содержимое подаётся на выход stdout в строке 5. Python скрывает открытие и закрытие файла, когда закончится исполнение. Хотя такой способ неэффективен, он позволяет вам больше не иметь дело с файловым потоком.

К сожалению, код выше менее явный и полагается на сборщик мусора Python, чтобы закрыть файл. Введённая в Python 2.5 команда with инкапсулирует весь процесс ещё больше и также открывает и закрывает файлы лишь однажды на протяжении блока кода. Листинг 3 показывает, как использовать команду with .

Комбинация оператора with и команды open() открывает файл только один раз (строка 4). Если цикл for завершён успешно, содержимое файла напечатано в поток stdout (строки 5 и 6).

Чтение файла как набора строк

До сих пор мы обрабатывали файл построчно. Это довольно медленный способ для огромных файлов, но его можно улучшить, если читать несколько строк одновременно. Чтобы этого добиться, в дело вступает метод islice() из модуля itertools. Также он работает как итератор и возвращает набор данных, состоящий из n строк. В конце файла результат может быть короче, и завершающий вызов вернёт пустой список.

Чтение определённой строки из файла

Используя показанные выше методы, мы можем также выполнить другие полезные действия, например, прочесть определённую строку из файла. Чтобы это сделать, применим счётчик и напечатаем соответствующую строку, когда дойдём до неё, проходя итерациями по файлу.

Листинг 6 достаточно просто понять, но он немного больше, чем предыдущие примеры. Его можно сократить, используя модуль linecache. Листинг 7 поазывает, как упростить код с помощью метода getline() . Если запрашиваемая строка выпадает из ряда валидных строк в файле, то метод getline() взамен возвращает пустую строку.

Чтение из всего файла целиком

Python также предлагает метод readlines() , похожий на метод readline() из первого примера. В отличие от read() , содержимое файла сохраняется в список, где каждый элемент есть строка содержимого. Листинг 9 показывает, как получить доступ к этим данным:

Вывод

Как обычно, есть больше одного способа прочитать содержимое файла. В плане скорости все они примерно одинаковы. Какое решение для вас работает лучше, зависит от решаемых вами задач. Мы думаем, что было бы полезно увидеть разные возможности и выбрать более подходящее решение.

Хотя Python значительно упрощает процесс чтения файлов, иногда он бывает довольно сложным, в таком случае рекомендую взглянуть на официальную документацию Python для дальнейшего ознакомления.

Одна из наиболее распространенных задач, которые вы можете выполнять с помощью Python, — это чтение и запись файлов. Будь то запись в простой текстовый файл, чтение сложного журнала сервера или даже анализ необработанных байтовых данных, все эти ситуации требуют чтения или записи файла.

В этом руководстве вы узнаете:

Из чего состоит файл и почему это важно в Python
Основы чтения и записи файлов на Python
Некоторые базовые сценарии чтения и записи файлов

В основном, этот урок для питонистов от новичка до среднего уровня, но здесь есть несколько советов, которые могут быть оценены и более продвинутыми программистами.

Содержание

Что такое файл?

По своей сути файл — это непрерывный набор байтов, используемых для хранения данных. Эти данные организованы в определенном формате и могут быть как простыми, как текстовый файл, так и сложными, как исполняемый файл программы. В конце эти байтовые файлы затем преобразуются в двоичные 1 и 0 для облегчения обработки компьютером.

Файлы в большинстве современных файловых систем состоят из трех основных частей:

Заголовок (Header): метаданные о содержимом файла (имя файла, размер, тип и т. д.)
Данные (Data): содержимое файла, написанное создателем или редактором.
Конец файла (End of file — EOF): специальный символ, обозначающий конец файла.

Пути к файлам

При доступе к файлу в операционной системе требуется указать путь к файлу. Путь к файлу — это строка, представляющая расположение файла. Он разделен на три основные части:

Путь к папке: расположение папки с файлами в файловой системе, где последующие папки разделены косой чертой / (Unix) или обратной косой чертой \ (Windows).
Имя файла: фактическое имя файла.
Расширение: конец пути к файлу с точкой (.), Используемой для обозначения типа файла.

Вот небольшой пример. Допустим, у вас есть файл, расположенный в такой файловой структуре:

Допустим, вы хотите получить доступ к файлу cats.jpg, и ваше текущее местоположение находится в той же папке, что и путь. Чтобы получить доступ к файлу, вам нужно пройти через папку path, затем через папку to, наконец, дойдя до файла cats.jpg. Путь к папке — это путь /to/. Имя файла — cats. Расширение файла — .jpg. Таким образом, полный путь — это path/to/cats.jpg.

Теперь предположим, что ваше текущее местоположение или текущий рабочий каталог (cwd) находится в папке to нашего примера структуры папок. Вместо того, чтобы ссылаться на cats.jpg по полному пути path/to/cats.jpg, на файл можно просто ссылаться по имени файла и расширению cats.jpg.

А как насчет dog_breeds.txt? Как бы вы могли получить к нему доступ, не используя полный путь? Вы можете использовать специальные символы с двумя точками (..) для перемещения на один каталог вверх. Это означает, что ../dog_breeds.txt будет ссылаться на файл dog_breeds.txt из каталога в:

Двойную точку ( .. ) можно объединить в цепочку, чтобы перемещаться по нескольким каталогам над текущим каталогом. Например, чтобы получить доступ к animals.csv из папки to, вы должны использовать ../../animals.csv.

Окончание строк

Одна из проблем, часто возникающих при работе с данными файла, — это представление новой строки или окончания строки. Окончание строки уходит корнями в эпоху азбуки Морзе, когда определенный про-знак использовался для обозначения конца передачи или конца строки.

Windows использует символы CR + LF для обозначения новой строки, в то время как Unix и более новые версии Mac используют только символ LF. Это может вызвать некоторые сложности при обработке файлов в операционной системе, отличной от исходной. Вот небольшой пример. Допустим, мы исследуем файл dog_breeds.txt, созданный в системе Windows:

Этот же вывод будет интерпретироваться на устройстве Unix по-разному:

Это может сделать перебор каждой строки проблематичным, и вам, возможно, придется учитывать подобные ситуации.

Кодировки символов

ASCII на самом деле является подмножеством Unicode (UTF-8), что означает, что ASCII и Unicode имеют одинаковые числовые и символьные значения. Важно отметить, что анализ файла с неправильной кодировкой символов может привести к сбоям или искажению символа. Например,если файл был создан с использованием кодировки UTF-8, и вы пытаетесь проанализировать его, используя кодировку ASCII, если есть символ, который находится за пределами этих 128 значений, тогда будет ошибка.

Открытие и закрытие файла в Python

Если вы хотите работать с файлом, первое, что нужно сделать, — это открыть его. Это делается путем вызова встроенной функции open(). open() имеет единственный обязательный аргумент — путь к файлу. open() имеет единственный возврат, файловый объект:

После открытия файла нужно научиться закрывать его.

Предупреждение: вы всегда должны следить за тем, чтобы открытый файл был правильно закрыт.

Важно помнить, что закрыть файл — это ваша святая обязанность. В большинстве случаев после завершения работы приложения или скрипта файл в конечном итоге закрывается. Тем не менее, нет никакой гарантии, когда именно это произойдет. Это может привести к нежелательному поведению, включая утечку ресурсов. Также рекомендуется использовать Python (Pythonic), чтобы убедиться, что ваш код ведет себя хорошо определенным образом и снижает любое нежелательное поведение.

Когда вы манипулируете файлом, есть два способа гарантировать, что файл закрыт должным образом, даже при возникновении ошибки. Первый способ закрыть файл — использовать блок try-finally :

Если вы не знакомы с блоком try-finally , ознакомьтесь с разделом Исключения Python: введение.

Второй способ закрыть файл — использовать оператор with :

Оператор with автоматически закрывает файл после того, как он покидает блок with , даже в случае ошибки. Я настоятельно рекомендую вам как можно чаще использовать оператор with , поскольку он позволяет сделать код более чистым и упрощает обработку любых неожиданных ошибок.

Скорее всего, вы также захотите использовать второй позиционный аргумент, mode (режим). Этот аргумент представляет собой строку, содержащую несколько символов, обозначающих способ открытия файла. По умолчанию и наиболее часто используется r , что означает открытие файла в режиме только для чтения в виде текстового файла:

Другие варианты режимов полностью задокументированы в Интернете, но наиболее часто используются следующие:

mode (режим)	Описание
'r'	Открыть для чтения (по умолчанию)
'w'	Открыть для записи, сначала обрезать (перезаписать) файл
'rb' или 'wb'	Открыть в двоичном режиме (чтение / запись с использованием байтовых данных)

Вернемся назад и поговорим немного о файловых объектах. Файловый объект:

«Объект, предоставляющий файловый API (с такими методами, как read() или write() ) для базового ресурса». (Источник цитаты)

Есть три разные категории файловых объектов:

Текстовые файлы
Буферизованные двоичные файлы
Необработанные двоичные файлы

Каждый из этих типов файлов определяется в модуле io. Вот краткое изложение того, как все выстраивается.

Типы текстовых файлов

Текстовый файлы — это файлы самого распространенного типа, с которым вы можете столкнуться. Вот несколько примеров того, как открываются эти файлы:

Для этих типов файлов open() вернет объект файла TextIOWrapper :

Это объект файла по умолчанию, возвращаемый open() .

Типы буферизованных двоичных файлов

Буферизованный двоичный тип файла используется для чтения и записи двоичных файлов. Вот несколько примеров того, как открываются эти файлы:

С этими типами файлов open() вернет либо объект файла BufferedReader , либо BufferedWriter :

Типы необработанных файлов

Необработанный тип файла:

Обычно используется в качестве низкоуровневого строительного блока для двоичных и текстовых потоков. (Источник цитирования)

Поэтому он обычно не используется.

Вот пример того, как открываются эти файлы:

Для этих типов файлов open() вернет файловый объект FileIO :

Чтение и запись открытых файлов

После того, как вы открыли файл, вы захотите прочитать или записать в файл. Во-первых, посмотрим на чтение файла. Есть несколько методов, которые могут быть вызваны для файлового объекта, чтобы помочь вам:

Используя тот же файл dog_breeds.txt, который вы использовали выше, давайте рассмотрим несколько примеров использования этих методов. Вот пример того, как открыть и прочитать весь файл с помощью .read() :

Вот пример того, как читать по 5 байтов из строки с помощью метода Python .readline() :

Вот пример того, как прочитать весь файл в виде списка с помощью метода Python .readlines() :

Вышеупомянутый пример также может быть выполнен с помощью list() для создания списка файловых объектов:

Итерация по каждой строке в файле

Обычно при чтении файла нужно перебирать каждую строку. Вот пример того, как использовать метод Python .readline() для выполнения этой итерации:

Другой способ перебора каждой строки в файле — использовать метод Python .readlines() объекта файла. Помните, что .readlines() возвращает список, в котором каждый элемент представляет собой строку в файле:

Однако приведенные выше примеры можно еще больше упростить, перебирая сам файловый объект:

Этот последний подход является более питоническим и может быть более быстрым и более эффективным с точки зрения памяти. Поэтому рекомендуется использовать это вместо этого.

Примечание. Некоторые из приведенных выше примеров содержат print('some text', end = '') . end='' предотвращает добавление Python дополнительной строки в печатаемый текст и выводит только то, что читается из файла..

Теперь перейдем к написанию файлов. Как и при чтении файлов, файловые объекты имеют несколько методов, которые полезны для записи в файл:

Метод	Что он делает
.write(string)	Эаписывает строку в файл.
.writelines(seq)	Pаписывает последовательность в файл. К каждому элементу последовательности не добавляются окончания строк. Вы можете добавить соответствующие окончания строки.

Вот быстрый пример использования .write() и .writelines() :

Работа с байтами

Иногда вам может потребоваться работать с файлами, используя байтовые строки. Это делается путем добавления символа «b» к аргументу mode . Применяются все те же методы для файлового объекта. Однако каждый из методов вместо этого ожидает и возвращает байтовый объект:

Значение	Интерпретация
0x89	«Магическое» число, указывающее, что это начало PNG
0x50 0x4E 0x47	PNG в ASCII
0x0D 0x0A	Строка в стиле DOS, заканчивающаяся \r\n
0x1A	Символ EOF в стиле DOS
0x0A	Строка в стиле Unix, заканчивающаяся \n

Конечно, когда вы открываете файл и читаете эти байты по отдельности, вы можете видеть, что это действительно заголовочный файл .jpg:

Полный пример: dos2unix.py

Давайте принесем все это домой и рассмотрим полный пример того, как читать и писать в файл. Ниже приведен инструмент, похожий на dos2unix, который преобразует файл, содержащий окончания строк \r\n , вместо \n .

Этот инструмент разбит на три основных раздела. Первый — это str2unix() , которая преобразует строку из концов строки \r\n в \n . Второй — dos2unix() , который преобразует строку, содержащую символы \r\n , в \n . dos2unix() вызывает внутреннюю функцию str2unix() . Наконец, есть блок __main__ , который вызывается только тогда, когда файл выполняется как скрипт. Думайте об этом как об основной функции в других языках программирования.

Советы и приемы

Теперь, когда вы освоили основы чтения и записи файлов, вот несколько советов и приемов, которые помогут вам развить свои навыки.

file

Атрибут __file__ — это специальный атрибут модулей, аналогичный __name__ . Это:

«Путь к файлу, из которого был загружен модуль, если он был загружен из файла». (Источник)

Примечание. Чтобы повторить итерацию, __file__ возвращает путь относительно того, где был вызван исходный скрипт Python. Если вам нужен полный системный путь, вы можете использовать os.getcwd() , чтобы получить текущий рабочий каталог вашего исполняемого кода.

Вот пример из реального мира. На одной из моих прошлых работ я провел несколько тестов для аппаратного устройства. Каждый тест был написан с использованием скрипта Python с именем файла тестового скрипта, используемым в качестве заголовка. Затем эти сценарии будут выполнены и смогут распечатать свой статус с помощью специального атрибута __file__ . Вот пример структуры папок:

Запуск main.py дает следующее:

Я смог запустить и получить статус всех моих тестов динамически с помощью специального атрибута __file__.

Добавление к файлу

Иногда вам может понадобиться добавить в файл или начать запись в конце уже заполненного файла. Это легко сделать, используя символ 'a' в качестве аргумента режима:

Когда вы снова изучите dog_breeds.txt, то увидите, что начало файла не изменилось, и теперь Beagle добавлен в конец файла:

Работа с двумя файлами одновременно

Бывают случаи, когда необходимо одновременно читать файл и записать в другой файл. Если вы воспользуетесь примером, который был показан, когда вы учились писать в файл, его можно объединить в следующее:

Создание собственного диспетчера контекста

Может наступить время, когда вам понадобится более тонкий контроль над файловым объектом, поместив его в специальный класс. Когда вы это сделаете, использование оператора with будет невозможно, если вы не добавите несколько волшебных методов: __enter__ и __exit__ . Добавив их, вы создадите так называемый диспетчер контекста.

__enter__() вызывается при вызове оператора with . __exit__() вызывается при выходе из блока операторов with .

Вот шаблон, который можно использовать для создания собственного класса:

Теперь, когда у вас есть собственный класс, который теперь является диспетчером контекста, вы можете использовать его аналогично встроенному open() :

Вот хороший пример. Помните милый образ Джека Рассела, который у нас был? Возможно, вы хотите открывать другие файлы .jpg, но не хотите каждый раз анализировать файл заголовка. Вот пример того, как это сделать. В этом примере также используются настраиваемые итераторы. Если вы не знакомы с ними, ознакомьтесь с Итераторами Python:

Теперь вы можете открывать файлы .jpg и правильно их анализировать с помощью своего настраиваемого диспетчера контекста:

Не изобретайте змею заново

Кроме того, существуют встроенные библиотеки, которые вы можете использовать, чтобы помочь вам, вот их названия:

: чтение и запись файлов WAV (аудио); : чтение и запись файлов AIFF и AIFC (аудио); : чтение и запись файлов Sun AU; : чтение и запись файлов tar-архива; : работа с ZIP-архивами; :легко создавать и анализировать файлы конфигурации; : создавать или читать файлы на основе XML; : чтение и запись файлов установщика Microsoft; : создание и анализ айлов Mac OS X .plist .

Есть всего много чего ещё. Кроме того, в PyPI доступно еще больше сторонних инструментов. Вот самые популярные из них:

: инструменты работы с PDF; : чтение и запись Excel-файлов; : чтение и манипулирование изображениями.

Ты файловый мастер, Гарри!

Ты сделал это! Теперь вы знаете, как работать с файлами с помощью Python, включая некоторые продвинутые методы. Работа с файлами в Python теперь должна быть проще, чем когда-либо, и это приятное чувство, когда вы начинаете это делать.

Из этого урока вы узнали:

Что это за файл такой?
Как правильно открывать и закрывать файлы?
Как читать и писать файлы?
Некоторые продвинутые приемы работы с файлами
Некоторые библиотеки для работы с распространенными типами файлов

Если у вас есть вопросы, пишите нам в комментариях.

ст. преп. кафедры ЦЭиИТ. Автор более 130 научных и учебно-методических работ. Лауреат ВДНХ (серебряная медаль). Посмотреть больше записей

Читайте также: