Как в питоне открыть файл: Функция open — Intermediate Python

Функция open — Intermediate Python

​open открывает файл. Логично, правда? Зачастую она используется следующим образом:

f = open('photo.jpg', 'r+')
jpgdata = f.read()
f.close()

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

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

Явно вызывая close вы закрываете дескриптор файла, но только при успешном чтении. При вызове Exception после f = open(...) f.close() не будет выполнен (в зависимости от интерпретатора Python дескриптор может быть возвращён, но это уже другая история). Чтобы быть уверенным в закрытии файла вне зависимости от потенциальных ошибок необходимо использовать выражение with:

with open('photo.jpg', 'r+') as f:
    jpgdata = f.read()

Первый аргумент open это файл. Второй — (метод) определяет как файл будет открыт.

• Если вы хотите прочесть файл — r

• Для чтения и записи r+

• Для перезаписи содержимого файла w

• Добавление информации в файл a

Существуют и другие методы, но вы их скорее всего никогда не встретите. Метод важен не только из-за изменения поведения, но и поскольку он может привести к ошибкам доступа. Например, если мы хотим открыть jpg файл в директории, защищённой от записи, open(.., 'r+') вызовет ошибку. Метод также может содержать один дополнительный символ — мы можем открыть файл в бинарном виде (вы получите строку байтов) или в текстовом (строка символов).

В целом, если формат написан людьми, то вам нужен текстовый метод. jpg изображения не пишутся строка за строкой людьми (и не могут читаться ими), поэтому их стоит открывать в бинарном виде, добавляя b в метод (если вы следуете примеру выше, то корректным будет rb). Если вы открываете что-то в текстовом формате (добавьте t или ничего к r/r+/w/a) вы также должны знать кодировку. Для компьютера все файлы это наборы байтов, не символов.

К сожалению, open не позволяет непосредственно выбирать кодировку в Python 2. x. Тем не менее, io.open доступна в обоих ветках Python (в 3.x open выступает в качестве алиаса) и делает то, что нам нужно. Вы можете передавать кодировку в аргументе encoding. Если вы её не выберете, то система и Python остановятся на кодировке по умолчанию. Вы можете попробовать довериться им, однако стандартный выбор может быть полностью ошибочен или кодировка не сможет отобразить часть символов в файле (такое часто происходит с Python 2.x и Windows). Так что лучше выбирайте её самостоятельно. utf-8 превосходна и поддерживается большинством браузеров и языков программирования. При записи файла вы можете выбрать любую на свой вкус (или отталкиваясь от предпочтений программы, которая будет этот файл читать).

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

Вооруженные этими знаниями, давайте напишем программу, которая читает файл, определяет является ли он JPG изображением (подсказка: эти файлы начинаются с байтов FF D8) и записывает текстовый файл, описывающий входной файл:

import io
​
with open('photo.jpg', 'rb') as inf:
    jpgdata = inf.read()
​
if jpgdata.startswith(b'\xff\xd8'):
    text = 'Это JPEG файл (%d байт)\n'
else:
    text = 'Это произвольный файл (%d байт)\n'
​
with io.open('summary.txt', 'w', encoding='utf-8') as outf:
    outf.write(text % len(jpgdata))

Теперь, я уверен, вы будете использовать open правильно!

Файлы — Погружение в Python 3

11.

Файлы

«девять миль ходьбы это не шутка, особенно во время дождя.» —Harry Kemelman, The Nine Mile Walk

На моём Windows ноутбуке было 38493 файла, прежде чем я установил одно приложение. Установка Python 3 добавила почти 3000 файлов к общему объёму. Файлы представляют собой первичную парадигму хранения информации в основных операционных системах; эта концепция настолько укоренилась, что большинство людей не воспримут нечто другое альтернативное. Образно говоря, Ваш компьютер тонет в море файлов.

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

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

a_file = open(‘examples/chinese.txt’, encoding=’utf-8′)

Python имеет встроенную функцию open(), которой передается имя файла в качестве аргумента. В примере имя файла ‘examples/chinese.txt’ и в нём есть 5 интересных вещей:

1. Это не просто имя файла, это комбинация пути к каталогу и имя файла. Гипотетически, в функцию открытия файла можно было бы передать два параметра: путь к файлу и имя файла, но в функцию open() можно передать только один. В Python, когда это необходимо вы можете включать все или некоторые пути к каталогу.
2. При указании пути к каталогу используется / (прямая обратная черта, слэш, правый слэш), не обсуждая какая операционная система используется. Windows использует \ (обратную косую черту, обратный слэш, слэш влево) для указания пути к каталогам, а операционные системы Linux и MacOS используют / (прямая обратная черта, слэш, правый слэш). В Python прямой слэш просто работает всегда, даже на Windows.
3. Путь каталога не начинается с косой черты (слэша) или буквы, это называется относительным путем. Относительно чего? Имей терпение, кузнечик!
4. Это строки. Все современные операционные системы (включая Windows) используют Unicode для хранения имён файлов и директорий. Python 3 полностью поддерживает не-ascii пути.
5. Файл не обязательно должен находиться на локальных дисках. Вы можете использовать сетевые диски. Этот файл может быть объектом виртуальной файловой системы (/proc в linux). Если ваш компьютер считает это за файл и даёт возможность обращаться к этому как к файлу, то Python сможет открыть этот файл.

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

11.2.1 Особенности кодировки показывают своё страшное лицо

