python-labs/TEMA6/report.md

# Отчет по теме 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.