# Отчет по теме 6

Володин Денис, А-02-23


## Пункт 1

```py
>>> import os
>>> os.chdir(r"C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA6")
```

## Пункт 2. Вывод данных на экран дисплея

## Пункт 2.1. Вывод данных в командной строке.

Эхо-вывод в терминал

```py
>>> stroka='Автоматизированная система управления'
>>> stroka
'Автоматизированная система управления'
```

## Пункт 2.2 Вывод с использованием функции print

```py
>>> help(print)
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

>>> fff = 234.5; gg = 'Значение температуры = '
>>> print(gg, fff)
Значение температуры =  234.5
```

Это работает и в терминале, и в скриптах, которые записаны в файлы .ру. Причем видно, что
вывод через print() убирает у строки кавычки при выводе.

По умолчанию выводимые объекты разделяются через пробел, но это можно изменить, задав
значение сепаратору sep:

```py
>>> print(gg, fff, sep='/')
Значение температуры = /234.5
```

По умолчанию после того, как функция print() сделала вывод, происходит перенос каретки на
следующую строку. Это тоже можно изменить. Параметр end по умолчанию имеет значение "\n",
его можно изменить на другое.

```py
>>> print(gg, fff,sep = '/', end = '**'); print('___')
Значение температуры = /234.5**___

>>> print()

>>> 
```

Если текст большой, можно расположить его в несколько строк:

```py
>>> print(""" Здесь может выводиться
большой текст,
занимающий несколько строк""")
 Здесь может выводиться
большой текст,
занимающий несколько строк
    
>>> print("Здесь может выводиться",
      "большой текст,",
      "занимающий несколько строк")
Здесь может выводиться большой текст, занимающий несколько строк

>>> print(repr(""" Здесь может выводиться
большой текст,
занимающий несколько строк"""))
' Здесь может выводиться\nбольшой текст,\nзанимающий несколько строк'
```

(Функция repr() показывает то, как объект видит python, а не человек, отображая все символы
табуляции)


## Пункт 2.3. Вывод с использованием write объекта stdout (поток стандартного вывода) модуля sys.

```py
>>> help(sys.stdout.write)
Help on method write in module idlelib.run:

write(s) method of idlelib.run.StdOutputFile instance
    Write string to stream.
    Returns the number of characters written (which is always equal to
    the length of the string).

>>> import sys
>>> sys.stdout.write("Функция write")
Функция write13

>>> sys.stdout.write("Функция write\n")
Функция write
14
```

Важно отметить, что функция выводит текст, но возвращает число. Это число - количество
введенных символов.

```py    
>>> type(sys.stdout.write("Функция write"))
Функция write<class 'int'>

>>> sys.stdout.write()
Traceback (most recent call last):
...
TypeError: write() missing 1 required positional argument: 's'

>>> sys.stdout.write("")
0
```

## Пункт 3. Ввод данных с клавиатуры.

```py
>>> help(input)
Help on built-in function input in module builtins:

input(prompt=None, /)
    Read a string from standard input.  The trailing newline is stripped.
    
    The prompt string, if given, is printed to standard output without a
    trailing newline before reading input.
    
    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
    On *nix systems, readline is used if available.
```

Функция input() приостанавливает дальнейшее выполнение программы и ожидает ввод от пользователя.
Выполнение программы продолжится только после нажатия Enter. input() всегда возвращает строку,
даже если ввести число.

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

```py
>>> psw = input('Введите пароль:')
Введите пароль:qwerty123
>>> psw
'qwerty123'
>>> type(psw)
<class 'str'>

>>> input()
hehe\n
'hehe\\n'
```

Так происходит из-за того, что input() считал все символы как символы, то есть "h", "e", ... "\",
"n". Но при выводе в консоль внутри самой функции input() используется вышеупомянутое
"техническое" отображение repr(). Оно всегда дублирует ("экранирует") бэкслеш, чтобы не дать
python'у воспринять его как символ табуляции.

```py
# Пример 1
>>> while True:
	znach=float(input('Задайте коэф.усиления = '))
	if znach < 17.5 or znach > 23.8:
		print('Ошибка!')
	else:
		break

	
Задайте коэф.усиления = 15.4
Ошибка!
Задайте коэф.усиления = 21.6

# Пример 2
>>> import math
>>> print(eval(input('введите выражение для расчета = ')))
введите выражение для расчета = math.log10(23 / (1 + math.exp(-3.24)))
1.34504378689765
>>> type(eval(input('введите выражение для расчета = ')))
введите выражение для расчета = 2+3
<class 'int'>
>>> type(eval(input('введите выражение для расчета = ')))
введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
<class 'float'>
```

## Пункт 4.  Ввод-вывод при работе с файлами.

## Пункт 4.1. Функции для работы с путём к файлу.

