Содержание

Основы работы с файлами в 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), если другое не указано. Далее полный список режимов открытия файла
РежимОписание
rТолько для чтения.
wТолько для записи. Создаст новый файл, если не найдет с указанным именем.
rbТолько для чтения (бинарный).
wbТолько для записи (бинарный). Создаст новый файл, если не найдет с указанным именем.
r+Для чтения и записи.
rb+Для чтения и записи (бинарный).
w+Для чтения и записи. Создаст новый файл для записи, если не найдет с указанным именем.
wb+Для чтения и записи (бинарный). Создаст новый файл для записи, если не найдет с указанным именем.
aОткроет для добавления нового содержимого. Создаст новый файл для записи, если не найдет с указанным именем.
a+Откроет для добавления нового содержимого. Создаст новый файл для чтения записи, если не найдет с указанным именем.
abОткроет для добавления нового содержимого (бинарный). Создаст новый файл для записи, если не найдет с указанным именем.
ab+Откроет для добавления нового содержимого (бинарный). Создаст новый файл для чтения записи, если не найдет с указанным именем.

Пример

Создадим текстовый файл 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)  # чтение 7 символов из example.txt
'This is '

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

>>> f.read(7)  # чтение следующих 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 в файл
Hello
World
>>> f.close()  # закрытие файла

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

Функция rename()

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

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

import os
os.rename(src,dest)

Где,

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

Пример

>>> import os
>>> # переименование xyz.txt в abc.txt
>>> os.rename("xyz.txt","abc.txt")

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

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

Пример

>>> f = open('example.txt')  # example.txt, который мы создали ранее
>>> f.read(4)  # давайте сначала перейдем к 4-й позиции
This
>>> f.tell()  # возвращает текущую позицию
4
>>> f.seek(0,0)  # вернем положение на 0 снова

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

file. close()закрывает открытый файл
file.fileno()возвращает целочисленный дескриптор файла
file.flush()очищает внутренний буфер
file.isatty()возвращает True, если файл привязан к терминалу
file.next()возвращает следующую строку файла
file.read(n)чтение первых n символов файла
file.readline()читает одну строчку строки или файла
file.readlines()читает и возвращает список всех строк в файле
file.seek(offset[,whene])устанавливает текущую позицию в файле
file.seekable()проверяет, поддерживает ли файл случайный доступ. Возвращает True, если да
file.tell()возвращает текущую позицию в файле
file. truncate(n)уменьшает размер файл. Если n указала, то файл обрезается до n байт, если нет — до текущей позиции
file.write(str)добавляет строку str в файл
file.writelines(sequence)добавляет последовательность строк в файл
  • ТЕГИ
  • для начинающих

Максим

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

Python Q https://yandex.ru/q/loves/python Online

Python QCEO [email protected]://secure.gravatar.com/avatar/b16f253879f7349f64830c64d1da4415?s=96&d=mm&r=gCEO PythonruPythonАлександрРедакторhttps://t.me/cashncarryhttps://pythonru.com/https://yandex.ru/q/profile/cashnc/[email protected] Zabrodin2018-10-26OnlinePython, Programming, HTML, CSS, JavaScript

Функция open.

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

Большие объемы данных хранят не в списках или словарях, а в файлах и базах данных. В этом уроке изучим особенности работы с текстовыми файлами в 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 OTUS

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

Файл представляет собой набор данных, сохраненных на компьютере, причем каждый файл имеет название — filename (имя файла, name of file).

В языке программирования Python выделяют 2 вида файлов:

— текстовые;

— бинарные.

Поговорим о каждом из типов подробнее.

Текстовые файлы. Формат .txt

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

Также важно отметить, что текст хранят не только в форме .txt, но и в формате.rtf (так называемом «формате обогащенного текста»).

Бинарные файлы. Формат .bin

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

Основные операции

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

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

Открытие. Метод open

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

Синтаксис относительно прост:

f = open(file_name, access_mode)

Что здесь что:

  • file_name — это имя файла, который надо открыть;
  • access_mode — это режим открытия файла. Это может быть чтение, запись и так далее. Если ничего не указать, будут справедливы настройки по умолчанию, те есть станет использоваться режим чтения (r).

Полный список режимов открытия смотрите в таблице ниже:

В качестве примера давайте выполним создание текстового файла test.txt с последующим сохранением его в рабочей директории.

Открыть созданный документ можно в режиме чтения из рабочей директории:

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

Здесь f представляет собой переменную-указатель на файл test.txt.

Идем далее. Код ниже выведет содержимое файла и информацию об этом файле.

>>> print(*f) # вывод содержимого

Hello, Otus!

>>> print(f) # вывод объекта

