TsvetkovaTA
/
python-labs
форкнуто от main/python-labs
1
0
Форкнуть 0
Код Задачи Запросы на слияние Пакеты Проекты Релизы Вики Активность

laba6

Просмотр исходного кода
main
Tsvetkova Tatyana 1 месяц назад
Родитель a621ace813
Сommit ae4e396508
1 изменённых файлов: 624 добавлений и 0 удалений
Показать статистику Скачать Patch файл Скачать Diff файл

624
TEMA6/laba5.md
Unescape Просмотреть файл

@ -0,0 +1,624 @@
# Пункт 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
```
После вывода автоматически осуществляется переход на другую строку. Если курсор надо оста-вить в той же строке, то следует использовать еще один аргумент, например,
```py
>>> print(gg, fff,sep='/',end='***'); print('____')
Значение температуры = /234.5***____
```
После end= надо указать какими символами должна закончиться выводимая строка или ука-зать пустую строку. Наоборот, если в какой-то момент требуется просто перейти на новую стро-ку, можно использовать такое обращение к функции:
```py
>>> print()
```
Если текст большой, можно расположить его в несколько строк с использованием тройных кавычек
```py
>>> print(""" Здесь может выводиться
... большой текст,
... занимающий несколько строк""")
Здесь может выводиться
большой текст,
занимающий несколько строк
```
Или переносить отдельные объекты, разделенные запятой:
```py
>>> print("Здесь может выводиться",
... "большой текст,",
... "занимающий несколько строк")
Здесь может выводиться большой текст, занимающий несколько строк
```
Разница в том, что в первом случае тройные кавычки воспроизводят текст ровно так, как он был
введен. В тексте были введены переносы строки, но они были введены не как символ \n, а
в обычном человекопонятном виде. Тем не менее, при желании на них можно посмотреть:
```py
>> print(repr(""" Здесь может выводиться
большой текст,
занимающий несколько строк"""))
' Здесь может выводиться\nбольшой текст,\nзанимающий несколько строк'
```
(Функция repr() показывает то, как объект видит python, а не человек, отображая все символы
табуляции)
Во втором случае три выводимых объекта-строки перечисленны через запятую, и это работает как
обычный print(), разделяющий объекты с помощью пробелов, если не указано иное.
## Пункт 2.3. Вывод с использованием write объекта stdout (поток стандартного вывода) модуля sys.
```py
>>> import sys
>>> sys.stdout.write('Функция write')
Функция write13
>>> sys.stdout.write('Функция write\n')
Функция write
14
```
Важно отметить, что функция выводит текст, но возвращает число. Это число - количество
введенных символов, причем \n считается за один символ, а не за два.
```py
>>> type(sys.stdout.write("Функция write"))
Функция write<class 'int'>
```
Если вызвать эту функцию без аргументов, вернется ошибка:
```py
>>> sys.stdout.write()
Traceback (most recent call last):
...
TypeError: write() missing 1 required positional argument: 's'
```
Если сообщить пустую строку, то, соответственно, 0.
```py
>>> sys.stdout.write("")
0
```
## Пункт 3. Ввод данных с клавиатуры.
```py
>>> psw=input('Введите пароль:')
Введите пароль:sewfx
>>> psw
'sewfx'
>>> type(psw)
<class 'str'>
```
input() не воспринимает символы табуляции, считывая их как обычные строки. Более того, возможно
такое:
```py
>>> input()
dpdpdp\n
'dpdpdp\\n'
```
Так происходит из-за того, что input() считал все символы как символы, то есть "p", "d", ... "\",
"n". Но при выводе в консоль внутри самой функции input() используется вышеупомянутое
"техническое" отображение repr(). Оно всегда дублирует ("экранирует") бэкслеш, чтобы не дать
python'у воспринять его как символ табуляции.
```py
>>> while True:
... znach=float(input('Задайте коэф. усиления= '))
... if znach<17.5 or znach>23.8:
... print('Ошибка!')
... else:
... break
...
Задайте коэф. усиления= 16
Ошибка!
Задайте коэф. усиления= 26.7
Ошибка!
Задайте коэф. усиления= 20
```
```py
>>> import math
>>> print(eval(input('введите выражение для расчета=')))
введите выражение для расчета=math.log10(23/(1+math.exp(-3.24)))
1.34504378689765
```
Введенная через input() строка преобразуется в исполнительные инструкции с помощью eval(),
они потом выполняются и результат выводится на экран. Строка имеет тип, соответствующий
результату вычислений и задаваемый автоматически:
```py
>>> type(eval(input('введите выражение для расчета = ')))
введите выражение для расчета = 2+3
<class 'int'>
```
```py
>>> type(eval(input('введите выражение для расчета = ')))
введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
<class 'float'>
```
# Пункт 4. Ввод-вывод при работе с файлами.
## Пункт 4.1. Функции для работы с путём к файлу.
```py
>>> import os
>>> os.getcwd()
'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6'
>>> tsvetkova=os.getcwd()
>>> print(tsvetkova)
C:\Users\Admin\Documents\Tsvetkova\python-labs\TEMA6
>>> print(type(tsvetkova))
<class 'str'>
```
По умолчанию:
```py
>>> import os
>>> os.getcwd()
'C:\\WINDOWS\\System32'
```
Сменим директорию и посмотрим, что смена произошла:
```py
>>> os.chdir(r'C:\Users\Admin\Documents\Tsvetkova\python-labs\TEMA1')
>>> os.getcwd()
'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA1'
```
Сменим директорию на верную:
```py
os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6')
```
познкомимся с другими командами модуля os
```py
>>>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.
```
Создание каталога (mkdir)
```py
>>> os.mkdir('lalala')
>>> os.getcwd()
'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6'
>>> os.listdir()
['.gitkeep', 'lab5.txt', 'lalala']
```
удаление папки
```py
>>> 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.
```
```py
>>> os.rmdir('lalala')
>>> os.listdir()
['.gitkeep', 'lab5.txt']
```py
Одако, если мы будем находиться в самой папке, которую хотим удалить, то у нас это не получится и питон выведет ошибку. Чтобы это исправить необходимо сменить путь и выйти из папки. Можно использовать команду
```py
os.chdir('../') # Поднимает нас на одну папку выше. ../../ - для двух папок и т.д.
```
Просмотр списка директории
```py
>>> os.listdir()
['.gitkeep', 'lab5.txt']
```
Проверка существования каталога
```py
>>> help(os.path.isdir)
Help on function isdir in module genericpath:
isdir(s)
Return true if the pathname refers to an existing directory.
```
Функция isdir() модуля os.path возвращает True если путь path существует и является каталогом,
False в противном случае.
```py
>>> os.path.isdir('gagagaga')
False
>>> os.mkdir('lalala')
>>> os.path.isdir('lalala')
True
```
Функция os.path.abspath() в Python преобразует путь, переданный в качестве аргумента, в
абсолютный путь
```py
>>> fil=os.path.abspath("oplata.dbf")
>>> fil
'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\oplata.dbf'
>>> fil=os.path.abspath("lalala")
>>> fil
'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\lalala'
```
Абсолютный путь — это полный путь к файлу или каталогу, начиная от
корневого каталога системы, а не относительный путь (который зависит от текущего рабочего
каталога)
Если передать в os.path.abspath() несуществующий файл или каталог, функция не проверяет
наличие этого файла в файловой системе. Она просто преобразует путь в абсолютный, не
проверяя его существование.
Отделение из абсолютного пути только каталога/только имени файла
Функция os.path.dirname() из абсолютного пути выделяется путь доступа (от диска до последней
папки). Функция os.path.basename(), наоборот, убирает из абсолютного пути все, кроме имени
файла.
Выделите путь доступа к файлу из строки, содержащей и этот путь, и имя файла с помощью функции os.path.dirname
```py
>>> drkt = os.path.dirname(fil)
>>> print(drkt)
C:\Users\Admin\Documents\Tsvetkova\python-labs\TEMA6
```
Bыделить имя файла из этой строки с отбрасыванием пути можно с помощью функции os.path.basename
```py
>>> bsnm=os.path.basename(fil)
>>> print(bsnm)
lalala
```
Разделение на кортеж из пути и из имени файла
```py
>>> help(os.path.split)
Help on function split in module ntpath:
split(p)
Split a pathname.
Return tuple (head, tail) where tail is everything after the final slash.
Either part may be empty.
```
```py
>>> os.path.split(fil)
('C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6', 'lalala')
>>> type(os.path.split(fil))
<class 'tuple'>
```
Проверка существования любого объекта (пути или файла)
```py
>>> os.path.exists("D:/GAMES") # Такой каталог есть на ПК
True
>>> os.path.exists("D:/Arts")
False
>>> os.path.exists("D:/Games/Heavy Rain/unins000.exe") # Такой файл есть
True
>>> os.path.exists("D:/Games/Heavy Rain/unins00000.exe")
False
>>> os.path.isfile("D:/Games/Sid Meiers Civilization VI/unins000.exe") # Это есть и это файл
True
>>> os.path.isfile("D:/Games/Sid Meiers Civilization VI/") # Это есть, но это не файл!
False
>>> os.path.isfile("D:/Games/sss.jpg") # Это файл, но это не существует
False
```
## Пункт 4.2 Общая схема работы с файлом
Для обмена данными с файлом необходимо выполнить следующие операции:
• Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
• Выполнение одной или нескольких операций обмена данными с файлом;
• Закрытие файла.
4.3. Открытие файла для записи или чтения данных – функция open.
При открытии файла необходимо указать имя файлы (с путем, если он не в рабочем каталоге) и цель работы с ним. Для открытия используется функция open. Запросите помощь по этой функ-ции, обратите внимание на возможные аргументы этой функции.
```py
>>> fp = open(file = drkt+'\\zapis1.txt', mode='w')
>>> type(fp)
<class '_io.TextIOWrapper'>
```
Объект класса _io.TextIOWrapper - файловый объект для текстовых данных, имеющий ряд атрибутов
и методов.
```py
>>> fp
<_io.TextIOWrapper name='C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
```
Здесь перечислены атрибуты объекта:
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.closed
False
```
Если имя файла на первом месте, а режим на втором, то имена можно не указывать. (позиционные аргументы
всегда должны идти первыми, а именованные — после них)
Путь можно опустить, если он совпадает с текущей рабочей директории:
```py
>>> fp = open('zapis1.txt','w')
>>> fp
<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
```
Список атрибутов объекта fp:
```py
>>> 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']
```
Пример открытия бинарного файла:
```py
>>> fp1 = open(drkt + '\\zapis2.bin', mode = 'wb+')
>>> fp1
<_io.BufferedRandom name='C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\zapis2.bin'>
```
## Пункт 4.4. Закрытие файла.
Когда файл успешно открывается / создается и открывается, ему задается целочисленный
номер, называемый файловым дескриптором. Он создается только на один сеанс работы и указывает,
с каким именно файлом нужно работать.
После того, как программа отработала, надо очистить ресурсы, связанные с файлом (область
в оперативной памяти, в буфере при буферизации), и удалить дескриптор. Если не закрыть
файл, это может его повредить, данные могут быть утеряны или система может быть перегружена,
т.к. исчерпается ресурс оперативной памяти. Для закрытия есть метод close().
После закрытия на объект все еще можно посмотреть:
```py
>>> fp.close()
>>> fp
<_io.TextIOWrapper name='C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
```
Но значение атрибута closed сменится на True:
```py
>>> fp.closed
True
```
## 4.5. Запись информации в файл с помощью метода write.
Пример 1
```py
>>> sps=list(range(1,13))
>>> 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()
```
открыли файл и увидели
```py
[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]
```
Пример 2
```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Сидоров.
```
Легко заметить, что информация записана в файл не очень удачно.Тогда попробум сделать так:
```py
>>> 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 Первый способ чтения информации из текстового файла.
```py
>>> sps1=[]
>>> fp=open('zapis3.txt')
>>> for stroka in fp:
... stroka=stroka.rstrip('\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']
```
Обратите внимание, что в функции открытия файла использован только один аргумент, остальные – со значениями «по умолчанию».
Здесь, перед занесением строки в список с помощью метода rstrip, из неё удаляется сим-вол конца строки, а с помощью метода replace – скобки.
Видно, что полученный список отличается от исходного sps, в первую очередь, типом данных.
К тому же, в sps1 убрались не все пробелы.
Преобразовать sps1 в sps можно, например, так:
```py
>>> sps2 = [int(i.strip()) for i in sps1]
>>> sps2
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
```
Это list comprehension, который у кажлого элемента sps1 убирает лишние пробелы с обеих
сторон (в этом отличие rstrip от strip). Затем полученная строка конвертируется в число.
## Пункт 4.7. Чтение информации из файла с помощью метода read.
Метод read, как и write, относится к объекту – файловой переменной. В качестве аргумен-та этого метода может задаваться целое число – количество символов или, если открыт бинарный файл, - количество байт, которое должно быть прочитано, соответственно, из текстового или би-нарного файла, начиная с текущего положения маркера. Если указанное число превышает коли-чество оставшихся символов (байт) в файле, то считываются все оставшиеся символы (байты). Если это число не указано, то считываются вся информация от маркера до конца файла. Метод возвращает строку с символами или совокупность байт, прочитанных из файла. Например,
```py
>>> fp=open('zapis3.txt')
>>> stroka1=fp.read(12) # Чтение первых 12 файлов, курсор остановится на 13-ом (/n)
>>> stroka2=fp.read() # Чтение всех оставшихся файлов вплоть до EOF
>>> 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) # Вовзращение указателя обратно в начало, чтобы нагляднее выполнить
readlines
0
>>> file.readlines()
['Иванов И. 1\n', 'Петров П. 2\n', 'Сидоров С. 3\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()
```
Откроем получившийся файл в текстовом редакторе, увидим подобную строку.
```py
Ђ•# Џ”(ЊiPhone”Њbook”Њtable”Њpen”ђ.
```
Так происходит, потому что байты в этом файле не предназначены для текстового представления.
Они могут содержать символы, которые не могут быть корректно интерпретированы в рамках
любой текстовой кодировки. Но в некоторых байтах содержатся символы, которые попадают в
диапазон, поддерживаемый текстовым редактором и конкретной кодировкой (в моем случае ANSI),
поэтому правильно дешифрованные буквы все же есть.
Десериализуем множество обратно:
```py
>>> fp = open('zapis6.mnz','rb')
>>> mnoz2 = pickle.load(fp)
>>> fp.close()
>>> mnoz2
{'book', 'iPhone', 'table', 'pen'}
>>> mnoz1
{'book', 'iPhone', 'table', 'pen'}
>>> mnoz1 == mnoz2
True
```
mnoz1 не совпадает с тем, что было задано, потому что это множество. Оно исключает
повторяющиеся элементы, оставляя только один, а еще не содержит конкретный порядок элементов.
Но два множества равны, если у них равны все элементы и их одинаковое количество, вне
зависимости от порядка, так что сравнение возвращает 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]]
>>> mnoz1 == obj1
True
>>> obj2 == sps3
True
```
# Пункт 5. Перенаправление потоков ввода и вывода данных.
Поток в python и других ЯП - это абстракция, которая позволяет регулировать источники
ввода информации и то, куда её выводить. Всего их по умолчанию три (еще можнно создать
пользовательские):
sys.stdin — поток ввода (обычно клавиатура)
sys.stdout — поток вывода
sys.stderr — поток ошибок (оба обычно экран)
Для работы с потоками импортируем модуль sys:
```py
>>> import sys
```
Сохраним адрес в памяти текущего потока вывода:
```py
>>> vr_out = sys.stdout
>>> vr_out
<idlelib.run.StdOutputFile object at 0x0000018C2F7961C0>
```
Откроем (созадем) файл на запись:
```py
>>> fc = open('Stroka.txt','w')
```
Теперь зададим в качестве потока вывода этот файл:
```py
>>> sys.stdout = fc
>>> print('запись строки в файл')
```
Видно, что в консоли не появилось строки. Вернем поток по умолчанию обратно:
```py
>>> 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: # Конструкция try-except предназначена для отладки исключений
# То есть если возвращается ошибка, можно ее перехватить и
# указать, что делать в таком случае
line = input()
print(line)
except EOFError:
break
запись строки в файл
>>> fd.close()
>>> sys.stdin = tmp_in
```
Редактирование Предпросмотр
Загрузка…
Отмена
Сохранить