```py
>>> import os
>>> os.getcwd()
'C:\\Users\\denvo\\AppData\\Local\\Programs\\Python\\Python313'
>>> volodin = os.getcwd()
>>> volodin          
'C:\\Users\\denvo\\AppData\\Local\\Programs\\Python\\Python313'

>>> os.chdir(r"C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA6")
>>> os.getcwd()
'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6'


#Создание каталога (mkdir) 
>>> help(os.mkdir)
Help on built-in function mkdir in module nt:

mkdir(path, mode=511, *, dir_fd=None)
    Create a directory.

    If dir_fd is not None, it should be a file descriptor open to a directory,
      and path should be relative; path will then be relative to that directory.
    dir_fd may not be implemented on your platform.
      If it is unavailable, using it will raise a NotImplementedError.

    The mode argument is ignored on Windows. Where it is used, the current umask
    value is first masked out.

>>> os.chdir("mod2")
>>> os.getcwd()
'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\mod2'


#Удаление каталога 
>>> help(os.rmdir)
Help on built-in function rmdir in module nt:

rmdir(path, *, dir_fd=None)
    Remove a directory.
    
    If dir_fd is not None, it should be a file descriptor open to a directory,
      and path should be relative; path will then be relative to that directory.
    dir_fd may not be implemented on your platform.
      If it is unavailable, using it will raise a NotImplementedError.


>>> os.rmdir('C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\mod2')
Traceback (most recent call last):
  File "<pyshell#88>", line 1, in <module>
    os.rmdir('C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\mod2')
PermissionError: [WinError 32] Процесс не может получить доступ к файлу, так как этот файл занят
другим процессом: 'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\mod2'

>>> os.getcwd()
'd:\\STUDY\\LVL3\\Программное обеспечение автоматизированных систем\\Тема6\\testdir'
>>> os.chdir('../') 
>>> os.getcwd()
'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6'
>>> os.rmdir("mod2")

>>> os.rmdir("mod2") 
Traceback (most recent call last):
  File "<pyshell#81>", line 1, in <module>
    os.rmdir("mod2")
FileNotFoundError: [WinError 2] Не удается найти указанный файл: 'mod2'


#Показать список всех файлов и папок, вложенных в текущую
>>> help(os.listdir)
Help on built-in function listdir in module nt:

listdir(path=None)
    Return a list containing the names of the files in the directory.
    
    path can be specified as either str, bytes, or a path-like object.  If path is bytes,
      the filenames returned will also be bytes; in all other circumstances
      the filenames returned will be str.
    If path is None, uses the path='.'.
    On some platforms, path may also be specified as an open file descriptor;\
      the file descriptor must refer to a directory.
      If this functionality is unavailable, using it raises NotImplementedError.
    
    The list is in arbitrary order.  It does not include the special
    entries '.' and '..' even if they are present in the directory.

>>> os.chdir(r'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6')
>>> os.listdir()
['.gitkeep', 'report.md']


#Проверка существования каталога
>>> help(os.path.isdir)
Help on function isdir in module genericpath:

isdir(s)
    Return true if the pathname refers to an existing directory.
    
>>> os.path.isdir("report.md")
False
>>> os.path.isdir("фото")
False


#Возвращение абсолютного пути 
>>> fil = os.path.abspath("report.md")
>>> fil
'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\report.md'
>>> fil = os.path.abspath("test.txt") 
>>> fil
'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\test.txt'


#Отделение из абсолютного пути только каталога/только имени файла
>>> drkt = os.path.dirname(fil)
>>> drkt
'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6'

>>> bsnm = os.path.basename(fil)
>>> print(bsnm)
testest.txt


#Разделение на кортеж из пути и из имени файла
>>> os.path.split(fil)
('C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6', 'test.txt')
>>> type(os.path.split(fil))
<class 'tuple'>


#Проверка существования любого объекта
>>> os.path.exists("D:/GAMES") 
True
>>> os.path.exists("D:/Art")  
False
>>> os.path.exists("D:/Фото/me.jpg") 
False


#Проверка существования файла
>>> os.path.isfile("C:/Users/denvo/OneDrive/Рабочий стол/python-labs/TEMA6/report.md") 
True
>>> os.path.isfile("C:/Users/denvo/OneDrive/Рабочий стол/python-labs/")
False
>>> os.path.isfile("D:/Фото/me.jpg") 
False
```

## Пункт 4.2 	Общая схема работы с файлом

Для обмена данными с файлом необходимо выполнить следующие операции:

•   Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);

•   Выполнение одной или нескольких операций обмена данными с файлом;

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

## Пункт 4.3    Открытие файла для записи или чтения

```py
>>> fp = open(file = drkt+'\\zapis1.txt', mode='w')
>>> type(fp)
<class '_io.TextIOWrapper'>
>>> fp
<_io.TextIOWrapper name='C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
>>> fp.closed
False

>>> dir(fp)
['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__',
 '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__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']
```

Здесь перечислены атрибуты объекта:
    name - абсолютный путь
    mode - режим:
        r - чтение
        w - запись (если такой файл уже есть, его содержимое будет удалено, если нет,
                    создается. Содержимое удаляется в момент открытия, а не в момент первой
                    записи)
        a - дозапись (в конец)
        x - открывает для записи, но только если файл есть, иначе FileExistsError.
        + - чтение и запись:
            r+ - чтение и запись, файл должен существовать.
            w+ - запись и чтение, файл создаётся или перезаписывается.
            a+ - добавление и чтение, файл создаётся, если не существует.

        rb, wb, ab, xb - все то же, но в бинарном режиме (читаются байты)

    encoding - кодировка:
        В Windows в консоли по умолчанию cp1251 или cp1252 в зависимости от языка системы.
        В файлах чаще UTF-8
        Linux, MacOS - UTF-8.

    Еще есть атрибут-флаг closed: True, если файл закрыт, False, если открыт.

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

