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

Кузьменко Елена, А-02-23

## 1. Запустили интерактивную оболочку IDLE.

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

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

```py
>>> stroka = 'Автоматизированная система управления'; stroka # эхо-вывод
'Автоматизированная система управления' 
```

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

Обычный вывод:

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

Помимо пробела разделителем могут служить другие знаки, используя команду sep:

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

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

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

С помощью print() можно перейти на новую строку:

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

Оператор вывода на нескольких строках:

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

Или

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

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

### 2.3. Использование метода write объекта sys.stdout.

Объект stdout представляет собой поток стандартного вывода – объект, в который программы выводят символьное представление данных.

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

Метод sys.stdout.write() выводит строку без автоматического перевода на новую строку (в отличие от print()), из чего следует добавить один или несколько символов "\n":

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

Также можно заметить, что при вызове sys.stdout.write() печатается не только аргумент функции, но и некоторое число, отвечающее за количество успешно записанных символов.

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

Для ввода используется функция input:

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

#### Пример 1.Ввод и контроль контроль значения в цикле while.

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

	
Задайте коэф.усиления = 10.1
Ошибка!
Задайте коэф.усиления = 31.0
Ошибка!
Задайте коэф.усиления = 18.9
>>> 
```

#### Пример 2.Ввод и обрабтка выражения eval().

```py
>>> import math
>>> print(eval(input('введите выражение для расчета = ')))
введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
1.34504378689765
```

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

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

Чтобы узнать текущий рабочий каталог используется функция os.getcwd (cwd = current working directory)

```py
>>> import os
>>> os.getcwd() # пути разделяются двойными обратными слэшами \\
'C:\\Users\\Admin\\AppData\\Local\\Programs\\Python\\Python39'
>>> os1 = os.getcwd(); print(os1) # пути разделются \
C:\Users\Admin\AppData\Local\Programs\Python\Python39
```

Смена рабочего каталога:

```py
>>> os.chdir('C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6')
>>> os.getcwd()
'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6'
```

#### Самостоятельно:

os.mkdir() - создание нового каталога:

```py
>>> os.mkdir('help')
>>> os.chdir('help'); os.getcwd()
'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\help'
```

os.listdir() - список каталогов и файлов в текущем рабочем каталоге.

```py
>>> os.chdir('../'); os.getcwd()
'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6'
>>> os.listdir()
['.gitkeep', 'help', 'report.md', 'task.md']
```

os.rmdir() - удаление каталога.

```py
>>> os.rmdir('help'); os.listdir()
['.gitkeep', 'report.md', 'task.md']
```

os.path.isdir() - проверка наличия каталога.

```py
>>> os.mkdir('test'); os.listdir()
['.gitkeep', 'report.md', 'task.md', 'test']
>>> os.path.isdir('tast.md')
False # не является каталогом
>>> os.path.isdir('help')
False # отсутствие каталога
>>> os.path.isdir('test')
True
```

Путь до файла report.md с помощью функции os.path.abspath():

```py
>>> fil = os.path.abspath("report.md"); fil
'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\report.md'
```

Пусть в каталоге есть файла oplata.dbf:

```py
>>> fil = os.path.abspath("oplata.dbf"); fil
'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\oplata.dbf'
```

Извлечем путь каталога из "абсолютного" пути с помощью функции os.path.dirname():

```py
>>> drkt = os.path.dirname(fil); drkt
'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6'
```

Наоборот, отобразим название файла из абсолютного пути с помощью функции os.path.basename():

```py
>>> bsn = os.path.basename(fil); bsn
'oplata.dbf'
```

os.path.split() позволяет работать с директорией и именем файла в пути, создавая кортеж:

```py
>>> os.path.split(fil)
('C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6', 'oplata.dbf')
```

os.path.exists(fil) проверяет наличие объекта с известным расположением:

```py
os.path.exists(fil)       
True
fil1=drkt + '\\katalog1'; print(fil1)        
C:\Users\Admin\Desktop\python-labs\TEMA6\katalog1
os.path.exists(fil1)       
False