<_io.TextIOWrapper name='test.txt' mode='r' encoding='cp1252'>

Учтите, что в операционной системе «Виндовс» стандартная кодировка — это cp1252, в то время как в Linux — utf-08.

Закрытие. Метод close

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

Для закрытия есть несколько вариантов действий.

Вариант №1

Один из наиболее простых способов. Открытый файл закрываем с помощью метода close.

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

# работаем с файлом

f. close()

Все, документ закрыт (closed). Закрыв его таким образом, вы не сможете его использовать, пока не откроете по новой.

Вариант №2

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

Синтаксис создания исключения следующий:

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

try:

   # работаем с файлом

finally:

   f.close()

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

Вариант №3

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

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

Реализация в коде относительно проста:

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

    # работаем с документом

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

Используя соответствующие режимы, можно выполнять чтение информации и ее сохранение (save) в буфер памяти.

Функция read

Применяется для чтения содержимого после открытия документа в режиме чтения (r).

Вот, как это выглядит:

file.read(size)

Что здесь что:

  • file — это объект файла;
  • size — это число символов, которые необходимо прочесть. Если конкретное число не указывать, документ будет прочитан полностью.

>>> f = open('test.txt','r')

>>> f.read(7)  # читаем семь символов из test.txt

Функция readline

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

Для примера создадим test. txt со следующими строками:

This is Otus for developers 1.

This is Otus for developers 2.

This is Otus for developers 3.

И воспользуемся readline:

x = open('test.txt','r')

x.readline()  # читаем первую строку

This is Otus for developers 1.

>>> x.readline(2)  # читаем 2-ю строку

This is Otus for developers 2.

>>> x.readlines()  # читаем все строки сразу

['This is Otus for developers 1.','This is Otus for developers 2.','This is Otus for developers 3.']

Функция write

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

Синтаксис несложен:

file.write(string)

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

f = open('supertest.txt','w')  # открываем в режиме записи

f.write('Hello \n Otus')  # пишем Hello Otus в документ

Hello

Otus

f.close()  # закрываем документ

Переименование. Функция rename

Может возникнуть необходимость в переименовании имен файлов (filenames). Вопрос можно решить посредством функции rename. Но чтобы это сделать, сначала надо импортировать модуль os.

Синтаксис:

import os

os.rename(src,dest)

Что здесь что:

  • src — это файловый документ, которому надо изменить name;
  • dest — это новое имя.

Вот, как это выглядит в коде:

import os

# переименовываем otus1.txt в otus2.txt

>>> os. rename("otus1.txt","otus2.txt")

Основные методы

В таблице ниже вы увидите основные методы, которые используются при работе с файлами (files) в «Пайтон»:

Источник

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

Автор оригинала: Pankaj Kumar.

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

Ключевые методы, предоставленные нам Python для обработки файлов, являются Открыть () , Закрыть () , Написать () , Читать () , Ищите () и Добавить () Отказ

Давайте перейдем на Открыть () Метод, который позволяет нам открывать файлы в Python в разных режимах.

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

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

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

1. Открытие файла с помощью метода Open ()

Чтобы открыть OpenFile.txt и прочитайте текстовое содержимое файла, давайте использовать Открыть () и Читать () методы.

file = open('OpenFile.txt')
print(file.read())
file.close()

Читать () Метод будет прочитать все содержимое файла.

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

2. Разные режимы для Open () метода

Давайте попробуем написать файл с режимом по умолчанию.

file = open('OpenFile.txt')
print(file.read())
file.write("testing write")
file.close()

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

Так что, что такое режимы, и как мы их добавляем? Ниже приведен список режимов при использовании метода Open ().

  • R : Режим только для чтения.
  • R +: Режим прочитанного и записи. Не будет создавать новый файл и открыть не удастся, если файл не существует
  • RB : Двоичный режим только для чтения для чтения изображений, видео и т. Д.
  • W: Режим только для записи. Перезаписывает существующий файл содержимого. Это создаст новый файл, если указанное имя файла не существует.
  • W +: Режим прочитанного и записи.
  • WB: Двоичный режим только для записи в Media файлы.
  • WB +: Двоичный режим чтения и записи.
  • A: Режим добавления. Не перезаписывает существующий контент
  • A +: Присоединяйтесь и читайте режим. Он создаст новый файл, если имя файла не существует.
  • AB: Добавьте двоичный режим для изображений, видео и т. Д.
  • AB +: Добавьте и читайте двоичный режим.

3. Открытие файлов в режиме записи в Python

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

file = open('OpenFile. txt', 'w')
print(file.read())
file.close()

