Открыть файл python: Файлы. Работа с файлами. | Python 3 для начинающих и чайников

Файлы. Работа с файлами. | Python 3 для начинающих и чайников

В данной статье мы рассмотрим встроенные средства python для работы с файлами: открытие / закрытие, чтение и запись.

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

f = open('text.txt', 'r')

У функции open много параметров, они указаны в статье «Встроенные функции», нам пока важны 3 аргумента: первый, это имя файла. Путь к файлу может быть относительным или абсолютным. Второй аргумент, это режим, в котором мы будем открывать файл.

Режим	Обозначение
‘r’	открытие на чтение (является значением по умолчанию).
‘w’	открытие на запись, содержимое файла удаляется, если файла не существует, создается новый.
‘x’	открытие на запись, если файла не существует, иначе исключение.
‘a’	открытие на дозапись, информация добавляется в конец файла.
‘b’	открытие в двоичном режиме.
‘t’	открытие в текстовом режиме (является значением по умолчанию).
‘+’	открытие на чтение и запись

Режимы могут быть объединены, то есть, к примеру, ‘rb’ — чтение в двоичном режиме. По умолчанию режим равен ‘rt’.

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

Чтение из файла

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

Первый — метод read, читающий весь файл целиком, если был вызван без аргументов, и n символов, если был вызван с аргументом (целым числом n).

>>> f = open('text.txt')
>>> f.read(1)
'H'
>>> f.read()
'ello world!\nThe end.\n\n'

Ещё один способ сделать это — прочитать файл построчно, воспользовавшись циклом for:

>>> f = open('text.txt')
>>> for line in f:
...     line
...
'Hello world!\n'
'\n'
'The end.\n'
'\n'

Запись в файл

Теперь рассмотрим запись в файл. Попробуем записать в файл вот такой вот список:

>>> l = [str(i)+str(i-1) for i in range(20)]
>>> l
['0-1', '10', '21', '32', '43', '54', '65', '76', '87', '98', '109', '1110', '1211', '1312', '1413', '1514', '1615', '1716', '1817', '1918']

Откроем файл на запись:

>>> f = open('text.txt', 'w')

Запись в файл осуществляется с помощью метода write:

>>> for index in l:
...     f.write(index + '\n')
...
4
3
3
3
3

Для тех, кто не понял, что это за цифры, поясню: метод write возвращает число записанных символов.

После окончания работы с файлом его обязательно нужно закрыть с помощью метода close:

>>> f.close()

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

>>> f = open('text.txt', 'r')
>>> l = [line.strip() for line in f]
>>> l
['0-1', '10', '21', '32', '43', '54', '65', '76', '87', '98', '109', '1110', '1211', '1312', '1413', '1514', '1615', '1716', '1817', '1918']
>>> f.close()

Мы получили тот же список, что и был. В более сложных случаях (словарях, вложенных кортежей и т. д.) алгоритм записи придумать сложнее. Но это и не нужно. В python уже давно придумали средства, такие как pickle или json, позволяющие сохранять в файле сложные структуры.

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

Михаил Свинцов

автор курса «Full-stack веб-разработчик на Python»

Взаимодействие с файловой системой позволяет хранить информацию, полученную в результате работы программы. Михаил Свинцов из SkillFactory расскажет о базовой функциональности языка программирования Python для работы с файлами.

Встроенные средства Python

Основа для работы с файлами — built-in функция open()

open(file, mode="rt")

Эта функция имеет два аргумента. Аргумент file принимает строку, в которой содержится путь к файлу. Второй аргумент, mode, позволяет указать режим, в котором необходимо работать с файлом. По умолчанию этот аргумент принимает значение «rt», с которым, и с некоторыми другими, можно ознакомиться в таблице ниже

Эти режимы могут быть скомбинированы. Например, «rb» открывает двоичный файл для чтения. Комбинируя «r+» или «w+» можно добиться открытия файла в режиме и чтения, и записи одновременно с одним отличием — первый режим вызовет исключение, если файла не существует, а работа во втором режиме в таком случае создаст его.

Начать саму работу с файлом можно с помощью объекта класса io.TextIOWrapper, который возвращается функцией open(). У этого объекта есть несколько атрибутов, через которые можно получить информацию

• name — название файла;
• mode — режим, в котором этот файл открыт;
• closed — возвращает True, если файл был закрыт.

По завершении работы с файлом его необходимо закрыть при помощи метода close()

f = open("examp.le", "w")
//  работа с файлом
f.close()

Однако более pythonic way стиль работы с файлом встроенными средствами заключается в использовании конструкции with .. as .., которая работает как менеджер создания контекста. Написанный выше пример можно переписать с ее помощью

with open("examp.le", "w") as f:
// работа с файлом

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

Чтение из файла

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

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

with open("examp.le", "r") as f:
    text = f.read()

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

with open("examp.le", "r") as f:
    part = f.read(16)

При этом будут получены только первые 16 символов текста. Важно понимать, что при применении этой функции несколько раз подряд будет считываться часть за частью этого текста — виртуальный курсор будет сдвигаться на считанную часть текста. Его можно сдвинуть на определенную позицию, при необходимости воспользовавшись методом seek().

with open("examp.le", "r") as f: # 'Hello, world!'
    first_part = f.read(8)       # 'Hello, w'
    f.seek(4)
    second_part = f.read(8)      # 'o, world'

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

with open("examp.le", "r") as f:
    for line in f.readlines():
        print(line)

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

with open("examp.le", "r") as f:
    for line in f:
        print(line)

Запись в файл

Функциональность внесения данных в файл не зависит от режима — добавление данных или перезаписывание файла. В выполнении этой операции также существует несколько подходов.

Самый простой и логичный — использование функции write()

with open("examp.le", "w") as f:
    f.write(some_string_data)

Важно, что в качестве аргумента функции могут быть переданы только строки. Если необходимо записать другого рода информацию, то ее необходимо явно привести к строковому типу, используя методы __str__(self) для объектов или форматированные строки.

Есть возможность записать в файл большой объем данных, если он может быть представлен в виде списка строк.

with open("examp.le", "w") as f:
    f.writelines(list_of_strings)

Здесь есть еще один нюанс, связанный с тем, что функции write() и writelines() автоматически не ставят символ переноса строки, и это разработчику нужно контролировать самостоятельно.

Существует еще один, менее известный, способ, но, возможно, самый удобный из представленных. И как бы не было странно, он заключается в использовании функции print(). Сначала это утверждение может показаться странным, потому что общеизвестно, что с помощью нее происходит вывод в консоль. И это правда. Но если передать в необязательный аргумент file объект типа io.TextIOWrapper, каким и является объект файла, с которым мы работаем, то поток вывода функции print() перенаправляется из консоли в файл.

with open("examp.le", "w") as f:
    print(some_data, file=f)

Сила такого подхода заключается в том, что в print() можно передавать не обязательно строковые аргументы — при необходимости функция сама их преобразует к строковому типу.

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

Работа с файлами в python. Чтение и запись в файл ~ PythonRu

Эта статья посвящена работе с файлами (вводу/выводу) в Python: открытие, чтение, запись, закрытие и другие операции.

Файлы Python

Файл — это всего лишь набор данных, сохраненный в виде последовательности битов на компьютере. Информация хранится в куче данных (структура данных) и имеет название «имя файла» (filename).

В Python существует два типа файлов:

1. Текстовые
2. Бинарные

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

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

Текст может храниться в двух форматах: (.txt) — простой текст и (.rtf) — «формат обогащенного текста».

Бинарные файлы

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

Они хранятся в формате .bin.

Любую операцию с файлом можно разбить на три крупных этапа:

1. Открытие файла
2. Выполнение операции (запись, чтение)
3. Закрытие файла

Открытие файла

Метод open()

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

Синтаксис следующий:

f = open(file_name, access_mode)

Где,

• file_name = имя открываемого файла
• access_mode = режим открытия файла. Он может быть: для чтения, записи и т. д. По умолчанию используется режим чтения (r), если другое не указано. Далее полный список режимов открытия файла

Пример

Создадим текстовый файл example.txt и сохраним его в рабочей директории.

Следующий код используется для его открытия.

f = open('example.txt','r')  
fp = open('C:/xyz.txt','r')  

В этом примере f — переменная-указатель на файл example.txt.

Следующий код используется для вывода содержимого файла и информации о нем.

>>> print(*f) 
This is a text file.
>>> print(f) 
<_io.TextIOWrapper name='example.txt' mode='r' encoding='cp1252'>

Стоит обратить внимание, что в Windows стандартной кодировкой является cp1252, а в Linux — utf-08.

Закрытие файла

Метод close()

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

Существуют следующие способы:

Способ №1

Проще всего после открытия файла закрыть его, используя метод close().

f = open('example.txt','r')

f.close()

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

Способ №2

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

Без него программа завершается некорректно.

Вот как сделать это исключение:

f = open('example.txt','r')
try:
   
finally:
   f.close()

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

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

Способ №3

Инструкция with

Еще один подход — использовать инструкцию with, которая упрощает обработку исключений с помощью инкапсуляции начальных операций, а также задач по закрытию и очистке.

В таком случае инструкция close не нужна, потому что with автоматически закроет файл.

Вот как это реализовать в коде.

with open('example.txt') as f:
    

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

В Python файлы можно читать или записывать информацию в них с помощью соответствующих режимов.

Функция read()

Функция read() используется для чтения содержимого файла после открытия его в режиме чтения (r).

Синтаксис

file.read(size)

Где,

• file = объект файла
• size = количество символов, которые нужно прочитать. Если не указать, то файл прочитается целиком.

Пример

>>> f = open('example.txt','r')
>>> f.read(7)  
'This is '

Интерпретатор прочитал 7 символов файла и если снова использовать функцию read(), то чтение начнется с 8-го символа.

>>> f.read(7)  
' a text'

Функция readline()

Функция readline() используется для построчного чтения содержимого файла. Она используется для крупных файлов. С ее помощью можно получать доступ к любой строке в любой момент.

Пример

Создадим файл test.txt с нескольким строками:

This is line1.
This is line2.
This is line3.

Посмотрим, как функция readline() работает в test.txt.

>>> x = open('test.txt','r')
>>> x.readline()  
This is line1.
>>> x.readline(2)  
This is line2.
>>> x.readlines()  
['This is line1.','This is line2.','This is line3.']

Обратите внимание, как в последнем случае строки отделены друг от друга.

Функция write()

Функция write() используется для записи в файлы Python, открытые в режиме записи.

Если пытаться открыть файл, которого не существует, в этом режиме, тогда будет создан новый.

Синтаксис

file.write(string)

Пример

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

>>> f = open('xyz.txt','w')  
>>> f.write('Hello \n World')  
Hello
World
>>> f.close()  

Переименование файлов в Python

Функция rename()

Функция rename() используется для переименовывания файлов в Python. Для ее использования сперва нужно импортировать модуль os.

Синтаксис следующий.

import os
os.rename(src,dest)

Где,

• src = файл, который нужно переименовать
• dest = новое имя файла

Пример

>>> import os
>>> 
>>> os.rename("xyz.txt","abc.txt")

Текущая позиция в файлах Python

В Python возможно узнать текущую позицию в файле с помощью функции tell(). Таким же образом можно изменить текущую позицию командой seek().

Пример