Байты байт; символы абстракции. Строка представляет собой последовательность символов в кодировке Юникод. Но файлы на диске не являются последовательностью символов в кодировке Unicode, а являются последовательностью байтов. Если вы читаете текстовый файл с диска, то как Python преобразует эту последовательность байт в последовательность символов? Он декодирует байт по определенному алгоритму кодировки и возвращает последовательность символов в кодировке Unicode (т. е. в виде строки).

>> file = open('examples/chinese.txt')
…>>> a_string = file.read()
…Traceback (most recent call last):
… File «<stdin>», line 1, in <module>
… File «C:\Python31\lib\encodings\cp1252.py», line 23, in decode
… return codecs.charmap_decode(input, self.errors, decoding_table)[0]
…UnicodeDecodeError: 'charmap' codec can’t decode byte 0x8f in position 28: character maps to <undefined>
 
[[Категория:Погружение в Python 3]]

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

у меня есть текстовый файл с именем inputs.txt , который находится в папке с именем task1 входной файл содержит ряд строк, которые мне нужно обработать в функции Python.

Мне нужно написать функцию, которая может открыть этот файл intputs.txt и присвоить содержимое строки переменной S

Пока что у меня есть:

def open_func(task1/test-input. txt):   # syntax error thrown here with forward-slash
    S = open(task1/test-input.txt, "r")
    print(S)
    return S

Но это приводит к синтаксической ошибке при прямой косой черте

Входной файл в настоящее время содержит acbcbba, который я хочу передать переменной S

Что я делаю не так?

EDIT:

Я прикрепил снимок экрана решения, которое я пробовал, но я все еще получаю ошибку «no файла или каталога test-input.txt»

Овации

python

file

Поделиться

Источник

Mike5298    

20 августа 2020 в 10:31

2 ответа

• Как записать содержимое переменной в текстовый файл в Rebol 2?

  Вопрос новичка здесь… Я хотел бы записать выходные данные функции what в текстовый файл. Итак, вот что я сделал: Я создал переменную с именем text и назначил ей выход what текст: [что] Теперь я хочу записать содержимое переменной text в txt-файл. .. Любая помощь будет оценена по достоинству….

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

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

1

Здесь есть несколько проблем:

1. То, что находится внутри круглой скобки в определении , должно быть параметром, а не строкой (поэтому замените этот task1/test-input.txt чем-то вроде file или filename, потому что task1/test-input.txt -это то, что вы пытаетесь открыть, а не параметр функции). OR

2. Если вы хотите открыть файл с именем task1/test-input. txt , вам нужно окружить его кавычками (либо простыми, либо двойными, лично я предпочитаю двойные), поэтому "task1/test-input.txt"

3. функция open открывает дескриптор файла , а не его содержимое. Вам нужно вызвать read() на ручке, а затем close() его. Так что что-то вроде:

   file = open(filename, "r")
   S = file.read()
   file.close()
   print(S)
   return S
   

4. Кроме того, вы должны использовать синтаксис with , как указано в комментарии, что упрощает вышеизложенное (поскольку это автоматически close s дескриптор):

   with open(filename, "r") as file:
       S = file.read()
   print(S)
   return S
   

Поделиться

rajdakin    

20 августа 2020 в 10:36

1

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

def open_func(filename):
    f = open(filename, "r")
    content = f.read()
    f.close()
    print(content)
    return content

path = "task1/test-input.txt"
content = open_func(path)
# do something with the file content now

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

task1/
    script.py
    test-input.txt

Вам нужно позвонить по этому пути, если вы вызываете свой скрипт изнутри «task1/»:

path = "test-input.txt

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

import os
print(os.getcwd())

Поделиться

PawelBoe    

20 августа 2020 в 10:40

Похожие вопросы:

Получить содержимое онлайн-файла и присвоить его переменной

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

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

Как прочитать текстовый файл в python 3.3.3 и сохранить его в переменной? Я борюсь с этим юникодом, идущим от python 2.x

Как прочитать текстовый файл и проверить его содержимое с помощью python

