Python открыть файл: Работа с файлами в Python

Содержание

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

Мне интересно, как открывать файлы в таких программах, как Notepad и Picture Viewer, в зависимости от расширения файла. Я использую Python 3.3 на Windows.

Я провел некоторые исследования , и люди упоминали модуль с именем Image, но когда я пытаюсь импортировать этот модуль, я получаю ImportError.

Вот что у меня есть до сих пор:

def openFile():
    fileName = listbox_1.get(ACTIVE)
    if fileName.endswith(".jpg"):
        fileName.open()

У меня также будут файлы HTML и JSON, которые мне нужно будет открыть в блокноте.

python

Поделиться

Источник

Unknown

24 февраля 2013 в 17:31

3 ответа

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

import os
os.startfile(filename)

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

import webbrowser
webbrowser.open(filename)

это может автоматически использовать команду open в 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) блокирует до завершения команды и вызывает исключение, если команда завершается ненулевым кодом выхода.

Поделиться

jfs

24 февраля 2013 в 18:37

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

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)

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

Поделиться

Unknown

24 февраля 2013 в 17:35

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

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

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

subprocess.call .

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

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

import subprocess    

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 нацелен на программу, которую я хочу запустить. Argument2 предоставляет этой программе аргумент, сообщающий ей, что она собирается запустить JAR, и, наконец, Argument3 сообщает целевой программе, где найти файл для открытия.

Поделиться

Zack Yoshyaro

24 февраля 2013 в 18:15

Как я могу получить доступ к словарю в разных программах в python
Настройка в Python выглядит следующим образом: Запуск программы 1 Программа 1 создает словарь в виде myDictionary = {: {:}} Программа 1 выходит Запуск программы 2 # На данный момент я хочу получить доступ к myDictioanry. Выходы из программы 2 Если быть точным, я храню файлы cookie в этом словаре….
Как изменить файлы в папке внешних библиотек
Я был занят добавлением simple_form и mail_form gem в мое приложение rails 4.2.6, и я не был удовлетворен дизайном. Единственное место, которое я могу придумать, чтобы изменить этот дизайн на данный момент, — это папка внешних библиотек. Но возможно ли вообще успешно изменить эти файлы или это…

как открыть файл .txt в python в одной строке

Я пытаюсь открыть файл .txt и путаюсь с тем, какая часть куда идет. Я также хочу, чтобы при открытии текстового файла в python пробелы были удалены. И при ответе не могли бы вы сделать имя файла ‘clues’.

Моя первая попытка:

def clues():
    file = open("clues.txt", "r+")
    for line in file:
        string = ("clues.txt")
        print (string)

моя вторая попытка:

def clues():
f = open('clues.txt')
lines = [line.strip('\n') for line in open ('clues.txt')]

Трид пытается это сделать:

def clues():
    f = open("clues.txt", "r")
    print f.read()
    f.close()

python

python-3.x

Поделиться

Источник

jamie

25 ноября 2014 в 23:27

3 ответа

Как открыть файл ppt с помощью Python
Я хочу открыть файл ppt с помощью Python на linux (например, python открыть файл .txt). Я знаю win32com, но работаю над linux. Итак, что мне нужно сделать?
как открыть большой (100 ГБ) файл .txt?
У меня есть .txt файл ~100GB. есть ли текстовый редактор, который я могу использовать, чтобы открыть это? Если да, то как это на самом деле будет храниться в памяти? У меня есть только 16 ГБ RAM. Я также изучаю другие варианты, такие как разделение файла на 2 или более частей. Есть какие-нибудь…

Основываясь на @JonKiparsky, для вас было бы безопаснее использовать утверждение python with :

with open("clues.txt") as f:
    f.read().replace(" ", "")

Поделиться

Nick Humrich

25 ноября 2014 в 23:41

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

f.read().replace(' ', '')

Или, если вы хотите заменить все whitespace, а не только пробелы:

''.join(f.read().split())

Поделиться

abarnert

25 ноября 2014 в 23:33

Эта строка:

f = open("clues.txt")

откроет файл — то есть вернет файловую ручку, которую вы можете прочитать из

Эта строка:

open("clues.txt").read().replace(" ", "")

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

Поделиться

Jon Kiparsky

25 ноября 2014 в 23:33

Импортировать текстовый файл в Python

Используйте функцию open() для импорта файла в Python
Используйте функцию numpy.genfromtxt() для импорта файла в Python

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

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

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

Используйте функцию

open() для импорта файла в Python

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

Синтаксис функции open() представлен ниже.

open(path_to_file, mode)

Функция open() имеет несколько параметров, но самые важные из них — первые два, а именно path_to_file и mode.

Режим path_to_file указывает путь или имя файла, а параметр mode указывает режим, в котором мы хотим открыть файл.

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

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

Эта строка кода открывает файл с именем file.txt в режиме чтения.

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

Следующий код использует функцию close() для закрытия файла в Python.

f.close()

Используйте функцию

