форкнуто от main/python-labs
Родитель
483f69224a
Сommit
e62986477a
@ -0,0 +1 @@
|
||||
Запись строки в файл
|
||||
Двоичный файл не отображается.
@ -0,0 +1,3 @@
|
||||
[1, 2, 3, 4]
|
||||
[5, 6, 7, 8]
|
||||
[9, 10, 11, 12]
|
||||
@ -0,0 +1 @@
|
||||
Иванов И. 1Петров П. 2Сидоров С. 3
|
||||
@ -0,0 +1,3 @@
|
||||
Иванов И. 1
|
||||
Петров П. 2
|
||||
Сидоров С. 3
|
||||
Двоичный файл не отображается.
Двоичный файл не отображается.
@ -0,0 +1,390 @@
|
||||
# Отчет по теме 6
|
||||
|
||||
Беженарь Алёна, А-02-23
|
||||
|
||||
## Ввод-вывод данных и операции с файлами
|
||||
|
||||
## 1. Настройка текущего каталога.
|
||||
|
||||
```py
|
||||
>>> import os
|
||||
>>> os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA6")
|
||||
```
|
||||
|
||||
## 2. Вывод данных на экран дисплея.
|
||||
|
||||
Вывод данных на экран дисплея в среде Python можно осуществить разными способами, которые будут рассматриваться ниже.
|
||||
### 2.1. Вывод в командной строке.
|
||||
При работе с инструкциями, вводимыми в командной строке интерпретатора или среды IDLE, можно пользоваться так называемым "эхо-выводом", однако внутри скриптов и пользовательских функций такой способ не будет работать.
|
||||
```py
|
||||
>>> stroka = "Автоматизированная система управления"
|
||||
>>> stroka # Эхо-вывод переменной stroka
|
||||
'Автоматизированная система управления'
|
||||
```
|
||||
|
||||
### 2.2. Вывод с использованием функции print.
|
||||
Самый простой способ вывода данных на дисплей - использование встроенной функции print.
|
||||
```py
|
||||
>>> fff = 234; gg = "Значение температуры ="
|
||||
>>> print(gg, fff) # Вывод нескольких объектов за одно обращение к функции
|
||||
Значение температуры = 234
|
||||
```
|
||||
Для данной функции можно настроить определенный разделитель:
|
||||
```py
|
||||
>>> print(gg, fff, sep = "/") # Вывод объектов с заданным разделителем
|
||||
Значение температуры =/234
|
||||
```
|
||||
Также можно задать некоторый символ или их последовательность, который будет выводиться в конце строки (по умолчанию это переход на новую строку).
|
||||
```py
|
||||
>>> print(gg, fff, sep = "/", end = "***"); print("____") # Вывод объектов с указанным окончанием строки
|
||||
Значение температуры =/234***____
|
||||
```
|
||||
Внутри данной функции можно использовать многострочные последовательности, которые будут выводиться в соответствующем количестве строк.
|
||||
```py
|
||||
>>> print("""Здесь может выводиться
|
||||
... большой текст,
|
||||
... занимающий несколько строк""")
|
||||
Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк
|
||||
```
|
||||
Однако это не работает с обычными символьными последовательностями, записанными на новых строках:
|
||||
```py
|
||||
>>> print("Здесь может выводиться",
|
||||
... "большой текст,",
|
||||
... "занимающий несколько строк")
|
||||
Здесь может выводиться большой текст, занимающий несколько строк
|
||||
```
|
||||
Текст выводится в 1 строку.
|
||||
|
||||
### 2.3. Вывод с использованием метода write объекта sys.stdout.
|
||||
|
||||
Стандартный же способ вывода данных - через поток вывода stdout, находящийся в модуле sys. В данном методе не происходит автоматический переход на новую строку при последовательном его использовании, поэтому необходимо вручную добавлять символ "\n".
|
||||
|
||||
```py
|
||||
>>> import sys
|
||||
>>> sys.stdout.write("Функция write") # Вывод строки с помощью метода write
|
||||
Функция write13 # Число 13 в конце - количество символов в строке
|
||||
>>> sys.stdout.write("Функция write\n")
|
||||
Функция write
|
||||
14
|
||||
```
|
||||
## 3. Ввод данных с клавиатуры.
|
||||
Для ввода данных с клавиатуры используется изученная ранее функция input.
|
||||
```py
|
||||
>>> psw = input("Введите пароль: ") # Приглашение к вводу
|
||||
Введите пароль: 12345 # Отображение соответствующего приглашения и ввод данных
|
||||
>>> psw
|
||||
'12345'
|
||||
>>> print(psw)
|
||||
12345
|
||||
>>> type(psw)
|
||||
<class 'str'>
|
||||
```
|
||||
Ввод значений можно контролировать с помощью циклов и оператора прерывания:
|
||||
|
||||
```py
|
||||
>>> while True:
|
||||
... znach = float(input("Задайте коэф. усиления = "))
|
||||
... if znach < 17.5 or znach > 23.8:
|
||||
... print("Ошибка!")
|
||||
... else:
|
||||
... break
|
||||
...
|
||||
Задайте коэф. усиления = 15.4
|
||||
Ошибка!
|
||||
Задайте коэф. усиления = 21.6
|
||||
>>>
|
||||
```
|
||||
|
||||
Также с помощью оператора ввода можно вычислять значения выражений, корректно заданных пользователем:
|
||||
|
||||
```py
|
||||
>>> import math
|
||||
>>> print(eval(input("Введите выражение для расчета: ")))
|
||||
Введите выражение для расчета: math.log10(23 / (1 + math.exp(-3.24)))
|
||||
1.34504378689765
|
||||
```
|
||||
|
||||
## 4. Ввод-вывод при работе с файлами.
|
||||
При работе с файлом необходимо указывать источник данных - полное имя файла с путем доступа к его расположению.
|
||||
### 4.1. Функции для работы с путём к файлу.
|
||||
Если файл находится в текущем рабочем каталоге, то для получения полного пути доступа до этого файла будет проще сначала получить путь до рабочего каталога. Сделать это можно с помощью функции getcwd модуля os.
|
||||
```py
|
||||
>>> import os
|
||||
>>> os.getcwd() # Отображение текущего рабочего каталога
|
||||
'C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA6'
|
||||
>>> Bezhenar = os.getcwd()
|
||||
>>> print(Bezhenar)
|
||||
C:\Users\Дружок\Desktop\ПОАС\python-labs\TEMA6
|
||||
```
|
||||
В этом модуле также есть функции, позволяющие создавать и удалять директории, проверять их наличие в рабочем каталоге и другие.
|
||||
|
||||
```py
|
||||
>>> os.mkdir("New directory") # Создание новой директории
|
||||
>>> os.listdir() #Возвращает список имен файлов находящихся в рабочей директории
|
||||
['.gitkeep', 'New directory', 'report.md']
|
||||
>>> os.path.isdir("New directory"); os.path.isdir("ABC") # Проверка наличия директории в рабочем каталоге
|
||||
True
|
||||
False
|
||||
>>> os.rmdir('New directory') # Удаление директории
|
||||
>>> os.listdir()
|
||||
['.gitkeep', 'report.md']
|
||||
```
|
||||
Также полный путь доступа к файлу можно получить с помощью отдельной функции abspath. Затем из него можно выделить путь к директории, содержащей файл, и имя самого файла с помощью соответствующих функций dirname и basename.
|
||||
```py
|
||||
>>> fil = os.path.abspath("report.md") # Получение полного пути к файлу
|
||||
>>> print(fil)
|
||||
C:\Users\Дружок\Desktop\ПОАС\python-labs\TEMA6\report.md
|
||||
>>> drkt = os.path.dirname(fil) # Выделение пути доступа к файлу
|
||||
>>> print(drkt)
|
||||
C:\Users\Дружок\Desktop\ПОАС\python-labs\TEMA6
|
||||
>>> name = os.path.basename(fil) # Выделение имени файла
|
||||
>>> print(name)
|
||||
report.md
|
||||
>>> directory, fileName = os.path.split(fil) # Разделяет путь к файлу на путь доступа к файлу и его имя (Возвращает кортеж из этих двух составляющих)
|
||||
>>> print(directory);print(fileName)
|
||||
C:\Users\Дружок\Desktop\ПОАС\python-labs\TEMA6
|
||||
report.md
|
||||
```
|
||||
Проверка того, указывает ли путь на существующий файл, осуществляется с помощью функции isfile.
|
||||
```py
|
||||
>>> os.path.isfile(fil) # Проверка пути к файлу
|
||||
True
|
||||
>>> os.path.isfile("ABC.txt")
|
||||
False
|
||||
```
|
||||
|
||||
### 4.2. Общая схема работы с файлом.
|
||||
Для обмена данными с файлом необходимо выполнить следующие операции:
|
||||
*Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
|
||||
*Выполнение одной или нескольких операций обмена данными с файлом;
|
||||
*Закрытие файла.
|
||||
### 4.3. Открытие файла для записи и чтения файла.
|
||||
Для открытия файла используется функция open, в которой необходимо указывать путь и имя открывающегося файла и цель его использования. Имена аргументов в данной функции можно опускать, но тогда сами аргументы должны идти в правильном порядке. (Если же файл находится в текущем рабочем каталоге, то полный путь к нему можно не указывать, будет достаточно только его имени.)
|
||||
|
||||
Различные значения аргумента mode:
|
||||
|
||||
*w - запись/перезапись файла
|
||||
*w+ - чтение и запись/перезапись файла
|
||||
*r - только чтение существующего файла
|
||||
*r+ - чтение и/или запись в существующий файл
|
||||
*a - запись в конец существующего файла
|
||||
*a+ - запись в конец существующего файла с возможностью чтения
|
||||
|
||||
```py
|
||||
>>> fp = open(file = drkt + "\\zapis1.txt", mode = "w") # Открытие файла с явным указанием пути и цели использования
|
||||
>>> fp = open(drkt + "\\zapis1.txt", "w") # Открытие файла без указания имен аргументов
|
||||
>>> fp = open("zapis1.txt", "w") # Открытие файла, путь к которому совпадает с рабочим каталогом
|
||||
>>> type(fp)
|
||||
<class '_io.TextIOWrapper'>
|
||||
>>> dir(fp)
|
||||
['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
|
||||
>>> fp1 = open(drkt + "\\zapis2.bin", "wb+") # Открытие бинарного файла
|
||||
```
|
||||
|
||||
### 4.4. Закрытие файла.
|
||||
После завершения работы с файлом его необходимо закрывать для обеспечения сохранности его содержимого. Это делается с помощью функции close, применяемой к файловой переменной.
|
||||
```py
|
||||
>>> fp.close()
|
||||
```
|
||||
|
||||
### 4.5. Запись информации в файл.
|
||||
Стандартный вариант записи в файл - использование метода write.
|
||||
```py
|
||||
>>> sps = list(range(1, 13))
|
||||
>>> sps
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
|
||||
>>> fp2 = open("zapis3.txt", "w")
|
||||
>>> fp2.write(str(sps[:4]) + "\n") # Запись в файл первых 4 значений + переход на новую строку
|
||||
13
|
||||
>>> fp2.write(str(sps[4:8]) + "\n")
|
||||
13
|
||||
>>> fp2.write(str(sps[8:]) + "\n")
|
||||
16
|
||||
>>> fp2.close()
|
||||
```
|
||||
В файле можно наблюдать следующий вывод:
|
||||
```py
|
||||
[1, 2, 3, 4]
|
||||
[5, 6, 7, 8]
|
||||
[9, 10, 11, 12]
|
||||
```
|
||||
|
||||
Запись данных также можно проводить внутри цикла:
|
||||
|
||||
```py
|
||||
>>> sps3 = [["Иванов И.", 1], ["Петров П.", 2], ["Сидоров С.", 3]]
|
||||
>>> fp3 = open("zapis4.txt", "w")
|
||||
>>> for i in range(len(sps3)):
|
||||
... stroka4 = sps3[i][0] + " " + str(sps3[i][1])
|
||||
... fp3.write(stroka4)
|
||||
...
|
||||
11
|
||||
11
|
||||
12
|
||||
>>> fp3.close()
|
||||
```
|
||||
Получившаяся запись:
|
||||
```py
|
||||
Иванов И. 1Петров П. 2Сидоров С. 3
|
||||
```
|
||||
Вышло совсем не так, как мы хотели изначально.
|
||||
Попробуем иначе:
|
||||
```py
|
||||
>>> fp3.close()
|
||||
>>> gh = open("zapis5.txt", "w")
|
||||
>>> for r in sps3:
|
||||
... gh.write(r[0] + " " + str(r[1]) + "\n")
|
||||
...
|
||||
12
|
||||
12
|
||||
13
|
||||
>>> gh.close()
|
||||
```
|
||||
Вывод в файле:
|
||||
```py
|
||||
Иванов И. 1
|
||||
Петров П. 2
|
||||
Сидоров С. 3
|
||||
```
|
||||
Теперь делается с переходом на новую строку.
|
||||
|
||||
Весь этот цикл можно было бы представить в одной строчке, содержимое файла получилось бы таким же.
|
||||
```py
|
||||
>>> for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
|
||||
```
|
||||
### 4.6. Чтение информации из текстового файла внутри цикла.
|
||||
Чтение данных из файла происходит последовательно, начиная с некоторого символа. В качестве примера прочитан ранее созданный файл zapis3.txt:
|
||||
```py
|
||||
>>> sps1 = []
|
||||
>>> fp = open("zapis3.txt")
|
||||
>>> for stroka in fp:
|
||||
... stroka = stroka.rstrip("\n") # Удаление символа \n с конца строки
|
||||
... stroka = stroka.replace("[", "")
|
||||
... stroka = stroka.replace("]", "")
|
||||
... sps1 = sps1 + stroka.split(",")
|
||||
...
|
||||
>>> fp.close()
|
||||
>>> sps1
|
||||
['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
|
||||
```
|
||||
Как видно из результата, прочитанные данные несколько отличаются от исходных. Исправить это можно, внеся небольшие изменения в алгоритм чтения:
|
||||
```py
|
||||
>>> sps2 = []
|
||||
>>> fp = open("zapis3.txt")
|
||||
>>> for stroka in fp:
|
||||
... stroka = stroka.rstrip("\n")
|
||||
... stroka = stroka.replace("[", "").replace("]", "").replace(" ", "")
|
||||
... sps2 = sps2 + [int(x) for x in stroka.split(",")]
|
||||
...
|
||||
>>> fp.close()
|
||||
>>> sps2
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
|
||||
```
|
||||
### 4.7. Чтение информации с помощью метода read.
|
||||
Метод read, также как и write, относится к объекту - файловой переменной. В качестве аргумента можно задать определенное количество символов/байт, которое должно быть прочитано из файла.
|
||||
```py
|
||||
>>> fp = open("zapis3.txt")
|
||||
>>> stroka1 = fp.read(12) # Чтение первых 12 байт (символов)
|
||||
>>> stroka2 = fp.read() # Чтение файла полностью
|
||||
>>> fp.close()
|
||||
>>> stroka1
|
||||
'[1, 2, 3, 4]'
|
||||
>>> stroka2
|
||||
'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
|
||||
```
|
||||
### 4.8. Чтение информации с помощью методов readline и readlines.
|
||||
Методы readline и readlines позволяют прочитать одну или несколько строк символов соответственно. (Чтение происходит с текущего положения маркера)
|
||||
```py
|
||||
>>> fp = open("zapis3.txt")
|
||||
>>> stroka1 = fp.readline() # Чтение первой строки файла
|
||||
>>> stroka2 = fp.readline() # Чтение второй строки файла
|
||||
>>> fp.close()
|
||||
>>> fp = open("zapis3.txt")
|
||||
>>> stroka3 = fp.readlines() # Чтение всех строк файла
|
||||
>>> fp.close()
|
||||
>>> stroka1
|
||||
'[1, 2, 3, 4]\n'
|
||||
>>> stroka2
|
||||
'[5, 6, 7, 8]\n'
|
||||
>>> stroka3
|
||||
['[1, 2, 3, 4]\n', '[1, 2, 3, 4]\n', '[9, 10, 11, 12]\n']
|
||||
|
||||
```
|
||||
### 4.9. Ввод-вывод объектов с использованием функции из модуля pickle.
|
||||
Для работы с бинарными файлами можно пользоваться функциями из модуля pickle. Примером этого может послужить запись объекта-множества в бинарный файл:
|
||||
```py
|
||||
>>> import pickle
|
||||
>>> mnoz1 = {"pen", "book", "pen", "iPhone", "table", "book"}
|
||||
>>> fp = open("zapis6.mnz", "wb")
|
||||
>>> pickle.dump(mnoz1, fp) # Запись объекта в файл
|
||||
>>> fp.close()
|
||||
```
|
||||
Содержимое файла:
|
||||
```py
|
||||
耄锣 鐨谆楐桯湥钌Ѣ潯殔谅瑡扬斔调灥溔逮
|
||||
```
|
||||
Получение объекта из файла можно осуществить с помощью метода load:
|
||||
```py
|
||||
>>> fp = open("zapis6.mnz", "rb")
|
||||
>>> mnoz2 = pickle.load(fp) # Получение объекта из файла
|
||||
>>> fp.close()
|
||||
>>> mnoz2
|
||||
{'book', 'iPhone', 'table', 'pen'}
|
||||
>>> mnoz1 == mnoz2
|
||||
True
|
||||
```
|
||||
Важно подметить, что при считывании из файла объекты имеют тот же порядок, что и при их записи в него:
|
||||
```py
|
||||
>>> fp = open("zapis7.2ob", "wb")
|
||||
>>> pickle.dump(mnoz1, fp)
|
||||
>>> pickle.dump(sps3, fp)
|
||||
>>> fp.close()
|
||||
>>> fp = open("zapis7.2ob", "rb")
|
||||
>>> obj1 = pickle.load(fp) # Получение объекта, записанного первым
|
||||
>>> obj2 = pickle.load(fp) # Получение объекта, записанного вторым
|
||||
>>> fp.close()
|
||||
>>> obj1
|
||||
{'book', 'iPhone', 'table', 'pen'}
|
||||
>>> obj2
|
||||
[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
|
||||
```
|
||||
## 5. Перенаправление потоков ввода и вывода данных.
|
||||
Потоки ввода-вывода можно перенаправлять, например в файл:
|
||||
```py
|
||||
>>> import sys
|
||||
>>> vr_out = sys.stdout # Сохранение текущего потока вывода
|
||||
>>> fc = open("Stroka.txt", "w")
|
||||
>>> sys.stdout = fc # Перезапись потока вывода с экрана на файл
|
||||
>>> print("Запись строки в файл")
|
||||
>>> fc.close()
|
||||
>>> sys.stdout = vr_out # Возвращение истинного значения потока вывода
|
||||
>>> print("Запись строки на экран")
|
||||
Запись строки на экран
|
||||
```
|
||||
В результате данных действий строка "Запись строки в файл" записалась в файл Stroka.txt:
|
||||
```py
|
||||
Запись строки в файл
|
||||
```
|
||||
Аналогичную операцию можно провести и для потока ввода sys.stdin – вместо клавиатуры – из файла:
|
||||
```py
|
||||
>>> tmp_in = sys.stdin # Сохранение текущего потока ввода
|
||||
>>> fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
|
||||
>>> sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
|
||||
>>> sys.stdin
|
||||
<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
|
||||
>>> while True:
|
||||
... try:
|
||||
... line = input() # Чтение строки из файла
|
||||
... print(line)
|
||||
... except EOFError:
|
||||
... break
|
||||
...
|
||||
Запись строки в файл
|
||||
>>> fd.close()
|
||||
>>> sys.stdin = tmp_in # Возвращение истинного значения потока ввода
|
||||
```
|
||||
## 6. Завершение работы со средой.
|
||||
Сохранила файлы отчета в своем рабочем каталоге и закончила сеанс работы с IDLE.
|
||||
|
||||
Загрузка…
Ссылка в новой задаче