Я пытаюсь прочитать текстовый файл, распечатать его содержимое и остановиться, когда он достигнет flag. Мой код таков: import sys sys.path.append(/Libraries/Documents) file = open(readmepython.txt,…

Как записать содержимое переменной в текстовый файл в Rebol 2?

Вопрос новичка здесь… Я хотел бы записать выходные данные функции what в текстовый файл. Итак, вот что я сделал: Я создал переменную с именем text и назначил ей выход what текст: [что] Теперь я…

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

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

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

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

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

Я использую open() для чтения файла журнала, но у меня есть странное содержимое. Если я открою файл журнала С помощью Notepad++, скопирую содержимое и вставлю его в новый файл, сохраню его как файл…

Прочитайте файл из HDFS и назначьте его содержимое строке

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

Копирование текста из файла .txt и назначение его переменной в файле Python

Я хотел бы взять некоторый текст из файла, скопировать его и присвоить переменной. Как мне это сделать? Текстовый файл (text.txt): test Текстовый файл находится в той же папке, что и файл Python…

Python не удается открыть текстовый файл: «FileNotFoundError»

У меня возникла проблема с открытием текстового файла в Python 3: Я хочу открыть текстовый файл, который я создал ранее, и его имя «pythontest». файл содержит некоторые цифры и слова. Для…

Введение в Python. Часть 11. Работа с файлами

Этот выпуск – о работе с файлами в Python. Научимся открывать, создавать и изменять файлы с текстовой и табличной информацией. Тетрадка Jupyter Notebook этого урока доступна на нашем GitHub. 

Видео: Глеб Лиманский

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

Самый простой формат, в котором могут храниться текстовые данные, – txt. Для примера я создала на компьютере файл с текстом Конституции, в которую для тренировки мы внесем собственные поправки, как это сделал президент России в 2020 году. Прежде, чем работать с файлом, надо его открыть. Это делается с помощью встроенной функции open. В скобках мы сперва прописываем путь к файлу, а затем режим, в котором хотим открыть файл – в данном случае мы открываем файл для чтения, за это отвечает режим «r» (от слова read).

Открыли файл, теперь надо прочитать информацию из него. Для этого есть несколько способов. Самый простой – это вывести всю информацию из файла целиком. За это отвечает операция read.

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

Распечатать информацию построчно можно с помощью цикла и без использования read.

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

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

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

Чтобы получить список из строк, используют операцию readlines. 

Внутри всех этих операций можно указывать количество символов, которые мы хотим прочитать из файла. Например, read(11) прочитает первые 11 символов. 

Создаем файл и записываем в него данные

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

Еще один режим, который можно указать – «a» (от слова append) – это открытие на добавление данных. В таком случае данные добавятся в конец существующего файла. Давайте добавим в текст Конституции еще одну статью.

С помощью операции write мы записали в файл информацию из строки. Чтобы записать информацию из какой-либо последовательности, например, списка, используют writelines. Давайте запишем в Конституцию еще несколько статей.

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

Работаем с csv-файлами

Открытые данные, с которыми работают журналисты, часто представлены в формате csv – от слов comma separated values, то есть значения, разделенные запятыми. Это текстовый формат для представления табличных данных. Для примера зайдем на сайт Минобрнауки и скачаем данные о численности студентов по направлениям подготовки. Для упрощенной работы с файлами csv в Питоне есть специальный встроенный модуль csv. Давайте импортируем его. 

Для чтения используется функция reader. Откроем файл, создадим объект reader и попросим распечатать содержимое файла построчно.

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

Из результата мы копируем полученную кодировку и вставляем ее в код в параметре encoding. 

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

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

C помощью операции fieldnames мы сможем узнать названия столбцов в наших данных. 

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

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

И наконец, записываем старые данные из словаря в новый файл с помощью writerows.

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

Для того, чтобы открыть файл, в Python предусмотрена команда «open». Она может открывать как бинарные, так и текстовые файлы. У нее два параметра: имя файла и режим открытия. Например:

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

откроет файл с именем “text.txt” для чтения.

Существуют следующие режимы открытия файла:

·        На чтение “r”

·        На запись “w”. Если файл существует, он будет перезаписан.

·        На запись нового файла “x”. Если файл уже есть, выскочит исключение.

·        На дозапись “a”. Информация будет добавлена в конец файла.

·        В двоичном режиме “b”.

·        В текстовом режиме “t”.

·        На чтение и запись “+”.

Режимы можно комбинировать, например, если вы хотите открыть бинарник на чтение, то нужно использовать “rb”. Если вы хотите открыть текстовый файл, то “t” можно опустить, это является режимом по умолчанию.

Примеры работы с текстовым файлом вы можете посмотреть в цикле уроков «Взлом шифров»:

·        http://wiki.programstore.ru/python-vzlom-shifrov/

·        http://wiki.programstore.ru/python-vzlom-shifrov-prodolzhenie/

·        http://wiki.programstore.ru/python-vzlom-shifrov-prodolzhenie-2/

Теперь разберем еще примеры.

Чтение списка файлов из каталога с заданными расширениями и поиск в них заданной строки:

#Подключаем модуль 
import os 

#Каталог из которого будем брать файлы 
directory = 'd:\\1' 

#Получаем список файлов в переменную files 
files = os.listdir(directory)

#Задаем строку поиска
search_str="body"

for file in files:
    filename, file_extension = os.path.splitext(file)
    s=file_extension.lower()
    if s==".txt" or s==".html" or s==".htm":
        f = open(directory+"\\"+file)
        for line in f:
            if line.find(search_str)>-1:
                print("В файле "+file+" найдена строка "+search_str)
                break

Здесь для чтения списка файлов в каталоге используем модуль «os», его же и для распарсивания имени файла на расширение и собственно имя. Результат работ что-то вроде того:

В файле 1.html найдена строка body

Теперь попробуем сохранить в файле данные в json-формате:

import json 
numbers = [2, 3, 5, 7, 11, 13]
filename = 'numbers1.json'
with open(filename, 'w') as f_obj:
    json.dump(numbers, f_obj)

Как прочитать? Вот так:

import json 
filename = 'numbers.json'
with open(filename) as f_obj:
    numbers=json.load(f_obj)

print(numbers)

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

[2, 3, 5, 7, 11, 13]

А если попробовать записать более сложную структуру:

import json 
numbers = [2, 3, 5, 7, 11, 13]
dic1={"proba1":1,"probs2":2,"proba3":{"proba4":(1,2),"proba5":5},"proba6":4}
dic={"numbers":numbers,"proba":1,"dictionary":dic1}
filename = 'numbers2.json'
with open(filename, 'w') as f_obj:
    json.dump(dic, f_obj)

То и сам получены файл будет больше похож на истинный JSON:

{«numbers»: [2, 3, 5, 7, 11, 13], «proba»: 1, «dictionary»: {«proba1»: 1, «probs2»: 2, «proba3»: {«proba4»: [1, 2], «proba5»: 5}, «proba6»: 4}}

Ну и напоследок, сериализация в бинарные файлы:

import pickle
numbers = [2, 3, 5, 7, 11, 13]
dic1={"proba1":1,"probs2":2,"proba3":{"proba4":(1,2),"proba5":5},"proba6":4}
dic={"numbers":numbers,"proba":1,"dictionary":dic1}
filename = 'pickle. dat'
with open(filename, 'wb') as f_obj:
    pickle.dump(dic, f_obj)

А прочитать можно вот так:

import pickle
filename = 'pickle.dat'
with open(filename, 'rb') as f_obj:
    dic=pickle.load(f_obj)
    print(dic)

Как открыть файлы во внешних программах на Python? Ru Python

В Windows вы можете использовать os.startfile() чтобы открыть файл с использованием приложения по умолчанию:

 import os os.startfile(filename) 

Нет никакого shutil.open() , который сделает это кросс-платформенным. Близким приближением является webbrowser.open() :

 import webbrowser webbrowser.open(filename) 

который может автоматически использовать команду OS X, os.startfile() в Windows, xdg-open или аналогичную в Linux.

Если вы хотите запустить конкретное приложение, вы можете использовать модуль subprocess например, Popen() позволяет запустить программу, не дожидаясь ее завершения:

 import subprocess p = subprocess. Popen(["notepad.exe", fileName]) # ... do other things while notepad is running returncode = p.wait() # wait for notepad to exit 

Существует много способов использования модуля subprocess для запуска программ, например, subprocess.check_call(command) до тех пор, пока команда не завершится и не вызовет исключение, если команда закончит с ненулевым кодом выхода.

Используйте это, чтобы открыть любой файл с программой по умолчанию:

 import os def openFile(): fileName = listbox_1.get(ACTIVE) os.system("start " + fileName) 

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

 import os def openFile(): fileName = listbox_1.get(ACTIVE) os.system("notepad.exe " + fileName) 

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

Расширение предложения FatalError с примером.

Еще одно преимущество использования subprocessing а не os.system заключается в том, что он использует одну и ту же синтаксическую кросс-платформу ( os.system в Windows требует «начала» в начале, тогда как OS X требует и «открывать». Не огромная сделка, но еще одно, что нужно запомнить).

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

subprocess.call .

Все, что вам нужно сделать, чтобы запустить программу, – это вызов subprocess.call() и lass в list аргументов, где первый – это путь к программе, а остальные – дополнительные аргументы, которые вы хотите предоставить программе, которую вы запуск.

Например, для запуска Notepad.exe

 import subprocess import os path_to_notepad = 'C:\\Windows\\System32\\notepad.exe' path_to_file = 'C:\\Users\\Desktop\\hello.txt' subprocess.call([path_to_notepad, path_to_file]) 

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

Запуск с несколькими аргументами

Это, например, запускает JAR-файл, используя определенную копию среды выполнения Java.

 import subprocess import os current_path = os.getcwd() subprocess.call([current_path + '/contents/home/bin/java', # Param 1 '-jar', #Param2 current_path + '/Whoo.jar']) #param3 

Аргумент 1 нацелен на программу, которую я хочу запустить. Аргумент2 предоставляет аргумент этой программе, говорящий, что он будет запускать JAR, и, наконец, Аргумент3 сообщает целевой программе, где найти файл для открытия.

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

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

Файл записан. 

Введите имя файла: data.txt

1 one

2 two

3 three

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

one
two
three
four
five
six
seven
eight
nine
ten

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

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

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

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

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

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

, пример

my_file = open («my_file.txt», «r») # Открыть файл
print («Имя файла:», my_file.name)
print («Режим открытия:», my_file.mode)

выход

Имя файла: my_file.txt
Режим открытия: r

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

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

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

, пример

my_file = open («my_file.txt», «r») # Открыть файл
# выполняем файловые операции.
my_file.close ()

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

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

, пример

пытаться:
my_file = open («my_file.txt «,» r «) # Открыть файл
# выполнить некоторые файловые операции.
наконец-то:
my_file.close ()

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

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

, пример

с open («my_file.txt «,» r «) как my_file:
# выполняем некоторые файловые операции

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

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

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

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

os.rename (старое_имя_файла, новое_имя_файла)

, пример

импорт ОС
cur_file = «file1.txt»
new_file = «file2.txt»
os.rename (cur_file, новый_файл)

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

, пример

импорт ОС
cur_file = «file1. txt»
os.remove (cur_file)

Как эффективно читать текстовый файл в Python

Резюме : в этом руководстве вы изучите различные способы чтения текстовых файлов в Python.

TL; DR

Ниже показано, как прочитать все тексты из файла readme.txt в строку:

 
  с open ('readme.txt') как f:
    lines = f.readlines ()  
  Язык кода: JavaScript (javascript)  

Этапы чтения текстового файла в Python

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

• Сначала откройте текстовый файл для чтения с помощью функции open () .
• Во-вторых, прочтите текст из текстового файла с помощью метода файлового объекта read () , readline () или readlines () .
• В-третьих, закройте файл с помощью метода file close () .

1) функция open ()

Функция open () имеет много параметров, но вы сосредоточитесь на первых двух.

 
  open (path_to_file, mode)  
 

Параметр path_to_file указывает путь к текстовому файлу.

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

Чтобы указать путь к файлу, используйте косую черту ( '/' ), даже если вы работаете в Windows.

Например, если файл readme.txt хранится в папке с образцом в качестве программы, вам необходимо указать путь к файлу как c: /sample/readme.txt

Режим — это необязательный параметр. Это строка, определяющая режим, в котором вы хотите открыть файл.

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

Например, чтобы открыть файл с именем the-zen-of -python. txt , хранящийся в той же папке, что и программа, вы используете следующий код:

 
  f = open ('the-zen-of-python.txt', 'r')  
  Язык кода: JavaScript (javascript )  

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

2) Методы чтения текста

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

• read () — прочитать весь текст из файла в строку.Этот метод полезен, если у вас есть небольшой файл, и вы хотите управлять всем текстом этого файла.
• readline () — читать текстовый файл построчно и возвращать все строки как строки.
• readlines () — прочитать все строки текстового файла и вернуть их в виде списка строк.

3) метод close ()