numpy.genfromtxt() для импорта файла в Python

Для использования функции genfromtxt() необходимо импортировать библиотеку NumPy.

NumPy, сокращение от Numerical Python, представляет собой библиотеку, используемую в Python, которая состоит из объектов многомерных массивов и набора методов для обработки этих массивов. Логические и математические операции могут выполняться с массивами с помощью NumPy.

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

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

import numpy as np
...
f = np.genfromtxt(fname='file1.txt')

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

Как удалить файл и каталог на Python

Как найти файлы с определенным расширением только на Python

Формат файла PY

What is a PY file

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

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

Here’s a small, but not exhaustive list of programs that can open PY documents:

gedit (Linux)
GNU Emacs (Linux)
MacroMates TextMate (Mac)
Microsoft Notepad (Windows)
Notepad++ (Windows)
Python Software Foundation Python (Windows, Mac & Linux)
Other text editor

python — open () в Python не создает файл, если он не существует

Каков наилучший способ открыть файл для чтения / записи, если он существует, а если нет, то создать его и открыть как чтение / запись? Из того, что я прочитал, file = open('myfile.dat', 'rw') должен это сделать, верно?

Это не работает для меня (Python 2.6.2), и мне интересно, если это проблема с версией, или не должен работать так или что.

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

Вмещающий каталог доступен для записи пользователю и группе, а не другим (я в системе Linux … так что разрешения 775 другими словами), и точная ошибка была:

IOError: нет такого файла или каталога.

781

trh278

3 Июн 2010 в 19:05

16 ответов

Лучший ответ

Вы должны использовать open с режимом w+:

file = open('myfile.dat', 'w+')

771

Igor Chubin
29 Июн 2018 в 20:32

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

'w', 'a' разрешит запись и создаст файл, если он не существует.

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

Neuron
21 Ноя 2019 в 14:13

'''
w  write mode
r  read mode
a  append mode

w+  create file if it doesn't exist and open it in write mode
r+  open for reading and writing. Does not create file.
a+  create file if it doesn't exist and open it in append mode
'''

Пример:

file_name = 'my_file.txt'
f = open(file_name, 'w+')  # open file in write mode
f.write('python rules')
f.close()

Надеюсь, это поможет. [FYI использую версию Python 3.6.2]

ddaskal
22 Апр 2019 в 21:35

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

with open("file.dat","a+") as f:
    f.write(...)
    ...

a + Открывает файл для добавления и чтения. Указатель файла в конце файла, если файл существует. Файл открывается в режим добавления. Если файл не существует, он создает новый файл для чтение и запись. — режимы файлов Python

метод seek () устанавливает текущую позицию файла.

f.seek(pos [, (0|1|2)])
pos .. position of the r/w pointer
[] .. optionally
() .. one of ->
  0 .. absolute position
  1 .. relative position to current
  2 .. relative position from end

Разрешены только символы «rwab +»; должен быть точно один из «rwa» — см. вопрос переполнения стека Подробнее о режимах работы с файлами Python .

129

Community
23 Май 2017 в 11:55

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

import os

f_loc = r"C:\Users\Russell\Desktop\myfile.dat"

# Create the file if it does not exist
if not os.path.exists(f_loc):
    open(f_loc, 'w').close()

# Open the file for appending and reading
with open(f_loc, 'a+') as f:
    #Do stuff

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

wp-overwatch.com
11 Окт 2019 в 21:34

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

file = open('myfile.dat', 'a+')
file.seek(0, 0)

Danilo Souza Morães
12 Янв 2018 в 13:26

Начиная с python 3.4 вы должны использовать pathlib для «касания» файлов.
Это гораздо более элегантное решение, чем предлагаемые в этой ветке.

from pathlib import Path

filename = Path('myfile.txt')
filename.touch(exist_ok=True)  # will create file, if it exists will do nothing
file = open(filename)

То же самое с каталогами:

filename.mkdir(parents=True, exist_ok=True)

Granitosaurus
23 Апр 2018 в 06:34

import os, platform
os.chdir('c:\\Users\\MS\\Desktop')

try :
    file = open("Learn Python.txt","a")
    print('this file is exist')
except:
    print('this file is not exist')
file.write('\n''Hello Ashok')

fhead = open('Learn Python.txt')

for line in fhead:

    words = line.split()
print(words)

-2

Ganesh Jat
8 Авг 2018 в 05:45

>>> import os
>>> if os.path.exists("myfile.dat"):
...     f = file("myfile.dat", "r+")
... else:
...     f = file("myfile.dat", "w")

R + означает чтение / запись

Khorkrak
3 Июн 2010 в 15:18

open('myfile.dat', 'a') работает на меня, просто отлично.

В py3k ваш код повышается ValueError:

>>> open('myfile.dat', 'rw')
Traceback (most recent call last):
  File "<pyshell#34>", line 1, in <module>
    open('myfile.dat', 'rw')
ValueError: must have exactly one of read/write/append mode

В python-2.6 он поднимается IOError.