Добавляя «W» при открытии файла в первой строке, мы указываем, что файл должен быть открыт в режиме записи. Но Эта операция потерпит неудачу ТОО Потому что файл – только для записи И не позволит нам использовать метод чтения ().

file = open('OpenFile.txt', 'w')
file.write('New content\n')
file.close()

Приведенный выше код полностью очистит все содержимое текстового файла и вместо этого просто сказать «новый контент».

Если вы не хотите перезаписать файл, Вы можете использовать А + или R + Режимы.

Режим R + напишет любой контент, переданный на Написать () метод.

file = open('OpenFile.txt', 'r+')
print(file.read())
file.write('r+ method, adds a line\n')
file.close()

Режим A или A + будет выполнять то же действие, что и режим R + с одним главным отличием.

В случае метода R +, Новый файл не будет создан Если указанное имя файла не существует. Но с помощью режима A + новый файл будет создан, если указанный файл недоступен.

4. Открытие файлов с использованием предложения

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

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

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

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

А с Блок получает блокировку, как только он выполняется и выпускает блокировку после окончания блока.

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

with open('OpenFile. txt', 'r+') as file:
    lines = file.readlines()
    
    for line in lines:
        print(line.split())

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

Заключение

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

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

Последнее обновление: 21.06.2017

Запись в текстовый файл

Чтобы открыть текстовый файл на запись, необходимо применить режим w (перезапись) или a (дозапись). Затем для записи применяется метод write(str), в который передается записываемая строка. Стоит отметить, что записывается именно строка, поэтому, если нужно записать числа, данные других типов, то их предварительно нужно конвертировать в строку.

Запишем некоторую информацию в файл «hello. txt»:


with open("hello.txt", "w") as file:
    file.write("hello world")

Если мы откроем папку, в которой находится текущий скрипт Python, то увидем там файл hello.txt. Этот файл можно открыть в любом текстовом редакторе и при желании изменить.

Теперь дозапишем в этот файл еще одну строку:


with open("hello.txt", "a") as file:
    file.write("\ngood bye, world")

Дозапись выглядит как добавление строку к последнему символу в файле, поэтому, если необходимо сделать запись с новой строки, то можно использовать эскейп-последовательность «\n». В итоге файл hello.txt будет иметь следующее содержимое:


hello world
good bye, world

Еще один способ записи в файл представляет стандартный метод print(), который применяется для вывода данных на консоль:


with open("hello.txt", "a") as hello_file:
    print("Hello, world", file=hello_file)

Для вывода данных в файл в метод print в качестве второго параметра передается название файла через параметр file. А первый параметр представляет записываемую в файл строку.

Чтение файла

Для чтения файла он открывается с режимом r (Read), и затем мы можем считать его содержимое различными методами:

  • readline(): считывает одну строку из файла

  • read(): считывает все содержимое файла в одну строку

  • readlines(): считывает все строки файла в список

Например, считаем выше записанный файл построчно:


with open("hello.txt", "r") as file:
    for line in file:
        print(line, end="")

Несмотря на то, что мы явно не применяем метод readline() для чтения каждой строки, но в при переборе файла этот метод автоматически вызывается для получения каждой новой строки. Поэтому в цикле вручную нет смысла вызывать метод readline. И поскольку строки разделяются символом перевода строки «\n», то чтобы исключить излишнего переноса на другую строку в функцию print передается значение end="".

Теперь явным образом вызовем метод readline() для чтения отдельных строк:


with open("hello.txt", "r") as file:
    str1 = file.readline()
    print(str1, end="")
    str2 = file.readline()
    print(str2)

Консольный вывод:


hello world
good bye, world

Метод readline можно использовать для построчного считывания файла в цикле while:


with open("hello.txt", "r") as file:
    line = file.readline()
    while line:
        print(line, end="")
        line = file.readline()

Если файл небольшой, то его можно разом считать с помощью метода read():


with open("hello.txt", "r") as file:
    content = file.read()
    print(content)

И также применим метод readlines() для считывания всего файла в список строк:


with open("hello.txt", "r") as file:
    contents = file.readlines()
    str1 = contents[0]
    str2 = contents[1]
    print(str1, end="")
    print(str2)

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


filename = "hello.txt"
with open(filename, encoding="utf8") as file:
    text = file.read()

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


# имя файла
FILENAME = "messages.txt"
# определяем пустой список
messages = list()

for i in range(4):
    message = input("Введите строку " + str(i+1) + ": ")
    messages.append(message + "\n")

# запись списка в файл
with open(FILENAME, "a") as file:
    for message in messages:
        file.write(message)

# считываем сообщения из файла
print("Считанные сообщения")
with open(FILENAME, "r") as file:
    for message in file:
        print(message, end="")