Файл, который вы открываете, останется открытым, пока вы не закроете его с помощью метода close ().

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

Ниже показано, как вызвать метод close () для закрытия файла:

 
  f.close ()  
  Язык кода: CSS (css)  

Чтобы закрыть файл автоматически без вызова close () , вы используете с оператором следующим образом:

 
  с open (path_to_file) как f:
    content = f.readlines ()  
  Язык кода: JavaScript (javascript)  

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

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

Мы будем использовать файл-zen-of-python. txt для демонстрации.

В следующем примере показано, как использовать метод read () для чтения всего содержимого файла the-zen-of-python.txt в строку:

 
  с open ('the-zen -of-python.txt ') как f:
    content = f.read ()
    print (содержание)  
  Язык кода: JavaScript (javascript)  

Вывод:

 
  Красивое лучше уродливого.Явное лучше, чем неявное.
Лучше простое, чем сложное.
...
  
 

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

 
  lines = []
с open ('the-zen-of-python.txt') как f:
    lines = f.readlines ()

count = 0
для строки в строках:
    count + = 1
    print (f'line {count}: {line} ')  
  Язык кода: JavaScript (javascript)  

Вывод:

 
  строка 1: Красивое лучше, чем уродливое. строка 2: Явное лучше, чем неявное.

строка 3: Простое лучше, чем сложное.
...
  
 