SilentGhost
3 Июн 2010 в 15:19

Итак, вы хотите записать данные в файл, но только если он еще не существует?

Эта проблема легко решается с помощью малоизвестного режима x для open () вместо обычного режима w. Например:

 >>> with open('somefile', 'wt') as f:
 ...     f.write('Hello\n')
...
>>> with open('somefile', 'xt') as f:
...     f.write('Hello\n')
...
 Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
FileExistsError: [Errno 17] File exists: 'somefile'
  >>>

Если файл в двоичном режиме, используйте режим xb вместо xt.

njoshsn
14 Дек 2017 в 13:58

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

Gustavo6046
11 Окт 2015 в 20:10

Я думаю, что это r+, а не rw. Я просто начинающий, и это то, что я видел в документации.

Neuron
21 Ноя 2019 в 14:13

Мой ответ:

file_path = 'myfile.dat'
try:
    fp = open(file_path)
except IOError:
    # If not exists, create the file
    fp = open(file_path, 'w+')

Chien-Wei Huang
27 Май 2014 в 06:20

Измените «rw» на «w +»

Или используйте «+» для добавления (не стирая существующий контент)

baloo
3 Июн 2010 в 15:18

Хорошей практикой является использование следующего:

import os

writepath = 'some/path/to/file.txt'

mode = 'a' if os.path.exists(writepath) else 'w'
with open(writepath, mode) as f:
    f.write('Hello, world!\n')

lollercoaster
4 Май 2015 в 01:49

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

python-scripts.com

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

автор

9-12 минут

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

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

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

This is test file

line 2

line 3

this line intentionally left lank

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

handle = open(«test.txt»)

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

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

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

C:\Users\mike\py101book\data est.txt

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

C:\Users\mike\py101book\data\test.txt

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

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

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

data = handle.read()

print(data)

handle.close()

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

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

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

data = handle.readline() # read just one line

print(data)

handle.close()

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

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

data = handle.readlines() # read ALL the lines!

print(data)

handle.close()

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

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

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

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

for line in handle:

print(line)

handle.close()

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

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

while True:

data = handle.read(1024)

print(data)

if not data:

break

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

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

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

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

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

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

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

handle = open(«output.txt», «w»)

handle.write(«This is a test!»)

handle.close()

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

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

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

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

for line in file_handler:

print(line)

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

handle = open(«test.txt»)

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

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

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

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

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

try:

file_handler = open(«test.txt»)

for line in file_handler:

print(line)

except IOError:

print(«An IOError has occurred!»)

finally:

file_handler.close()

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

try:

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

for line in file_handler:

print(line)

except IOError:

print(«An IOError has occurred!»)

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

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

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

Как работать с простыми текстовыми файлами в Python 3

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

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

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

[[step-1 -—- create-a-text-file]] == Шаг 1. Создание текстового файла

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

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

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

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

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

[[step-2 -—- open-a-file]] == Шаг 2 — Открытие файла

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

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

path = '/users/sammy/days.txt'

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

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

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

days_file = open(path,'r')

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

[[шаг-3 -—- чтение-файл]] == Шаг 3 — Чтение файла

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

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

Output'Monday\nTuesday\nWednesday\nThursday\nFriday\nSaturday\nSunday\n'

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

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

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

Output['Monday\n', 'Tuesday\n', 'Wednesday\n', 'Thursday\n', 'Friday\n', 'Saturday\n', 'Sunday\n']

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

[[step-4 -—- writing-a-file]] == Шаг 4 — Запись файла

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

title = 'Days of the Week\n'

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

path = '/users/sammy/days.txt'
days_file = open(path,'r')
days = days_file.read()

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

new_path = '/users/sammy/new_days.txt'
new_days = open(new_path,'w')

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

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

new_days.write(title)
print(title)

new_days.write(days)
print(days)

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

[[шаг-5 -—- закрытие-файла]] == Шаг 5. Закрытие файла

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

days_file.close()
new_days.close()

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

[[step-6 -—- verify-our-code]] == Шаг 6. Проверка нашего кода

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

path = '/users/sammy/days.txt'
days_file = open(path,'r')
days = days_file.read()


new_path = '/users/sammy/new_days.txt'
new_days = open(new_path,'w')

title = 'Days of the Week\n'
new_days.write(title)
print(title)

new_days.write(days)
print(days)

days_file.close()
new_days.close()

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

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

OutputDays of the Week

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

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

Days of the Week
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

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

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

Python предоставляет встроенные функции для создания, записи и чтения файлов. Есть два типа файлов, с которыми можно работать в Python: обычные текстовые файлы и двоичные файлы (написанные на двоичном языке, 0s и 1s ).

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

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

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

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

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

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

Синтаксис:

File_object = open (r "Имя_файла", "Режим_доступа")

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

Пример # 1: Предположим, текстовый файл выглядел так.

Мы хотим прочитать содержимое файла с помощью Python.