Пример работы программы:


Введите строку 1: hello
Введите строку 2: world peace
Введите строку 3: great job
Введите строку 4: Python
Считанные сообщения
hello
world peace
great job
Python

НазадСодержаниеВперед

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

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

Файлы

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

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

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

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

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

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

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

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

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

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

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

Режим Описание
р Открывает файл для чтения. (по умолчанию)
ш Открывает файл для записи. Создает новый файл, если он не существует, или усекает файл, если он существует.
х Открывает файл для монопольного создания. Если файл уже существует, операция завершится ошибкой.
и Открывает файл для добавления в конец файла без его усечения. Создает новый файл, если он не существует.
т Открывается в текстовом режиме. (по умолчанию)
б Открывается в двоичном режиме.
+ Открывает файл для обновления (чтения и записи)
 f = open("test.txt") # эквивалентно 'r' или 'rt'
f = open("test.txt",'w') # запись в текстовом режиме
f = open("img.bmp",'r+b') # чтение и запись в двоичном режиме 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

Для этой цели доступны различные методы. Мы можем использовать метод read(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).

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

Файловые методы Python

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

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

Метод Описание
закрыть() Закрывает открытый файл. Это не имеет никакого эффекта, если файл уже закрыт.
отсоединить() Отделяет базовый двоичный буфер от TextIOBase и возвращает его.
файлно() Возвращает целое число (дескриптор файла) файла.
смыв() Очищает буфер записи файлового потока.
isatty() Возвращает True , если файловый поток является интерактивным.
чтение( n ) Читает не более n символов из файла. Читает до конца файла, если он отрицательный или Нет .
читаемый() Возвращает True , если файловый поток доступен для чтения.
readline( n =-1) Читает и возвращает одну строку из файла. Считывает не более n байт, если указано.
строки чтения( n =-1) Читает и возвращает список строк из файла. Считывает не более n байт/символов, если указано.
поиск ( смещение , от = SEEK_SET ) Изменяет позицию файла на со смещением байт относительно с (начало, текущая, конец).
поиск() Возвращает True , если файловый поток поддерживает произвольный доступ.
рассказать() Возвращает целое число, представляющее текущую позицию объекта файла.
усечение (размер = Нет ) Изменяет размер файлового потока до размера байт. Если размер не указан, размер изменяется в соответствии с текущим местоположением.
запись() Возвращает True , если файловый поток может быть записан.
запись( с ) Записывает строку s в файл и возвращает количество записанных символов.
строки записи( строк ) Записывает в файл список из строк .

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

В этом руководстве мы научимся читать и записывать файлы CSV в Python с помощью примеров.

Формат CSV (значения, разделенные запятыми) — один из самых простых и распространенных способов хранения табличных данных. Чтобы представить файл CSV, он должен быть сохранен с расширением .csv .

Возьмем пример:

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

  SN, Имя, Город
1, Майкл, Нью-Джерси
2, Джек, Калифорния
  

Как видите, элементы файла CSV разделены запятыми. Здесь , — разделитель.

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

Примечание: Модуль csv также можно использовать для других расширений файлов (например: .txt ), если их содержимое имеет правильную структуру.

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

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

Прежде чем мы сможем использовать методы модуля csv , нам нужно сначала импортировать модуль, используя:

 import csv
 

Чтение файлов CSV с помощью csv.reader()

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

Имя Возраст Профессия
Домкрат 23 Доктор
Миллер 22 Инженер

Давайте прочитаем этот файл, используя csv.reader() :

Пример 1: Чтение CSV с разделителем-запятой

 import csv
с open('people.csv', 'r') в виде файла:
    читатель = csv.reader (файл)
    для строки в читателе:
        печать (строка)
 

Выход

  ['Имя', 'Возраст', 'Профессия']
['Джек', '23', 'Доктор']
['Миллер', '22', 'Инженер']
  

Здесь мы открыли файл people.csv в режиме чтения, используя:

 с файлом open('people.csv', 'r'):
    .. .. ...
 

Чтобы узнать больше об открытии файлов в Python, посетите: Python File Input/Output

Затем для чтения файла используется csv.reader() , который возвращает повторяемый объект reader .

Объект считывателя затем повторяется с использованием цикла for для печати содержимого каждой строки.


В приведенном выше примере мы используем функцию csv.reader() в режиме по умолчанию для файлов CSV с разделителем-запятой.

Однако эта функция гораздо более настраиваема.

Предположим, что наш CSV-файл использует в качестве разделителя вкладку . Чтобы прочитать такие файлы, мы можем передать необязательные параметры в функцию csv.reader() . Возьмем пример.