В следующем примере показано, как использовать readline () для чтения текстового файла построчно:

 
  с open ('the-zen-of-python.txt') как f:
    line = f.readline ()
    а строка:
        line = f.readline ()
        print (строка)  
  Язык кода: JavaScript (javascript)  

Вывод:

 
  Явное лучше, чем неявное.Лучше простое, чем сложное.

Сложный лучше, чем сложный.
...
  
 

Более лаконичный способ чтения текстового файла построчно

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

 
  с open ('the-zen-of-python. txt') как f:
    для строки в f:
        print (line)  
  Язык кода: JavaScript (javascript)  

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

Чтение текстовых файлов UTF-8

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

Чтобы открыть текстовый файл UTF-8, вам необходимо передать encoding = 'utf-8' в функцию open () , чтобы она ожидала от файла символы UTF-8.

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

Ниже показано, как пройти через файл quotes.txt :

 
  с open ('quotes. txt', encoding = 'utf8') как f:
    для строки в f:
        печать (line.strip ())
  
  Язык кода: JavaScript (javascript)  

Вывод:

Сводка

• Используйте функцию open () с режимом 'r' , чтобы открыть текстовый файл для чтения.
• Используйте метод read () , readline () или readlines () для чтения текстового файла.
• Всегда закрывайте файл после завершения чтения с помощью метода close () или с оператором .
• Используйте encoding = 'utf-8' для чтения текстового файла UTF-8.

Вы нашли это руководство полезным?

Обработка файлов — документация Python для вас и меня 0.4.beta1

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

Открытие дела

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

• «r» -> открыть только для чтения, вы можете читать файл, но не можете редактировать / удалять что-либо внутри
• «w» -> открыть с возможностью записи, означает, что если файл существует, удалите все содержимое и откройте его для записи
• «a» -> открыть в режиме добавления

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

 >>> fobj = open ("love.txt")
>>> fobj
<_io.TextIOWrapper name = 'love.txt' mode = 'r' encoding = 'UTF-8'>
 

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

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

 >>> fobj = open ("love.txt")
>>> fobj
<_io.TextIOWrapper name = 'love.txt' mode = 'r' encoding = 'UTF-8'>
>>> fobj.close ()
 

Важно

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

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

Чтение файла

Для одновременного чтения всего файла используйте метод read () .

 >>> fobj = open ("sample.txt")
>>> fobj.read ()
'Я люблю Python \ nPradeepto любит KDE \ nСанкаршан любит Openoffice \ n'
 

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

 >>> fobj = open ("sample.txt")
>>> fobj.readline ()
"Я люблю Python \ n"
>>> fobj.readline ()
"Прадипто любит KDE \ n"
 

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

 >>> fobj = open ("sample.txt")
>>> fobj.readlines ()
['Я люблю Python \ n', 'Прадипто любит KDE \ n', 'Санкаршан любит Openoffice \ n']
 

Вы можете даже перебирать строки в файловом объекте.

 >>> fobj = open ("sample.txt")
>>> для x в fobj:
... печать (х, конец = '')
...
Я люблю Python
Прадепто любит KDE
Санкаршан любит Openoffice
 

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

 #! / Usr / bin / env python3
name = input ("Введите имя файла:")
fobj = open (имя)
печать (fobj.read ())
fobj.close ()
 

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

Выход

 $ ./showfile.py
Введите имя файла: образец.текст
Я люблю Python
Прадепто любит KDE
Санкаршан любит Openoffice
 

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

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

 >>> с open ('setup.py') как fobj:
... для строки в fobj:
... строка печати,
...
#! / usr / bin / env python3
"" "Факторный проект" ""
из setuptools импортируйте find_packages, настройте

настройка (имя = 'факториал',
    версия = '0,1',
    description = "Факторный модуль.",
    long_description = "Тестовый модуль для нашей книги.",
    платформы = ["Linux"],
    author = "Кушал Дас",
    author_email = "[email protected]",
    url = "https://pymbook.readthedocs.io/en/latest/",
    license = "http://www.gnu.org/copyleft/gpl.html",
    пакеты = find_packages ()
    )
 