>>> f = open('example.txt')  
>>> f.read(4)  
This
>>> f.tell()  
4
>>> f.seek(0,0)  

Методы файла в Python

Работа с файлами в Python

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

Как читать файлы

Python содержит в себе функцию, под названием «open», которую можно использовать для открытия файлов для чтения. Создайте текстовый файл под названием test.txt и впишите:

This is test file
line 2
line 3
this line intentionally left lank

Вот несколько примеров того, как использовать функцию «открыть» для чтения:

handle = open(«test.txt»)
handle = open(r»C:\Users\mike\py101book\data\test.txt», «r»)

В первом примере мы открываем файл под названием test.txt в режиме «только чтение». Это стандартный режим функции открытия файлов. Обратите внимание на то, что мы не пропускаем весь путь к файлу, который мы собираемся открыть в первом примере. Python автоматически просмотрит папку, в которой запущен скрипт для text.txt. Если его не удается найти, вы получите уведомление об ошибке IOError. Во втором примере показан полный путь к файлу, но обратите внимание на то, что он начинается с «r». Это значит, что мы указываем Python, чтобы строка обрабатывалась как исходная. Давайте посмотрим на разницу между исходной строкой и обычной:

>>> print(«C:\Users\mike\py101book\data\test.txt»)
C:\Users\mike\py101book\data est.txt

>>> print(r»C:\Users\mike\py101book\data\test.txt»)
C:\Users\mike\py101book\data\test.txt

Как видно из примера, когда мы не определяем строку как исходную, мы получаем неправильный путь. Почему это происходит? Существуют определенные специальные символы, которые должны быть отображены, такие как “n” или “t”. В нашем случае присутствует “t” (иными словами, вкладка), так что строка послушно добавляет вкладку в наш путь и портит её для нас. Второй аргумент во втором примере это буква “r”. Данное значение указывает на то, что мы хотим открыть файл в режиме «только чтение». Иными словами, происходит то же самое, что и в первом примере, но более явно. Теперь давайте, наконец, прочтем файл!

Введите нижеизложенные строки в скрипт, и сохраните его там же, где и файл test.txt.

handle = open(«test.txt», «r»)
data = handle.read()
print(data)
handle.close()

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

Давайте обратим внимание на различные способы чтения файлов.

handle = open(«test.txt», «r»)
data = handle.readline() # read just one line
print(data)
handle.close()

Если вы используете данный пример, будет прочтена и распечатана только первая строка текстового файла. Это не очень полезно, так что воспользуемся методом readlines() в дескрипторе:

handle = open(«test.txt», «r»)
data = handle.readlines() # read ALL the lines!
print(data)
handle.close()

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

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

Как читать файл по частям

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

handle = open(«test.txt», «r»)

for line in handle:
print(line)

handle.close()

Таким образом мы открываем файл в дескрипторе в режиме «только чтение», после чего используем цикл для его повторения. Стоит обратить внимание на то, что цикл можно применять к любым объектам Python (строки, списки, запятые, ключи в словаре, и другие). Весьма просто, не так ли? Попробуем прочесть файл по частям:

handle = open(«test.txt», «r»)

while True:
data = handle.read(1024)
print(data)

if not data:
break

В данном примере мы использовали Python в цикле, пока читали файл по килобайту за раз. Как известно, килобайт содержит в себе 1024 байта или символов. Теперь давайте представим, что мы хотим прочесть двоичный файл, такой как PDF.

Как читать бинарные (двоичные) файлы

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

handle = open(«test.pdf», «rb»)

Мы изменили способ доступа к файлу на rb, что значит read-binaryy. Стоит отметить то, что вам может понадобиться читать бинарные файлы, когда вы качаете PDF файлы из интернете, или обмениваетесь ими между компьютерами.

Пишем в файлах в Python

Как вы могли догадаться, следуя логике написанного выше, режимы написания файлов в Python это “w” и “wb” для write-mode и write-binary-mode соответственно. Теперь давайте взглянем на простой пример того, как они применяются.
ВНИМАНИЕ: использование режимов “w” или “wb” в уже существующем файле изменит его без предупреждения. Вы можете посмотреть, существует ли файл, открыв его при помощи модуля ОС Python.

handle = open(«output.txt», «w»)
handle.write(«This is a test!»)
handle.close()

Вот так вот просто. Все, что мы здесь сделали – это изменили режим файла на “w” и указали метод написания в файловом дескрипторе, чтобы написать какой-либо текст в теле файла. Файловый дескриптор также имеет метод writelines (написание строк), который будет принимать список строк, который дескриптор, в свою очередь, будет записывать по порядку на диск.

Выбирайте дешевые лайки на видео в YouTube на сервисе https://doctorsmm.com/. Здесь, при заказе, Вам будет предоставлена возможность подобрать не только недорогую цену, но и выгодные персональные условия приобретения. Торопитесь, пока на сайте действуют оптовые скидки!

Использование оператора «with»

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

with open(«test.txt») as file_handler:
for line in file_handler:
print(line)

Синтаксис для оператора with, на первый взгляд, кажется слегка необычным, однако это вопрос недолгой практики. Фактически, все, что мы делаем в данном примере, это:

handle = open(«test.txt»)

Меняем на это:

with open(«test.txt») as file_handler:

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

Выявление ошибок

Иногда, в ходе работы, ошибки случаются. Файл может быть закрыт, потому что какой-то другой процесс пользуется им в данный момент или из-за наличия той или иной ошибки разрешения. Когда это происходит, может появиться IOError. В данном разделе мы попробуем выявить эти ошибки обычным способом, и с применением оператора with. Подсказка: данная идея применима к обоим способам.

try:
file_handler = open(«test.txt»)
for line in file_handler:
print(line)
except IOError:
print(«An IOError has occurred!»)
finally:
file_handler.close()

В описанном выше примере, мы помещаем обычный код в конструкции try/except. Если ошибка возникнет, следует открыть сообщение на экране. Обратите внимание на то, что следует удостовериться в том, что файл закрыт при помощи оператора finally. Теперь мы готовы взглянуть на то, как мы можем сделать то же самое, пользуясь следующим методом:

try:
with open(«test.txt») as file_handler:
for line in file_handler:
print(line)
except IOError:
print(«An IOError has occurred!»)

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

Подведем итоги

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

Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

E-mail: [email protected]

Образование
Universitatea Tehnică a Moldovei (utm.md)

• 2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
• 2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»

Файлы. Курс «Python. Введение в программирование»

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

Обычно файлы делят на текстовые и байтовые (бинарные). Первые рассматриваются как содержащие символьные данные, строки. Вторые – как поток байтов. Побайтово считываются, например, файлы изображений.

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

Функция open() – открытие файла

Открытие файла выполняется с помощью встроенной в Python функции open(). Обычно ей передают один или два аргумента. Первый – имя файла или имя с адресом, если файл находится не в том каталоге, где находится скрипт. Второй аргумент – режим, в котором открывается файл.

Обычно используются режимы чтения ('r') и записи ('w'). Если файл открыт в режиме чтения, то запись в него невозможна. Можно только считывать данные из него. Если файл открыт в режиме записи, то в него можно только записывать данные, считывать нельзя.

Если файл открывается в режиме 'w', то все данные, которые в нем были до этого, стираются. Файл становится пустым. Если не надо удалять существующие в файле данные, тогда следует использовать вместо режима записи, режим дозаписи ('a').

Если файл отсутствует, то открытие его в режиме 'w' создаст новый файл. Бывают ситуации, когда надо гарантировано создать новый файл, избежав случайной перезаписи данных существующего. В этом случае вместо режима 'w' используется режим 'x'. В нем всегда создается новый файл для записи. Если указано имя существующего файла, то будет выброшено исключение. Потери данных в уже имеющемся файле не произойдет.

Если при вызове open() второй аргумент не указан, то файл открывается в режиме чтения как текстовый файл. Чтобы открыть файл как байтовый, дополнительно к букве режима чтения/записи добавляется символ 'b'. Буква 't' обозначает текстовый файл. Поскольку это тип файла по умолчанию, то обычно ее не указывают.

Нельзя указывать только тип файла, то есть open("имя_файла", 'b') есть ошибка, даже если файл открывается на чтение. Правильно – open("имя_файла", 'rb'). Только текстовые файлы мы можем открыть командой open("имя_файла"), потому что и 'r' и 't' подразумеваются по-умолчанию.

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

Чтение файла

С помощью файлового метода read() можно прочитать файл целиком или только определенное количество байт. Пусть у нас имеется файл data.txt с таким содержимым:

one - 1 - I
two - 2 - II
three - 3 - III
four - 4 - IV
five - 5 - V

Откроем его и почитаем:

>>> f1 = open('data.txt')
>>> f1.read(10)
'one - 1 - '
>>> f1.read()
'I\ntwo - 2 - II\nthree - 3 - III\n
four - 4 - IV\nfive - 5 - V\n'
>>> f1.read()
''
>>> type(f1.read())
<class 'str'>

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

Заметим, что метод read() возвращает строку, и что конец строки считывается как '\n'.

Для того, чтобы читать файл построчно существует метод readline():

>>> f1 = open('data.txt')
>>> f1.readline()
'one - 1 - I\n'
>>> f1.readline()
'two - 2 - II\n'
>>> f1.readline()
'three - 3 — III\n'

Метод readlines() считывает сразу все строки и создает список:

>>> f1 = open('data.txt')
>>> f1.readlines()
['one - 1 - I\n', 'two - 2 - II\n', 
'three - 3 - III\n',
'four - 4 - IV\n', 'five - 5 - V\n']

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

>>> for i in open('data.txt'):
...     print(i)
...
one - 1 - I

two - 2 - II

three - 3 - III

four - 4 - IV

five - 5 - V

>>> 

Здесь при выводе наблюдаются лишние пустые строки. Функция print() преобразует '\n' в переход на новую строку. К этому добавляет свой переход на новую строку. Создадим список строк файла без '\n':

>>> nums = []
>>> for i in open('data.txt'):
...     nums.append(i[:-1])
...
>>> nums
['one - 1 - I', 'two - 2 - II', 
'three - 3 - III', 
'four - 4 - IV', 'five - 5 - V']

Переменной i присваивается очередная строка файла. Мы берем ее срез от начала до последнего символа, не включая его. Следует иметь в виду, что '\n' это один символ, а не два.

Запись в файл

Запись в файл выполняется с помощью методов write() и writelines(). Во второй можно передать структуру данных:

>>> l = ['tree', 'four']
>>> f2 = open('newdata.txt', 'w')
>>> f2.write('one')
3
>>> f2.write(' two')
4
>>> f2.writelines(l)

Метод write() возвращает количество записанных символов.

Закрытие файла

После того как работа с файлом закончена, важно не забывать его закрыть, чтобы освободить место в памяти. Делается это с помощью файлового метода close(). Свойство файлового объекта closed позволяет проверить закрыт ли файл.

>>> f1.close()
>>> f1.closed
True
>>> f2.closed
False

Если файл открывается в заголовке цикла (for i in open('fname')), то видимо интерпретатор его закрывает при завершении работы цикла или через какое-то время.

Практическая работа

1. Создайте файл data.txt по образцу урока. Напишите программу, которая открывает этот файл на чтение, построчно считывает из него данные и записывает строки в другой файл (dataRu.txt), заменяя английские числительные русскими, которые содержатся в списке (["один", "два", "три", "четыре", "пять"]), определенном до открытия файлов.