```py
>>> fp = open('zapis1.txt','w')
>>> fp
<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>


#Пример открытия бинарного файла  
>>> fp1 = open(drkt + '\\zapis2.bin', mode = 'wb+')
>>> fp1
<_io.BufferedRandom name='C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\zapis2.bin'>
```

## Пункт 4.4. Закрытие файла.

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

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

```py
>>> fp.close()
>>> fp
<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
>>> fp.closed
True
```

## Пункт 4.5. Запись информации в файл.

```py
>>> help(fp.write)
Help on built-in function write:

write(text, /) method of _io.TextIOWrapper instance
    Write string to stream.
    Returns the number of characters written (which is always equal to
    the length of the string).

>>> 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')
13
>>> fp2.write(str(sps[4:8]) + '\n')
13
>>> fp2.write(str(sps[8:]) + '\n')
16
>>> fp2.close()
```

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

[1, 2, 3, 4]

[5, 6, 7, 8]

[9, 10, 11, 12]

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

```py
>>> sps3 = [['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
>>> 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()
```

Файл в текстовом редакторе выглядит так:

Иванов И. 1Петров П. 2Сидоров С. 3

Видно, что строки склеились там, где не надо. Попробуем по-другому.

```py
>>> gh = open('zapis5.txt','w')
>>> for r in sps3:
	gh.write(r[0] + ' '+str(r[1]) + '\n')

12
12
13
>>> gh.close()
```

Мы добавили перенос каретки на каждой итерации цикла и пробел в нужном месте. Стало так:

Иванов И. 1

Петров П. 2

Сидоров С. 3


## Пункт 4.6. Чтение из файла, способ 1.

```py
>>> sps1 = []
>>> fp = open('zapis3.txt')
>>> for stroka in fp:
	stroka = stroka.rstrip('\n')
	stroka = stroka.replace('[','')
	stroka = stroka.replace(']','')
	sps1 = sps1 + stroka.split(',') 
```

Метод .rstrip() убирает символы с конца строки. Если не задавать аргументов,
он удалит любые пробелы (пробел, табуляция, символы новой строки и т.п.) с конца строки.

Метод .replace() заменяет первый агрумент на второй. С помощью него мы убираем скобки.

```py
>>> fp.close()
>>> sps1
['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
>>> sps2 = [int(i.strip()) for i in sps1]
>>> sps2
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
```

## Пункт 4.7. Чтение информации из файла с помощью метода read.

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

```py
>>> fp = open('zapis3.txt')
>>> stroka1 = fp.read(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() считывает одну строку из файла за один вызов. Он читает символы до тех пор,
пока не встретит символ новой строки (\n; включается в строку) или конец файла (EOF).
Если файл содержит только одну строку или указатель чтения находится в конце файла, то при
вызове readline() будет возвращена пустая строка.

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

```py
>>> file = open("zapis5.txt")
>>> file.readline()
'Иванов И. 1\n'
>>> file.seek(0)  
0
>>> file.readlines()
['Иванов И. 1\n', 'Петров П. 2\n', 'Сидоров С. 3\n']
```

## Пункт 4.9. Ввод-вывод объектов с использованием функций из модуля pickle.

Этот модуль предназначен для перевода объектов в бинарную форму.

```py
>>> import pickle
>>> mnoz1={'book', 'iPhone', 'table', 'pen'}
>>> fp = open('zapis6.mnz', 'wb')   
>>> pickle.dump(mnoz1, fp)        
>>> fp.close()
```

Откроем получившийся файл в текстовом редакторе, увидим подобную строку.

Ђ•#       Џ”(Њbook”ЊiPhone”Њtable”Њpen”ђ.

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

```py
>>> fp = open('zapis6.mnz','rb')
>>> mnoz2 = pickle.load(fp)
>>> fp.close()
>>> mnoz2
{'book', 'iPhone', 'table', 'pen'}
>>> mnoz1 == mnoz2
True

>>> 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]]
>>> mnoz1 == obj1
True
>>> obj2 == sps3
True
```

## Пункт 5. Перенаправление потоков ввода и вывода данных.

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

sys.stdin — поток ввода 

sys.stdout — поток вывода

sys.stderr — поток ошибок 

```py
>>> import sys

#Сохраним адрес в памяти текущего потока вывода:
>>> vr_out = sys.stdout
>>> vr_out
<idlelib.run.StdOutputFile object at 0x0000018C2F7961C0>

#Откроем файл на запись:
>>> fc = open('Stroka.txt','w')

#Теперь зададим в качестве потока вывода этот файл:
>>> sys.stdout = fc
>>> print('запись строки в файл')

>>> sys.stdout = vr_out
>>> print('запись строки на экран')
запись строки на экран
>>> fc.close()
```

В файле 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
```