Запись в файл

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

 >>> fobj = open ("ircnicks.txt", 'w')
>>> fobj.write ('powerpork \ n')
>>> fobj.write ('индраг \ п')
>>> fobj.write ('мишти \ п')
>>> fobj.write ('санкаршан')
>>> print ("Это последняя строка.", file = fobj)
>>> fobj.close ()
 

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

 >>> fobj = open ('ircnicks.txt')
>>> s = fobj.read ()
>>> печать (и)
powerpork
индраг
мишти
Санкаршан
Это последняя строчка.

copyfile.py

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

 #! / Usr / bin / env python3
import sys
если len (sys.argv) <3:
    print («Неверный параметр»)
    print ("./ copyfile.py файл1 файл2")
    sys.exit (1)
с open (sys.argv [1]) как f1:
    s = f1.read ()
с open (sys.argv [2], 'w') как f2:
    f2.write (s)
 

Примечание

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

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

Первое значение в sys.argv - это имя самой команды.

 #! / Usr / bin / env python3
import sys
print ("Первое значение", sys.argv [0])
print ("Все значения")
для i, x в перечислении (sys.argv):
    печать (я, х)
 

Выход

 $ ./argvtest.py Привет!
Первое значение ./argvtest.py
Все ценности
0 ./argvtest.py
1 привет
2 там
 

Здесь мы использовали новую функцию enumerate (iterableobject) , которая возвращает номер индекса и значение из итерируемого объекта.

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

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

 #! / Usr / bin / env python3

импорт ОС
import sys


def parse_file (путь):
    "" "
    Анализирует текстовый файл по заданному пути и возвращает пробел, табуляцию и новую строку
    подробности.

    : arg path: Путь к текстовому файлу для синтаксического анализа

    : return: Кортеж с количеством пробелов, табуляции и строк.
    "" "
    fd = open (путь)
    я = 0
    пробелы = 0
    вкладки = 0
    для i строка в enumerate (fd):
        пробелы + = line.count ('')
        вкладки + = line.count ('\ t')
    # Теперь закройте открытый файл
    fd.close ()

    # Вернуть результат в виде кортежа
    возвращаемые пробелы, табуляция, i + 1

def main (путь):
    "" "
    Функция, которая выводит количество пробелов, табуляции и строк в файле.: arg path: Путь к текстовому файлу для синтаксического анализа
    : return: Истина, если файл закрывается, или Ложь.
    "" "
    если os.path.exists (путь):
        пробелы, табуляции, строки = parse_file (путь)
        print ("Пробелы% d. табуляции% d. строки% d"% (пробелы, табуляции, строки))
        вернуть True
    еще:
        вернуть ложь


если __name__ == '__main__':
    если len (sys.argv)> 1:
        основной (sys.argv [1])
    еще:
        sys.exit (-1)
    sys.exit (0)
 

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

Давайте напишем реальный код

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

Если вы работаете в Linux, вы можете сначала просмотреть вывод команды lscpu .
Фактически вы можете найти информацию в файле, расположенном по адресу / proc / cpuinfo .

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

Подсказка

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

После этого попробуйте написать собственную команду lscpu на Python 🙂

Откройте файл, используя оператор «открыть с помощью» и преимущества, объясненные на примерах - thispointer.com

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

Необходимость «открыть с помощью»

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

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

Посмотрите этот пример,

 # открыть файл
file_object = open ('образец.txt')

# читать содержимое файла
data = file_object.read ()

# распечатать содержимое файла
печать (данные)

# закрыть файл
file_object.close ()
 

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

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

Если у вас нет файла sample.txt в текущем каталоге, вы можете получить такую ​​ошибку:

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

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

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

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

Что делать, если кто-то в конце концов забудет закрыть файл?

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

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

Что делать, если возникнет исключение?

Проверить этот код

 # Файл не закрывается в случае исключения
пытаться:
    # открыть файл
    file_object = open ('образец.текст')
    # читать содержимое файла
    data = file_object.read ()
    # Это вызовет исключение
    х = 1/0
    печать (данные)
    file_object.close ()
Кроме:
    # Обработка исключения
    print ('Ошибка')
наконец-то:
    если file_object.closed == False:
        print ('Файл не закрыт')
    еще:
        print ('Файл закрыт')
 

Вывод:

 Ошибка
Файл не закрыт 

В этом коде мы правильно закрываем файл, вызывая функцию close () и также перехватывая исключение.Но закрывающий взгляд покажет вам, что когда возникло исключение, элемент управления переместился в блок except, а затем в блок finally. В блоке finally мы проверяем, закрыт файл или нет. Угадай, что! файл не был закрыт, потому что из-за исключения вызов функции close () был пропущен. Чтобы исправить это, нам нужно вызвать функцию close () в блоке except, как этот,

 # Файл не закрывается в случае исключения
пытаться:
    # открыть файл
    file_object = open ('образец.txt')
    # читать содержимое файла
    данные = объект_файла.читать()
    # Это вызовет исключение
    х = 1/0
    печать (данные)
    file_object.close ()
Кроме:
    file_object.close ()
    # Обработка исключения
    print ('Ошибка')
наконец-то:
    если file_object.closed == False:
        print ('Файл не закрыт')
    еще:
        print ('Файл закрыт')
 

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

Как открыть файл с помощью оператора «открыть с помощью» в Python

 # использование оператора with с функцией open ()
