форкнуто от main/python-labs
Вы не можете выбрать более 25 тем
Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
445 строки
21 KiB
Markdown
445 строки
21 KiB
Markdown
# Отчет по теме 6
|
|
|
|
Степанов Артём, А-02-23
|
|
|
|
## Ввод-вывод данных и операции с файлами
|
|
|
|
### 1. Установка рабочего каталога. Создание рабочего протокола.
|
|
|
|
В оболочке IDLE установил актуальный рабочий каталог, а затем в нём создал рабочий протокол.
|
|
|
|
|
|
|
|
### 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("Здесь может выводиться",
|
|
... "большой текст",
|
|
... "занимающий несколько строк")
|
|
Здесь может выводиться большой текст занимающий несколько строк
|
|
```
|
|
|
|
#### 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
|
|
>>> pws = input("Введите пароль: ") # Приглашение к вводу
|
|
Введите пароль: 1234567 # Отображение соответствующего приглашения и ввод данных
|
|
>>> pws
|
|
'1234567'
|
|
>>> type(pws)
|
|
<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\\User\\Desktop\\StepanovAV\\python-labs\\TEMA6'
|
|
>>> path = os.getcwd()
|
|
>>> path
|
|
'C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA6'
|
|
```
|
|
|
|
В этом модуле также есть функции, позволяющие создавать и удалять директории, проверять их наличие в рабочем каталоге и другие.
|
|
|
|
```py
|
|
>>> os.mkdir("New directory") # Создание новой директории
|
|
>>> os.mkdir("Another new directory")
|
|
```
|
|
|
|
|
|
|
|
```py
|
|
>>> os.rmdir("Another new directory") # Удаление директории
|
|
```
|
|
|
|
|
|
|
|
```py
|
|
>>> os.path.isdir("New directory"); os.path.isdir("ABCDEF") # Проверка наличия директории в рабочем каталоге
|
|
True
|
|
False
|
|
```
|
|
|
|
Также полный путь доступа к файлу можно получить с помощью отдельной функции __abspath__. Затем из него можно выделить путь к директории, содержащей файл, и имя самого файла с помощью соответствующих функций __dirname__ и __basename__.
|
|
|
|
```py
|
|
>>> fil = os.path.abspath("oplata.dbf") # Получение полного пути к файлу
|
|
>>> fil
|
|
'C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA6\\oplata.dbf'
|
|
>>> drkt = os.path.dirname(fil) # Выделение пути доступа к файлу
|
|
>>> drkt
|
|
'C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA6'
|
|
>>> name = os.path.basename(fil) # Выделение имени файла
|
|
>>> name
|
|
'oplata.dbf'
|
|
>>> directory, fileName = os.path.split(fil) # Одновременное выделение пути доступа к файлу и его имени
|
|
>>> directory
|
|
'C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA6'
|
|
>>> fileName
|
|
'oplata.dbf'
|
|
```
|
|
|
|
Проверка того, указывает ли путь на существующий файл, осуществляется с помощью функции __isfile__.
|
|
|
|
```py
|
|
>>> os.path.isfile(fil) # Проверка пути к файлу
|
|
True
|
|
>>> os.path.isfile("ABCDEF.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
|
|
>>> 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
|
|
>>> 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
|
|
>>> for r in sp3: 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
|
|
'[1, 2, 3, 4]\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()
|
|
```
|
|
|
|
Так как этот файл бинарный, то его содержимое имеет несколько нечитаемый для человека вид:
|
|
|
|
|
|
|
|
Получение объекта из файла можно осуществить с помощью метода __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
|
|
>>> 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.
|