2. Создайте файл nums.txt, содержащий несколько чисел, записанных через пробел. Напишите программу, которая подсчитывает и выводит на экран общую сумму чисел, хранящихся в этом файле.

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

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

Создание файла

В Python, чтобы создать файл, надо его открыть в режиме записи (‘w’, ‘wb’) или дозаписи (‘a’, ‘ab’).

f2 = open("text2.txt", 'w')

Функция open() возвращает файловый объект.

Без ‘b’ создается текстовый файл, представляющий собой поток символов. С ‘b’ — файл, содержащий поток байтов.

В Python также существует режим ‘x’ или ‘xb’. В этом режиме проверяется, есть ли файл. Если файл с определенным именем уже существует, он не будет создан. В режиме ‘w’ файл создается заново, старый при этом теряется.

>>> f1 = open('text1.txt', 'w')
>>> f2 = open('text1.txt', 'x')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileExistsError: [Errno 17] File exists: 'text1.txt'
>>> f3 = open('text1.txt', 'w')

Чтение данных из файла

Если в функцию open() не передается второй аргумент, файл расценивается как текстовый и открывается на чтение.

Попытка открыть на чтение несуществующий файл вызывает ошибку.

>>> f = open("text10.txt")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IOError: [Errno 2] No such file or directory: 'text10.txt'

Перехватить возникшее исключение можно с помощью конструкции try-except.

>>> try:
...     f = open("text10.txt")
... except IOError:
...     print ("No file")
... 
No file

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

>>> f = open("text.txt")
>>> f
<_io.TextIOWrapper name='text.txt' mode='r' encoding='UTF-8'>
>>> fd = f.read()
>>> fd1 = f.read()
>>> fd
'Hello\n\tOne\n   Two\nThree Four\nШесть!\n'
>>> fd1
''

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

>>> f = open("text.txt")
>>> fd = f.read(10)
>>> fd1 = f.read(5)
>>> fd
'Hello\n\tOne'
>>> fd1
'\n   T'

Метод readline() позволяет получать данные построчно.

>>> f = open("text.txt")
>>> f.readline()
'Hello\n'
>>> f.readline()
'\tOne\n'
>>> f.readline()
'   Two\n'

Принимает аргумент — число байт.

>>> f.readline(3)
'Thr'
>>> f.readline(3)
'ee '
>>> f.readline(3)
'Fou'
>>> f.readline(3)
'r\n'
>>> f.readline(5)
'Шесть'
>>> f.readline(5)
'!\n'

Метод readlines() считывает все строки и помещает их в список.

>>> f = open("text.txt")
>>> fd = f.readlines()
>>> fd
['Hello\n', '\tOne\n', '   Two\n', 'Three Four\n', 'Шесть!\n']

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

>>> f = open("text.txt")
>>> fd = f.readlines(3)
>>> fd
['Hello\n']
>>> fd1 = f.readlines(6)
>>> fd1
['\tOne\n', '   Two\n']

Запись данных в файл

Записать данные в файл можно с помощью метода write(), который возвращает число записанных символов.

>>> f1 = open("text1.txt", 'w')
>>> f1.write("Table, cup.\nBig, small.")
23
>>> a = f1.write("Table, cup.\nBig, small.")
>>> type(a)
<class 'int'>

Файл, открытый на запись, нельзя прочитать. Для этого требуется его закрыть, а потом открыть на чтение.

>>> f1.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
io.UnsupportedOperation: not readable
>>> f1.close()
>>> f1 = open("text1.txt", 'r')
>>> f1.read()
'Table, cup.\nBig, small.Table, cup.\nBig, small.'

С помощью метода writelines() можно записать в файл итерируемую последовательность.

>>> a = [1,2,3,4,5,6,7,8,9,0]
>>> f = open("text2.txt",'w')
>>> f.writelines("%s\n" % i for i in a)
>>> f.close()
>>> open("text2.txt").read()
'1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n'
>>> print(open("text2.txt").read())
1
2
3
4
5
6
7
8
9
0

Смена позиции в файле

>>> f = open('text.txt')
>>> f.read()
'Hello\n\tOne\n   Two\nThree Four\nШесть!\n'
>>> f.close()
>>> f = open('text.txt')
>>> f.seek(10)
10
>>> f.read()
'\n   Two\nThree Four\nШесть!\n'

Двоичные файлы

Пример копирования изображения:

>>> f1 = open('flag.png', 'rb')
>>> f2 = open('flag2.png', 'wb')
>>> f2.write(f1.read())
446
>>> f1.close()
>>> f2.close()

Модуль struct позволяет преобразовывать данные к бинарному виду и обратно.

>>> f = open('text3.txt', 'wb')
>>> f.write('3')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' does not support the buffer interface
>>> d = struct.pack('>i',3)
>>> d
b'\x00\x00\x00\x03'
>>> f.write(d)
4
>>> f.close()
>>> f = open('text3.txt')
>>> d = f.read()
>>> d
'\x00\x00\x00\x03'
>>> struct.unpack('>i',d)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' does not support the buffer interface
>>> f = open('text3.txt', 'rb')
>>> d = f.read()
>>> d
b'\x00\x00\x00\x03'
>>> struct.unpack('>i',d)
(3,)

запись и чтение после создания или открытия файла

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

Создание и открытие

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

Следующий код демонстрирует получение переменной file ссылки на новый документ. Если запустить эту программу, она создаст текстовый файл test.txt в папке, где хранится исходный код.

file = open("test.txt", "w")
file.close()

Если же файл с указанным именем test.txt уже существует в каталоге с кодом, программа просто продолжит работу с ним, не создавая новый документ. Как можно заметить, имя файла является первым параметром метода open. Сразу за ним следует специальная буква, которая обозначает метод обработки данных. В данном случае «w» означает write, то есть запись. Подробнее обо всех доступных режимах работы будет немного дальше, а сейчас важно усвоить, что после выполнения любых манипуляций над файлом, его обязательно следует закрыть с помощью функции close, чтобы гарантированно избежать потери информации.

В предыдущем примере для доступа к файлу был использован относительный путь, который не содержит в себе исчерпывающих сведений о местоположении объекта на жестком диске. Для того, чтобы задать их, необходимо в качестве первого аргумента функции open прописать абсолютный путь. В данном случае документ test.txt будет находиться в корневом каталоге на диске D, а не в папке программы.

file = open(r"D:\test.txt", "w")
file.close()

Перед строковым литералом мы использовали символ r, для отключения экранирования. Иначе компилятор посчитает последовательность «\t» как символ табуляции и выдаст исключение.

Режим открытия

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

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

Еще один пример: отличие «r+» и «w+» заключается в том, что во втором случае создастся новый файл, если такого нет. В первом же случае возникнет исключение. При использовании «r+» и «w+» файл будет открыт и на чтение и на запись. Пример обработки исключения разберем, когда будем рассматривать чтение файла.

Методы

Объект, который возвращает функция open, содержит ссылку на существующий файл. Также в нем имеется информация о созданном документе, представленная в виде четырех основных полей. Все они описаны в следующей таблице, которая содержит их имена и значение.

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

Например:

f = open(r"D:\test.txt", "w")
print(f.name)
f.close()

D:\test.txt

Запись

В Python 3 запись в файл осуществляется с помощью метода write. Метод вызываем у объекта, который ссылается на существующий файл. Важно помнить, что для этого следует предварительно открыть документ с помощью функции open и указать режим записи символом «w». Метод write принимает в качестве аргумента данные, которые нужно поместить в текстовый файл. Следующий пример кода показывает запись строки «hello».

file = open("test.txt", "w")
file.write("hello")
file.close()

Если необходимо добавить новую информацию к записанным ранее данным, следует заново вызвать функцию open, указав ей в качестве режима работы символ «a». В противном случае все сведения из файла test.txt будут полностью удалены. В приведенном ниже примере кода текстовый документ открывается для дополнительной записи, после чего в него помещается строковый литерал “ world” с пробелом вначале. Таким образом в test.txt будет располагаться «hello world». После всего этого не нужно забывать об обязательном закрытии файла.

file = open("test.txt", "a")
file.write(" world")
file.close()

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

Запись бинарных данных

При записи бинарных данных, следует использовать режим «wb». Вот пример записи строки в кодировке utf8:

f = open('test.dat', 'wb')
f.write(bytes('строка', 'utf8'))
f.close()

Чтение

Для чтения информации из файла в Python 3, следует вызывать метод read через объект, который ссылается на существующий документ. Также необходимо не забывать указывать «r» в качестве второго параметра функции open при открытии текстового файла.

В следующем примере read возвращает информацию из test.txt в метод print, который затем выводит сведения на экран. Как и прежде, программа завершается закрытием документа при помощи метода close. Метод read также может принимать целочисленный параметр, который используется для передачи количества символов для чтения. К примеру, введя 5, программа прочитает только hello.

try:
    file = open("test.txt", "r")
    print(file.read())
    file.close()
except FileNotFoundError:
    print('Not found')
except IOError:
    print('Something else')

Обратите внимание, что при открытии может возникнуть ошибка. Например, если указанный файл не найден. Поэтому нам пришлось обработать исключение. В Python можно воспользоваться конструкцией with, в таком случае не надо будет обрабатывать исключения и даже закрывать файл. Её рассмотрим ниже.

Есть еще один момент: нельзя делать закрытие в секции finally блока try. Если произойдет исключение при открытии файла, то в секции finally будет ошибка.

Чтение бинарных данных

В случае, если данные бинарного вида — следует использовать «rb» в функции open. Рассмотрим пример:

try:
    f = open("test.dat", "rb")
    b = f.read(1)
    str = ""
    while True:
        b = f.read(1)
        if b == b'':
            break
        str += b.hex()
    print(str)
    f.close()
except IOError:
    print('error')

81d182d180d0bed0bad0b0

Здесь побайтно читается файл. Каждый байт приводит к строковому виду в шестнадцатеричном представлении. С помощью функции print выводится результирующая строка.

with as

Чтобы немного автоматизировать обработку текстовых файлов, рекомендуется использовать связку операторов with as. Благодаря им пропадает необходимость в вызове метода close для документа, который необходимо закрыть, поскольку это происходит автоматически. Все это демонстрируется в следующем фрагменте кода, где происходит считывание данных из test.txt. Как обычно, метод print используется для вывода строковой информации на экран.

with open('test.txt', 'r') as file:
    print(file.read())

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

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

Python Файл открыт

Открыть файл на сервере

Предположим, у нас есть следующий файл, расположенный в той же папке, что и Python:

demofile.txt

Привет! Добро пожаловать в demofile.txt
Этот файл предназначен для тестирования.
Хорошо
Удача!

Чтобы открыть файл, используйте встроенную функцию open () .

Функция open () возвращает файловый объект, имеющий
read () метод чтения содержимого файла:

Если файл находится в другом месте, вам нужно будет указать путь к файлу,
как это:

Пример

Откройте файл в другом месте:

f = open («D: \\ myfiles \ welcome.txt «,» r «)
print (f.read ())

Пример запуска »

Части файла, доступные только для чтения

По умолчанию метод read () возвращает весь текст, но вы также можете указать, сколько символов вы хотите вернуть:

Пример

Вернуть 5 первых символов файла:

f = open («demofile.txt», «r»)
print (f.read ( 5 ))

Пример запуска »

Прочитать строки

Вы можете вернуть одну строку с помощью метода readline () :

Пример

Прочитать одну строку файла:

f = open («демофайл.txt «,» r «)
print (f.readline ())

Пример запуска »

Дважды позвонив readline () , можно прочитать
две первые строки:

Пример

Прочитать две строки файла:

f = open («demofile.txt», «r»)
print (f.readline ())
print (f.readline ())

Пример запуска »

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

Пример

Цикл по файлу построчно:

f = open («демофайл.txt «,» r «)
для x в f:
print (x)

Пример запуска »

Закрыть файлы

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

Пример

Закройте файл, когда закончите с ним:

f = open («demofile.txt», «r»)
print (f.readline ())
f.close ()

Пример запуска »

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

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

Файлы

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

Поскольку оперативная память (RAM) является энергозависимой (которая теряет свои данные при выключении компьютера), мы используем файлы для будущего использования данных, постоянно сохраняя их.

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

Следовательно, в Python файловая операция выполняется в следующем порядке:

1. Открыть файл
2. Чтение или запись (выполнение операции)
3. Закройте файл

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

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

  >>> f = open ("test.txt") # открыть файл в текущем каталоге
>>> f = open ("C: /Python38/README.txt") # указание полного пути  

Мы можем указать режим при открытии файла. В режиме мы указываем, хотим ли мы прочитать r , записать w или добавить a к файлу. Мы также можем указать, хотим ли мы открыть файл в текстовом или двоичном режиме.

По умолчанию чтение в текстовом режиме. В этом режиме мы получаем строки при чтении из файла.

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

  f = открытый ("test.txt ") # эквивалент 'r' или 'rt'
f = open ("test.txt", 'w') # писать в текстовом режиме
f = open ("img.bmp", 'r + b') # чтение и запись в двоичном режиме  

В отличие от других языков, символ a не подразумевает число 97, пока он не будет закодирован с использованием ASCII (или других эквивалентных кодировок).

Кроме того, кодировка по умолчанию зависит от платформы. В Windows это cp1252 , но utf-8 в Linux.

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

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

  f = open ("test.txt", mode = 'r', encoding = 'utf-8')  

Закрытие файлов в Python

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

Закрытие файла освободит ресурсы, которые были связаны с файлом. Это делается с помощью метода close () , доступного в Python.

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

  f = open ("test.txt", encoding = 'utf-8')
# выполнять файловые операции
f.close ()  

Этот метод не совсем безопасен. Если при выполнении какой-либо операции с файлом возникает исключение, код завершается без закрытия файла.

Более безопасный способ — использовать блок try … finally.

  попробовать:
   f = open ("test.txt ", кодировка = 'utf-8')
   # выполнять файловые операции
Ну наконец то:
   f.close ()  

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

Лучший способ закрыть файл — использовать с оператором . Это гарантирует, что файл будет закрыт при выходе из блока внутри с оператором .

Нам не нужно явно вызывать метод close () .Это делается изнутри.

  с open ("test.txt", encoding = 'utf-8') как f:
   # выполнять файловые операции  

Запись в файлы на Python

Для записи в файл на Python нам нужно открыть его в режиме записи w , добавить a или исключить создание x .

Мы должны быть осторожны с режимом w , так как он будет перезаписан в файл, если он уже существует. Благодаря этому стираются все предыдущие данные.

Запись строки или последовательности байтов (для двоичных файлов) выполняется с помощью метода write () . Этот метод возвращает количество символов, записанных в файл.

  с open ("test.txt", 'w', encoding = 'utf-8') как f:
   f.write ("мой первый файл \ n")
   f.write ("Этот файл \ n \ n")
   f.write ("содержит три строки \ n")  

Эта программа создаст новый файл с именем test.txt в текущем каталоге, если он не существует. Если он существует, он перезаписывается.

Мы должны сами включать символы новой строки, чтобы различать разные строки.

Чтение файлов в Python

Чтобы прочитать файл на Python, мы должны открыть файл в режиме чтения r .

Для этого доступны различные методы. Мы можем использовать метод read (size) для чтения размера количества данных. Если параметр size не указан, он считывает и возвращает до конца файла.

Мы можем прочитать файл text.txt , который мы написали в предыдущем разделе, следующим образом:

  >>> f = open ("test.txt", 'r', encoding = 'utf-8')
>>> f.read (4) # читать первые 4 данных
'Этот'

>>> f.read (4) # читать следующие 4 данные
' является '

>>> f.read () # читать остаток до конца файла
'мой первый файл \ nЭтот файл \ nсодержит три строки \ n'

>>> f.read () # дальнейшее чтение возвращает пустое жало
' 

Мы видим, что метод read () возвращает новую строку как '\ n' .По достижении конца файла при дальнейшем чтении мы получаем пустую строку.

Мы можем изменить текущий файловый курсор (позицию) с помощью метода seek () . Точно так же метод tell () возвращает нашу текущую позицию (в байтах).

  >>> f.tell () # получить текущую позицию в файле
56

>>> f.seek (0) # переводим файловый курсор в исходную позицию
0

>>> print (f.read ()) # читать весь файл
Это мой первый файл
Этот файл
содержит три строки  

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

  >>> для строки в f:
... печать (строка, конец = '')
...
Это мой первый файл
Этот файл
содержит три строки  

В этой программе строки в самом файле содержат символ новой строки \ n . Итак, мы используем конечный параметр функции print () , чтобы избежать появления двух символов новой строки при печати.

В качестве альтернативы мы можем использовать метод readline () для чтения отдельных строк файла.Этот метод читает файл до новой строки, включая символ новой строки.

  >>> f.readline ()
'Это мой первый файл \ n'

>>> f.readline ()
'Этот файл \ n'

>>> f.readline ()
'содержит три строки \ n'

>>> f.readline ()
' 

Наконец, метод readlines () возвращает список оставшихся строк всего файла. Все эти методы чтения возвращают пустые значения при достижении конца файла (EOF).

  >>> ф.readlines ()
['Это мой первый файл \ n', 'Этот файл \ n', 'содержит три строки \ n']  

Методы файла Python

С файловым объектом доступны различные методы. Некоторые из них были использованы в приведенных выше примерах.

Вот полный список методов в текстовом режиме с кратким описанием:

Чтение и запись файлов на Python (Руководство) — Real Python

Смотреть сейчас В этом руководстве есть связанный видеокурс, созданный командой Real Python.Посмотрите его вместе с письменным руководством, чтобы углубить свое понимание: Чтение и запись файлов на Python

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

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

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

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

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

Пройти тест »

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

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

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

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

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

То, что представляют эти данные, зависит от используемой спецификации формата, которая обычно представлена ​​расширением.Например, файл с расширением .gif , скорее всего, соответствует спецификации формата обмена графическими данными. Существуют сотни, если не тысячи, расширений файлов. В этом руководстве вы будете иметь дело только с расширениями файлов .txt или .csv .

Пути к файлам

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

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

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

  /
│
├── путь /
| │
│ ├── к /
│ │ └── cats.gif
│ │
│ └── dog_breeds.txt
|
└── animals.csv
  

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

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

  /
│
├── путь /
| │
| ├── to / ← Ваш текущий рабочий каталог (cwd) находится здесь
| │ └── cats.gif ← Доступ к этому файлу
| │
| └── dog_breeds.txt
|
└── animals.csv
  

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

  /
│
├── путь / ← Ссылка на эту родительскую папку
| │
| ├── в / ← Текущий рабочий каталог (cwd)
| │ └── cats.gif
| │
| └── dog_breeds.txt ← Доступ к этому файлу
|
└── animals.csv
  

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

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

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

Позже это было стандартизовано для телетайпов Международной организацией по стандартизации (ISO) и Американской ассоциацией стандартов (ASA).Стандарт ASA гласит, что в конце строки должна использоваться последовательность символов возврата каретки ( CR или \ r ) и перевода строки ( LF или \ n ) ( CR + LF или \ г \ п ). Однако стандарт ISO допускает использование символов CR + LF или только символа LF .

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

  Мопс \ r \ n
Джек Рассел Терьер \ r \ n
Английский спрингер-спаниель \ r \ n
Немецкая овчарка \ r \ n
Стаффордширский бультерьер \ r \ n
Кавалер кинг чарльз спаниель \ r \ n
Золотистый ретривер \ r \ n
Вест-хайленд-уайт-терьер \ r \ n
Боксёр \ r \ n
Бордер терьер \ r \ n
  

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

  Мопс \ г
\ п
Джек Рассел терьер \ r
\ п
Английский спрингер-спаниель \ r
\ п
Немецкая овчарка \ r
\ п
Стаффордширский бультерьер \ r
\ п
Кавалер кинг чарльз спаниель \ r
\ п
Золотистый ретривер \ r
\ п
Вест-хайленд-уайт-терьер \ r
\ п
Боксёр \ r
\ п
Бордер терьер \ r
\ п
  

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

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

Другая распространенная проблема, с которой вы можете столкнуться, — это кодирование байтовых данных. Кодировка — это перевод байтовых данных в символы, читаемые человеком. Обычно это делается путем присвоения числового значения для представления символа. Двумя наиболее распространенными кодировками являются форматы ASCII и UNICODE. ASCII может хранить только 128 символов, в то время как Unicode может содержать до 1114112 символов.

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

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

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

  файл = открытый ('dog_breeds.txt')
  

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

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

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

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

  reader = open ('dog_breeds.текст')
пытаться:
    # Далее идет обработка файла
Ну наконец то:
    reader.close ()
  

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

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

  с открытым ('dog_breeds.txt') в качестве читателя:
    # Далее идет обработка файла
  

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

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

  с открытым ('dog_breeds.txt ',' r ') в качестве читателя:
    # Далее идет обработка файла
  

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

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

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

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

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

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

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

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

  открыто ('abc.txt')

open ('abc.txt', 'r')

open ('abc.txt', 'ш')
  

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

>>>

  >>> file = open ('dog_breeds.txt')
>>> тип (файл)
<класс '_io.TextIOWrapper'>
  

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

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

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

  открытый ('abc.txt', 'rb')

открыть ('abc.txt', 'wb')
  

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

>>>

  >>> file = open ('dog_breeds.txt', 'rb')
>>> тип (файл)
<класс '_io.BufferedReader '>
>>> file = open ('dog_breeds.txt', 'wb')
>>> тип (файл)
<класс '_io.BufferedWriter'>
  

Типы файлов Raw

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

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

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

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

  открыть ('abc.txt', 'rb', буферизация = 0)
  

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

>>>

  >>> file = open ('dog_breeds.txt ',' rb ', буферизация = 0)
>>> тип (файл)
<класс '_io.FileIO'>
  

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

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

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

.
>>>

  >>> с open ('dog_breeds.txt', 'r') в качестве читателя:
>>> # Прочитать и распечатать весь файл
>>> print (reader.read ())
Мопс
Джек Рассел терьер
Английский спрингер-спаниель
Немецкая овчарка
Стаффордширский бультерьер
Кавалер кинг чарльз спаниель
Золотистый ретривер
Вест-хайленд-уайт-терьер
Боксер
Бордер терьер
  

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

>>>

  >>> с open ('dog_breeds.txt', 'r') в качестве читателя:
>>> # Прочтите и распечатайте первые 5 символов строки 5 раз
>>> print (reader.readline (5))
>>> # Обратите внимание, что строка больше 5 символов и продолжается
>>> # вниз по строке, читая каждый раз по 5 символов до конца
>>> # строка, а затем "оборачивается" вокруг
>>> print (reader.readline (5))
>>> напечатайте (читатель.readline (5))
>>> print (reader.readline (5))
>>> print (reader.readline (5))
Мопс

разъем
Russe
ll Te
Rrier
  

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

>>>

  >>> f = open ('dog_breeds.txt')
>>> f.readlines () # Возвращает объект списка
['Мопс \ n', 'Джек-рассел-терьер \ n', 'Английский спрингер-спаниель \ n', 'Немецкая овчарка \ n', 'Стаффордширский бультерьер \ n', 'Кавалер-кинг Чарльз-спаниель \ n', 'Золотистый ретривер \ n ',' Вест-хайленд-уайт-терьер \ n ',' Боксер \ n ',' Бордер-терьер \ n ']
  

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

>>>

  >>> f = open ('dog_breeds.текст')
>>> список (е)
['Мопс \ n', 'Джек-рассел-терьер \ n', 'Английский спрингер-спаниель \ n', 'Немецкая овчарка \ n', 'Стаффордширский бультерьер \ n', 'Кавалер-кинг Чарльз-спаниель \ n', 'Золотистый ретривер \ n ',' Вест-хайленд-уайт-терьер \ n ',' Боксер \ n ',' Бордер-терьер \ n ']
  

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

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

>>>

  >>> с открытым ('dog_breeds.txt ',' r ') в качестве читателя:
>>> # Прочитать и распечатать весь файл построчно
>>> line = reader.readline ()
>>> while line! = '': # Символ EOF - это пустая строка
>>> печать (строка, конец = '')
>>> line = reader.readline ()
Мопс
Джек Рассел терьер
Английский спрингер-спаниель
Немецкая овчарка
Стаффордширский бультерьер
Кавалер кинг чарльз спаниель
Золотистый ретривер
Вест-хайленд-уайт-терьер
Боксер
Бордер терьер
  

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

>>>

  >>> с open ('dog_breeds.txt', 'r') в качестве читателя:
>>> для строки в reader.readlines ():
>>> печать (строка, конец = '')
Мопс
Джек Рассел терьер
Английский спрингер-спаниель
Немецкая овчарка
Стаффордширский бультерьер
Кавалер кинг чарльз спаниель
Золотистый ретривер
Вест-хайленд-уайт-терьер
Боксер
Бордер терьер
  

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

>>>

  >>> с открытым ('dog_breeds.txt ',' r ') в качестве читателя:
>>> # Прочитать и распечатать весь файл построчно
>>> для строчки в ридере:
>>> печать (строка, конец = '')
Мопс
Джек Рассел терьер
Английский спрингер-спаниель
Немецкая овчарка
Стаффордширский бультерьер
Кавалер кинг чарльз спаниель
Золотистый ретривер
Вест-хайленд-уайт-терьер
Боксер
Бордер терьер
  

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

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

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

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

  с open ('dog_breeds.txt', 'r') в качестве читателя:
    # Примечание: строки чтения не обрезают окончания строк
    dog_breeds = читатель.readlines ()

с open ('dog_breeds_reversed.txt', 'w') в качестве писателя:
    # В качестве альтернативы вы можете использовать
    # writer.writelines (перевернутый (dog_breeds))

    # Запишите породы собак в файл в обратном порядке
    для породы реверс (dog_breeds):
        писатель. писать (порода)
  

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

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

>>>

  >>> с open ('dog_breeds.txt', 'rb') в качестве читателя:
>>> print (reader.readline ())
б'Мопс \ п '
  

Открытие текстового файла с помощью флага b не так уж и интересно. Допустим, у нас есть эта симпатичная фотография джек-рассел-терьера ( jack_russell.png ):