с open ('sample.txt', "r") как file_object:
    # читать содержимое файла
    data = file_object.read ()
    # распечатать содержимое файла
    печать (данные)

# Проверяем, закрыт ли файл
если file_object.closed == False:
    print ('Файл не закрыт')
еще:
    print ('Файл закрыт')
 

Вывод:

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

«With statement» создает исполнительный блок, и объект, созданный в операторе with, будет уничтожен или корректно закрыт, когда этот исполнительный блок завершится.

Это означает, что когда мы использовали оператор with с функцией open (), запускалось блокирование выполнения, и объект файла, возвращаемый функцией open (), назначается file_object. Когда этот блок выполнения «with statement» завершается, функция закрытия файлового объекта вызывается автоматически, и файл будет корректно закрыт.Нам больше не нужно вручную вызывать функцию close (), если мы используем «with statement»

.

Преимущества вызова open () с использованием оператора with

Меньше шансов на ошибку из-за ошибки кодирования

Нет необходимости явно закрывать открытый файл, об этом позаботится команда «with statement». Когда с блоком заканчивается, он автоматически закроет файл. Таким образом, это уменьшает количество строк кода и снижает вероятность ошибки.

Отличная управляемость в исключительных случаях

Посмотрите этот пример,

 # Файл будет закрыт перед обработкой исключения
пытаться:
    # использование оператора with с функцией open ()
    с открытым ('образец.txt ', "r") как объект_файла:
        # читать содержимое файла
        data = file_object.read ()
        # возникает ошибка
        х = 1/0
        печать (данные)
Кроме:
    # обработка исключения
    print ('Ошибка')
    если file_object.closed == False:
        print ('Файл не закрыт')
    еще:
        print ('Файл закрыт')
 

Вывод:

 Ошибка
Файл закрыт
 

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

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

Мы подтвердили это, используя file_object.closed в блоке except.

Открыть несколько файлов в одном «с оператором»

Давайте откроем два файла с помощью одного оператора with. Будем читать по образцу.txt и напишите в outfile.txt,

 # Прочтите из sample.txt и напишите в outfile.txt