Пример 2: чтение CSV-файла с разделителем табуляции

 импорт CSV
с open('people.csv', 'r',) в виде файла:
    читатель = csv.reader (файл, разделитель = '\ t')
    для строки в читателе:
        печать (строка)
 

Обратите внимание на необязательный параметр разделитель = '\t' в приведенном выше примере.


Полный синтаксис функции csv.reader() :

Как видно из синтаксиса, мы также можем передать параметр диалекта в функцию csv. reader() . Параметр диалект позволяет сделать функцию более гибкой. Чтобы узнать больше, посетите: Чтение файлов CSV в Python.


Запись файлов CSV с помощью csv.writer()

Чтобы записать файл CSV в Python, мы можем использовать функцию csv.writer () .

Функция csv.writer() возвращает объект Writer , который преобразует данные пользователя в строку с разделителями. Позже эту строку можно будет использовать для записи в CSV-файлы с помощью функции writerow(). Возьмем пример.

Пример 3. Запись в файл CSV

 импорт csv
с open('protagonist.csv', 'w', newline='') в виде файла:
    писатель = csv.writer (файл)
    Writer.writerow(["SN", "Фильм", "Главный герой"])
    author.writerow([1, "Властелин колец", "Фродо Бэггинс"])
    author.writerow([2, "Гарри Поттер", "Гарри Поттер"])
 

Когда мы запускаем указанную выше программу, создается файл protagonist.csv со следующим содержимым:

  SN, фильм, главный герой
1, Властелин колец, Фродо Бэггинс
2, Гарри Поттер, Гарри Поттер
  

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

Затем мы передали каждую строку как список. Эти списки преобразуются в строку с разделителями и записываются в файл CSV.


Пример 4. Запись нескольких строк с помощью writerows()

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

 импорт CSV
csv_rowlist = [["SN", "Фильм", "Главный герой"], [1, "Властелин колец", "Фродо Бэггинс"],
               [2, «Гарри Поттер», «Гарри Поттер»]]
с open('protagonist.csv', 'w') в виде файла:
    писатель = csv.writer (файл)
    писатель.writerows (csv_rowlist)
 

Вывод программы такой же, как и в Пример 3 .

Здесь наш двумерный список передается в write.writerows() метод для записи содержимого списка в файл CSV.


Пример 5. Запись в файл CSV с разделителем табуляции

 import csv
с open('protagonist.csv', 'w') в виде файла:
    писатель = csv.writer (файл, разделитель = '\ t')
    Writer.writerow(["SN", "Фильм", "Главный герой"])
    author. writerow([1, "Властелин колец", "Фродо Бэггинс"])
    author.writerow([2, "Гарри Поттер", "Гарри Поттер"])
 

Обратите внимание на необязательный параметр delimiter = '\t' в функции csv.writer() .


Полный синтаксис функции csv.writer() :

Подобно csv.reader() , вы также можете передать диалектный параметр функции csv.writer() , чтобы сделать функцию более настраиваемой. Чтобы узнать больше, посетите: Написание файлов CSV в Python


Python csv.DictReader() Class

Объекты Класс csv.DictReader() можно использовать для чтения файла CSV в качестве словаря.

Пример 6: Python csv.DictReader()

Предположим, у нас есть тот же файл people.csv , что и в Примере 1 .

Имя Возраст Профессия
Домкрат 23 Доктор
Миллер 22 Инженер

Давайте посмотрим, как можно использовать csv. DictReader() .

 импорт CSV
с open("people.csv", 'r') в виде файла:
    csv_file = csv.DictReader(файл)
    для строки в csv_file:
        печать (дикт (строка))
 

Выход

  {'Имя': 'Джек', 'Возраст': '23', 'Профессия': 'Доктор'}
{'Имя': 'Миллер', 'Возраст': '22', 'Профессия': 'Инженер'}
  

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

Здесь csv_file — это объект csv.DictReader() . Объект можно перебирать с помощью цикла for . csv.DictReader() возвратил тип OrderedDict для каждой строки. Вот почему мы использовали dict() для преобразования каждой строки в словарь.

Обратите внимание, что мы явно использовали метод dict() для создания словарей внутри цикла for .

 печать (дикт (строка))
 

Примечание : Начиная с Python 3. 8, csv.DictReader() возвращает словарь для каждой строки, и нам не нужно явно использовать dict() .


Полный синтаксис класса csv.DictReader() : )

Чтобы узнать об этом подробнее, посетите: Python csv.DictReader() class


Python csv.DictWriter() Class

Объекты Класс csv.DictWriter() можно использовать для записи в файл CSV из словаря Python.

Минимальный синтаксис класса csv.DictWriter() :

 csv.DictWriter(file, fieldnames)
 