Изображение: CC BY 3.0 (https://creativecommons.org/licenses/by/3.0)], из Wikimedia Commons

. Вы действительно можете открыть этот файл в Python и изучить его содержимое! Начиная с модели .Формат файла png четко определен, заголовок файла состоит из 8 байт, разбитых следующим образом:

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

>>>

  >>> с open ('jack_russell.png', 'rb') как byte_reader:
>>> печать (byte_reader.read (1))
>>> печать (byte_reader.read (3))
>>> печать (byte_reader.read (2))
>>> печать (byte_reader.read (1))
>>> печать (byte_reader.read (1))
б '\ x89'
b'PNG '
б '\ г \ п'
б '\ x1a'
б '\ п'
  

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

dos2unix.py

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

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

  "" "
Простой скрипт и библиотека для преобразования файлов или строк из dos, например
окончания строк с Unix-подобными окончаниями строк.
"" "

import argparse
импорт ОС


def str2unix (input_str: str) -> str:
    р"""
    Преобразует строку из концов строки \ r \ n в \ n

    Параметры
    ----------
    input_str
        Строка, окончание строки которой будет преобразовано

    Возврат
    -------
        Преобразованная строка
    "" "
    r_str = input_str.replace ('\ r \ n', '\ n')
    вернуть r_str


def dos2unix (исходный_файл: str, dest_file: str):
    "" "
    Преобразует файл, содержащий окончания строк типа Dos, в Unix, например

    Параметры
    ----------
    исходный файл
        Путь к исходному файлу, который нужно преобразовать
    dest_file
        Путь к преобразованному файлу для вывода
    "" "
    # ПРИМЕЧАНИЕ: можно добавить проверку существования файла и перезапись файла
    # защита
    с open (source_file, 'r') в качестве читателя:
        dos_content = reader.read ()

    unix_content = str2unix (dos_content)

    с open (dest_file, 'w') как писатель:
        писатель.написать (unix_content)


если __name__ == "__main__":
    # Создадим наш парсер аргументов и зададим его описание
    parser = argparse.ArgumentParser (
        description = "Скрипт, преобразующий файл, подобный DOS, в файл, подобный Unix",
    )

    # Добавьте аргументы:
    # - source_file: исходный файл, который мы хотим преобразовать
    # - dest_file: место назначения, куда должен идти вывод

    # Примечание: использование типа аргумента argparse.FileType может
    # оптимизировать некоторые вещи
    parser.add_argument (
        'исходный файл',
        help = 'Местоположение источника'
    )

    парсер.add_argument (
        '--dest_file',
        help = 'Расположение файла назначения (по умолчанию: исходный_файл с добавлением _unix' ',
        по умолчанию = Нет
    )

    # Разбираем аргументы (argparse автоматически берет значения из
    # sys.argv)
    args = parser.parse_args ()

    s_file = args.source_file
    d_file = args.dest_file

    # Если целевой файл не был передан, предположим, что мы хотим
    # создаем новый файл на основе старого
    если d_file - None:
        file_path, file_extension = os.path.splitext (s_file)
        d_file = f '{file_path} _unix {file_extension}'

    dos2unix (s_file, d_file)
  

Советы и хитрости

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

__file__

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

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

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

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

 проект  /
|
├── тесты /
| ├── test_commanding.py
| ├── test_power.py
| ├── test_wireHousing.py
| └── test_leds.py
|
└── main.py
  

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

  >>> python main.py
tests / test_commanding.py Начато:
tests / test_commanding.py Пройдено!
тесты / test_power.py Начато:
tests / test_power.py Пройдено!
tests / test_wireHousing.py Начато:
tests / test_wireHousing.py Ошибка!
tests / test_leds.py Начато:
tests / test_leds.py Пройдено!
  

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

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

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

  с открытым ('dog_breeds.txt ',' a ') как a_writer:
    a_writer.write ('\ nБигл')
  

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

>>>

  >>> с open ('dog_breeds.txt', 'r') в качестве читателя:
>>> print (reader.read ())
Мопс
Джек Рассел терьер
Английский спрингер-спаниель
Немецкая овчарка
Стаффордширский бультерьер
Кавалер кинг чарльз спаниель
Золотистый ретривер
Вест-хайленд-уайт-терьер
Боксер
Бордер терьер
Бигль
  

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

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

  d_path = 'dog_breeds.txt'
d_r_path = 'dog_breeds_reversed.txt'
с open (d_path, 'r') как читатель, open (d_r_path, 'w') как писатель:
    dog_breeds = reader.readlines ()
    писатель.writelines (перевернутый (dog_breeds))
  

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

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

__enter __ () вызывается при вызове с оператором . __exit __ () вызывается при выходе из с блоком операторов .

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

  класс my_file_reader ():
    def __init __ (self, file_path):
        себя.__path = путь к файлу
        self .__ file_object = Нет

    def __enter __ (сам):
        self .__ file_object = open (собственный .__ путь)
        вернуть себя

    def __exit __ (self, type, val, tb):
        self .__ file_object.close ()

    # Дополнительные методы, реализованные ниже
  

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

  с my_file_reader ('dog_breeds.txt') в качестве читателя:
    # Выполнение пользовательских операций класса
    проходить
  

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

.

  класс PngReader ():
    # Каждый файл .png содержит это в заголовке. Используйте это, чтобы проверить
    # файл действительно имеет формат .png.
    _expected_magic = b '\ x89PNG \ r \ n \ x1a \ n'

    def __init __ (self, file_path):
        # Убедитесь, что файл имеет правильное расширение
        если не file_path.заканчивается с ('. png'):
            поднять NameError ("Файл должен иметь расширение .png")
        self .__ path = file_path
        self .__ file_object = Нет

    def __enter __ (сам):
        self .__ file_object = open (self .__ путь, 'rb')

        magic = self .__ file_object.read (8)
        если магия! = self._expected_magic:
            Raise TypeError ("Файл не является правильно отформатированным файлом .png!")

        вернуть себя

    def __exit __ (self, type, val, tb):
        self .__ file_object.close ()

    def __iter __ (сам):
        # This и __next __ () используются для создания собственного итератора
        # См. Https: // dbader.org / blog / python-итераторы
        вернуть себя

    def __next __ (сам):
        # Прочитать файл в "Chunks"
        # См. Https://en.wikipedia.org/wiki/Portable_Network_Graphics#%22Chunks%22_within_the_file

        исходные_данные = self .__ file_object.read (4)

        # Файл не был открыт или не достиг EOF. Это означает, что мы
        # дальше идти нельзя, поэтому остановите итерацию, подняв
        # StopIteration.
        если self .__ file_object равно None или initial_data == b '':
            поднять StopIteration
        еще:
            # У каждого чанка есть len, тип, данные (на основе len) и crc
            # Захватываем эти значения и возвращаем их как кортеж
            chunk_len = int.from_bytes (начальные_данные, byteorder = 'большой')
            chunk_type = self .__ file_object.read (4)
            chunk_data = self .__ file_object.read (chunk_len)
            chunk_crc = self .__ file_object.read (4)
            вернуть chunk_len, chunk_type, chunk_data, chunk_crc
  

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

>>>

  >>> с PngReader ('jack_russell.png') в качестве читателя:
>>> для l, t, d, c в читателе:
>>> print (f "{l: 05}, {t}, {c}")
00013, b'IHDR ', b'v \ x121k'
00001, b'sRGB ', b' \ xae \ xce \ x1c \ xe9 '
00009, b'pHYs ', b' (<] \ x19 '
00345, b'iTXt ', b "L \ xc2'Y"
16384, b'IDAT ', b'i \ x99 \ x0c ('
16384, b'IDAT ', b' \ xb3 \ xfa \ x9a $ '
16384, b'IDAT ', b' \ xff \ xbf \ xd1 \ n '
16384, b'IDAT ', b' \ xc3 \ x9c \ xb1} '
16384, b'IDAT ', b' \ xe3 \ x02 \ xba \ x91 '
16384, b'IDAT ', b' \ xa0 \ xa99 = '
16384, b'IDAT ', b' \ xf4 \ x8b.\ x92 '
16384, b'IDAT ', b' \ x17i \ xfc \ xde '
16384, b'IDAT ', b' \ x8fb \ x0e \ xe4 '
16384, b'IDAT ', b') 3 = {'
01040, b'IDAT ', b' \ xd6 \ xb8 \ xc1 \ x9f '
00000, b'IEND ', b' \ xaeB` \ x82 '
  

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

Есть типичные ситуации, с которыми вы можете столкнуться при работе с файлами. Большинство этих случаев можно обрабатывать с помощью других модулей. Вам могут понадобиться два распространенных типа файлов: .csv и .json . Real Python уже собрал несколько отличных статей о том, как с этим справиться:

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

• wave : чтение и запись файлов WAV (аудио)
• aifc : чтение и запись файлов AIFF и AIFC (аудио)
• sunau : чтение и запись файлов Sun AU
• tarfile : чтение и запись файлов архива tar
• zipfile : работа с ZIP-архивами
• configparser : легко создавать и анализировать файлы конфигурации
• xml.etree.ElementTree : создание или чтение файлов на основе XML
• msilib : чтение и запись файлов установщика Microsoft
• plistlib : создание и анализ файлов Mac OS X .plist

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

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

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

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

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

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

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

Пройти тест »

Смотреть сейчас В этом руководстве есть связанный видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным руководством, чтобы углубить свое понимание: Чтение и запись файлов на Python

Как запускать сценарии Python - Настоящий Python

Смотреть сейчас В этом руководстве есть связанный видеокурс, созданный командой Real Python.Посмотрите его вместе с письменным руководством, чтобы углубить свое понимание: Запуск скриптов Python

Один из самых важных навыков, который вам необходимо приобрести как разработчика Python, - это уметь запускать сценарии и код Python. Это будет единственный способ узнать, работает ли ваш код так, как вы планировали. Это даже единственный способ узнать, работает ли ваш код вообще!

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

У вас будет возможность узнать, как запускать сценарии Python, используя:

• Командная строка операционной системы или терминал
• Интерактивный режим Python
• IDE или текстовый редактор, который вам больше всего нравится
• Файловый менеджер вашей системы, двойным щелчком по иконке вашего скрипта

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

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

Пройти тест »

Скрипты против модулей

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

Скрипты всегда обрабатываются каким-то интерпретатором, который отвечает за последовательное выполнение каждой команды.

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

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

Итак, основное различие между модулем и сценарием состоит в том, что модули предназначены для импорта , а сценарии предназначены для непосредственного выполнения .

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

Что такое интерпретатор Python?

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

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

В зависимости от используемой вами реализации Python, интерпретатор может быть:

• Программа, написанная на C, например CPython, которая является основной реализацией языка
• Программа, написанная на Java, например Jython
• Программа, написанная на самом Python, например PyPy
• Программа реализована на.NET, как IronPython

Какую бы форму ни принял интерпретатор, написанный вами код всегда будет выполняться этой программой. Следовательно, первое условие для запуска скриптов Python - это правильно установленный интерпретатор в вашей системе.

Интерпретатор может запускать код Python двумя способами:

• Как скрипт или модуль
• Как фрагмент кода, введенный в интерактивный сеанс

Как запустить код Python в интерактивном режиме

Широко используемый способ запуска кода Python - интерактивный сеанс.Чтобы запустить интерактивный сеанс Python, просто откройте командную строку или терминал и затем введите python или python3 в зависимости от вашей установки Python, а затем нажмите , введите .

Вот пример того, как это сделать в Linux:

  $ python3
Python 3.6.7 (по умолчанию, 22 октября 2018 г., 11:32:17)
[GCC 8.2.0] в Linux
Для получения дополнительной информации введите «помощь», «авторские права», «кредиты» или «лицензия».
>>>
  

Стандартное приглашение для интерактивного режима - >>> , поэтому, как только вы увидите эти символы, вы поймете, что находитесь внутри.

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

Когда вы работаете в интерактивном режиме, каждое выражение и оператор, которые вы вводите, оцениваются и немедленно выполняются:

>>>

  >>> print ('Hello World!')
Привет мир!
>>> 2 + 5
7
>>> print ('Добро пожаловать в настоящий Python!')
Добро пожаловать в Real Python!
  

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

Для выхода из интерактивного режима вы можете использовать одну из следующих опций:

• quit () или exit () , которые являются встроенными функциями
• Ctrl + Z и Введите комбинацию клавиш в Windows или просто Ctrl + D в Unix-подобных системах

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

Если вы никогда не работали с командной строкой или терминалом, вы можете попробовать следующее:

• В Windows командная строка обычно называется командной строкой или консолью MS-DOS, и это программа с именем cmd.exe . Путь к этой программе может значительно отличаться от одной версии системы к другой.

  Быстрый способ получить к нему доступ - нажать комбинацию клавиш Win + R , что приведет вас к диалоговому окну Выполнить .Когда вы окажетесь там, введите cmd и нажмите Введите .

• В GNU / Linux (и других Unix) есть несколько приложений, которые предоставляют вам доступ к системной командной строке. Некоторые из самых популярных - xterm, Gnome Terminal и Konsole. Это инструменты, запускающие оболочку или терминал, такие как Bash, ksh, csh и т. Д.

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

• В Mac OS X вы можете получить доступ к системному терминалу из Приложения → Утилиты → Терминал .

Как интерпретатор запускает сценарии Python?

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

1. Последовательная обработка операторов вашего скрипта

2. Скомпилировать исходный код в промежуточный формат, известный как байт-код

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

   Строго говоря, эта оптимизация кода предназначена только для модулей (импортированных файлов), а не для исполняемых скриптов.

3. Отгрузить код для исполнения

   В этот момент вступает в действие нечто, известное как виртуальная машина Python (PVM). PVM - это среда выполнения Python. Это цикл, который повторяет инструкции вашего байт-кода, чтобы запускать их одну за другой.

   PVM не является изолированным компонентом Python. Это просто часть системы Python, установленной на вашем компьютере. Технически PVM - это последний этап того, что называется интерпретатором Python.

Весь процесс выполнения скриптов Python известен как модель выполнения Python .

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

Как запускать сценарии Python с помощью командной строки

Интерактивный сеанс Python позволит вам написать много строк кода, но как только вы закроете сеанс, вы потеряете все, что написали. Вот почему обычный способ написания программ на Python - использовать простые текстовые файлы. По соглашению эти файлы будут иметь расширение .py . (В системах Windows расширение также может быть .pyw .)

Файлы кода

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

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

  1 #! / Usr / bin / env python3
 2
 3print ('Привет, мир!')
  

Сохраните файл в рабочем каталоге с именем hello.py . Когда тестовый сценарий готов, вы можете продолжить чтение.

Использование

python Команда

Чтобы запустить сценарии Python с помощью команды python , вам необходимо открыть командную строку и ввести слово python или python3 , если у вас есть обе версии, а затем указать путь к вашему сценарию, как это :

  $ python3 hello.py
Привет мир!
  

Если все работает нормально, после нажатия Введите вы увидите фразу Hello World! на вашем экране.Вот и все! Вы только что запустили свой первый скрипт Python!

Если это не работает, возможно, вам нужно будет проверить вашу систему PATH , вашу установку Python, способ создания сценария hello.py , место, где вы его сохранили, и так далее.

Это самый простой и практичный способ запуска скриптов Python.

Перенаправление вывода

Иногда полезно сохранить вывод сценария для последующего анализа. Вот как это сделать:

  $ python3 привет.py> output.txt
  

Эта операция перенаправляет вывод вашего скрипта на output.txt , а не на стандартный вывод системы ( stdout ). Этот процесс широко известен как перенаправление потока и доступен как в Windows, так и в Unix-подобных системах.

Если output.txt не существует, он создается автоматически. С другой стороны, если файл уже существует, его содержимое будет заменено новым выводом.

Наконец, если вы хотите добавить вывод последовательных выполнений в конец вывода .txt , то вы должны использовать две угловые скобки ( >> ) вместо одной, вот так:

  $ python3 hello.py >> output.txt
  

Теперь вывод будет добавлен в конец output.txt .

Рабочие модули

с опцией

-m Опция

Python предлагает ряд параметров командной строки, которые вы можете использовать в соответствии с вашими потребностями. Например, если вы хотите запустить модуль Python, вы можете использовать команду python -m <имя-модуля> .

Опция -m ищет sys.path для имени модуля и запускает его содержимое как __main__ :

  $ python3 -m привет
Привет мир!
  

Примечание. имя-модуля должно быть именем объекта модуля, а не строкой.

Использование имени файла сценария

В последних версиях Windows можно запускать сценарии Python, просто вводя имя файла, содержащего код, в командной строке:

  C: \ devspace> привет.ру
Привет мир!
  

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

В Unix-подобных системах, таких как GNU / Linux, вы можете добиться чего-то подобного. Вам нужно будет только добавить первую строку с текстом #! / Usr / bin / env python , как вы это сделали с hello.py .

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

Эта строка начинается с #! Комбинация символов , которая обычно называется hash bang или shebang , и продолжается путем перехода к интерпретатору.

Есть два способа указать путь к интерпретатору:

• #! / Usr / bin / python : запись абсолютного пути
• #! / Usr / bin / env python : с использованием команды операционной системы env , которая находит и выполняет Python путем поиска в переменной среды PATH

Эта последняя опция полезна, если вы помните, что не все Unix-подобные системы размещают интерпретатор в одном и том же месте.

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

Вот пример того, как это сделать:

  $ # Назначить разрешения на выполнение
$ chmod + x hello.py
$ # Запустить скрипт, используя его имя файла
$ ./hello.py
Привет мир!
  

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

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

Как запустить скрипты Python в интерактивном режиме

Также можно запускать сценарии и модули Python из интерактивного сеанса. Этот вариант предлагает вам множество возможностей.

Использование импорта

Когда вы импортируете модуль, на самом деле происходит то, что вы загружаете его содержимое для последующего доступа и использования.В этом процессе интересно то, что import запускает код в качестве последнего шага.

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

Это дает вам еще один вариант для запуска скриптов Python:

>>>

  >>> импорт привет
Привет мир!
  

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

>>>

  >>> import hello # Ничего не делать
>>> import hello # Больше ничего не делать
  

Эти две операции import ничего не делают, потому что Python знает, что hello уже импортирован.

Для работы этого метода есть некоторые требования:

• Файл с кодом Python должен находиться в вашем текущем рабочем каталоге.
• Файл должен находиться в пути поиска модулей Python (PMSP), где Python ищет модули и пакеты, которые вы импортируете.

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

>>>

  >>> import sys
>>> для пути в sys.path:
... печать (путь)
...
/usr/lib/python36.zip
/usr/lib/python3.6
/usr/lib/python3.6/lib-dynload
/usr/local/lib/python3.6/dist-packages
/ usr / lib / python3 / dist-пакеты
  

Запустив этот код, вы получите список каталогов и файлов .zip и , в которых Python будет искать модули, которые вы импортируете.

Использование

importlib и imp

В стандартной библиотеке Python вы можете найти importlib , который представляет собой модуль, предоставляющий import_module () .

С помощью import_module () вы можете эмулировать операцию import и, следовательно, выполнять любой модуль или скрипт. Взгляните на этот пример:

>>>

  >>> import importlib
>>> importlib.import_module ('привет')
Привет мир!
<модуль 'привет' из '/home/username/hello.py'>
  

После того, как вы впервые импортировали модуль, вы не сможете продолжать использовать import для его запуска. В этом случае вы можете использовать importlib.reload () , что заставит интерпретатор повторно импортировать модуль снова, как в следующем коде:

>>>

  >>> import hello # Первый импорт
Привет мир!
>>> import hello # Второй импорт, который ничего не делает
>>> импортировать importlib
>>> importlib.reload (привет)
Привет мир!
<модуль 'привет' из '/home/username/hello.py'>
  

Здесь важно отметить, что аргумент reload () должен быть именем объекта модуля, а не строкой:

>>>

  >>> importlib.перезагрузить ('привет')
Отслеживание (последний вызов последний):
    ...
TypeError: аргумент reload () должен быть модулем
  

Если вы используете строку в качестве аргумента, то reload () вызовет исключение TypeError .

Примечание: Вывод предыдущего кода был сокращен ( ... ) для экономии места.

importlib.reload () пригодится, когда вы модифицируете модуль и хотите проверить, работают ли ваши изменения, не выходя из текущего интерактивного сеанса.

Наконец, если вы используете Python 2.x, то у вас будет imp , который представляет собой модуль, который предоставляет функцию под названием reload () . imp.reload () работает аналогично importlib.reload () . Вот пример:

>>>

  >>> import hello # Первый импорт
Привет мир!
>>> import hello # Второй импорт, который ничего не делает
>>> импортный чертенок
>>> imp.reload (привет)
Привет мир!
<модуль 'hello' из '/ home / username / hello.py '>
  

В Python 2.x reload () является встроенной функцией. В версиях 2.6 и 2.7 он также включен в imp , чтобы облегчить переход на 3.x.

Примечание. imp устарел, начиная с версии 3.4 языка. Пакет imp ожидает прекращения поддержки в пользу importlib .

Использование

runpy.run_module () и runpy.run_path ()

Стандартная библиотека включает модуль под названием runpy .В этом модуле вы можете найти run_module () , функцию, которая позволяет запускать модули без их предварительного импорта. Эта функция возвращает словарь globals исполняемого модуля.

Вот пример того, как его можно использовать:

>>>

  >>> runpy.run_module (mod_name = 'hello')
Привет мир!
{'__name__': 'привет',
    ...
'_': Никто}}
  

Модуль находится с использованием стандартного механизма import и затем выполняется в новом пространстве имен модуля.

Первый аргумент run_module () должен быть строкой с абсолютным именем модуля (без расширения .py ).

С другой стороны, runpy также предоставляет run_path () , что позволит вам запустить модуль, указав его местоположение в файловой системе:

>>>

  >>> import runpy
>>> runpy.run_path (path_name = 'hello.py')
Привет мир!
{'__name__': '',
    ...
'_': Никто}}
  

Подобно run_module () , run_path () возвращает словарь globals исполняемого модуля.

Параметр path_name должен быть строкой и может относиться к следующему:

• Местоположение исходного файла Python
• Расположение скомпилированного файла байт-кода
• Значение действительной записи в sys.path , содержащей модуль __main__ (файл __main__.py )

Взлом

exec ()

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

exec () предоставляет альтернативный способ запуска ваших скриптов:

>>>

  >>> exec (open ('hello.py'). Read ())
'Привет, мир!'
  

Этот оператор открывает hello.py , считывает его содержимое и отправляет его в exec () , которая, наконец, запускает код.

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

Использование

execfile () (Python 2.только x)

Если вы предпочитаете использовать Python 2.x, вы можете использовать встроенную функцию execfile () , которая может запускать сценарии Python.

Первым аргументом execfile () должна быть строка, содержащая путь к файлу, который вы хотите запустить. Вот пример:

>>>

  >>> execfile ('hello.py')
Привет мир!
  

Здесь hello.py анализируется и оценивается как последовательность операторов Python.

Как запускать сценарии Python из среды IDE или текстового редактора

При разработке более крупных и сложных приложений рекомендуется использовать интегрированную среду разработки (IDE) или расширенный текстовый редактор.

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

Стандартный дистрибутив

Python включает IDLE в качестве IDE по умолчанию, и вы можете использовать его для написания, отладки, изменения и запуска ваших модулей и скриптов.

Другие IDE, такие как Eclipse-PyDev, PyCharm, Eric и NetBeans, также позволяют запускать сценарии Python изнутри среды.

Расширенные текстовые редакторы, такие как Sublime Text и Visual Studio Code, также позволяют запускать ваши скрипты.

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

Как запускать сценарии Python из файлового менеджера

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

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

Windows, например, связывает расширения .py и .pyw с программами python.exe и pythonw.exe соответственно. Это позволяет запускать сценарии двойным щелчком по ним.

Если у вас есть сценарий с интерфейсом командной строки, скорее всего, вы увидите на экране только вспышку черного окна.Чтобы избежать этой раздражающей ситуации, вы можете добавить в конец скрипта оператор типа input ('Press Enter to Continue ...') . Таким образом, программа остановится, пока вы не нажмете Введите .

Однако у этого трюка есть свои недостатки. Например, если в вашем скрипте есть ошибка, выполнение будет прервано до достижения input () оператора, и вы все равно не сможете увидеть результат.

В Unix-подобных системах вы, вероятно, сможете запускать свои скрипты, дважды щелкнув их в файловом менеджере.Для этого у вашего скрипта должны быть разрешения на выполнение, и вам нужно будет использовать уловку shebang, которую вы уже видели. Точно так же вы можете не увидеть на экране никаких результатов, когда дело касается скриптов интерфейса командной строки.

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

Заключение

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

Теперь вы можете запускать сценарии Python из:

• Командная строка операционной системы или терминал
• Интерактивный режим Python
• IDE или текстовый редактор, который вам больше всего нравится
• Файловый менеджер вашей системы, двойным щелчком по иконке вашего скрипта

Эти навыки сделают ваш процесс разработки намного быстрее, а также более продуктивным и гибким.

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

Пройти тест »

Смотреть сейчас В этом руководстве есть связанный видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным руководством, чтобы углубить свое понимание: Запуск скриптов Python

Как создавать текстовые файлы, читать, писать, открывать и добавлять файлы в Python

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

В этом руководстве по обработке файлов в Python мы узнаем:

Как открыть текстовый файл в Python

Чтобы открыть файл, вам необходимо использовать встроенную функцию open . Функция открытия файла Python возвращает объект файла, который содержит методы и атрибуты для выполнения различных операций по открытию файлов в Python.

Синтаксис функции открытия файла Python

 file_object = open ("имя файла", "режим") 

Здесь

• имя_файла: дает имя файла, который открыл файловый объект.
• mode: атрибут файлового объекта сообщает вам, в каком режиме был открыт файл.

Более подробная информация об этих режимах объясняется ниже

Как создать текстовый файл в Python

с записью в файл Python, вы можете создать текстовые файлы (guru99.txt) с помощью кода, который мы продемонстрировали здесь:

Шаг 1) Откройте файл .txt

 f = open ("guru99.txt", "w +") 

• Мы объявили переменную f, чтобы открыть файл с именем guru99.текст. Open принимает 2 аргумента: файл, который мы хотим открыть, и строку, представляющую типы разрешений или операций, которые мы хотим выполнить с файлом.
• Здесь мы использовали букву «w» в нашем аргументе, которая указывает Python на запись в файл. и он создаст файл на Python, если он не существует в библиотеке
• Знак плюс указывает как чтение, так и запись для операции создания файла Python.

Шаг 2) Введите данные в файл

 для i в диапазоне (10):
     f.write ("Это строка% d \ r \ n"% (i + 1)) 

• У нас есть цикл for, который работает в диапазоне из 10 чисел.
• Использование функции записи для ввода данных в файл.
• Результат, который мы хотим повторить в файле, - это «это номер строки», который мы объявляем с помощью функции записи файла Python, а затем процент d (отображает целое число)
• Таким образом, в основном мы вводим номер строки, которую мы пишем , затем поместите его в символ возврата каретки и новой строки

Шаг 3) Закройте экземпляр файла

 f.close () 

• Это закроет экземпляр сохраненного файла guru99.txt

Вот результат после выполнения кода для создания текстового файла Пример Python:

Как создать текстовый файл в Python

При нажатии в текстовом файле в нашем случае "guru99.txt" он будет выглядеть примерно так

Пример создания текстового файла в Python

Как добавить в файл в Python

Вы также можете добавить / добавить новый текст в уже существующий файл или новый файл.

Шаг 1)

 f = open ("guru99.txt", "a +") 

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

Шаг 2)

 для i в диапазоне (2):
     f.write ("Добавленная строка% d \ r \ n"% (i + 1)) 

Это запишет данные в файл в режиме добавления.

Как добавить в файл в Python

Вы можете увидеть результат в файле «guru99.txt». Результатом кода является то, что более ранний файл добавляется с новыми данными Python к операции добавления к файлу.

Пример добавления к файлу в Python

Как читать файлы в Python

Вы можете прочитать файл в Python, вызвав файл .txt в «режиме чтения» (r).

Шаг 1) Откройте файл в режиме чтения

 f = open ("guru99.txt", "r") 

Шаг 2) Мы используем функцию режима в коде, чтобы проверить, что файл в открытом режиме.Если да, продолжаем дальше

 if f.mode == 'r': 

Шаг 3) Используйте f.read для чтения данных файла и сохраните его в переменном содержимом для чтения файлов в Python

 contents = f. read () 

Шаг 4) Распечатать содержимое для текстового файла чтения Python

Вот результат чтения файла Пример Python:

Как читать файлы в Python

Как читать файл построчно в Python

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

Как читать файл построчно в Python

Когда вы запускаете код ( f1 = f.readlines ()) для построчного чтения файла в Python, он разделяет каждую строку и представляет файл в виде читаемый формат. В нашем случае строка короткая и читабельная, вывод будет похож на режим чтения. Но если есть сложный файл данных, который не читается, этот фрагмент кода может быть полезен.

Файловые режимы в Python

Ниже приведены различные файловые режимы в Python :

Вот полный код для Python print () в примере файла

Python 2 Example

 def main ( ):
     f = open ("guru99.txt", "w +")
     # f = open ("guru99.txt", "a +")
     для i в диапазоне (10):
         f.write ("Это строка% d \ r \ n"% (i + 1))
     f.Закрыть()
     # Откройте файл и прочтите его содержимое
     # f = open ("guru99.txt", "r")
     # если f.mode == 'r':
     # contents = f.read ()
     # распечатать содержимое
     # или readlines считывает отдельную строку в список
     #fl = f.readlines ()
     # для x in fl:
     #print x
если __name __ == "__main__":
  main () 

Пример Python 3

Ниже приведен еще один пример Python print () в файл:

 def main ():
    f = open ("guru99.txt "," w + ")
    # f = open ("guru99.txt", "a +")
    для i в диапазоне (10):
         f.write ("Это строка% d \ r \ n"% (i + 1))
    f.close ()
    # Откройте файл и прочтите его содержимое
    # f = open ("guru99.txt", "r")
    #if f.mode == 'r':
    # contents = f.read ()
    # print (содержимое)
    # или readlines считывает отдельную строку в список
    #fl = f.readlines ()
    # для x in fl:
    #print (x)
если __name __ == "__main__":
  main () 

Сводка

• Python позволяет читать, записывать и удалять файлы
• Используйте функцию open ("filename", "w +") для создания текстового файла Python.Знак + сообщает интерпретатору Python для открытого текстового файла Python с разрешениями на чтение и запись.
• Чтобы добавить данные в существующий файл или выполнить операцию печати Python в файл, используйте команду open («Имя файла», « a »).
• Используйте функцию чтения Python из файла для чтения ВСЕГО содержимого файла.
• Используйте функцию readlines, чтобы читать содержимое файла по одному.

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

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

• Текстовые файлы: В файлах этого типа каждая строка текста заканчивается специальным символом EOL (конец строки), который по умолчанию является символом новой строки (‘\ n’) в Python.
• Двоичные файлы: В файлах этого типа отсутствует терминатор для строки, и данные сохраняются после их преобразования в понятный для машины двоичный язык.

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

Режимы доступа к файлам

Режимы доступа определяют тип операций, возможных в открытом файле. Это относится к тому, как файл будет использоваться после его открытия. Эти режимы также определяют расположение дескриптора файла в файле. Дескриптор файла подобен курсору, который определяет, откуда данные должны быть прочитаны или записаны в файле. В python есть 6 режимов доступа.

1. Только чтение («r»): Открыть текстовый файл для чтения. Ручка находится в начале файла. Если файл не существует, возникает ошибка ввода-вывода. Это также режим по умолчанию, в котором открывается файл.
2. Чтение и запись («r +»): Откройте файл для чтения и записи. Ручка находится в начале файла. Вызывает ошибку ввода-вывода, если файл не существует.
3. Только запись («w»): Откройте файл для записи.Для существующего файла данные усекаются и перезаписываются. Ручка находится в начале файла. Создает файл, если файл не существует.
4. Запись и чтение («w +») : открыть файл для чтения и записи. Для существующего файла данные усекаются и перезаписываются. Ручка находится в начале файла.
5. Только добавление (‘a’) : Откройте файл для записи. Если файл не существует, он создается. Ручка находится в конце файла.Записываемые данные будут вставлены в конце после существующих данных.
6. Добавить и прочитать («a +»): Откройте файл для чтения и записи. Если файл не существует, он создается. Ручка находится в конце файла. Записываемые данные будут вставлены в конце после существующих данных.

Открытие файла

Это делается с помощью функции open (). Для этой функции импорт модуля не требуется.

 File_object = open (r "File_Name", "Access_Mode") 

Файл должен существовать в том же каталоге, что и программный файл python, иначе полный адрес файла должен быть записан вместо имени файла.
Примечание: r помещается перед именем файла, чтобы символы в строке имени файла не рассматривались как специальные символы. Например, если в адресе файла есть \ temp, то \ t рассматривается как символ табуляции и возникает ошибка недопустимого адреса. R делает строку необработанной, то есть сообщает, что в строке нет специальных символов. Букву r можно игнорировать, если файл находится в том же каталоге, а адрес не помещается.

Здесь файл1 создается как объект для MyFile1 и файл2 как объект для MyFile2

Закрытие файла

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

File_object.close ()

Запись в файл

Есть два способа записи в файл.

1. write (): Вставляет строку str1 в одну строку в текстовый файл.

    File_object.write (str1) 

2. writelines (): Для списка строковых элементов каждая строка вставляется в текстовый файл. Используется для одновременной вставки нескольких строк.

    File_object.writelines (L) для L = [str1, str2, str3] 

Чтение из файла

Есть три способа чтения данных из текстового файла.

1. read (): Возвращает прочитанные байты в виде строки. Читает n байтов, если n не указано, читает весь файл.

    File_object.read ([n]) 

2. readline (): Считывает строку файла и возвращает в виде строки. Для указанного n считывает не более n байтов. Однако не читает более одной строки, даже если n превышает длину строки.

    File_object.readline ([n]) 

3. readlines (): Считывает все строки и возвращает их как каждую строку как строковый элемент в списке.

    File_object.readlines () 

Примечание: ‘\ n’ рассматривается как специальный символ из двух байтов

Выход:

Вывод функции чтения
Привет
Это Дели
Это париж
Это лондон


Вывод функции Readline:
Привет


Вывод функции Read (9):
Привет
Чт

Вывод функции Readline (9):
Привет

Вывод функции Readlines:
['Привет \ n', 'Это Дели \ n', 'Это Париж \ n', 'Это Лондон \ n']

 

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

Выход:

Вывод строк чтения после добавления
['Это Дели \ n', 'Это Париж \ n', 'Это Лондон \ n', 'Сегодня \ n']

Вывод строк чтения после записи
['Завтра \ n']
 

Связанная статья:
Объекты файлов в Python

Эта статья предоставлена ​​ Harshit Agrawal . Если вам нравится GeeksforGeeks, и вы хотите внести свой вклад, вы также можете написать статью, используя свой вклад.geeksforgeeks.org или отправьте свою статью по адресу [email protected]. Посмотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогите другим гикам.

Пожалуйста, напишите комментарии, если вы обнаружите что-то неправильное, или если вы хотите поделиться дополнительной информацией по теме, обсуждаемой выше.

Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS .И чтобы начать свое путешествие по машинному обучению, присоединяйтесь к Машинное обучение - курс базового уровня

Как открывать файлы PY на ПК с Windows 10

автор: Мэтью Адамс

Эксперт по Windows и программному обеспечению

Мэтью - фрилансер, опубликовавший множество статей по различным темам, связанным с технологиями. Его основное внимание уделяется ОС Windows и всему, что с ней связано.Он увлечен ... Читать дальше

Обновлено: 27 авг.2020 г.

Размещено: август 2017 г.

• Вы ищете быстрый способ открыть файлы PY на ПК с Windows 10? Именно с этой целью мы составили список советов.
• Один полезный трюк заключается в использовании интерпретатора Python для открытия сценариев PY, как описано ниже.
• Вы можете легко отредактировать сценарий PY в Блокноте или использовать одну из этих замечательных альтернатив Блокноте.
• Неважно, что вы не профессионал. Наш File Opener Hub может помочь вам запустить бесчисленные типы файлов.

Один инструмент, чтобы открыть их все!
Популярные форматы файлов больше не требуют специального программного обеспечения. Просто скачайте File Viewer Plus 4 и откройте их все в одной среде. Документы, медиа, архивы, электронная почта, камера, инфографика, исходные коды и многое другое - все это поддерживается этим инструментом. Вот что он делает:

открыть все файлы
в той же среде

Загрузить сейчас

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

Скрипты

PY также могут иметь альтернативные расширения файлов, в том числе PYC, PYD и PWC. Сценарии представляют собой текстовые файлы, но вам понадобится интерпретатор Python для запуска сценария PY в Windows.

Как я могу открывать файлы PY на моем ПК с Windows 10?

1. Загрузите инструмент File Viewer Plus

Вы можете открывать PY и многие другие файлы исходного кода с помощью File Viewer Plus. Это универсальный просмотрщик файлов для Windows, который может открывать и отображать более 300 различных типов файлов, просматривать и редактировать файлы исходного кода.

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

Ваш бюджет ограничен? Тогда ограниченное по времени предложение, включающее 30-дневную гарантию возврата денег, скорее всего, будет звучать для ваших ушей как музыка.

Программа просмотра файлов Plus

File Viewer Plus - лучший инструмент для быстрого открытия файлов PY на вашем компьютере с Windows 10.Готовы попробовать?

2. Откройте сценарии Python с помощью Notepad ++

1. Начните, щелкнув правой кнопкой мыши кнопку «Пуск» и выбрав Система , чтобы открыть окно на снимке экрана непосредственно ниже.
2. Щелкните либо Notepad ++ Installer 32-bit x86 (32-bit) , либо Notepad ++ Installer 64-bit x64 (64-bit) . Будет загружен 32- или 64-разрядный мастер установки, с помощью которого вы сможете установить программное обеспечение.
3. Затем вы можете открыть сценарий в Notepad ++, щелкнув Файл > Открыть .

Программисты могут редактировать сценарии Python с помощью разнообразного программного обеспечения. Фактически, вы можете редактировать сценарий PY в Блокноте. Однако Notepad ++ - лучший сторонний текстовый редактор, который также поддерживает формат файла PY.

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

Notepad ++ можно добавить на большинство платформ Windows. Обратите внимание, что это программное обеспечение имеет 32- и 64-битную версии.64-битные версии не работают в 32-битных системах.

Существуют также различные редакторы Python, с помощью которых вы можете открывать скрипты. В остальном это редакторы IDE, предназначенные для написания сценариев Python.

PyScripter, PyDev и PyCharm - это три программы IDE с открытым исходным кодом, с помощью которых вы можете открывать файлы PY.

IDE

, вероятно, является лучшим программным обеспечением для кодирования Python, чем Notepad ++, поскольку они также включают инструменты отладки и интегрированные интерпретаторы.

3. Легко запускать сценарии Python

1. Загрузите интерпретатор CPython.Нажмите кнопку Download Python 3.6.2 , чтобы сохранить один из наиболее обновленных интерпретаторов в Windows.
2. Откройте меню Win + X, нажав сочетание клавиш Win + X.
3. Выберите Командная строка (администратор) , чтобы открыть окно CP.
4. Откройте папку, содержащую ваш скрипт Python, в командной строке, введя «Cd», а затем путь к файлу.
5. Затем введите полный путь к интерпретатору CPython, а затем полное расположение файла PY в командной строке, которое должно включать интерпретатор Python exe и заголовок файла PY.Например, вы можете ввести что-то вроде этого: C: Python27python.exe C: User FolderPY Files SubfolderPy file title.PY
6. Нажмите Enter, чтобы открыть и запустить сценарий PY.

Текстовые редакторы подходят для редактирования файлов, но вам понадобится интерпретатор Python, чтобы открывать и запускать сценарии PY. Некоторые интерпретаторы поставляются в комплекте с программным обеспечением IDE Python.

Однако CPython, иначе эталонная реализация, является интерпретатором по умолчанию для языка программирования. Используйте описанные выше шаги, чтобы открыть скрипты PY с этим интерпретатором.

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

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

Вы также можете конвертировать файлы сценариев PY в Portable Document Format с помощью бесплатного программного обеспечения PDF24 Creator. Скорее всего, PDF24 просто идеально подходит для того, что вам нужно.

Если у вас есть другие предложения или вопросы, не стесняйтесь оставлять их в разделе комментариев ниже.

Была ли эта страница полезной?

896

Спасибо!

Недостаточно подробностей

Сложно понять

Другой

Связаться с экспертом

Начать разговор

.