с open ('outfile.txt', 'w') как file_obj_2, open ('sample.txt', 'r') как file_obj_1:
    data = file_obj_1.read ()
    file_obj_2.write (данные)
    # Оба файла будут закрыты автоматически по окончании выполнения блока.
 

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

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

 def main ():

    print ('*** Открыть файл без оператора "открыть с помощью" ***')

    print ('Обычный способ открытия и чтения из файла с помощью функции open ()')

    # открыть файл
    file_object = open ('образец.текст')

    # читать содержимое файла
    data = file_object.read ()
    печать (данные)

    # закрыть файл
    file_object.close ()

    print ('** Открыть файл с помощью функции open () и обработать исключение **')

    # Файл не закрывается в случае исключения
    пытаться:
        # открыть файл
        file_object = open ('образец.txt')
        # читать содержимое файла
        data = file_object.read ()
        # Это вызовет исключение
        х = 1/0
        печать (данные)
        файл_объект.Закрыть()
    Кроме:
        # Обработка исключения
        print ('Ошибка')
    наконец-то:
        если file_object.closed == False:
            print ('Файл не закрыт')
        еще:
            print ('Файл закрыт')

    print ('**** Открыть файл с помощью оператора «открыть с помощью» ****)

    # использование оператора with с функцией open ()
    с open ('sample.txt', "r") как file_object:
        # читать содержимое файла
        данные = объект_файла.читать()
        # распечатать содержимое файла
        печать (данные)

    # Проверяем, закрыт ли файл
    если file_object.closed == False:
        print ('Файл не закрыт')
    еще:
        print ('Файл закрыт')

    print ('**** оператор «открыть с помощью» и обработка исключений ****)

    # Файл будет закрыт перед обработкой исключения
    пытаться:
        # использование оператора with с функцией open ()
        с open ('sample.txt', "r") как file_object:
            # читать содержимое файла
            данные = объект_файла.читать()
            # возникает ошибка
            х = 1/0
            печать (данные)
    Кроме:
        # обработка исключения
        print ('Ошибка')
        если file_object.closed == False:
            print ('Файл не закрыт')
        еще:
            print ('Файл закрыт')


    print ('**** Несколько вызовов функции open () в одном операторе with ****)

    # Читать из sample.txt и писать в outfile.txt
    с открытым ('Outfile.txt ',' w ') как file_obj_2, откройте (' sample.txt ',' r ') как file_obj_1:
        data = file_obj_1.read ()
        file_obj_2.write (данные)
        # Оба файла будут закрыты автоматически по окончании выполнения блока.

если __name__ == '__main__':
   основной()
 

Вывод:

 *** Откройте файл без оператора «открыть с помощью» ***
Обычный способ открытия и чтения из файла с помощью функции open ()
Это образец файла.
Он содержит образец строки.вы собираетесь его использовать.
Спасибо.
** Откройте файл с помощью функции open () и обработайте исключение **
Ошибка
Файл не закрыт
**** Откройте файл с помощью оператора "открыть с помощью" ****
Это образец файла.
Он содержит образец строки.
вы собираетесь его использовать.
Спасибо.
Файл закрыт
**** Оператор "открыть с помощью" и обработка исключений ****
Ошибка
Файл закрыт
**** Несколько вызовов функции open () в одном операторе with ****
 

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

Введение

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

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

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

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

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

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

Фон

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

В этом руководстве основное внимание уделяется файловому формату 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.

Как открыть файлы PY на ПК с Windows 10

Скрипты

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

Как я могу открывать файлы PY на моем ПК с Windows 10?

1. Загрузите инструмент File Viewer Plus

Вы можете открывать PY и многие другие файлы исходного кода с помощью File Viewer Plus. Это универсальный просмотрщик файлов для Windows, который может открывать и отображать более 300 различных типов файлов, просматривать и редактировать файлы исходного кода.

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

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

File Viewer Plus

File Viewer Plus - лучший инструмент для быстрого открытия файлов PY на вашем компьютере с Windows 10.Готовы попробовать?

2. Откройте сценарии Python с помощью Notepad ++

1. Начните, щелкнув правой кнопкой мыши кнопку «Пуск» и выбрав Система , чтобы открыть окно на снимке экрана непосредственно ниже.
2. Щелкните либо Notepad ++ Installer 32-bit x86 (32-bit) , либо Notepad ++ Installer 64-bit x64 (64-bit) . Будет загружен 32- или 64-разрядный мастер установки, с помощью которого вы сможете установить программное обеспечение.
3. Затем вы можете открыть сценарий в Notepad ++, щелкнув Файл > Открыть .

Программисты могут редактировать сценарии Python с помощью разнообразного программного обеспечения. Фактически, вы можете редактировать сценарий PY в Блокноте. Однако Notepad ++ - лучший сторонний текстовый редактор, который также поддерживает формат файла PY.

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

Notepad ++ можно добавить на большинство платформ Windows. Обратите внимание, что это программное обеспечение имеет 32- и 64-битную версии.64-битные версии не работают в 32-битных системах.

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

PyScripter, PyDev и PyCharm - это три программного обеспечения IDE с открытым исходным кодом, с помощью которых вы можете открывать файлы PY.

IDE

, вероятно, является лучшим программным обеспечением для кодирования Python, чем Notepad ++, поскольку они также включают инструменты отладки и интегрированные интерпретаторы.

Python 101: Как открыть файл или программу

Когда я начал изучать Python, мне в первую очередь нужно было научиться открывать файл.Теперь термин «открыть файл» может означать разные вещи в зависимости от контекста. Иногда это означает фактически открыть файл с помощью Python и читать из него, например, с помощью текстового файла. В других случаях это означает «открыть файл в программе по умолчанию»; а иногда это означает «открыть файл в указанной мной программе». Итак, когда вы ищете, как сделать последние два, вам нужно знать, как задать Google правильный вопрос, иначе все, что у вас получится, - это научиться открывать и читать текстовый файл.

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

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

Начнем с того, что узнаем, как открыть файл с помощью Python. В данном случае мы имеем в виду использовать Python для его открытия, а не какую-либо другую программу. Для этого у нас есть два варианта (в Python 2.x): открыть или файл. Давайте посмотрим, как это делается!

# ключевое слово open открывает файл в режиме только для чтения по умолчанию
f = open («путь / к / файлу.txt »)

# прочитать все строки в файле и вернуть их в виде списка
lines = f.readlines ()

f.close ()

Как видите, действительно легко открыть и прочитать текстовый файл. Вы можете заменить ключевое слово «open» на ключевое слово «file», и оно будет работать так же. Если вы хотите быть более явным, вы можете вместо этого написать команду открытия следующим образом:

f = open («путь / к / file.txt», режим = «r»)

«r» означает просто прочитать файл. Вы также можете открыть файл в формате «rb» (чтение двоичного кода), «w» (запись), «a» (добавление) или «wb» (запись двоичного файла).Обратите внимание, что если вы используете «w» или «wb», Python перезапишет файл, если он уже существует, или создаст его, если файл не существует.

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

• read - читает весь файл и возвращает все в виде строки
• readline - читает первую строку файла и возвращает ее как строку
• readlines - читает весь файл и возвращает его как список строк

Вы также можете прочитать файл с помощью цикла, например:

f = open («путь / к / файлу.txt ”)
для строки в f:
для строки печати
f.close ()

Довольно круто, да? Питон крут! Пришло время узнать, как открыть файл в другой программе.

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

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

import os
os.startfile (путь)

Да, это так просто, если у вас Windows. Если вы используете Unix или Mac, вам понадобится модуль подпроцесса или «os.система". Конечно, если вы настоящий компьютерщик, у вас, вероятно, есть несколько программ, которые вы, возможно, захотите использовать для открытия определенного файла. Например, я мог бы захотеть отредактировать свой файл JPEG с помощью Picasa, Paint Shop Pro, Lightroom, Paint.NET или множества других программ, но я не хочу менять программу редактирования JPEG по умолчанию. Как решить эту проблему с помощью Python? Мы используем модуль подпроцесса Python! Примечание. Если вы хотите следовать старой школе, вы также можете использовать os.popen * или os.system, но предполагается, что подпроцесс заменяет их.

подпроцесс импорта

pdf = «путь / к / pdf»
acrobatPath = r’C: \ Program Files \ Adobe \ Reader 9.0 \ Reader \ AcroRd32.exe ’
subprocess.Popen («% s% s »% (acrobatPath, pdf))

Последнюю строку можно также записать так: subprocess.Popen ([acrobatPath, pdf]) . Достаточно сказать, что использование модуля подпроцесса также несложно. Есть много других способов использования модуля подпроцесса, но это одна из его основных задач. Я обычно использую его, чтобы открыть определенный файл (как указано выше) или открыть для меня программу с определенными аргументами.Я также использую метод «call» подпроцесса, который заставляет скрипт Python ждать завершения «вызванного» приложения, прежде чем продолжить. Вы также можете общаться с процессами, которые запускает подпроцесс, если у вас есть знания.

Завершение

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