Здесь,

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

Пример 7: Python csv.DictWriter()

 импорт csv
с open('players.csv', 'w', newline='') в виде файла:
    fieldnames = ['player_name', 'fide_rating']
    писатель = csv. DictWriter (файл, имена полей = имена полей)
    писатель.writeheader()
    Writer.writerow({'player_name': 'Магнус Карлсен', 'fide_rating': 2870})
    Writer.writerow({'player_name': 'Фабиано Каруана', 'fide_rating': 2822})
    Writer.writerow({'player_name': 'Дин Лижэнь', 'fide_rating': 2801})
 

Программа создает Файл player.csv со следующими записями:

  player_name,fide_rating
Магнус Карлсен, 2870
Фабиано Каруана, 2822 г.
Дин Лижэнь, 2801
  

Полный синтаксис класса csv.DictWriter() :

 csv.DictWriter(f, fieldnames, restval='', extrasaction='raise', dialect='excel', *args, * *kwds)
 

Чтобы узнать больше об этом, посетите: Python csv.DictWriter() class


Использование библиотеки Pandas для обработки файлов CSV

Pandas — это популярная библиотека данных на Python для обработки и анализа данных. Если мы работаем с огромными объемами данных, для простоты и эффективности лучше использовать pandas для обработки CSV-файлов.

Прежде чем мы сможем использовать pandas, нам нужно установить его. Чтобы узнать больше, посетите: Как установить Pandas?

После установки мы можем импортировать Pandas как:

 импортировать pandas как pd
 

Чтобы прочитать файл CSV с помощью pandas, мы можем использовать read_csv() 9Функция 0027.

 импортировать панд как pd
pd.read_csv("люди.csv")
 

Здесь программа считывает people.csv из текущего каталога.


Для записи в файл CSV нам нужно вызвать функцию to_csv() DataFrame.

 импортировать панд как pd
# создание фрейма данных
df = pd.DataFrame([['Джек', 24], ['Роза', 22]], columns = ['Имя', 'Возраст'])
# запись фрейма данных в файл CSV
df.to_csv('person.csv')
 

Здесь мы создали DataFrame, используя Метод pd.DataFrame() . Затем вызывается функция to_csv() для этого объекта, чтобы записать в person.csv .

Чтобы узнать больше, посетите:

  • Python pandas. read_csv (официальный сайт)
  • Python pandas.pandas.DataFrame.to_csv (официальный сайт)

Чтение, запись, анализ JSON (с примерами)

В этом руководстве вы научитесь анализировать, читать и писать JSON в Python с помощью примеров. Кроме того, вы научитесь преобразовывать JSON в dict и красиво печатать его.

JSON ( J ava S cript O bject N otation) — популярный формат данных, используемый для представления структурированных данных. Обычно данные между сервером и веб-приложением передаются и получаются в формате JSON.

В Python JSON существует в виде строки. Например:

 p = '{"имя": "Боб", "языки": ["Python", "Java"]}'
 

Также обычно объект JSON хранится в файле.


Модуль импорта json

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

 import json 

Анализ JSON в Python

Модуль json упрощает анализ строк и файлов JSON, содержащих объект JSON.


Пример 1: Python JSON для dict

Вы можете проанализировать строку JSON, используя метод json.loads() . Метод возвращает словарь.

 импорт json
человек = '{"имя": "Боб", "языки": ["английский", "французский"]}'
person_dict = json.loads (человек)
# Вывод: {'имя': 'Боб', 'языки': ['английский', 'французский']}
печать(человек_дикт)
# Вывод: ['Английский', 'Французский']
print(person_dict['languages']) 

Здесь person — это строка JSON, а person_dict — словарь.


Пример 2: Python читает файл JSON

Вы можете использовать метод json.load() для чтения файла, содержащего объект JSON.

Предположим, у вас есть файл с именем person.json , который содержит объект JSON.

{"имя": "Боб",
"языки": ["английский", "французский"]
}
 

Вот как вы можете разобрать этот файл:

импортировать json
с open('path_to_file/person. json', 'r') как f:
  данные = json.load(f)
# Вывод: {'имя': 'Боб', 'языки': ['английский', 'французский']}
печать (данные)
 

Здесь мы использовали функцию open() для чтения файла json. Затем файл анализируется с использованием json.load() , который дает нам словарь с именем data .

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


Преобразование Python в строку JSON

Вы можете преобразовать словарь в строку JSON, используя метод json.dumps() .


Пример 3. Преобразование dict в JSON