file1 = открыть ( «myfile.txt»

(file1.read ())

file1.close ()

Выход:

Добро пожаловать в GeeksForGeeks !!

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

файл1 = открыть ( "myfile.txt" ,

000

file1.write ( "\ nЗапись в файл :)" )

file1.close ()

Вывод:

00 9000 и закройте файл в Python

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

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

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

Здесь имя файла - это строковый аргумент, который указывает имя файла вместе с его путем, а режим файла также является строковым аргументом, который используется для указания того, как файл будет использоваться, например, для чтения или записи. 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 = "файл1.текст"
os.remove (cur_file)

Python Функция open () - обучение на примере

Открывает файл и возвращает его как файловый объект

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

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

Подробнее об обработке файлов здесь.

Синтаксис

open (файл, режим, буферизация, кодировка, ошибки, новая строка, closefd, opener)

Буферизация

Параметры функции Python open ()
файл	Обязательно	Путь и имя файла
режим	Необязательно	Указывает режим, в котором вы хотите открыть файл в
	Необязательно	Устанавливает политику буферизации
кодировка	Необязательно	Указывает кодировку
ошибок	Необязательно	Указывает другую схему обработки ошибок
перевод строки	Необязательно	Управляет работой универсального режима новой строки
closefd	Необязательно	Сохраняет дескриптор файла открытым при закрытии файла
открывалка	опционально	нестандартное использование открывателя d для низкоуровневых операций ввода-вывода

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

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

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

  # Указание абсолютного пути
f = open (r'C: \ Python33 \ Scripts \ myfile.txt ')

Помните! При указании точного пути символы, начинающиеся с \ (например, \ n \ r \ t и т. Д.), Интерпретируются как специальные символы.

Вы можете избежать их, используя:

необработанных строк, например r'C: \ new \ text.txt '
двойная обратная косая черта, например ' C: \\ new \\ text.txt '

Укажите режим файла

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

Режимы файлов Python
'r'	Чтение (по умолчанию)	Открыть файл только для чтения
'w'	Запись	Открыть файл только для записи (перезапись)
'a'	Приложение	Открыть файл только для записи (добавить)
'r +'	Чтение + запись	открыть файл для чтения и записи
'x'	Создать	Создать новый файл

Вы также можете указать, как следует обрабатывать файл.

Режимы файлов Python
‘t’	Текст (по умолчанию)	Чтение и запись строк из файла и в файл.
‘b’	Binary	Чтение и запись байтовых объектов из файла и в файл. Этот режим используется для всех файлов, не содержащих текста (например, изображений).

Вот несколько примеров:

  # Открыть файл для чтения
f = открытый ('myfile.txt')

# Открыть файл для записи
f = open ('myfile.txt ',' ш ')

# Открыть файл для чтения и записи
f = открытый ('myfile.txt', 'r +')

# Открываем бинарный файл для чтения
f = open ('myfile.txt', 'rb')

Поскольку режим чтения «r» и текстовый режим «t» являются режимами по умолчанию, вам не нужно их указывать.

Укажите кодировку

Указав параметр кодировки, вы можете декодировать или закодировать файл в популярной кодировке, например 'ascii' , 'UTF-8' и т. Д.

  # Прочитать файл в 'UTF-8' кодирование
f = open ('myfile.txt ', encoding =' UTF-8 ')

  # Прочитать файл в кодировке ascii
f = open ('myfile.txt', encoding = 'ascii')

Обработка ошибок кодирования и декодирования

По умолчанию Python вызывает исключение UnicodeError при ошибках кодирования или декодирования. Однако вы можете указать, как следует обрабатывать эти ошибки, с помощью параметра errors.

В таблице ниже указаны различные схемы обработки ошибок.

1 ignore

Схемы обработки ошибок кодирования
'strict' (по умолчанию)	вызывает исключение UnicodeError при сбое
'backslashreplace'	некодируемый символ заменяется обратной косой чертой
некодируемый символ игнорируется
'namereplace'	некодируемый символ заменяется своим именем
'replace'	некодируемый символ заменяется вопросительным знаком
'xmlcharrefreplace' 9014cod заменяется символом xml

В следующем примере показано, как немецкая буква ß игнорируется при чтении файла в кодировке 'ascii' .

  # Читать файл в формате ascii и игнорировать ошибки декодирования
f = open ('myfile.txt', encoding = 'ascii', errors = 'игнорировать')
печать (f.read ())

# Печатает Das strae

`Python - чтение и запись файлов`

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

Любые файловые операции можно выполнить за три следующих шага:

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

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

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

read (chars): читает указанное количество символов, начиная с текущей позиции.
readline (): считывает символы, начиная с текущей позиции чтения до символа новой строки.
readlines (): читает все строки до конца файла и возвращает объект списка.

Следующий файл C: \ myfile.txt будет использоваться во всех примерах чтения и записи файлов.

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

В следующем примере выполняется операция чтения с использованием метода read (chars) .

  >>> f = open ('C: \ myfile.txt') # открытие файла
>>> lines = f.read () # чтение файла
>>> линии
«Это первая строка. \ nЭто вторая строка. \ nЭто третья строка. '
>>> f.close () # закрытие файлового объекта

Выше f = open ('C: \ myfile.txt ') открывает myfile.txt в режиме чтения по умолчанию из текущего каталога и возвращает файловый объект. Функция f.read () считывает все содержимое до EOF в виде строки. Если вы укажете аргумент размера символа в методе read (chars) , то он будет читать только это количество символов. f.close () очистит и закроет поток.

`Чтение строки`

В следующем примере показано чтение строки из файла.

  >>> f = open ('C: \ myfile.txt') # открытие файла
>>> line1 = f.readline () # чтение строки
>>> line1
«Это первая строка. \ п '
>>> line2 = f.readline () # чтение строки
>>> line2
'Это вторая строка. \ N'
>>> line3 = f.readline () # чтение строки
>>> line3
«Это третья строка».
>>> line4 = f.readline () # чтение строки
>>> line4
''
>>> е.close () # закрытие файлового объекта

Как видите, нам нужно открыть файл в режиме 'r' . Метод readline () вернет первую строку, а затем укажет на вторую строку в файле.

`Чтение всех строк`

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

  >>> f = open ('C: \ myfile.txt') # открытие файла
>>> lines = f.readlines () # чтение всех строк
>>> линии
«Это первая строка. \ nЭто вторая строка. \ nЭто третья строка. '
>>> f.close () # закрытие файлового объекта

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

  f = open ('C: \ myfile.текст')
в то время как True:
    пытаться:
        строка = следующий (е)
        печать (строка)
    кроме StopIteration:
        перерыв
f.close ()

Используйте цикл for, чтобы легко прочитать файл.

  f = открытый ('C: \ myfile.txt')
для строки в f:
    печать (строка)
f.close ()

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

`Чтение двоичного файла`

Используйте режим 'rb' в функции open () для чтения двоичных файлов, как показано ниже.

  >>> f = open ('C: \ myimg.png', 'rb') # открытие двоичного файла
>>> content = f.read () # чтение всех строк
>>> содержание
б '\ x89PNG \ r \ n \ x1a \ n \ x00 \ x00 \ x00 \ rIHDR \ x00 \ x00 \ x00 \ x08 \ x00 \ x00 \ x00 \ x08 \ x08 \ x06
\ x00 \ x00 \ x00 \ xc4 \ x0f \ xbe \ x8b \ x00 \ x00 \ x00 \ x19tEXtSoftware \ x00Adobe ImageReadyq
\ xc9e \ x00 \ x00 \ x00 \ x8dIDATx \ xdab \ xfc \ xff \ xff? \ x03 \ x0c0 / zP \ n \ xa4b \ x818 \ xeco \ x9c
\ xc2 \ r \ x90 \ x18 \ x13 \ x03 * 8 \ t \ xc4b \ xbc \ x01 \ xa8X \ x07 $ \ xc0 \ xc8 \ xb4 \ xf0> \\\ x11P \ xd7?
\ xa0 \ x84 \ r \ x90 \ xb9 \ t \ x88? \ x00q H \ xc1C \ x16 \ xc9 \ x94_ \ xcc \ x025 \ xfd2 \ x88 \ xb1 \ x04
\ x88 \ x85 \ x90 \ x14 \ xfc \ x05 \ xe2 (\ x16 \ x00 \ xe2 \ xc3 \ x8c \ xc8 \ x8e \ x84: \ xb4 \ x04H5 \ x03
\ xf1 \\.bD \ xf3E \ x01 \ x90 \ xea \ x07 \ xe2 \ xd9 \ xaeB` \ x82 '
>>> f.close () # закрытие файлового объекта

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

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

запись (и): записать строку s в поток и вернуть количество записанных символов.
строк записи (строк): записать список строк в поток. В конце каждой строки должен быть разделитель.

`Создать новый файл и записать`

Следующий код создает новый файл, если он не существует, или заменяет существующий файл.

  >>> f = open ('C: \ myfile.txt', 'w')
>>> f.write ("Hello") # запись в файл
5
>>> f.close ()

# чтение файла
>>> f = open ('C: \ myfile.txt', 'r')
>>> f.read ()
'Привет'
>>> f.close ()

В приведенном выше примере f = open ("myfile.txt "," w ") Оператор открывает myfile.txt в режиме записи, метод open () возвращает объект файла и присваивает его переменной f . 'w' указывает, что файл должен быть доступен для записи. Затем f.write («Привет») перезаписывает существующее содержимое файла myfile.txt . Он возвращает количество символов, записанных в файл, которое в приведенном выше примере равно 5. В конце концов, f.close () закрывает файловый объект.

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

Следующий код добавляет содержимое в конец существующего файла, передавая 'a' или 'a +' mode в методе open () .

  >>> f = open ('C: \ myfile.txt', 'a')
>>> f.write («Мир!»)
7
>>> f.close ()

# чтение файла
>>> f = open ('C: \ myfile.txt', 'r')
>>> е.читать()
'Привет, мир!'
>>> f.close ()

`Запись нескольких строк`

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

  >>> lines = ["Привет, мир. \ N", "Добро пожаловать в TutorialsTeacher.\ n "]
>>> f = open ("D: \ myfile.txt", "w")
>>> f.writelines (строки)
>>> f.close ()

Открытие файла в режиме «w» или «a» может быть только записано, но не может быть прочитано. Точно так же режим «r» позволяет только чтение, но не запись. Для одновременного выполнения операций чтения / добавления используйте режим «a +».

`Запись в двоичный файл`

Функция open () по умолчанию открывает файл в текстовом формате.Чтобы открыть файл в двоичном формате, добавьте 'b' к параметру режима. Следовательно, режим «rb» открывает файл в двоичном формате для чтения, а режим «wb» открывает файл в двоичном формате для записи. В отличие от текстовых файлов, двоичные файлы не читаются человеком. При открытии с помощью любого текстового редактора данные невозможно распознать.

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

  f = open ("binfile.bin", "wb")
число = [5, 10, 15, 20, 25]
arr = bytearray (число)
f.write (обр.)
f.close ()

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

`Введение`

Распространенной задачей в программировании является открытие файла и анализ его содержимого. Что вы делаете, если файл, который вы пытаетесь обработать, довольно большой, например, несколько ГБ данных или больше? Ответ на эту проблему - читать по частям файла за раз, обрабатывать его, а затем освобождать его из памяти, чтобы вы могли обработать другой фрагмент, пока не будет обработан весь массивный файл.Хотя вы сами определяете подходящий размер для фрагментов данных, которые вы обрабатываете, для многих приложений целесообразно обрабатывать файл по одной строке за раз.

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

`Базовый файловый ввод-вывод в Python`

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

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

  fp = open ('путь / к / file.txt', 'r')

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

Режим	Описание
`r`	Открыт для чтения обычного текста
`Вт`	Открыт для ввода обычного текста
`а`	Открыть существующий файл для добавления простого текста
`руб`	Открыто для чтения двоичных данных
`ВБ`	Открыть для записи двоичных данных

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

  фп. Закрыть ()

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

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

  с open ('path / to / file.txt') как fp:

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

  попробуйте:
    fp = open ('путь / к / file.txt')
    
наконец:
    fp.close ()

Подходит любой из этих двух методов, причем первый пример более Pythonic.

Файловый объект, возвращаемый функцией open () , имеет три общих явных методов ( read () , readline () и readlines () ) для чтения данных.Метод read () считывает все данные в одну строку. Это полезно для файлов меньшего размера, когда вы хотите выполнять манипуляции с текстом для всего файла. Затем есть readline () , который является полезным способом читать только отдельные строки, постепенно увеличивая их количество, и возвращать их в виде строк. Последний явный метод readlines () будет читать все строки файла и возвращать их в виде списка строк.

Примечание : В оставшейся части этой статьи мы будем работать с текстом книги «Илиада Гомера», которую можно найти на сайте Gutenberg.org, а также в репозитории GitHub, где находится код для этой статьи.

`Построчное чтение файла в Python с помощью строки чтения`

()

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

  filepath = 'Iliad.txt'
с открытым (путь к файлу) как fp:
   линия = fp.readline ()
   cnt = 1
   а строка:
       print ("Строка {}: {}". формат (cnt, line.strip ()))
       линия = fp.readline ()
       cnt + = 1

Этот фрагмент кода открывает файловый объект, ссылка на который хранится в fp , затем читает по одной строке, вызывая readline () для этого файлового объекта итеративно в цикле while . Затем он просто выводит строку на консоль.

Запустив этот код, вы должны увидеть что-то вроде следующего:

  ...
Строка 567: крайне пустяк. У нас нет оставшейся надписи раньше, чем
Строка 568: сороковая Олимпиада, и первые надписи грубые и неумелые.
Строка 569: выполнено; мы даже не можем убедиться, что Архилох, Симонид
Строка 570: Аморга, Каллина, Тиртея, Ксанфа и других ранних элегических и
Строка 571: лирические поэты, написавшие свои сочинения, или в какое время
Строка 572: практика стала привычной.Первая положительная земля, которая
Строка 573: позволяет нам предположить существование рукописи Гомера, находится в
Строка 574: знаменитое постановление Солона о рапсодиях в
Строка 575: Панафинея: но в течение какого времени ранее рукописи имели
Строка 576: существовала, мы не можем сказать.
...

Хотя этот подход грубый, и явный. Определенно не очень питонический. Мы можем использовать метод readlines () , чтобы сделать этот код более лаконичным.

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

строками чтения ()

Метод readlines () считывает всех строк и сохраняет их в списке List . Затем мы можем перебрать этот список и, используя enumerate () , создать индекс для каждой строки для нашего удобства:

  файл = открытый ('Iliad.txt', 'r')
lines = file.readlines ()

для индекса строка в перечислении (строки):
    print ("Строка {}: {}". format (index, line.strip ()))
    
file.close ()

Результат:

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

  ...
Строка 160: ВВЕДЕНИЕ.
Строка 161:
Строка 162:
Строка 163: Скептицизм в такой же степени результат знания, как и знание
Строка 164: скептицизм. Довольствоваться тем, что мы знаем в настоящее время, - это, по большей части,
Строка 165: часть, чтобы заткнуть уши от осуждения; так как из очень постепенного
Строка 166: характер нашего образования, который мы должны постоянно забывать и эмансипировать.
Строка 167: мы сами, знания, полученные ранее; мы должны отложить старую
Строка 168: идеи и новые идеи; и, как мы узнаем, мы должны ежедневно
Строка 169: отучиться чему-то, что стоило нам немалых усилий и беспокойства.
Строка 170: приобретение....

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

`Построчное чтение файла с помощью цикла`

для цикла - наиболее питонический подход

Возвращаемый Файл сам по себе является итерируемым. Нам вообще не нужно извлекать строки через readlines () - мы можем перебирать сам возвращаемый объект.Это также упрощает enumerate () it, чтобы мы могли записывать номер строки в каждый оператор print () .

Это самый короткий, наиболее питонический подход к решению проблемы, который предпочитает большинство:

  с открытым ('Iliad.txt') как f:
    для индекса строка в enumerate (f):
        print ("Строка {}: {}". format (index, line.strip ()))

Результат:

  ...
Строка 277: Ментес из Лейкадии, современной Санта-Мауры, проявивший свои знания и умения.
Строка 278: редко встречающийся в те времена интеллект убедил Мелезигена закрыть
Строка 279: его школа и сопровождать его в путешествиях.Он обещал не только заплатить
Строка 280: его расходы, но чтобы обеспечить ему дополнительную стипендию, настаивая на том, чтобы
Строка 281: «В то время как он был еще молод, он должен был видеть своими собственными глазами.
Строка 282: глаза на страны и города, которые в будущем могут стать подданными его
Строка 283: беседы ". Мелезиген согласился и отправился со своим покровителем,
Строка 284: "изучение всех диковинок стран, которые они посетили, и
...

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

`Приложения для построчного чтения файлов`

Как это можно использовать на практике? Большинство приложений НЛП работают с большими массивами данных. В большинстве случаев нецелесообразно зачитывать все корпуса в память. Хотя это элементарно, вы можете написать с нуля решение для подсчета частоты определенных слов без использования каких-либо внешних библиотек. Давайте напишем простой скрипт, который загружается в файл, читает его построчно и подсчитывает частоту слов, выводит 10 наиболее часто встречающихся слов и количество их вхождений:

  импортная система
импорт ОС

def main ():
   путь к файлу = sys.argv [1]
   если не os.path.isfile (путь к файлу):
       print ("Путь к файлу {} не существует. Выход из ...". формат (путь к файлу))
       sys.exit ()
  
   bag_of_words = {}
   с открытым (путь к файлу) как fp:
       для строки в fp:
           record_word_cnt (line.strip (). split (''), bag_of_words)
   sorted_words = order_bag_of_words (bag_of_words, desc = True)
   print ("10 наиболее часто встречающихся слов {}". формат (sorted_words [: 10]))
  
def order_bag_of_words (bag_of_words, desc = False):
   words = [(word, cnt) для слова, cnt в bag_of_words.Предметы()]
   вернуть отсортированный (слова, ключ = лямбда x: x [1], обратный = по убыванию)

def record_word_cnt (слова, bag_of_words):
    словом в словах:
        если слово! = '':
            если word.lower () в bag_of_words:
                bag_of_words [word.lower ()] + = 1
            еще:
                bag_of_words [word.lower ()] = 1

если __name__ == '__main__':
    главный()

Сценарий использует модуль os , чтобы убедиться, что файл, который мы пытаемся прочитать, действительно существует. Если это так, его построчное чтение и каждая строка передается в функцию record_word_cnt () .Он разделяет пробелы между словами и добавляет слово в словарь - bag_of_words . После того, как все строки записаны в словарь, мы упорядочиваем их через order_bag_of_words () , который возвращает список кортежей в формате (word, word_count) , отсортированный по количеству слов.

Напоследок печатаем десять самых распространенных слов.

Обычно для этого вы создаете модель Bag of Words Model , используя библиотеки, такие как NLTK, хотя и этой реализации будет достаточно.Запустим скрипт и предоставим ему наш Iliad.txt :

  $ python app.py Iliad.txt

Результат:

  Наиболее часто встречающиеся 10 слов [('the', 15633), ('and', 6959), ('of', 5237), ('to', 4449), ('his', 3440), ('in ', 3158), (' с ', 2445), (' а ', 2297), (' он ', 1635), (' от ', 1418)]

Если вы хотите узнать больше о НЛП, у нас есть серия руководств по различным задачам: Обработка естественного языка в Python.

`Заключение`

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

`Открытие файла с помощью метода open () в Python`

`Введение`

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

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

`Метод open () в Python`

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

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

Здесь

файл относится к имени / дескриптору файла, а режим - это режим, в котором файл должен быть открыт. Это основные параметры, необходимые для открытия файла.
буферизация - необязательное целое число, используемое для установки политики буферизации.По умолчанию установлено значение (-1),
кодировка - это имя кодировки, используемой для декодирования или кодирования файла,
ошибок - дополнительная строка, которая указывает, как должны обрабатываться ошибки кодирования и декодирования. . Обратите внимание, что это нельзя использовать в двоичном режиме.
Новая строка управляет тем, как работает универсальный режим новой строки (применяется только к текстовому режиму). Это может быть Нет (по умолчанию), '' , '\ n' , '\ r' и '\ r \ n' .
closefd указывает, является ли переданный параметр файла именем файла или дескриптором файла. Если упоминается дескриптор файла, он должен иметь значение False. Или True (по умолчанию). В противном случае возникнет ошибка,
открыватель - вызываемый настраиваемый открыватель. Указанный файловый дескриптор для файлового объекта получается путем вызова этого средства открытия с помощью (файл, флаги). opener должен возвращать дескриптор открытого файла (передача os.open как opener приводит к функциональности, аналогичной передаче None ).

`Режимы открытия для open () в Python`

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

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

Таблица режимов открытия файлов

`Python open (), пример`

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

Мы собираемся открыть файл с именем file.txt с содержимым (как показано ниже), используя метод open () .

Содержимое файла

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

 # открытие файла
f = open ('file.txt', 'r') # файловый объект

print ("Тип f:", тип (f))

print ("Содержимое файла:")

для i в f:
    печать (я)

f.close () # закрытие файла после успешной операции

Выход:

 Тип f: 
Содержимое файла:
Python

Джава

Идти

C

C ++

Котлин

Здесь мы открыли файл .txt в режиме только для чтения ( 'r' ). Метод open () возвращает объект файла в f . Затем мы выполнили итерацию по этому объекту, используя цикл for для доступа к содержимому файла.

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

`Открытие нескольких файлов`

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

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

 # открытие нескольких файлов
пытаться:
    с open ('file1.txt', 'r +') как a, open ('file2.txt', 'r +') как b:
        print ("Файл 1:")
        для я в:
            печать (я)
        print ("Файл 2:")
        для j в b:
            печать (j)
кроме IOError как e:
    print (f "Произошла ошибка: {e}")

# закрытие файла не требуется

Вывод:

 Файл 1:
Джон Алекс Лео Мэри Джим
Файл 2:
Сил Рантофф Пард Ким Парсонс

Примечание: Мы не закрывали файлы после использования этого времени.Это потому, что нам это не нужно, оператор with гарантирует, что открытые файлы закрываются автоматически, вызывая метод close () .

`Заключение`

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

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

`Ссылки`

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

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

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

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

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

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

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

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

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

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

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

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

Если у вас нет файла 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 открыть файл: Работа с файлами в Python

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

3 ответа

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

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

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

как открыть файл .txt в python в одной строке

3 ответа

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

Импортировать текстовый файл в Python

Используйте функцию

Используйте функцию

Формат файла PY

What is a PY file

python — open () в Python не создает файл, если он не существует

16 ответов

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

Как работать с простыми текстовыми файлами в Python 3

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

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

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

пример

выход

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

пример

пример

пример

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

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

пример

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

, пример

Python Функция open () - обучение на примере

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

Синтаксис

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

Укажите режим файла

Укажите кодировку

Обработка ошибок кодирования и декодирования

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

Чтение файла

Чтение строки

Чтение всех строк

Чтение двоичного файла

Запись в файл

Создать новый файл и записать

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

Запись нескольких строк

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

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

Введение

Базовый файловый ввод-вывод в Python

Построчное чтение файла в Python с помощью строки чтения

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

Построчное чтение файла с помощью цикла

Приложения для построчного чтения файлов

Заключение

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

Введение

Метод open () в Python

Режимы открытия для open () в Python

Python open (), пример

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

Заключение

Ссылки

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

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

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

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

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

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

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

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

`Python - чтение и запись файлов`

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

`Чтение строки`

`Чтение всех строк`

`Чтение двоичного файла`

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

`Создать новый файл и записать`

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

`Запись нескольких строк`

`Запись в двоичный файл`

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

`Введение`

`Базовый файловый ввод-вывод в Python`

`Построчное чтение файла в Python с помощью строки чтения`

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

`Построчное чтение файла с помощью цикла`

`Приложения для построчного чтения файлов`

`Заключение`

`Открытие файла с помощью метода open () в Python`

`Введение`

`Метод open () в Python`

`Режимы открытия для open () в Python`

`Python open (), пример`

`Открытие нескольких файлов`

`Заключение`

`Ссылки`

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

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

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

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

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

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

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

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