Открыть файл для чтения python: Работа с файлами в Python

Содержание

Функция open() в Python, открывает файл на чтение/запись.

Открывает файл для чтения или записи файлового потока.

Синтаксис:

fp = open(file, mode='r', buffering=-1, encoding=None,
          errors=None, newline=None, closefd=True, opener=None)

Параметры:

  • file — абсолютное или относительное значение пути к файлу или файловый дескриптор открываемого файла.
  • mode — необязательно, строка, которая указывает режим, в котором открывается файл. По умолчанию 'r'.
  • buffering — необязательно, целое число, используемое для установки политики буферизации.
  • encoding — необязательно, кодировка, используемая для декодирования или кодирования файла.
  • errors — необязательно, строка, которая указывает, как должны обрабатываться ошибки кодирования и декодирования. Не используется в -бинарном режиме
  • newline — необязательно, режим перевода строк. Варианты: None, '\n', '\r' и '\r\n'. Следует использовать только для текстовых файлов.
  • closefd — необязательно, bool, флаг закрытия файлового дескриптора.
  • opener — необязательно, пользовательский объект, возвращающий открытый дескриптор файла.

Возвращаемое значение:

Описание:

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

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

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

Аргумент mode — это необязательная строка, которая указывает режим, в котором открывается файл. По умолчанию 'r', это означает, что файл открыт для чтения в текстовом режиме.

Значения аргумента mode:

  • r — открывает файл только для чтения,
  • w — открыт для записи (перед записью файл будет очищен),
  • x — эксклюзивное создание, бросается исключение FileExistsError, если файл уже существует.
  • a — открыт для добавления в конец файла (на некоторых Unix-системах пишет в конец файла вне зависимости от позиции курсора)
  • + — символ обновления (чтение + запись).
  • t — символ текстового режима.
  • b — символ двоичного режима (для операционных систем, которые различают текстовые и двоичные файлы).

Режим по умолчанию 'r', открывает файл только для чтения текста, синоним 'rt'. Режимы 'r+' и 'r+b' открывают файл и устанавливают курсор на начало файла, запись в файл начинается с места остановки курсора при его чтении перед записью. Если файл перед записью не читался то запись осуществляется в начало файла. Режимы 'w' и 'wb' создают новый файл или открывают существующий файл только для записи, с последующей его очисткой (стирает все перед записью). У режимов 'w+' и 'wb+' поведение такое же как в предыдущем случае, только если не закрывать файл после записи, его еще можно потом прочитать.

Варианты использования режимов:

  • 'r' — Открывает файл только для чтения. Указатель файла помещается в начале файла. Это режим «по умолчанию».
  • 'rb' — Открывает файл в бинарном режиме только для чтения. Указатель файла помещается в начале файла. Это режим «по умолчанию».
  • 'r+' — Открывает файл для чтения и записи. Указатель файла помещается в начало файла.
  • 'rb+' — Открывает файл в бинарном режиме для чтения и записи. Указатель файла помещается в начале файла. Это режим «по умолчанию».
  • 'w' — Открывает файл только для записи. Перезаписывает файл, если файл существует. Если файл не существует, создает новый файл для записи.
  • 'wb' — Открывает файл в бинарном режиме только для записи. Перезаписывает файл, если файл существует. Если файл не существует, создает новый файл для записи.
  • 'w+' — Открывает файл для записи и чтения. Перезаписывает существующий файл, если файл существует. Если файл не существует, создается новый файл для чтения и записи.
  • 'wb+' — Открывает файл в бинарном режиме для записи и чтения. Перезаписывает существующий файл, если файл существует. Если файл не существует, создается новый файл для чтения и записи.
  • 'a' — Открывает файл для добавления. Указатель файла находится в конце файла, если файл существует. То есть файл находится в режиме добавления. Если файл не существует, он создает новый файл для записи.
  • 'ab' — Открывает файл в бинарном режиме для добавления. Указатель файла находится в конце файла, если файл существует. То есть файл находится в режиме добавления. Если файл не существует, он создает новый файл для записи.
  • 'a+' — Открывает файл для добавления и чтения. Указатель файла находится в конце файла, если файл существует. Файл открывается в режиме добавления. Если файл не существует, он создает новый файл для чтения и записи.
  • 'ab+' — Открывает файл в бинарном режиме для добавления и чтения. Указатель файла находится в конце файла, если файл существует. Файл открывается в режиме добавления. Если файл не существует, он создает новый файл для чтения и записи.

Python различает двоичный и текстовый ввод/вывод. Файлы, открытые в двоичном режиме, возвращают содержимое в виде bytes объектов без какого-либо декодирования. В текстовом режиме (по умолчанию или когда 't' включен в аргумент mode) содержимое файла возвращается как строка байтов, которые были сначала декодированы с использованием кодировки, используемой системой по умолчанию или с использованием переданного аргумента encoding.

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

  • 0 — отключить буферизацию, только для бинарного режима;
  • 1 — построчная буферизация, только для текстового режима;
  • int число > 1 — размер буфера в байтах.
  • -1 — по умолчанию.

У текстовых файлов, если buffering не задан, используется построчная буферизаця. Двоичные файлы буферизируются кусками фиксированного размера. Этот размер определяется эвристикой, пытающейся определить размер блока устройства, на котором находится файл, в случае неудачи использует io.DEFAULT_BUFFER_SIZE. Для многих систем буфер равен 4096 или 8192 байт.

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

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

Доступны стандартные обработчики ошибок:

  • 'strict' — бросает исключение ValueError, если есть ошибка кодирования. Значение по умолчанию None имеет тот же эффект.
  • 'ignore' — игнорирует ошибки. Обратите внимание, что игнорирование ошибок кодирования может привести к потере данных.
  • 'replace' — вставляет символ ? на место непрочитанных символов, ввиду их отсутствия в используемой кодировке.
  • 'surrogateescape' — любые некорректные байты будут представлены как символы Юникода в диапазоне от U+DC80 до U+DCFF. Эти символы, при обратной операции кодирования будут возвращаться в те же байты. Полезно для обработки файлов в неизвестной кодировке.
  • 'xmlcharrefreplace' — поддерживается только при записи в файл. Символы, не поддерживаемые кодировкой, заменяются соответствующей ссылкой на символ XML.
  • 'backslashreplace' — заменяет искаженные данные на escape-последовательности Python с обратной косой чертой.
  • 'namereplace' — поддерживается только при записи, заменяет не поддерживаемые символы на \N{...} escape-последовательности.

Аргумент newline контролирует работу режима новой строки. Работает только с текстовым режимом. Допустимые аргументы: None, '', '\n', '\r' и '\r\n'.

Это работает следующим образом:

  • Чтение файла:
    • если аргумент newline=None или не указан, то символами окончания строк '\n', '\r' или '\r\n' на выходе преобразуются в разделитель строки '\n'.
    • если newline='', то получим результат с вырезанными символами окончания строк '\n', '\r' или '\r\n', то есть файл прочитается как одна большая строка.
    • если newline='\n', то в результате чтения функция open() уберет только символ \n из результата, если newline='\r', то только \r, если newline='\r\n', то только сочетание '\r\n' не будет учитываться.
  • При записи файла:
    • если аргумент newline=None или не указан, то символы окончания строк \n будут переведены в разделители строк, которые система использует по умолчанию;
    • если newline='' или newline='\n', то символы окончания строк \n переводится в разделители строк не будут. В файл запишется одна большая строка.
    • если newline='\r', то в результате записи функция open() сохранит значение \r в качестве разделителя строк, если newline='\r\n', то запишется сочетание '\r\n'.

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

Необязательный аргумент opener (по умолчанию None), пользовательский объект поддерживающий вызов, который следует использовать для открытия файла. Этот объект получая на входе file и flags, должен возвращать открытый дескриптор файла.

Дополнительно смотрите функцию os.open(), которая открывает файл и возвращает его файловый дескриптор. Вновь созданный дескриптор не наследуется .

В следующем примере используется параметр dir_fd функции os.open(), чтобы открыть файл относительно данного каталога:

>>> import os
>>> dir_fd = os.open('/some/dir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('test.txt', 'w', opener=opener) as f:
...     print('This will be written to /some/dir/test.txt', file=f)
...
>>> os.close(dir_fd)  # не забывайте закрыть файловый дескриптор

Тип файлового объекта, возвращаемого функцией open(), зависит от режима. Когда используется open(), чтобы открыть файл в текстовом режиме 'w', 'r', 'wt', 'rt' и т. д., она возвращает подкласс io.TextIOBase, в частности io.TextIOWrapper. При использовании для открытия файла в двоичном режиме с буферизацией возвращаемый класс является подклассом io.BufferedIOBase.

Итоговый класс меняется в зависимости от операции:

  • в режиме чтения двоичных файлов он возвращает io.BufferedReader;
  • в двоичном режиме записи и в двоичном режиме добавления он возвращает io.BufferedWriter;
  • в режиме чтения/записи — io.BufferedRandom.

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

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

Чтение и вывод на печать стазу всего файла

f = open('demofile.txt', 'r')
print(f.read())
f.close()  # не забывайте закрыть файл

Чтение всего файла и вывод на печать построчно

f = open('demofile.txt', 'r')
for line in f:
  print(line)
f.close() # не забывайте закрыть файл

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

f = open('newfile.txt', 'w')
f.write('Это единственная строка в файле\n')
f.close() # не забывайте закрыть файл

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

with open('demofile.txt', 'a') as f:
    f.write('Привет Мир\n')

# здесь закрывать файл не надо, менеджер контекста сделает это за вас.

Файловый ввод-вывод — Python documentation

  • Написать программу, которая будет получать у пользователя строку и
    записывать её в файл “data.txt”

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

    Введите имя файла: data.txt
    Начните вводить строки
    > one
    > two
    > three
    >
    
    Файл записан.
    

    После выполнения программы должен появиться файл data.txt, содержащий
    три строки:

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

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

    Введите имя файла: data.txt
    
    1 one
    
    2 two
    
    3 three
    

    Используйте метод строки rstrip(), чтобы избавиться от лишних переносов
    сток. После этого результат работы программы примет вид:

    Введите имя файла: data.txt
    1 one
    2 two
    3 three
    
  • Разработать приложение для разделения файла на части. Приложение принимает
    на вход имя файла для разделения и целое число N. На выходе у приложения
    множество файлов, каждый из которых содержит не более, чем N строк из
    исходного файла.

    Пусть на вход программе подается файл data.txt, со следующим текстом:

    one
    two
    three
    four
    five
    six
    seven
    eight
    nine
    ten
    

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

    Введите имя входного файла: data.txt
    Введите максимальное количество строк: 3
    

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

    В файле 2.txt:

    И так далее.

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

  • Работа с файлами в Python: открытие, чтение, запись в файл

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

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

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

    my_file = open("myfile.txt", "r")
    file_contents = my_file.read()
    my_file.close()
    

    В этом коде:

    • Функция open() принимает на вход 2 аргумента: путь до файла и права, с которыми его открыть. r — от read, т.е. мы просим открыть файл в режиме чтения.
    • Функция open() возвращает не текст в файле, а сам файл. Файл как бы теперь открыт, как если вы бы щёлкнули по нему дважды левой клавишей.
    • Метод файла .read() позволяет читать данные из файла. Строка с содержимым файла запишется в переменную file_contents.
    • Метод .close закрывает файл.

    Как сделать правильно

    Закрывать файлы важно по двум причинам:

    1. Чтобы читать и писать в один и тот же файл из разных мест программы.
    2. Чтобы не превысить лимиты операционной системы. У неё есть ограничение на число одновременно открытых файлов. Ограничение легко превысить, если открывать файлы в цикле.

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

    with open("myfile.txt", "r") as my_file:
      file_contents = my_file.read()
    print(file_contents)
    

    Выглядит немного непривычно, но суть простая: всё, что лежит “внутри” блока with (т.е. с отступом от него) — делается с открытым файлом. Как только файл не нужен, вы убираете отступ и файл сам закроется.

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

    Допустим, рядом c вашим файлом main.py, из которого вы запускаете код, лежит папка files. В этой папке лежит файл file.txt:

    .
    ├── files
    │   └── file.txt
    └── main.py
    

    Вам очень нужно открыть файл file.txt, но он спрятался в папке, что же делать? Вот как его открыть:

    with open("files/file.txt", "r") as my_file:
      file_contents = my_file.read()
    print(file_contents)
    

    Ошибки кодировки

    Бывает, что вы знаете, что файл в порядке, но Python читает его со странными символами: ������. Дело в кодировках: одни программы пользуют CP1251, другие ASCII, третьи UTF-8. К сожалению, программистам до сих пор не получилось окончательно перейти к какому-то одному варианту.

    Чтобы открыть файл с нужной кодировкой, нужно передать функции open именованный аргумент encoding:

    with open("myfile.txt", "r", encoding="ваша кодировка") as my_file:
       
    

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

    Запись в файл

    Для записи в файл нужно лишь указать режим w (write) и использовать не .read(), а .write():

    my_text = "Хочу записать эту строку в файл"
    with open("myfile.txt", "w") as my_file:
      my_file.write(my_text)
    

    Альтернативные статьи

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

    Причин для того, чтобы возникла необходимость прочитать файл огромное множество. Может быть вам понадобилось прочитать текстовый файл, например, log-file, или XML, в целях извлечения данных. Иногда это становится трудной задачей. Не беспокойтесь, Питон не является каверзным в данном вопросе. Существует два способа при помощи которых Питон сможет прочитать файл. Для простоты, мы дадим Питону прочитать текстовые файлы, но не стесняйтесь попробовать прочитать XML самостоятельно.

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

    Допустим, у нас есть удивительный файл test.txt, который заполнен каким-то случайным текстом. Теперь, в примере, у нас есть наш код. Также как и вы должны определится с файлом, прежде чем на него щелкнуть, так и Python должен знать, какой файл открыть. Таким образом, мы используем метод open, чтобы сказать Python, что мы от него хотим, а именно открыть его. “r” просто говорит Python, что мы хотим прочитать (“w”, когда мы хотим что-то записать в файл). И, конечно же, мы связываем это с переменной, чтобы мы могли это использовать позже. Тем не менее, мы только открыли файл, и согласитесь, что пока это не так интересно. Давайте попробуем прочитать файл.

    Чтение файла

    file.read(n) – Данный метод читает n количество знаков из файла, или если n – пусто, то читает полностью весь файл.
    file.readline(n) – Данный метод читает полностью весь файл.

    Итак, это может показаться небольшой путаницей. Во-первых, мы открываем файл, как и ожидалось. Далее, мы используем read(1), и обратите внимание, что мы предоставили аргумент 1, который просто означает, что мы хотим прочитать следующий символ. Так, Python печатает “Я” для нас, потому что это первый символ в файле test.txt. Что происходит дальше, немного странно. Мы даем задачу Питону прочитать весь файл при помощи read(). Но разве он не включает в себя тот символ, который мы уже прочитали? Так происходит потому, что Питон просто продолжит с того момента, где он был прерван. Так что, если Python уже прочитал «Я», он начнет чтение со следующего символа. Это сделано для того, чтобы вы могли пролистать содержимое файла без необходимости пропуска большого количества данных каждый раз, когда вы хотите перейти к новому символу. Питон ленив, он не хочет возвращаться и перечитывать содержимое.

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

    Происходит что-то странное… Во-первых, не берите в голову \n. Это всего лишь символ, означающий новую строку. Питон хочет сохранить существующий формат. Мы открываем файл как обычно, и создаем лист. Затем, мы разбиваем файл на линии, используя ключевые слова. Питон довольно сообразителен и понимает, что от него требуется. Потом, мы используем myList.append(line), чтобы добавить каждую линию в наш лист myList. Наконец, мы отправляем на печать и видим, что нам выдал Питон. Он разил каждую линию файла на строку (string), которыми мы впоследствии сможем делать то, что захотим.

    Подождите! Не забудьте закрыть файл!

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

    Поделитесь с друзьями:

    Python. Примеры работы с текстовыми файлами

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


    Содержание


    Поиск на других ресурсах:

    1. Чтение/запись списка, содержащего n целых чисел

    В примере демонстрируются следующие операции:

    • создание списка из 10 случайных чисел;
    • сохранение списка в текстовом файле;
    • чтение из файла в новый список с целью контроля.

    Текст программы следующий:

    # Запись/чтение списка случайных чисел
    # 1. Подключить модуль random
    import random
    
    # 2. Создать список из 10 случайных чисел
    i = 0
    lst = []
    while i<10:
        number = random.randint(0, 101) # число от 0 до 100
        lst = lst + [number]
        i = i+1
    
    print("lst = ", lst)
    
    # 3. Сохранить список в текстовом файле
    # 3.1. Открыть файл для записи
    f = open('file.txt', 'wt')
    
    # 3.2. Записать количество элементов в списке
    s = str(len(lst)) # Конвертировать целое число в строку
    f.write(s + '\n') # Записать строку
    
    # 3.3. Записать каждый элемент
    for i in lst:
        s = str(i) # конвертировать элемент списка в строку
        f.write(s + ' ') # записать число в строку
    
    # 4. Закрыть файл
    f.close()
    
    # -------------------------------------------
    # 5. Чтение из файла 'file.txt'
    f = open('file.txt', 'r')
    
    # 6. Прочитать из файла числа и сформировать список
    # 6.1. Прочитать количество элементов в списке,
    # сначала читается строка, затем эта строка
    # конвертируется в целое число методом int()
    s = f.readline()
    n = int(s)
    
    # 6.2. Создать пустой список
    lst2 = []
    
    # 6.3. Реализовать обход файла по строкам и считать числа.
    # Для чтения строк используется итератор файла.
    for line in f:
        # метод split - разбивает на слова на основании символа пробел
        strs = line.split(' ') # получить массив строк strs
    
        # Вывести strs с целью контроля
        print("strs = ", strs)
    
        # прочитать все слова и записать их в список как целые числа
        for s in strs:
            if s!='':
                lst2 = lst2 + [int(s)] # добавить число к списку
    
    # 6.4. Вывести результат для контроля
    print("n = ", len(lst2))
    print("lst2 = ", lst2)
    
    # 6.5. Закрыть файл - необязательно
    f.close()

    Результат работы программы

    lst = [48, 89, 1, 36, 68, 26, 61, 38, 1, 6]
    strs = ['48', '89', '1', '36', '68', '26', '61', '38', '1', '6', '']
    n = 10
    lst2 = [48, 89, 1, 36, 68, 26, 61, 38, 1, 6]

      ⇑

    2. Чтение/запись списка, содержащего строки

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

    # Запись/чтение списка строк
    # 1. Заданный список строк
    L = [ 'abc', 'bcd', 'cba', 'abd']
    
    # 2. Открыть файл для записи
    f = open('filestrs.txt', 'wt')
    
    # 3. Цикл записи строк
    
    for s in L:
        # записать каждую строку в отдельную строку файла
        f.write(s + '\n')
    
    # 4. Закрыть файл
    f.close()
    
    # -------------------------------------------
    # 5. Чтение из файла 'filestrs.txt'
    f = open('filestrs.txt', 'rt')
    
    # 6. Сформировать новый список
    lst2 = [] # сначала пустой список
    
    # 7. Реализовать обход файла по строкам и считать числа.
    # Для чтения строк используется итератор файла.
    for s in f:
        # Убрать последний символ '\n' из s
        s = s.rstrip()
    
        # Вывести s для контроля
        print("s = ", s)
    
        # Добавить строку s в список lst2
        lst2 = lst2 + [s]
    
    # 8. Вывести список lst2 для контроля
    print("lst2 = ", lst2)
    
    # 9. Закрыть файл - необязательно
    f.close()

    Результат работы программы

    s = abc
    s = bcd
    s = cba
    s = abd
    lst2 = ['abc', 'bcd', 'cba', 'abd']

      ⇑

    3. Чтение/запись кортежа, содержащего объекты чисел с плавающей запятой

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

    # Запись/чтение кортежа, содержащего объекты типа float.
    # 1. Исходный кортеж
    T1 = ( 3.8, 2.77, -11.23, 14.75)
    
    # 2. Запись кортежа в файл
    
    # 2.2. Открыть файл для записи в текстовом режиме
    f = open('myfile5.txt', 'wt')
    
    # 2.3. Цикл записи объектов в файл
    for item in T1:
        # 2.3.1. Конвертировать item в строку
        s = str(item)
    
        # 2.3.2. Записать строку + символ ' ' пробел
        f.write(s + ' ')
    
        # 2.4. Закрыть файл
        f.close()
    
    # 3. Чтение из файла, который содержит вещественные числа
    # и создание нового кортежа T2
    f = open('myfile5.txt', 'rt')
    
    # 3.1. Создать пустой кортеж T2
    T2 = ()
    
    # 3.2. Чтение данных из файла и образование кортежа
    for lines in f: # Использовать итератор файла
        # 3.2.1. Разбить строку lines на подстроки strings.
        # Любая подстрока strings[i] - это вещественное число,
        # представленное в строчном формате
        strings = lines.split(' ')
    
    # 3.2.2. Обойти все подстроки в файле,
    # конвертировать и добавить их к кортежу T2
    for s in strings:
        if s != '': # если непустая строка
            # Конвертировать в вещественное число
            num = float(s)
    
            # Добавить к кортежу
            T2 += (num,)
    
    # 3.3. Вывести кортеж для контроля
    print("T2 = ", T2) # T2 = (3.8, 2.77, -11.23, 14.75)
    
    # 3.4. Закрыть файл
    f.close()

    Результат работы программы

    T2 = (3.8, 2.77, -11.23, 14.75)

    Вид файла myfile5.txt

    3.8 2.77 -11.23 14.75

      ⇑



    4. Чтение/запись кортежа содержащего разнотипные объекты

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

    # Запись/чтение кортежа, содержащего разнотипные объекты
    # 1. Запись кортежа в файл
    
    # 1.1. Исходный кортеж
    T1 = ( 5, True, "abcde fghi")
    
    # 1.2. Открыть файл для записи в текстовом режиме
    f = open('myfile4.txt', 'wt')
    
    # 1.3. Поэлементная запись кортежа в файл,
    # поскольку в кортеже есть строки, то записываем
    # каждый элемент в отдельную строку
    for item in T1:
        s = str(item) + '\n' # добавить символ новой строки
        f.write(s)
    
    # Закрыть файл
    f.close()
    
    # 2. Чтение кортежа
    f = open('myfile4.txt', 'rt')
    
    # 2.1. Создать пустой кортеж
    T3 = ()
    
    # 2.2. Чтение данных из файла и создание кортежа
    # Первым читается число типа int
    s = f.readline()
    T3 = T3 + (int(s),) # конкатенация кортежей
    
    # Вторым читается логическое значение типа bool
    s = f.readline()
    T3 = T3 + (bool(s),)
    
    # Третьим читается строка типа str
    s = f.readline()
    s = s.rstrip() # убрать символ '\n' из строки
    T3 = T3 + (s,)
    
    # 2.3. Вывести кортеж для контроля
    print("T3 = ", T3) # T3 = (5, True, 'abcde fghi')
    
    # 2.4. Закрыть файл
    f.close()

    Результат выполнения программы

    T3 = (5, True, 'abcde fghi')

      ⇑

    5. Чтение/запись словаря

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

    # Запись/чтение словаря в текстовый файл.
    # Словарь содержит объекты типа {int:str}
    
    # 1. Исходный словарь - перечень дней недели и их номеров
    D = { 1:'Sun', 2:'Mon', 3:'Tue', 4:'Wed', 5:'Thu', 6:'Fri', 7:'Sat' }
    
    # 2. Запись словаря в файл
    
    # 2.1. Открыть текстовый файл для записи
    f = open('myfile6.txt', 'w')
    
    # 2.2. Цикл записи элементов словаря в файл
    for item in D:
        # 2.2.1. Сформировать строку вида key:value
        s = str(item) # взять ключ как строку
        s += ':' # добавить символ ':'
        s += D.get(item) # добавить значение value по его ключу
        s += '\n' # добавить символ новой строки
    
        # 2.2.2. Записать строку в файл
        f.write(s)
    
    # 2.3. Закрыть файл
    f.close()
    
    # 3. Чтение из файла, который содержит данные словаря D
    # 3.1. Открыть файл для чтения
    f = open('myfile6.txt', 'rt')
    
    # 3.2. Создать пустой словарь D2
    D2 = {}
    
    # 3.3. Чтение данных из файла и образование нового словаря
    for lines in f: # Использовать итератор файла
        # 3.3.1. Любая подстрока lines - это элемент вида key:value
        # представленный в строчном формате.
        # Разбить lines на 2 подстроки
        strings = lines.split(':')
    
        # 3.3.2. Получить ключ и значение
        key = int(strings[0]) # получить ключ
        value = strings[1].rstrip() # получить значение без '\n'
    
        # 3.3.3. Добавить пару key:value к словарю D2
        D2[key] = value
    
    # 3.4. Вывести словарь для контроля
    print("D2 = ", D2)
    
    # 3.5. Закрыть файл
    f.close()

    Результат работы программы

    D2 = {1: 'Sun', 2: 'Mon', 3: 'Tue', 4: 'Wed', 5: 'Thu', 6: 'Fri', 7: 'Sat'}

    Вид файла myfile6.txt

    1:Sun
    2:Mon
    3:Tue
    4:Wed
    5:Thu
    6:Fri
    7:Sat

      ⇑

    6. Чтение/запись двумерной матрицы целых чисел, представленной в виде списка

    В примере демонстрируется запись и чтение двумерной матрицы целых чисел размерностью 3*4.

    # Запись/чтение двумерной матрицы чисел
    # 1. Исходная матрица целых чисел размером 3*4
    M = [ [ 2, 1, -3],
          [ 4, 8, -2],
          [ 1, 2,  3],
          [ 7, -3, 8] ]
    
    # 2. Запись матрицы в текстовый файл
    
    # 2.1. Открыть текстовый файл для записи
    f = open('myfile8.txt', 'w')
    
    # 2.2. Цикл записи элементов матрицы в файл
    #      в удобном для отображения виде
    i = 0
    while i < 4: # цикл по строкам
        j = 0
        while j < 3: # цикл по столбцам
            s = str(M[i][j])
            f.write(s + ' ') # между числами символ ' ' пробел
            j = j+1
        f.write('\n')
        i = i + 1
    
    # 2.3. Закрыть файл
    f.close()
    
    # 3. Чтение матрицы из файла
    # 3.1. Открыть файл для чтения
    f = open('myfile8.txt', 'rt')
    
    # 3.2. Создать пустой список
    M2 = []
    
    # 3.3. Чтение данных из файла и образование новой матрицы
    
    i = 0
    for line in f: # Использовать итератор файла
        # Конвертировать строку line в список строк
        lines = line.split(' ') # разбить строку line на подстроки lines
    
        # временный список
        lst = []
    
        # обход элементов в строке
        for ln in lines:
            # забрать символ '\n'
            ln = ln.rstrip()
    
            if ln != '':
                num = int(ln) # взять отдельное число
                lst = lst + [num] # добавить число к списку
    
        M2 = M2 + [lst] # добавить строку к результирующей матрице
    
    # 3.4. Вывести матрицу M2 для контроля
    print("M2 = ", M2) #
    
    # 3.5. Закрыть файл
    f.close()

    Результат работы программы

    M2 = [[2, 1, -3], [4, 8, -2], [1, 2, 3], [7, -3, 8]]

    Вид файла myfile8.txt

    2 1 -3
    4 8 -2
    1 2 3
    7 -3 8

      ⇑

    7. Чтение/запись множества, которое содержит целые числа

    В примере демонстрируется возможный вариант сохранения множества в текстовом файле

    # Запись/чтение множества в текстовом файле.
    
    # 1. Задано множество целочисленных объектов
    M = { 2, 3, -12, 22, 38 }
    
    # 2. Запись множества в файл
    
    # 2.1. Открыть текстовый файл для записи
    f = open('myfile7.txt', 'w')
    
    # 2.2. Цикл записи элементов множества в файл
    for item in M:
        # 2.2.1. Конвертировать элемент множества в строку + '\n'
        s = str(item) + '\n'
    
        # 2.2.2. Записать строку в файл
        f.write(s)
    
    # 2.3. Закрыть файл
    f.close()
    
    # 3. Чтение множества из файла
    # 3.1. Открыть файл для чтения
    f = open('myfile7.txt', 'rt')
    
    # 3.2. Создать пустое множество
    M2 = set()
    
    # 3.3. Чтение данных из файла и образование нового множества
    for line in f: # Использовать итератор файла
        # Конвертировать строку line в целое число
        num = int(line)
        M2 = M2.union({num})
    
    # 3.4. Вывести множество для контроля
    print("M2 = ", M2) # M2 = {2, 3, -12, 38, 22}
    
    # 3.5. Закрыть файл
    f.close()

    Результат работы программы

    M2 = {2, 3, -12, 38, 22}

    Вид файла myfile7.txt

    2
    3
    38
    -12
    22

      ⇑

    8. Чтение/запись данных разных типов: список и кортеж

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

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

    # Запись/чтение данных разных типов.
    # Обработка списка и кортежа.
    # 1. Задан некоторый список строк и кортеж чисел
    L = [ 'John Johnson', 'Peter Petrov', 'O Neill', 'J. Dunkan' ]
    T = ( 2, 3.85, 7.77, -1.8, 5.25 )
    
    # 2. Запись данных в файл: сначала записывается список, затем кортеж
    # 2.1. Открыть текстовый файл для записи
    f = open('myfile9.txt', 'w')
    
    # 2.2. Записать количество элементов списка + '\n'
    f.write(str(len(L)) + '\n')
    
    # 2.3. Цикл записи элементов списка в файл
    # Каждый из элементов списка размещается в новой строке.
    for item in L: # обход списка
        f.write(item + '\n') # записать строку в файл
    
    # 2.4. После списка записывается кортеж,
    # каждый элемент кортежа размещается в отдельной строке.
    # Сначала записать количество элементов кортежа
    f.write(str(len(T)) + '\n')
    
    # обход кортежа в цикле
    for item in T:
        f.write(str(item) + '\n') # запись каждого элемента кортежа
    
    # 2.3. Закрыть файл
    f.close()
    
    # 3. Чтение списка и кортежа из файла
    # 3.1. Открыть файл для чтения
    f = open('myfile9.txt', 'rt')
    
    # 3.2. Создать результирующий пустой список
    # и результирующий кортеж
    L2 = []
    T2 = ()
    
    # 3.3. Чтение данных из файла и формирование списка L2
    n = int(f.readline()) # прочитать количество элементов в списке
    
    i = 0
    while i < n: # цикл чтения строк из файла и образования списка
        s = f.readline().rstrip() # прочитать строку без символа '\n'
        if (s != ''):
            L2 += [s]
        i = i + 1
    
    # 3.4. Прочитать количество элементов кортежа
    n = int(f.readline())
    
    i = 0
    while i < n: # цикл чтения строк и образование кортежа
        s = f.readline()
        if (s != ''):
            T2 = T2 + (float(s),) # добавить вещественное число к кортежу
        i = i+1
    
    # 3.5. Закрыть файл
    f.close()
    
    # Вывести список и кортеж для контроля
    print("L2 = ", L2)
    print("T2 = ", T2)

    Результат работы программы

    L2 = ['John Johnson', 'Peter Petrov', 'O Neill', 'J. Dunkan']
    T2 = (2.0, 3.85, 7.77, -1.8, 5.25)

    Вид файла myfile9.txt

    4
    John Johnson
    Peter Petrov
    O Neill
    J. Dunkan
    5
    2
    3.85
    7.77
    -1.8
    5.25

      ⇑


    Связанные темы

      ⇑


     

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

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

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

    my_file = open(filename, filemode)

    my_file = open(filename, filemode)

    Здесь filename — это строковый аргумент, который указывает имя файла вместе с его путем, а filemode также является строковым аргументом, который используется для указания способа использования файла, то есть для чтения или записи. И my_file — это объект обработчика файлов, также известный как указатель на файл.

    Пример:

    my_file = open(«my_file.txt», «r») # Open a file
    print («Name of the file: «, my_file.name)
    print («Opening mode : «, my_file.mode)

    my_file = open(«my_file.txt», «r») # Open a file

    print («Name of the file: «, my_file.name)

    print («Opening mode : «, my_file.mode)

    Вывод:

    Name of the file: my_file.txt
    Opening mode : r

    Name of the file: my_file.txt

    Opening mode : r

    В приведенном выше примере откройте текстовый файл с именем «my_file.txt» в режиме только чтения.

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

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

    Пример:

    my_file = open(«my_file.txt», «r») # Open a file
    # do file operations.
    my_file.close()

    my_file = open(«my_file.txt», «r») # Open a file

    # do file operations.

    my_file.close()

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

    Метод close() не совсем безопасен. Если возникает исключение, когда мы выполняем некоторую операцию с файлом, код выходит из него, не закрывая файл. Лучше использовать try … finally block.

    Пример:

    try:
    my_file = open(«my_file.txt», «r») # Open a file
    # do some file operations.
    finally:
    my_file.close()

    try:

    my_file = open(«my_file.txt», «r») # Open a file

    # do some file operations.

    finally:

    my_file.close()

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

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

    Пример:

    with open(«my_file.txt», «r») as my_file:
    # do some file operations

    with open(«my_file.txt», «r») as my_file:

    # do some file operations

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

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

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

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

    os.rename (old_file_name, new_file_name)

    os.rename (old_file_name, new_file_name)

    Пример:

    import os
    cur_file = «file1.txt»
    new_file = «file2.txt»
    os.rename(cur_file, new_file)

    import os

    cur_file = «file1.txt»

    new_file = «file2.txt»

    os.rename(cur_file, new_file)

    Удаление файла в Python

    Пример:

    import os
    cur_file = «file1.txt»
    os.remove(cur_file)

    import os

    cur_file = «file1.txt»

    os.remove(cur_file)

     

     

    Источник: net-informations.com

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

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

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

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

    
    
    file = open("text.txt") # Открытие файла
    
    file = open("C:/text.txt") #Открытие файла по его пути
    

    Существует несколько режимов открытия файла, r — для чтения, w — для записи, a — для добавления. По умолчанию Python использует режим чтение файла

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

    Режим открытия указывается следующим образом:

    
    
    f = open("text.txt") #Режим r по умолчанию
    
    f = open("text.txt", "w")# Режим записи в файл
    
    f = open("text.txt", "a") # Режим добавления
    
    

    Кроме того, надо учитывать кодировку файла, по умолчанию кодировка зависит от вашей операционной системы. Для Windows, кодировка cp1251, а для Linux utf — 8. Соответственно, что бы наша программа вела себя одинаково на разных платформах, лучшим решением будет указание явной кодировки.

    
    
    file = open("text.txt", "r", encoding = "utf-8" )
    
    

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

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

    
    
    file = open("text.txt", "r", encoding = "utf-8" )
    
    file.close()
    
    

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

    
    
    try:
    
        file = open("text.txt", "r", encoding = "utf-8" )
    
    finally:
    
        file.close()
    
    

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

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

    
    
    with open("text.txt", "r", encoding = "utf-8" ) as file:
    
    

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

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

    
    
    with open("text.txt", "r", encoding = "utf-8" ) as file:
    
        file.write("Моя первая запись\n")
    
        file.write("Еще немного\n")
    
    

    Приведенный выше код, создаст новый файл text.txt, если его не существует, если существует, то она будет перезаписана. При записи не забывайте про символ переноса на новую строку \n.

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

    Что бы открыть файл для чтения, мы используем режим r. Для чтения мы воспользуемся функцией read(size), если параметр size не указан, функция вернет нам всю строку.

    
    
    file = open("text.txt",'r', encoding = 'utf-8')
    
    file.read(3)
    
    file.read()
    
    Результат:
    
    "Моя"
    
    "Моя первая запись"
    
    

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

    
    
    for line in file:
    
        print(line,end='')
    Результат:
    
    Моя первая запись
    
    Еще немного
    

    Методы работы с файлами

    Методы Описание
    close() Закрывает открытый файл.
    detach()
    fileno() Возвращает целое число (файловый дескриптор) файла.
    flush() Сбрасывает буфер записи потока файлов.
    isatty() ВОЗВРАТ True если файловый поток является интерактивным.
    read(n) Читает самое большее n символы из файла. Читает до конца файла, если он отрицательный или None.
    readable() ВОЗВРАТ True если файловый поток можно прочитать.
    readline(n=-1) Считывает и возвращает одну строку из файла
    readlines(n=-1) Считывает и возвращает список строк из файла
    seek(offset,from=SEEK_SET)
    seekable() ВОЗВРАТ True если файловый поток поддерживает произвольный доступ.
    tell() Возвращает текущее местоположение файла.
    truncate(size=None) Изменяет размер потока файлов следующим образом size байты. Если size не указан, изменяет размер до текущего местоположения.
    writable() ВозвращаетTrue, если файловый поток может быть записан.
    write(s) Записывает строку sв файл и возвращает количество записанных символов.
    writelines(lines) Записывает список lines в файл.

     

    Как открывать, читать и писать текстовые файлы в Python [с примерами]

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

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

    Приступим!

    Предварительные требования

    Это руководство представляет собой пошаговое руководство.Если вы хотите продолжить, убедитесь, что у вас есть следующее:

    • Python v3.6 или новее — в этом руководстве будет использоваться Python v3.9.2 на компьютере с Windows 10.

    Связано: как установить Python 3.6?

    Открытие текстового файла с помощью Python

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

    1. Откройте ваш любимый редактор кода; предпочтительно такой, как VS Code.

    2. Создайте простой текстовый файл в домашнем каталоге (~) и назовите его DevOps.txt с текстом * «* Здравствуйте, друзья ATA».

    3. Теперь создайте файл и скопируйте в него код Python, показанный ниже, а затем сохраните его как сценарий Python с именем ata_python_read_file_demo.py в своем домашнем каталоге.

      # newfile - это объект файла, DevOps.txt - это файл, который нужно открыть, и режим доступа по умолчанию читается
     newfile = open ('DevOps.txt')
    # Объявление режима доступа "только чтение"
    # newfile = open ('DevOps.txt', 'r')
     печать (новый файл)  

    Приведенный выше сценарий содержит встроенный в Python метод open () , который открывает DevOps .txt для чтения без объявления режима доступа. Затем метод open () возвращает файловый поток, который фиксируется в переменной newfile .

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

    • r — Открыть файл для чтения.Это режим доступа по умолчанию.
    • w — Открыть файл для записи.
    • x — Эта опция создает новый файл, если он не существует, но не работает, если он уже существует.
    • a — открывает файл для записи и добавляет данные в конец файла.
    • b — открывает файл в двоичном режиме. Этот режим используется для работы с файлами, отличными от текста, такими как pdf, изображения и т. Д.
    • t — Открыть файл в текстовом режиме.Это режим «по умолчанию».
    • + — открывает файл для чтения или записи.

    4. Теперь запустите сценарий Python.

      Python ata_python_read_file_demo.py  

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

    Открытие текстового файла с помощью Python

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

    Чтение текстового файла с помощью Python

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

    Откройте сценарий Python ata_python_read_file_demo.py в редакторе кода сверху, замените текст следующим кодом Python, сохраните и выполните его.

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

      # Чтение файла как одного файлового потока
    файл = открытый ('DevOps.txt', 'г')
    # Читает сразу весь файл и помещает его содержимое в память.
    read_content = a.read ()
    печать (read_content)
    
    # Итерации по каждой строке в текстовом файле с ключевым словом with
    # и чтение каждой строки по очереди
    с open ('DevOps.txt', 'r') в виде строки:
    # Читает определенную строку текста в файле.
    line_text = c.readline ()
    печать (текст_строки)
    
    # Итерации по каждой строке в текстовом файле с ключевым словом with
    # и чтение первых пяти символов каждой строки
    с открытым ('DevOps.txt ',' r ') в виде строки:
    # Читает определенное количество символов из одной строки текста в файле.
    read_char = строка.read (5)
    печать (read_char)  

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

    Чтение файла CSV с помощью Python

    Вы узнали, что Python может открывать простые текстовые файлы. Файлы CSV, по сути, представляют собой просто текстовые файлы с определенной схемой. Вы, , могли бы использовать метод open (), , используя метод read () или readline () для чтения строк CSV, но это было бы не слишком полезно.Почему? Потому что читают методы не понимают схему файла CSV.

    По теме: что такое CSV-файл, как создавать, открывать и работать с ними

    Чтобы прочитать файл CSV, чтобы Python понимал данные, хранящиеся в CSV, используйте модуль CSV Python.

    Предполагая, что вы все еще находитесь в редакторе кода:

    1. Откройте другую вкладку и вставьте следующие данные CSV и сохраните их как ata_csv_demo.csv . Вы увидите, что данные CSV содержат четыре столбца и четыре строки.

      Дата, PreviousUserCount, UserCountTotal, страница сайта
     02-01-2021,61,5336, ATA.com/blog
     03-01-2021, 42,5378, ATA.com/blog1
     04-01-2021, 26,5404, ATA.com/blog2
     05.01.2021, 65,5469, ATA.com/blog3  

    2. Теперь откройте другую вкладку, создайте следующий сценарий Python, сохраните его как сценарий Python с именем по вашему выбору. Этот скрипт Python ниже:

    1. Импортирует модуль csv , чтобы сделать методы доступными.
    2. Открывает ata_csv_demo.csv для чтения.
    3. Считывает каждую строку в файле CSV с помощью метода reader () , сообщая Python, что строка разделена запятой.
    4. Использует цикл для для чтения текста в каждой строке, возвращая список Python для каждой записи CSV.
      # Импортировать модуль CSV
     импорт csv
     
    # Откройте файл CSV для чтения и начните перебирать каждую строку
     с open ('ata_csv_demo.csv', 'r') как csv_row:
         ## Разобрать строку как разделенную запятыми
         csv_data = csv.читатель (csv_row, delimiter = ',')
       # Вывести определенные строки из файлов csv с помощью цикла for и выполнить итерацию по функции range () 
     для _ в диапазоне (5):
           печать (далее (csv_data))
     распечатать (прочитать)  

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

    Вывод при чтении только 5 строк из файла CSV

    Добавление к текстовому файлу с помощью Python

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

    Вы можете записать в текстовый файл одним из двух способов:

    • write () — Записывает содержимое в виде строки в файл.
    • Writelines () — Записывает в файл несколько строк одновременно.

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

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

      # Откройте файл для добавления (a) и начните читать каждую строку
    с open ('DevOps.txt', 'a') как файл:
         file.write ("\ nДобавление еще 5 друзей ATA")
         file.writelines (['\ nДобавление еще 5 друзей ATA', '\ nДобавление еще 15 друзей ATA'])
      

    добавить данные в текстовый файл

    Запись данных в файл CSV с помощью Python

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

    Чтобы добавить строки в тот же файл DevOps.csv , который вы создали ранее, откройте новую вкладку редактора кода и вставьте следующий скрипт Python в свой редактор кода, сохраните и выполните его.

      # импорт модуля csv
     импорт csv
    # открыть функцию в операторе with
     Здесь вы использовали новую строку, поскольку модуль csv выполняет свою (универсальную) обработку новой строки.с open ('DevOps.csv', 'a', newline = '') как csv_file: # функция open () вместе с режимом добавления "a" и новой строкой = ''
         write_csv = csv.writer (csv_file, delimiter = ',') # csv.writer () используется для записи содержимого в файл CSV
         write_csv.writerow (['08-08-2021', '68', '8888', 'ATA.com/blog8']) # csv.writerow () для добавления строки и добавления содержимого Выполните сценарий writing_into_csv.py, используя Python,  

    Откройте файл DevOps.csv и посмотрите последнюю строку!

    Добавленная строка в файл CSV

    Заключение

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

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

    Python Open File — Как читать текстовый файл построчно

    В Python есть несколько способов чтения текстового файла.

    В этой статье я рассмотрю функцию open () , read () , readline () , readlines () , close () методы и с ключевым словом . .

    Что такое функция open () в Python?

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

    Это основной синтаксис для функции Python open () :

      open («имя файла, который вы хотите открыть», «дополнительный режим»)  

    Имена файлов и правильные пути

    Если текстовый файл и ваш текущий файл находится в том же каталоге («папке»), тогда вы можете просто указать имя файла в функции open () .

      open ("demo.txt")  

    Вот пример, когда оба файла находятся в одном каталоге:

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

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

    Чтобы получить доступ к этому файлу в main.py , вы должны включить имя папки с имя файла.

      open ("text-files / random-text.txt")  

    Если у вас нет правильного пути к файлу, вы получите такое сообщение об ошибке:

      open ("random -text.txt ")  

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

    Необязательный параметр режима в

    open ()

    При работе с файлами существуют разные режимы. Режим по умолчанию — это режим чтения.

    Буква r обозначает режим чтения.

      open ("demo.txt", mode = "r")  

    Вы также можете опустить mode = и просто написать "r" .

      открыть ("demo.txt", "r")  

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

    Полный список других режимов можно найти в документации.

    Дополнительные параметры для функции

    open () в Python

    Функция open () может принимать эти необязательные параметры.

    • буферизация
    • кодирование
    • ошибки
    • новая строка
    • closefd
    • opener

    Чтобы узнать больше об этих необязательных параметрах, прочтите документацию.

    Что такое метод readable () в Python?

    Если вы хотите проверить, можно ли прочитать файл, вы можете использовать метод readable () .Это вернет True или False .

    Этот пример вернет True , потому что мы находимся в режиме чтения:

      file = open ("demo.txt")
    print (file.readable ())  

    Если я изменил этот пример на режим "w" (запись), тогда метод readable () вернет False :

      file = open (" demo.txt "," w ")
    print (file.readable ())  

    Что такое метод read () в Python?

    Метод read () будет читать все содержимое файла как одну строку.Это хороший метод, если у вас мало содержимого в текстовом файле.

    В этом примере я использую метод read () для распечатки списка имен из файла demo.txt :

      file = open ("demo.txt")
    print (file.read ())  

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

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

      file = open ("demo.txt")
    print (file.read (4))  

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

    Что такое метод close () в Python?

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

    Это пример того, как закрыть файл demo.txt :

      file = open ("demo.txt")
    распечатать файл.читать())
    file.close ()  

    Как использовать

    с ключевым словом для закрытия файлов в Python

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

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

      с открытым ("demo.txt") как файлом:
        print (file.read ())  

    Что такое метод readline () в Python?

    Этот метод будет читать одну строку из файла и возвращать ее.

    В этом примере у нас есть текстовый файл с этими двумя предложениями:

      Это первая строка
    Это вторая строка.  

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

      с открытым ("demo.txt") как файл:
        print (file.readline ())  

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

      с open ("demo.txt ") в виде файла:
        print (file.readline (7))  

    Что такое метод readlines () в Python?

    Этот метод считывает и возвращает список всех строк в файле.

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

      с открытым ("demo.txt") как файл:
        print (file.readlines ())  

    Как использовать цикл for для чтения строк из файла в Python

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

    В этом примере мы можем распечатать все элементы в файле demo.txt , перебирая объект в цикле.

      с открытым ("demo.txt") как файл:
        для элемента в файле:
            print (item)  

    Заключение

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

      open («имя файла, который вы хотите открыть», «дополнительный режим»)
      

    Если текстовый файл и текущий файл находятся в одном каталоге («папке»), то вы можете просто указать имя файла в функции open () .

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

    Функция open () принимает необязательный параметр режима. Режим по умолчанию — это режим чтения.

      open ("demo.txt", "r")  

    Если вы хотите проверить, можно ли прочитать файл, вы можете использовать метод readable () . Это вернет True или False .

      файл.readable ()  

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

      file.read ()  

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

      file.close ()  

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

      с открытым ("demo.txt") как файл:
        распечатать файл.read ())  

    Метод readline () будет читать одну строку из файла и возвращать ее.

      file.readline ()  

    Метод readlines () будет читать и возвращать список всех строк в файле.

      file.readlines ()  

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

      с открытым ("demo.txt") как файл:
        для элемента в файле:
            print (item)  

    Надеюсь, вам понравилась эта статья, и желаю удачи в вашем путешествии по Python.

    7 примеров Python open () для чтения / записи файлов — операции с файлами ввода / вывода

    Чтобы выполнять операции ввода / вывода (I / O) в файлах, вы должны открыть файл. Функция Python open () используется для открытия указанного файла, в котором вы можете выполнять чтение, запись и другие операции.

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

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

    Синтаксис использования функции open ():

    открыть (файл, режим = ’r’, буферизация = -1, кодировка = Нет, ошибки = Нет, новая строка = Нет)

    Параметры функции открытия поясняются ниже:

    • файл — Параметр файла указывает относительный путь к текущему рабочему каталогу или абсолютный путь к файлу, который вы хотите открыть и выполнить некоторую операцию. Если файл не открывается, возникает ошибка (OSError).
    • режим — Здесь вы указываете цель открытия файла. Например, значение ‘r’ (по умолчанию) открывает файл в режиме чтения для текстовых файлов. Если вам требуется запись в текстовый файл, используйте режим ‘w’ . Чтобы открыть файл в режиме записи для добавления текста, используйте значение ‘a’ . Подробный список режимов приведен в последнем разделе.
    • buffering — Включите или выключите буферизацию, используя целочисленное значение.Значение 1 — это буферизация строки в текстовом режиме. Для выключения буферизации в двоичном режиме используйте значение 0 . Это необязательный параметр. Таким образом, если не указано иное, применяется политика буферизации по умолчанию.
    • новая строка — этот параметр применяется только к текстовому режиму и используется для указания универсальных новых строк. Могут использоваться следующие значения: \ n, \ r, \ r \ n, None и ‘’ .

    Пример чтения файла методом чтения функции open ()

    В этом примере текстовый файл открывается в режиме только для чтения с использованием значения ‘r’ для параметра режима в функции Python open () file.Текст файла readme.txt отображается на экране. Файл readme.txt находится в том же месте, где находится исходный файл Python:

    Посмотреть онлайн-демонстрацию и код

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    140002

    14

    18

    19

    # Пример функции open () для чтения текстового файла

    objFile = open («readme.txt «,» r «)

    fileContent = objFile.read ();

    print (» Текстовый файл содержит: «, fileContent)

    # After выполняя операцию, закройте файл

    objFile.close ()

    В программе следует отметить следующее:

    • Прежде всего, создается файловый объект и используется функция open ().
    • В функции open () указывается относительный путь к файлу readme.txt.
    • Параметр режима — «r», что означает открытие файла в режиме только для чтения.
    • Содержимое файла считывается с помощью метода Python read () функции open ().
    • Функция печати отображает содержимое файла.
    • Наконец, функция close () используется для закрытия файла.

    Пример записи в файл методом write ()

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

    Для демонстрации содержимого файла «readme.txt» изначально является «Hello World Python». Это отображается перед открытием файла в режиме только для чтения.

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

    Посмотреть онлайн-демонстрацию и код

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    140002

    14

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    000

    000 34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    # Пример функции open () для чтения текстового файла

    objRead1 = open («readme.txt «,» r «)

    ContFile = objRead1.read ();

    print (» Content before write (): «, ContFile)

    # Закрытие первого экземпляра

    objRead1.close ()

    # Открытие снова для записи в файл

    objWrite = open («readme.txt», «w»)

    obj Использование ‘w’ для записи текста в файл «)

    # Закрытие файла в режиме записи

    objWrite.close ()

    # Повторное открытие файла для отображения содержимого после записи

    objRead2 = open («readme.txt», «r»)

    ContAfterWrite = objRead2.read ;

    print («Содержимое после записи ():», ContAfterWrite)

    objRead2.close ()

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

    Использование примера режима добавления

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

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

    Посмотреть онлайн-демонстрацию и код

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    140002

    14

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    000

    000 34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    # Пример режима добавления

    objRead1 = open («readme.txt «,» r «)

    ContFile = objRead1.read ();

    print (« Содержимое перед добавлением текста: », ContFile)

    # Закрытие первого экземпляра

    objRead1.close ()

    # Открыть файл в режиме добавления

    objAppend = open («readme.txt», «a»)

    objAppend удалить текст.. \ nПросто добавьте перед существующим текстом! Спасибо «)

    # Закрытие файла в режиме добавления

    objAppend.close ()

    #Open и чтение после добавления

    (0 9000Read («readme.txt», «r»)

    ContAfterAppend = objRead2.read ();

    print («Содержимое после append ():», ContAfterAppend)

    ad

    0002 .закрыть ()

    Как видите, новое содержимое добавляется перед существующим текстом. Новая строка «\ n» используется для написания текста в следующей строке.

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

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

    # Прочитать файл размером

    objFile = open («readme.txt «,» r «)

    fileContent = objFile.read (10);

    print (» Чтение ограниченных данных: «, fileContent)

    objFile.close ()

    Вывод:

    Чтение ограниченных данных: Python Hel

    >>>

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

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

    Python читать построчно, пример

    Вы можете использовать цикл for для перебора файлового объекта для построчного чтения. Взгляните на этот пример, где я написал несколько строк текста в файле readme.txt:

    # Прочитать файл построчно

    objFile = open («readme.txt», «r»)

    для построчно в objFile:

    строка

    печать

    , конец = »)

    objFile.закрыть ()

    Вывод:

    Строка 1 — Python крутой

    Строка 2 — Python великолепен

    Строка 3 — Python — это круто

    Строка 4 — Обожаю !!!

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

    Пример метода readline () для чтения построчно

    Метод readline () также можно использовать для чтения одной строки из файла.В этом случае символ новой строки остается в конце строки. Новая строка опускается в последней строке.

    # Прочитать файл readline ()

    objFile = open («readme.txt», «r»)

    print (objFile.readline ());

    печать (objFile.readline ());

    objFile.закрыть ()

    Вывод:

    Чтение всех строк в примере списка

    Вы также можете прочитать все строки файла в список. См. Пример ниже:

    # Прочитать файл в примере списка

    objFile = open («readme.txt», «r»)

    a_list = list (objFile)

    a_list)

    objFile.закрыть ()

    Вывод:

    [‘Python \ n’, ‘Read \ n’, ‘Write \ n’, ‘Read \ n’, ‘Open \ n’, ‘Close \ n’, ‘\ n’]

    Список режимов

    • ‘r’ — значение по умолчанию, которое используется для открытия файла только в режиме чтения.
    • ‘r +’ открывает файл в режиме чтения и записи.
    • ‘w’ Текстовый файл открыт только для записи. Обрезает содержимое текстового файла.
    • «rb» — открывает файл в двоичном формате — только для чтения.
    • ‘rb +’ — двоичный режим. Прочитайте и напишите.
    • ‘wb’ — двоичный режим — только запись.
    • ‘a’ — Создает новый файл, если он не существует. Используется для добавления в конец файла. Таким образом, существующее содержимое остается на месте.
    • ‘a +’ — файл откроется для чтения и добавления.

    Полезные ссылки по теме: Ключевое слово with как выполнение операций ввода-вывода в файлах.

    Как читать и записывать файлы в Python 3

    Введение

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

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

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

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

    Предварительные требования

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

    Фон

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

    Тип файла Описание
    текст В текстовом файле хранятся данные, представляющие только символы (или строки), и исключаются любые структурированные метаданные
    CSV В файле значений, разделенных запятыми, используются запятые (или другие разделители) для структурирования хранимых данных, что позволяет сохранять данные в формате таблицы
    HTML Файл языка разметки гипертекста хранит структурированные данные и обычно используется на большинстве веб-сайтов
    JSON Нотация объектов JavaScript — это простой и эффективный формат, который делает его одним из наиболее часто используемых форматов для хранения и передачи данных

    В этом руководстве основное внимание уделяется файловому формату txt .

    Шаг 1. Создание текстового файла

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

    В новом файле введите несколько строк текста. В этом примере давайте перечислим дни недели:

    days.txt

      Понедельник
    вторник
    среда
    четверг
    Пятница
    Суббота
    Воскресенье
      

    Затем сохраните файл и убедитесь, что знаете, куда вы его поместили.В нашем примере наш пользователь sammy сохранил файл здесь: /users/sammy/days.txt . Это будет очень важно на следующих этапах, когда мы откроем файл в Python.

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

    Шаг 2 — Открытие файла

    Прежде чем мы сможем написать нашу программу, мы должны создать программный файл Python, поэтому создайте файл files.py в текстовом редакторе. Чтобы упростить задачу, сохраните его в том же каталоге, что и наши дней.txt файл: / users / sammy / .

    Чтобы открыть файл в Python, нам сначала нужно каким-то образом связать файл на диске с переменной в Python. Этот процесс называется , открытие файла. Мы начинаем с того, что сообщаем Python, где находится файл. Местоположение вашего файла часто обозначается как путь к файлу . Чтобы Python мог открыть ваш файл, ему требуется путь. Путь к нашему файлу days.txt : /users/sammy/days.txt . В Python мы создадим строковую переменную для хранения этой информации.В нашем сценарии files.py мы создадим переменную path и установим для нее путь days.txt.

    files.py

      путь = '/users/sammy/days.txt'
      

    Затем мы воспользуемся функцией Python open () , чтобы открыть наш файл days.txt . Функция open () требует в качестве первого аргумента путь к файлу. Функция также позволяет использовать многие другие параметры. Однако наиболее важным является необязательный параметр mode .Mode — необязательная строка, определяющая режим, в котором открывается файл. Выбранный вами режим будет зависеть от того, что вы хотите делать с файлом. Вот некоторые из наших вариантов режима:

    • 'r' : использовать для чтения
    • 'w' : использовать для записи
    • 'x' : использовать для создания и записи в новый файл
    • 'a' : использовать для добавления в файл
    • 'r +' : использовать для чтения и записи в один и тот же файл

    В этом примере мы хотим только читать из файла, поэтому мы будем использовать режим 'r' .Мы воспользуемся функцией open () , чтобы открыть файл days.txt и присвоить его переменной days_file .

    files.py

      days_file = open (путь, 'r')
      

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

    Шаг 3 — Чтение файла

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

    Первая операция <файл> .read () возвращает все содержимое файла в виде одной строки.

      days_file.read ()
      
      

    Выход

    'Понедельник \ n Вторник \ n Среда \ n Четверг \ n Пятница \ n Суббота \ nВоскресенье \ n'

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

      days_file.readline ()
      
      

    Вывод

    'Понедельник \ n'

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

      days_file.readline ()
      
      

    Выход

    'Вторник \ n'

    Последняя операция, <файл>.readlines () возвращает список строк в файле, где каждый элемент списка представляет одну строку.

      days_file.readlines ()
      
      

    Вывод

    ['понедельник \ n', 'вторник \ n', 'среда \ n', 'четверг \ n', 'пятница \ n', 'суббота \ n', 'воскресенье \ n']

    Следует помнить о том, что при чтении из файлов, после того, как файл был прочитан с помощью одной из операций чтения, он не может быть прочитан снова. Например, если вы сначала запустите days_file.read () , за которым следует days_file.readlines () , вторая операция вернет пустую строку. Следовательно, в любое время, когда вы захотите прочитать из файла, вам придется сначала открыть новую файловую переменную. Теперь, когда мы прочитали из файла, давайте узнаем, как записать в новый файл.

    Шаг 4 — Запись файла

    На этом этапе мы собираемся написать новый файл, который будет включать заголовок «Дни недели», за которым следуют дни недели. Во-первых, давайте создадим нашу переменную title .

    files.py

      title = 'Дни недели \ n'
      

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

    files.py

      путь = '/users/sammy/days.txt'
    days_file = open (путь, 'r')
    days = days_file.читать()
      

    Теперь, когда у нас есть переменные для заголовка и дней недели, мы можем начать запись в наш новый файл. Во-первых, нам нужно указать расположение файла. Опять же, мы будем использовать каталог / users / sammy / . Нам нужно будет указать новый файл, который мы хотим создать. Итак, наш путь на самом деле будет /users/sammy/new_days.txt . Мы предоставляем информацию о нашем местоположении в переменной new_path . Затем мы открываем наш новый файл в режиме записи, используя функцию open () с указанным режимом 'w' .

    files.py

      new_path = '/users/sammy/new_days.txt'
    new_days = open (новый_путь, 'w')
      

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

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

    files.py

      new_days.write (заголовок)
    печать (заголовок)
    
    new_days.write (дни)
    печать (дни)
      

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

    Шаг 5 — Закрытие файла

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

    files.py

      days_file.close ()
    new_days.close ()
      

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

    Шаг 6 — Проверка нашего кода

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

    files.py

      путь = '/users/sammy/days.txt'
    days_file = open (путь, 'r')
    days = days_file.read ()
    
    
    new_path = '/users/sammy/new_days.txt'
    new_days = open (новый_путь, 'w')
    
    title = 'Дни недели \ n'
    new_days.write (заголовок)
    печать (заголовок)
    
    new_days.write (дни)
    печать (дни)
    
    days_file.close ()
    new_days.close ()
      

    После сохранения кода откройте терминал и запустите сценарий Python, например:

      

    Наш результат должен выглядеть так:

      

    Вывод

    дней недели понедельник вторник среда четверг Пятница Суббота Воскресенье

    Теперь давайте дважды проверим, что наш код полностью работает, открыв новый файл ( new_days.txt ). Если все прошло хорошо, когда мы откроем наш новый файл, он должен выглядеть так:

    new_days.txt

      Дни недели
    понедельник
    вторник
    среда
    четверг
    Пятница
    Суббота
    Воскресенье
      

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

    Заключение

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

    Открытие файлов и чтение из файлов

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

    Давайте сразу перейдем к примеру кода. Представьте, что у вас есть файл с именем example.txt в текущем каталоге. Если вы этого не сделаете, просто создайте его, а затем заполните его этими строками и сохраните:

      привет мир
    и сейчас
    Я говорю
    до свидания
      

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

      myfile = open ("example.txt")
    txt = myfile.read ()
    печать (txt)
    myfile.close ()
      

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

      myfile = open ("example.txt")
    печать (myfile.read ())
    myfile.close ()
      

    Вот как прочитать этот файл построчно, используя цикл for:

      myfile = open ("example.txt")
    для строки в myfile:
        печать (строка)
    myfile.close ()
      

    (Примечание: если вы получаете FileNotFoundError уже — этого почти следовало ожидать.Продолжайте читать!)

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

    А теперь давайте рассмотрим это по шагам.

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

      myfile = open ("example.текст")
      

    Это кажется достаточно простым, поэтому давайте перейдем к некоторым распространенным ошибкам.

    Как напортачить при открытии файла

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

      FileNotFoundError: [Errno 2] Нет такого файла или каталога: 'SOME_FILENAME'
      

    На самом деле, я видел, как студенты тратили десятки часов, пытаясь обойти это сообщение об ошибке, потому что они не останавливаются, чтобы прочитать его .Итак, прочитал это : Что означает FileNotFoundError ?

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

      Ошибка файла не найдена
      

    Вы получите эту ошибку, потому что вы пытались открыть файл, которого просто не существует. Иногда это простая опечатка: open () пытается открыть файл с именем "example.txt" , но случайно неправильно написала его как "exmple.txt" .

    Но чаще всего это происходит потому, что известно, что файл существует под заданным именем файла, например, "например.txt " — но как ваш код Python узнает, где находится этот файл? Это " example.txt ", который существует в вашей папке Downloads ? Или тот, который может существовать в вашей папке Documents ? Или тысячи других папок в вашей компьютерной системе?

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

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

    Как исправить ошибку FileNotFoundError

    Вот верное решение: убедитесь, что файл действительно существует.

    Начнем с нуля, сделав ошибку. В системной оболочке (т.е. в Терминале) перейдите в папку Desktop :

      $ cd ~ / Рабочий стол
      

    Теперь запустите ipython :

      $ ipython
      

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

      >>> myfile = open ("whatdude.текст")
      
      ------------------------------------------------ ---------------------------
    FileNotFoundError Traceback (последний вызов последним)
     в  ()
    ----> 1 myfile = open ("whatdude.txt")
    
    FileNotFoundError: [Errno 2] Нет такого файла или каталога: 'anydude.txt'
      

    Теперь вручную создайте файл на рабочем столе , используя Sublime Text 3 или что угодно.Добавьте к нему текст и сохраните его.

      это
    мой
    файл
      

    Посмотрите и убедитесь сами, что этот файл действительно существует в вашей папке Desktop :

    Хорошо, теперь переключитесь обратно на интерактивную оболочку Python (например, ipython ), ту, которую вы открыли после перехода в папку Desktop (например, cd ~ / Desktop ). Повторно запустите команду open () , которая привела к ошибке FileNotFoundError :

      >>> myfile = open ("whatdude.текст")
      

    Надеюсь, вы не получите ошибку.

    Но что это за объект, на который указывает переменная myfile ? Используйте метод type () , чтобы выяснить это:

      >>> тип (myfile)
     _io.TextIOWrapper
      

    А что это за , что за ? Детали не важны, кроме как указать, что myfile определенно не просто строковый литерал, то есть str .

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

      myfile.buffer myfile.isatty myfile.readlines
    myfile.close myfile.line_buffering myfile.seek
    myfile.closed myfile.mode myfile.seekable
    myfile.detach myfile.name myfile.tell
    myfile.encoding myfile.newlines myfile.truncate
    myfile.errors myfile.read myfile.writable
    мой файл.fileno myfile.readable myfile.write
    myfile.flush myfile.readline myfile.writelines
      

    Что ж, с файлами мы можем делать гораздо больше, чем просто read () из них. Но давайте пока сосредоточимся на чтении.

    Предполагая, что переменная myfile указывает на какой-то файловый объект, вы читаете из нее вот так:

      >>> mystuff = myfile.read ()
      

    Что находится в этой переменной mystuff ? Снова используйте функцию type () :

      >>> тип (mystuff)
    ул.
      

    Это просто строка.Что, конечно же, означает, что мы можем его распечатать:

      >>> печать (mystuff)
    это
    мой
    файл
      

    Или посчитайте количество символов:

      >>> len (mystuff)
    15
      

    Или распечатайте прописными буквами:

      >>> print (mystuff.upper ())
    ЭТО
    МОЙ
    ФАЙЛ
      

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

    Теперь об ошибках.

    Как напортачить при чтении из файла

    Вот очень-очень распространенная ошибка:

      >>> filename = "пример.текст"
    >>> filename.read ()
      

    Вывод ошибки:

      AttributeError Traceback (последний вызов последним)
     в <модуль> ()
    ----> 1 имя_файла.read ()
    
    AttributeError: объект 'str' не имеет атрибута 'read'
      

    Обратите внимание, что это , а не , а FileNotFoundError . Это AttributeError — что, по общему признанию, не очень понятно — но прочтите следующую часть:

      объект 'str' не имеет атрибута 'read'
      

    Сообщение об ошибке доходит до сути: объект str — i.е. строковый литерал, например что-то вроде "hello world" не имеет атрибута read .

    Возвращаясь к ошибочному коду:

      >>> filename = "example.txt"
    >>> filename.read ()
      

    Если filename указывает на «example.txt», тогда filename — это просто объект str .

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

      >>> "пример.txt ".read ()
      

    И бить по голове:

      >>> "привет мир, это всего лишь строка" .read ()
      

    Почему это такая частая ошибка? Потому что в 99% наших типичных взаимодействий с файлами мы видим имя файла в графическом интерфейсе рабочего стола и дважды щелкаем по нему, чтобы открыть его. Графический интерфейс запутывает процесс — и не зря. Какая разница, что происходит, если мой файл открывается, когда я дважды щелкаю по нему!

    К сожалению, мы должны проявлять осторожность, пытаясь прочитать файл программно. Открытие файла — это отдельная операция от чтения его.

    • Вы открываете файл, передавая его имя файла — например, example.txt — в функцию open () . Функция open () возвращает файловый объект.
    • Чтобы на самом деле прочитать содержимое файла, вы вызываете метод read () этого файлового объекта.

    Опять же, вот код, немного более подробный:

      >>> myfilename = "пример.текст"
    >>> myfile = open (myfilename)
    >>> mystuff = myfile.read ()
    >>> # сделать что-нибудь с mystuff, например, распечатать или что-то в этом роде
    >>> myfile.close ()
      

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

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

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

      >>> myfile = open ("example.текст")
    >>> mystuff = myfile.read ()
      

    Сейчас это не кажется таким уж большим делом, но это потому, что example.txt , вероятно, содержит всего несколько строк. Но когда мы имеем дело с файлами размером огромных — как и все 3,3 миллиона записей всех, кто пожертвовал более 200 долларов единственному комитету президентской кампании США в 2012 году или всех, кто когда-либо посещал Белый дом — открываем и читаем файл все сразу заметно медленнее. И это может даже привести к сбою вашего компьютера.

    Если вам интересно, почему программное обеспечение для работы с электронными таблицами, такое как Excel, имеет ограничение на количество строк (примерно 1 000 000), это потому, что большинство пользователей хотят работать с файлом данных одновременно. Однако многие интересные файлы данных слишком велики для этого. Мы столкнемся с этими сценариями позже в этом квартале.

    А пока вот как обычно выглядит построчное чтение:

      myfile = open ("example.txt")
    для строки в myfile:
        печать (строка)
    myfile.close ()
      

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

    Чтобы избавиться от этого эффекта, вызовите метод strip () , который принадлежит к объектам str и удаляет символы пробела с левой и правой стороны текстовой строки:

      myfile = open ("example.txt")
    для строки в myfile:
        печать (line.strip ())
    myfile.close ()
      

    И, конечно же, вы можете сделать вещи громкими с помощью старой доброй функции upper () :

      myfile = open ("example.текст")
    для строки в myfile:
        печать (line.strip ())
    myfile.close ()
      

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

    Лучшая практика чтения текстовых файлов в Python | Кристофер Тао

    Объедините несколько файлов в один поток с более богатыми метаданными

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

    Это уже лучшая практика и более простых способов быть не может. Однако, когда мы хотим читать контент из нескольких файлов, определенно есть лучший способ. То есть с помощью модуля «Ввод файла», встроенного в Python. Он объединяет контент из нескольких файлов, что позволяет нам обрабатывать все в одном цикле for и имеет множество других преимуществ.

    В этой статье я продемонстрирую этот модуль на примерах.

    Фото DGlodowska на Pixabay

    Давайте посмотрим на «обычный» способ чтения нескольких текстовых файлов с помощью функции open () . Но перед этим нам нужно создать два демонстрационных файла.

     с open ('my_file1.txt', mode = 'w') как f: 
    f.write ('Это строка 1-1 \ n')
    f.write ('Это строка 1-2 \ n ') с open (' my_file2.txt ', mode =' w ') как f:
    f.write (' Это строка 2-1 \ n ')
    f.write (' Это строка 2-2 \ n ')

    В приведенном выше коде мы открываем файл с режимом w , что означает «запись».Затем мы записываем в файл две строки. Обратите внимание, что нам нужно добавить новую строку \ n . В противном случае два предложения будут записаны в одну строку.

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

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

     # Перебрать весь файл 
    для файла в ['my_file1.txt ',' my_file2.txt ']:
    с open (file,' r ') как f:
    для строки в f:
    print (line)

    Здесь мы должны использовать два вложенных цикла for. Внешний цикл предназначен для файлов, а внутренний — для строк в каждом файле.

    Фото Free-Photos на Pixabay

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

    Прежде всего, нам нужно импортировать модуль.Это встроенный модуль Python, поэтому нам не нужно ничего скачивать.

     import fileinput as fi 

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

     с fi.input (files = ['my_file1.txt', 'my_file2.txt']) как f: 
    для строки в f:
    print (line)

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

    Фото jarmoluk на Pixabay

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

    В этом случае мы можем использовать модуль glob , который является еще одним встроенным модулем Python вместе с модулем fileinput .

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

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

     из glob import globglob ('*. Txt') 

    Теперь мы можем поместить функцию glob () на файловый вход .input () в качестве параметра. Таким образом, будут прочитаны только эти два текстовых файла.

     с fi.input (files = glob ('*. Txt')) как f: 
    для строки в f:
    print (line)

    Фото StockSnap на Pixabay

    Вы можете спросить, как мы можем узнать, какой именно файл «Строка» — это когда мы читаем из потока, который фактически объединен с несколькими файлами?

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

     с fi.input (files = glob ('*. Txt')) как f: 
    для строки в f:
    print (f'Имя файла: {f.filename ()} | Номер строки: {f.lineno ()} | {line} ')

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

    Фото DariuszSankowski на Pixabay

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

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

     с fi.input (files = glob ('*. Txt')) как f: 
    для строки в f:
    , если f.isfirstline ():
    print (f '> Начать чтение {f.filename () } ... ')
    print (line)

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

    Фото Free-Photos на Pixabay

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

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

     с open ('my_file1.txt', mode = 'w') как f: 
    f.write ('Это строка 1-1 \ n')
    f.write ('прекратить чтение \ n')
    f .write ('Это строка 1-2 \ n') с open ('my_file2.txt', mode = 'w') как f:
    f.write ('Это строка 2-1 \ n')
    f .write ('Это строка 2-2 \ n')

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

     с fi.input (files = glob ('*. Txt')) как f: 
    для строки в f:
    , если f.isfirstline ():
    print (f '> Начать чтение {f.filename () } ... ')
    if line ==' прекратить чтение \ n ':
    f.nextfile ()
    else:
    print (line)

    В приведенном выше коде добавлено еще одно условие if. Когда текст строки , прекратите чтение , он перейдет к следующему файлу.Таким образом, мы видим, что строка «1–2» не была прочитана и выведена.

    Фото kaboompics на Pixabay

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

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

     import gzip 
    import shutilwith open ('my_file1.txt ',' rb ') как f_in:
    с gzip.open (' my_file.gz ',' wb ') как f_out:
    shutil.copyfileobj (f_in, f_out)

    В приведенном выше коде мы добавили файл my_file1.txt в сжатый файл с помощью gzip. Теперь давайте посмотрим, как fileinput может его прочитать без дополнительных действий по распаковке.

     с fi.input (files = 'my_file.gz', openhook = fi.hook_compressed) как f: 
    для строки в f:
    print (line)

    Используя параметр openhook и флаг fi.hook_compressed , файл gzip будет распакован на лету.

    Модуль fileinput в настоящее время поддерживает gzip и bzip2. К сожалению, не в другом формате.

    Фото Free-Photos на Pixabay

    В этой статье я представил встроенный в Python модуль fileinput и рассказал о том, как использовать его для чтения нескольких текстовых файлов. Конечно, он никогда не заменит функцию open () , но с точки зрения чтения нескольких файлов в один поток, я считаю, что это лучшая практика.

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

    Больше не используйте библиотеку ОС Python, если Pathlib может это делать

    Знаете ли вы, что у Python есть встроенный массив?

    Как сделать меньше «ошибок» в Python

    Сгенерировать все, что вы хотите в Python

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

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

    • Открыть файл
    • Прочитать файл
    • Сохранить содержимое как список

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

      lst = список (открыть (имя файла))
      

    Однако я добавлю еще несколько пояснений.

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

    Я предполагаю, что вы хотите открыть определенный файл и не имеете дело непосредственно с дескриптором файла (или дескриптором, подобным файлу). Наиболее часто используемая функция для открытия файла в Python — это open , она принимает один обязательный аргумент и два необязательных аргумента в Python 2.7:

    .

    • Имя файла
    • Режим
    • Буферизация (я проигнорирую этот аргумент в этом ответе)

    Имя файла должно быть строкой, представляющей путь к файлу .Например:

      open ('afile') # открывает файл с именем afile в текущем рабочем каталоге
    open ('adir / afile') # относительный путь (относительно текущего рабочего каталога)
    open ('C: / users / aname / afile') # абсолютный путь (окна)
    open ('/ usr / local / afile') # абсолютный путь (linux)
      

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

    Второй аргумент — это режим , по умолчанию это r , что означает «только для чтения». Это именно то, что вам нужно в вашем случае.

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

    Для чтения файла вы можете опустить режим или передать его явно:

      открыто (имя файла)
    open (имя файла, 'r')
      

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

      открыто (имя файла, 'rb')
      

    На других платформах 'b' (двоичный режим) просто игнорируется.


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

    Пока можно было использовать:

      f = open (имя файла)
    # ... делать что-нибудь с f
    f.close ()
      

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

      f = open (имя файла)
    # ничего промежуточного!
    пытаться:
        # делать что-нибудь с f
    наконец:
        f.close ()
      

    Однако Python предоставляет диспетчеры контекста с более красивым синтаксисом (но для open он почти идентичен try и , наконец, выше):

      с открытым (имя файла) как f:
        # делать что-нибудь с f
    # Файл всегда закрывается после окончания области видимости. 

    Последний подход — это рекомендуемый подход для открытия файла в Python!

    Чтение файла

    Хорошо, вы открыли файл, теперь как его читать?

    Функция open возвращает объект file и поддерживает итерационный протокол Pythons. Каждая итерация даст вам строку:

      с открытым (имя файла) как f:
        для строки в f:
            печать (строка)
      

    Будет напечатана каждая строка файла.Однако обратите внимание, что каждая строка будет содержать символ новой строки \ n в конце (вы можете проверить, построен ли ваш Python с универсальной поддержкой новой строки — в противном случае у вас также может быть \ r \ n в Windows или \ r на Mac как символы новой строки). Если вы этого не хотите, вы можете просто удалить последний символ (или последние два символа в Windows):

      с открытым (имя файла) как f:
        для строки в f:
            печать (строка [: - 1])
      

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

      с открытым (имя файла) как f:
        для строки в f:
            если line.endswith ('\ n'):
                строка = строка [: - 1]
            печать (строка)
      

    Но вы можете просто удалить все пробелы (включая символ \ n ) с конца строки , это также удалит все остальные конечных пробелов , поэтому вы должны быть осторожны, если они важны:

      с открытым (имя файла) как f:
        для строки в f:
            печать (ф.rstrip ())
      

    Однако, если строки заканчиваются на \ r \ n («новые строки» Windows), то .rstrip () также позаботится о \ r !

    Сохранить содержимое как список

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

      с открытым (имя файла) как f:
        lst = список (f)
      

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

      с открытым (имя файла) как f:
        lst = [строка.rstrip () для строки в f]
      

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

      с открытым (имя файла) как f:
        lst = f.readlines ()
      

    Это также будет включать завершающие символы новой строки, если они вам не нужны, я бы рекомендовал подход [line.rstrip () for line in f] , потому что он позволяет избежать хранения двух списков, содержащих все строки в памяти.

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

      с открытым (имя файла) как f:
        lst = f.read (). split ('\ n')
      

    или:

      с открытым (имя файла) как f:
        lst = f.read (). splitlines ()
      

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

    Добавить комментарий

    Ваш адрес email не будет опубликован.