импортировать json
person_dict = {'имя': 'Боб',
'возраст': 12,
«дети»: нет
}
person_json = json.dumps(person_dict)
# Вывод: {"name": "Боб", "возраст": 12, "дети": null}
печать (person_json)
 

Вот таблица, показывающая объекты Python и их эквивалентное преобразование в JSON.

Питон JSON Эквивалент
дикт объект
список , кортеж массив
ул строка
целое число , число с плавающей запятой , целое число номер
Правда правда
Ложь ложь
Нет ноль

Запись JSON в файл

Чтобы записать JSON в файл на Python, мы можем использовать метод json. dump() .


Пример 4. Запись JSON в файл

импортировать json
person_dict = {"имя": "Боб",
"языки": ["английский", "французский"],
"замужем": Правда,
"возраст": 32
}
с open('person.txt', 'w') как json_file:
  json.dump(person_dict, json_file)
 

В приведенной выше программе мы открыли файл с именем person.txt в режиме записи, используя 'w' . Если файл еще не существует, он будет создан. Затем json.dump() преобразует person_dict в строку JSON, которая будет сохранена в файле person.txt .

При запуске программы будет создан файл person.txt . Файл имеет следующий текст внутри него.

 {"имя": "Боб", "языки": ["английский", "французский"], "замужем": правда, "возраст": 32} 

Python pretty print JSON

Для анализа и отладки данных JSON нам может потребоваться распечатать их в более читаемом формате. Это можно сделать, передав дополнительные параметры indent и sort_keys в методы json. dumps() и json.dump() .


Пример 5: красивая печать Python JSON

импортировать json
person_string = '{"name": "Боб", "languages": "English", "numbers": [2, 1.6, null]}'
# Получение словаря
person_dict = json.loads(person_string)
# Красивая печать строки JSON назад
печать (json.dumps (person_dict, отступ = 4, sort_keys = True))
 

Когда вы запустите программу, вывод будет:

 
{
    "языки": "английский",
    "имя": "Боб",
    "числа": [
        2,
        1,6,
        нулевой
    ]
}
  

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

Кстати, значение по умолчанию для отступа равно Нет . И значение по умолчанию sort_keys равно False .


Рекомендуемые чтения:

  • Python JSON в CSV и наоборот
  • Python XML в JSON и наоборот
  • Простой Python

Обработка файлов в Python — GeeksforGeeks

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

Работа функции open()

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

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

Если поддерживается следующий режим:

  1. r: открыть существующий файл для операции чтения.
  2. w: открыть существующий файл для операции записи. Если файл уже содержит некоторые данные, он будет переопределен.
  3. a:   открыть существующий файл для операции добавления. Он не будет переопределять существующие данные.
  4. r+:  Для чтения и записи данных в файл. Предыдущие данные в файле будут переопределены.
  5. w+: Для записи и чтения данных. Он переопределит существующие данные.
  6. a+: Для добавления и чтения данных из файла. Он не будет переопределять существующие данные.

Take a look at the below example:

Python3

(каждый) . напечатает каждую строку, присутствующую в файле.

Работа в режиме read()

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

Python3

file = open ( 'geek. txt' , 'r' )

для Каждая в Файл :

Печать (каждый)

Файл = Open ( "TXT" , "R.TXT , " R.TXT , "R.TXT , " R " , " R " , " R " . распечатать ( файл .read())

Другой способ прочитать файл - вызвать определенное количество символов, как в следующем коде, интерпретатор прочитает первые пять символов сохраненных данных и return it as a string: 

Python3

file = open ( "file.txt" , "r" )

Печать ( Файл .Read ( 5 ))

Создание файла с использованием файла () режим

режим работает, поэтому для управления файлом напишите в среде Python следующее: 

Python3

0026, 'W' )

Файл . WRITE ( «Это команда записи» )