```
Провека наличия файла с известным расположением с помощью функции os.path.isfile():

```py
>>> fil
'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\oplata.dbf'
>>> os.path.isfile(fil)
False
```

### 4.2. Общая схема работы с файлом.

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

### 4.3. Функция open() - открытия файла.

Откроем файл zapis1.txt для записи данных с помощью функции open():

```py
>>> fp = open(file = drkt + '\\zapis1.txt', mode=  'w')
>>> fp
<_io.TextIOWrapper name='C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
>>> type(fp); dir(fp)
<class '_io.TextIOWrapper'> # для работы с текстовыми данными
['_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']
```

fp – это файловый объект, который в других языках программирования обычно называют файловой переменной. Он сохраняет ссылку на открываемый файл и позволяет в дальнейшем ссылаться на файл, не указывая путь и имя открытого файла.

В аргумент mode записывается операция, используемая с файлом:

	1) r – только чтение (это значение - по умолчанию)
	2) w – запись с созданием нового файла или перезапись существующего файла
	3) a - запись в конец существующего файла или, если его нет, запись с созданием файла,

Существуют комбинированные операции: 

	1) r+ - чтение и/или запись в существующий файл
	2) w+ - чтение и запись/перезапись файла
	3) a+ - то же, что и в «a», но с возможностью чтения из файла

Если имя файла на месте первого аргумента, а операция на втором, то можно записывать без имён:

```py
>>> fp = open('zapis1.txt','w'); fp
<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
>>> fp = open(drkt + '\\zapis1.txt', 'w'); fp
<_io.TextIOWrapper name='C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
```

Файлы могут быть бинарными или символьными. При открытии бинарного файла к аргументу-цели добавляется "b":

```py
>>> fp1 = open(drkt + '\\zapis2.bin', mode = 'wb+')
```

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

### 4.4. Закрытие файла. Метод close().

Сохранность файла после завершения работы с ним обеспечивается, например, с помощью метода close():

```py
>>> fp.close()
```

### 4.5. Запись информации в файл. Метод write().

```py
>>> sps = list(range(1,13))
>>> fp2 = open('zapis3.txt','w')
>>> fp2.write(str(sps[:4])+'\n')
13 # количество записанных символов 12 "[1, 2, 3, 4]" + 1 перенос "\n"
>>> fp2.write(str(sps[4:8])+'\n')
13
>>> fp2.write(str(sps[8:])+'\n')
16
>>> fp2.close()
```

Содержимое файла zapis3.txt:

```py
[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]
```

#### Пример со списком.

```py
>>> sps3 = [['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]; sps3
[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
```

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

```py
>>> fp3 = open('zapis4.txt', 'w')
for i in range(len(sps3)):
	stroka4=sps3[i][0]+' '+str(sps3[i][1])
	fp3.write(stroka4)
>>> for i in range(len(sps3)):
	stroka4=sps3[i][0]+' '+str(sps3[i][1])
	fp3.write(stroka4)

	
11
11
12
>>> fp3.close()
```

Содержимое файла zapis3.txt:

```py
Иванов И. 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()
```

Содержимое файла zapis5.txt:

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

Запись в одной строке:

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

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

Содержимое файла zapis6.txt:

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

### 4.6. Первый способ чтения информации из текстового файла.

```py
>>> sps1 = []
>>> fp = open('zapis3.txt')
>>> for stroka in fp:
	stroka=stroka.rstrip('\n') # rstrip() - удаляется символ конца строки
	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']
>>> sps
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
```

Список sps1 содержит элементы строкового типа, а в sps целочисленного. Преобразуем:

```py
>>> sps3 = list(map(int,sps1)); sps3
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
```

### 4.7. Чтение информации из файла. Метод read().

Содержание файла zapis3.txt:

```py
[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]
```

```py
>>> fp = open('zapis3.txt')
>>> stroka1 = fp.read(12) # читает первые 12 элементов, маркер на 13-м
>>> stroka2 = fp.read() # считывает оставшиеся
>>> stroka1; stroka2
'[1, 2, 3, 4]'
'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
>>> fp.close()
```

### 4.8. Методы readline и readlines.

```py
>>> fp = open('zapis3.txt')
>>> st1 = fp.readline() # прочитает одну строку символов(или совокупность байт для бинарного)
>>> st2 = fp.readlines() # прочитает все строки(все байты)
>>> fp.close()
>>> st1; st2
'[1, 2, 3, 4]\n'
['[5, 6, 7, 8]\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)  #dump – метод записи объекта в файл
>>> fp.close()
```

Содержимое файла zapis6.mnz:

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

Прочтение файла выводит такой же результат, какой был при записывании:

```py
>>> fp = open('zapis6.mnz','rb')
>>> mnoz2 = pickle.load(fp)  #load – метод чтения объекта из бинарного файла
>>> fp.close()
>>> mnoz2
{'table', 'pen', 'iPhone', 'book'}
>>> 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)  # первое обращение к load читает первый объект
>>> obj2 = pickle.load(fp)  # второе – читает второй
>>> fp.close()
>>> obj1; obj2
{'table', 'pen', 'iPhone', 'book'}
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
>>> obj1 == mnoz1; obj2 == sps3
True
True
```

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

```py
>>> import sys
>>> vr_out = sys.stdout # запоминаем текущий поток вывода
>>> 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 # возвращаем стандартное назначение для потока ввода
```

## 6. Завершение сеанса работы с IDLE.