Файл .WRITE (77 9003

. в определенном файле" )

файл .close()

Команда close() завершает использование всех ресурсов и освобождает систему этой конкретной программы.
 

Работа Append () Режим

Давайте посмотрим, как работает режим приложения:

Python3

69.6324475 1538998552.2402923 1540233322.4009316 15371.0497339 1540266380.3434134

os.scandir() возвращает объект ScandirIterator . Каждая запись в объекте ScandirIterator имеет . stat() , который извлекает информацию о файле или каталоге, на который он указывает. .stat() предоставляет такую ​​информацию, как размер файла и время последней модификации. В приведенном выше примере код выводит атрибут st_mtime , то есть время последнего изменения содержимого файла.

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

>>>

 >>> из пути импорта pathlib
>>> текущий_каталог = путь('мой_каталог')
>>> для пути в current_dir.itertir():
... информация = путь.стат()
... печать (info.st_mtime)
...
15399.0052035
15369.6324475
1538998552.2402923
1540233322.4009316
15371.0497339
1540266380.3434134
 

В приведенном выше примере код перебирает объект, возвращаемый функцией .itertir() , и извлекает атрибуты файла с помощью вызова .stat() для каждого файла в списке каталогов. Атрибут st_mtime возвращает значение с плавающей запятой, представляющее секунды с начала эпохи. Чтобы преобразовать значения, возвращаемые st_mtime , для целей отображения, вы можете написать вспомогательную функцию для преобразования секунд в дата-время объект:

 из даты и времени импорта даты и времени
из ОС импорт Scandir
def convert_date (отметка времени):
    d = datetime.utcfromtimestamp(timestamp)
    formated_date = d.strftime('%d %b %Y')
    вернуть форматированную_дату
защита get_files():
    dir_entries = scandir('мой_каталог/')
    для записи в dir_entries:
        если запись.is_file():
            информация = запись.стат()
            print(f'{entry.name}\t Last Modified: {convert_date(info.st_mtime)}')
 

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

Аргументы, переданные в .strftime() , следующие:

  • %d : день месяца
  • %b : месяц, сокращенно
  • %Y : год

Вместе эти директивы производят вывод, который выглядит следующим образом:

>>>

 >>> get_files()
file1.py Последнее изменение: 04 октября 2018 г.
file3.txt Последнее изменение: 17 сентября 2018 г.
file2.txt Последнее изменение: 17 сентября 2018 г.
 

Синтаксис преобразования даты и времени в строки может быть довольно запутанным. Чтобы узнать больше об этом, ознакомьтесь с официальной документацией по нему. Еще одна удобная ссылка, которую легко запомнить, — http://strftime.org/.

Создание каталогов

Рано или поздно программам, которые вы пишете, придется создавать каталоги для хранения в них данных. os и pathlib включают функции для создания каталогов. Мы рассмотрим эти:

Файл = Open ( = ( = ( . 'a' )

Файл . Write ( "Это добавит эту линию" )

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

 rstrip(): Эта функция удаляет пробелы с правой стороны каждой строки файла.
lstrip(): эта функция удаляет пробелы с левой стороны каждой строки файла. 

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

Пример:

Python3

с Open ( "File. txt" ) AS 6 ". файл .read()

Использование записи вместе с функцией with()

Мы также можем использовать функцию записи вместе с функцией with(): 

Python3

с Open ( "File.txt" , "W" ) AS "W" ) as F: "W" ) AS "W" ) AS "W" «Привет, мир!!!» )

split() с помощью обработки файлов

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

Python3

with open ( "file.text" , "r" ) as file :

     data = file .readlines()

     for line in data:

         word = line.split()

         print (слово)

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

Эту статью предоставил Чинмой Ленка . Если вам нравится GeeksforGeeks и вы хотите внести свой вклад, вы также можете написать статью с помощью write.geeksforgeeks.org или отправить ее по адресу [email protected] Посмотрите, как ваша статья появится на главной странице GeeksforGeeks, и помогите другим гикам.

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


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

Функция Описание
os.mkdir() Создает один подкаталог
pathlib.Path.mkdir() Создает один или несколько каталогов
os.makedirs() Создает несколько каталогов, включая промежуточные каталоги

Создание единого каталога

Чтобы создать один каталог, передайте путь к каталогу в качестве параметра os.mkdir() :

 импорт ОС
os.mkdir('example_directory/')
 

Если каталог уже существует, os.mkdir() вызывает FileExistsError . Кроме того, вы можете создать каталог, используя pathlib :

.
 из пути импорта pathlib
p = Путь ('example_directory/')
p.mkdir()
 

Если путь уже существует, mkdir() вызывает FileExistsError :

>>>

 >>> p. mkdir()
Traceback (последний последний вызов):
  Файл '', строка 1, в 
  Файл '/usr/lib/python3.5/pathlib.py', строка 1214, в mkdir
    self._accessor.mkdir(я, режим)
  Файл '/usr/lib/python3.5/pathlib.py', строка 371, в упаковке
    вернуть strfunc(str(pathobj), *args)
FileExistsError: [Errno 17] Файл существует: '.'
[Errno 17] Файл существует: '.'
 

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

 из пути импорта pathlib
p = Путь ('example_directory')
пытаться:
    p.mkdir()
кроме FileExistsError как exc:
    печать (отл.)
 

Кроме того, вы можете игнорировать FileExistsError , передав аргумент exists_ok=True в .mkdir() :

 из пути импорта pathlib
p = Путь ('example_directory')
p.mkdir(exist_ok=Истина)
 

Это не приведет к ошибке, если каталог уже существует.