ответвлено от main/python-labs
commit
Этот коммит содержится в:
KireevYP
515
TEMA6/report.md
Обычный файл
515
TEMA6/report.md
Обычный файл
@@ -0,0 +1,515 @@
|
||||
# Отчёт по теме 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
|
||||
```
|
||||
После вывода автоматически осуществляется переход на другую строку. Если курсор надо оста-вить в той же строке, то следует использовать еще один аргумент, например:
|
||||
```py
|
||||
>>> print(gg, fff,sep='/',end='***'); print('____')
|
||||
Значение температуры = /234.5***____
|
||||
```
|
||||
Наоборот, если в какой-то момент требуется просто перейти на новую строку, можно использо-вать такое обращение к функции:
|
||||
```py
|
||||
>>> print()
|
||||
|
||||
```
|
||||
Наконец, оператор вывода может располагаться на нескольких строках с использованием тройных кавычек:
|
||||
```py
|
||||
>>> print(""" Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк""")
|
||||
|
||||
Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк
|
||||
|
||||
>>> print("Здесь может выводиться",
|
||||
"большой текст,",
|
||||
"занимающий несколько строк")
|
||||
Здесь может выводиться большой текст, занимающий несколько строк
|
||||
```
|
||||
### 2.3. Вывод с использованием метода write объекта sys.stdout.
|
||||
Объект stdout представляет собой поток стандартного вывода – объект, в который программы выводят символьное представление данных. Обычно это – экран дисплея. Объект находится в модуле sys, который надо импортировать.
|
||||
```py
|
||||
>>> import sys
|
||||
>>> sys.stdout.write('Функция write')
|
||||
Функция write13
|
||||
```
|
||||
Если это требуется, то следует в конце строки добавить один или несколько символов “\n”:
|
||||
```py
|
||||
>>> sys.stdout.write('Функция write\n')
|
||||
Функция write
|
||||
14
|
||||
```
|
||||
## 3. Ввод данных с клавиатуры
|
||||
За ввод отвечает функция input:
|
||||
```py
|
||||
>>> psw=input('Введите пароль:')
|
||||
Введите пароль:123
|
||||
>>> psw
|
||||
'123'
|
||||
>>> type(psw)
|
||||
<class 'str'>
|
||||
```
|
||||
#### Пример 1. Ввод с контролем значения.
|
||||
Пусть вводится число, которое должно находиться в интервале значений от 17.5 до 23.8.
|
||||
```py
|
||||
>>> while True:
|
||||
>>> znach=float(input('Задайте коэф.усиления = '))
|
||||
>>> if znach<17.5 or znach>23.8:
|
||||
>>> print('Ошибка!')
|
||||
>>> else:
|
||||
>>> break
|
||||
|
||||
Задайте коэф.усиления = 15.4
|
||||
Ошибка!
|
||||
Задайте коэф.усиления = 21.6
|
||||
znach
|
||||
21.6
|
||||
```
|
||||
#### Пример 2. Ввод и обработка выражения, подлежащего расчету.
|
||||
```py
|
||||
import math
|
||||
print(eval(input('введите выражение для расчета = ')))
|
||||
введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
|
||||
1.34504378689765
|
||||
```
|
||||
## 4. Ввод-вывод при работе с файлами.
|
||||
### 4.1. Функции для работы с путем к файлу.
|
||||
Эти функции собраны в модуле os:
|
||||
```py
|
||||
>>> import os
|
||||
>>> os.getcwd()
|
||||
'C:\\Users\\user\\AppData\\Local\\Programs\\Python\\Python310'
|
||||
>>> KireevYuri = os.getcwd()
|
||||
>>> print(KireevYuri)
|
||||
C:\Users\user\AppData\Local\Programs\Python\Python310
|
||||
```
|
||||
Изменить расположение рабочего каталога можно обращением к уже многократно применявшейся функции os.chdir:
|
||||
```py
|
||||
>>> os.chdir('C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA6')
|
||||
```
|
||||
Самостоятельно изучим некоторые функции из модуля:
|
||||
```py
|
||||
>>> os.mkdir("new_folder") #создание нового подкаталога
|
||||
>>> print("Папка 'new_folder' создана")
|
||||
Папка 'new_folder' создана
|
||||
>>> os.rmdir("new_folder") #удаление подкаталога
|
||||
>>> os.listdir() #отображение содержимого папки (в данном случае текущего каталога)
|
||||
['.gitkeep', 'report.md']
|
||||
os.path.isdir('C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA6') #является ли путь директорией
|
||||
True
|
||||
```
|
||||
Попробуем получить символьную строку, содержащую имя файла вместе с полным путем доступа к нему.
|
||||
```py
|
||||
>>> fil=os.path.abspath('Методические указания по ПОАС (4)')
|
||||
>>> print(fil)
|
||||
C:\Users\user\Desktop\ПОАС\python-labs\TEMA6\Методические указания по ПОАС (4)
|
||||
```
|
||||
Выделим путь доступа к файлу из строки, содержащей и этот путь, и имя файла с помощью функции os.path.dirname:
|
||||
```py
|
||||
>>> drkt=os.path.dirname(fil)
|
||||
>>> print(drkt)
|
||||
C:\Users\user\Desktop\ПОАС\python-labs\TEMA6
|
||||
```
|
||||
Наоборот, выделить имя файла из этой строки с отбрасыванием пути можно с помощью функции os.path.basename:
|
||||
```py
|
||||
>>> name = os.path.basename(fil); print(name)
|
||||
Методические указания по ПОАС (4)
|
||||
```
|
||||
Cамостоятельно изучите функцию os.path.split.
|
||||
```py
|
||||
>>> sp = os.path.split(fil)
|
||||
>>> print(sp)
|
||||
('C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA6', 'Методические указания по ПОАС (4)')
|
||||
```
|
||||
Проверим, существуют ли заданные пути с помощью функции os.path.exists.
|
||||
```py
|
||||
>>> os.path.exists(drkt)
|
||||
True
|
||||
>>> os.path.exists('C:\\Users\\user\\Desktop\\ПОАСC')
|
||||
False
|
||||
```
|
||||
Проверим наличие файла с известным расположением с помощью функции os.path.isfile.
|
||||
```py
|
||||
os.path.isfile(fil)
|
||||
True
|
||||
os.path.isfile(os.path.dirname(fil)+'fil1.txt')
|
||||
False
|
||||
```
|
||||
### 4.2. Общая схема работы с файлом
|
||||
Для обмена данными с файлом необходимо выполнить следующие операции:
|
||||
1. Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
|
||||
2. Выполнение одной или нескольких операций обмена данными с файлом;
|
||||
3. Закрытие файла.
|
||||
### 4.3. Открытие файла для записи или чтения данных – функция open.
|
||||
```py
|
||||
>>> help(open)
|
||||
Help on built-in function open in module io:
|
||||
|
||||
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
|
||||
Open file and return a stream. Raise OSError upon failure.
|
||||
|
||||
file is either a text or byte string giving the name (and the path
|
||||
if the file isn't in the current working directory) of the file to
|
||||
be opened or an integer file descriptor of the file to be
|
||||
wrapped. (If a file descriptor is given, it is closed when the
|
||||
returned I/O object is closed, unless closefd is set to False.)
|
||||
|
||||
mode is an optional string that specifies the mode in which the file
|
||||
is opened. It defaults to 'r' which means open for reading in text
|
||||
mode. Other common values are 'w' for writing (truncating the file if
|
||||
it already exists), 'x' for creating and writing to a new file, and
|
||||
'a' for appending (which on some Unix systems, means that all writes
|
||||
append to the end of the file regardless of the current seek position).
|
||||
In text mode, if encoding is not specified the encoding used is platform
|
||||
dependent: locale.getpreferredencoding(False) is called to get the
|
||||
current locale encoding. (For reading and writing raw bytes use binary
|
||||
mode and leave encoding unspecified.) The available modes are:
|
||||
|
||||
========= ===============================================================
|
||||
Character Meaning
|
||||
--------- ---------------------------------------------------------------
|
||||
'r' open for reading (default)
|
||||
'w' open for writing, truncating the file first
|
||||
'x' create a new file and open it for writing
|
||||
'a' open for writing, appending to the end of the file if it exists
|
||||
'b' binary mode
|
||||
't' text mode (default)
|
||||
'+' open a disk file for updating (reading and writing)
|
||||
'U' universal newline mode (deprecated)
|
||||
========= ===============================================================
|
||||
|
||||
The default mode is 'rt' (open for reading text). For binary random
|
||||
access, the mode 'w+b' opens and truncates the file to 0 bytes, while
|
||||
'r+b' opens the file without truncation. The 'x' mode implies 'w' and
|
||||
raises an `FileExistsError` if the file already exists.
|
||||
|
||||
Python distinguishes between files opened in binary and text modes,
|
||||
even when the underlying operating system doesn't. Files opened in
|
||||
binary mode (appending 'b' to the mode argument) return contents as
|
||||
bytes objects without any decoding. In text mode (the default, or when
|
||||
't' is appended to the mode argument), the contents of the file are
|
||||
returned as strings, the bytes having been first decoded using a
|
||||
platform-dependent encoding or using the specified encoding if given.
|
||||
|
||||
'U' mode is deprecated and will raise an exception in future versions
|
||||
of Python. It has no effect in Python 3. Use newline to control
|
||||
universal newlines mode.
|
||||
|
||||
buffering is an optional integer used to set the buffering policy.
|
||||
Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
|
||||
line buffering (only usable in text mode), and an integer > 1 to indicate
|
||||
the size of a fixed-size chunk buffer. When no buffering argument is
|
||||
given, the default buffering policy works as follows:
|
||||
|
||||
* Binary files are buffered in fixed-size chunks; the size of the buffer
|
||||
is chosen using a heuristic trying to determine the underlying device's
|
||||
"block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
|
||||
On many systems, the buffer will typically be 4096 or 8192 bytes long.
|
||||
|
||||
* "Interactive" text files (files for which isatty() returns True)
|
||||
use line buffering. Other text files use the policy described above
|
||||
for binary files.
|
||||
|
||||
encoding is the name of the encoding used to decode or encode the
|
||||
file. This should only be used in text mode. The default encoding is
|
||||
platform dependent, but any encoding supported by Python can be
|
||||
passed. See the codecs module for the list of supported encodings.
|
||||
|
||||
errors is an optional string that specifies how encoding errors are to
|
||||
be handled---this argument should not be used in binary mode. Pass
|
||||
'strict' to raise a ValueError exception if there is an encoding error
|
||||
(the default of None has the same effect), or pass 'ignore' to ignore
|
||||
errors. (Note that ignoring encoding errors can lead to data loss.)
|
||||
See the documentation for codecs.register or run 'help(codecs.Codec)'
|
||||
for a list of the permitted encoding error strings.
|
||||
|
||||
newline controls how universal newlines works (it only applies to text
|
||||
mode). It can be None, '', '\n', '\r', and '\r\n'. It works as
|
||||
follows:
|
||||
|
||||
* On input, if newline is None, universal newlines mode is
|
||||
enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
|
||||
these are translated into '\n' before being returned to the
|
||||
caller. If it is '', universal newline mode is enabled, but line
|
||||
endings are returned to the caller untranslated. If it has any of
|
||||
the other legal values, input lines are only terminated by the given
|
||||
string, and the line ending is returned to the caller untranslated.
|
||||
|
||||
* On output, if newline is None, any '\n' characters written are
|
||||
translated to the system default line separator, os.linesep. If
|
||||
newline is '' or '\n', no translation takes place. If newline is any
|
||||
of the other legal values, any '\n' characters written are translated
|
||||
to the given string.
|
||||
|
||||
If closefd is False, the underlying file descriptor will be kept open
|
||||
when the file is closed. This does not work when a file name is given
|
||||
and must be True in that case.
|
||||
|
||||
A custom opener can be used by passing a callable as *opener*. The
|
||||
underlying file descriptor for the file object is then obtained by
|
||||
calling *opener* with (*file*, *flags*). *opener* must return an open
|
||||
file descriptor (passing os.open as *opener* results in functionality
|
||||
similar to passing None).
|
||||
|
||||
open() returns a file object whose type depends on the mode, and
|
||||
through which the standard file operations such as reading and writing
|
||||
are performed. When open() is used to open a file in a text mode ('w',
|
||||
'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
|
||||
a file in a binary mode, the returned class varies: in read binary
|
||||
mode, it returns a BufferedReader; in write binary and append binary
|
||||
modes, it returns a BufferedWriter, and in read/write mode, it returns
|
||||
a BufferedRandom.
|
||||
|
||||
It is also possible to use a string or bytearray as a file for both
|
||||
reading and writing. For strings StringIO can be used like a file
|
||||
opened in a text mode, and for bytes a BytesIO can be used like a file
|
||||
opened in a binary mode.
|
||||
```
|
||||
Откройте файл zapis1.txt для записи данных с помощью инструкции:
|
||||
```py
|
||||
>>> fp=open(file=drkt+'\\zapis1.txt',mode='w') #в рабочем каталоге был создан файл zapis1.txt
|
||||
```
|
||||
Вообще говоря, аргументы функции с их именами могут располагаться в любом порядке. Если имя файла располагается на месте первого аргумента, а цель использования – на втором, то имена аргументов можно не указывать и просто вводить.
|
||||
```py
|
||||
>>> fp=open(drkt+'\\zapis1.txt','w')
|
||||
```
|
||||
Если путь в переменной drkt совпадает с рабочим каталогом, то его можно опустить, оставив только имя открываемого файла:
|
||||
```py
|
||||
>>> fp=open('zapis1.txt','w')
|
||||
```
|
||||
Создаваемые и читаемые файлы могут быть бинарными или символьными. При открытии бинарного файла к указанным выше буквам в аргументе-цели надо добавить символ «b». Например:
|
||||
```py
|
||||
fp1=open(drkt+'\\zapis2.bin',mode='wb+') #был создан бинарный файл zapis2.bin в рабочем каталоге.
|
||||
```
|
||||
### 4.4. Закрытие файла
|
||||
Сразу после завершения работы с файлом его следует закрыть для обеспечения сохранности его содержимого. Это делается с помощью метода close, применяемого к объекту – файловой пе-ременной. Например:
|
||||
```py
|
||||
>>> fp.close()
|
||||
```
|
||||
### 4.5. Запись информации в файл с помощью метода write
|
||||
Метод write относится к объекту – файловой переменной.
|
||||
Пример: Cоздадим список с элементами-числами от 1 до 12 и запишем их в файл по 4 числа на строке:
|
||||
```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()
|
||||
...
|
||||
```
|
||||
Покажем, что произошло в файле zapis3.txt:
|
||||
```py
|
||||
[1, 2, 3, 4]
|
||||
[5, 6, 7, 8]
|
||||
[9, 10, 11, 12]
|
||||
```
|
||||
Создадим список с элементами-списками и пусть его элементы требуется построчно записать в файл zapis4.txt.
|
||||
```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
|
||||
>>> 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
|
||||
>>> gh=open('zapis5.txt','w')
|
||||
>>> for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
|
||||
|
||||
|
||||
12
|
||||
12
|
||||
13
|
||||
>>> gh.close()
|
||||
```
|
||||
В файле ничего не изменилось.
|
||||
|
||||
### 4.6. Первый способ чтения информации из текстового файла.
|
||||
Прочитаем информацию из ранее созданного файла zapis3.txt.
|
||||
```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()
|
||||
>>> print(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('[', '')
|
||||
>>> stroka = stroka.replace(']', '')
|
||||
>>> stroka = stroka.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'
|
||||
>>> fp.close()
|
||||
```
|
||||
### 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
|
||||
Ђ•# Џ”(Њpen”ЊiPhone”Њbook”Њtable”ђ.
|
||||
```
|
||||
Получение объекта из файла можно осуществить с помощью метода 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) # Первое обращение к load читает первый объект
|
||||
>>> 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. Завершение работы со средой.
|
||||
81
TEMA6/task.md
Обычный файл
81
TEMA6/task.md
Обычный файл
@@ -0,0 +1,81 @@
|
||||
# Общее контрольное задание по теме 6
|
||||
|
||||
Киреев Юрий, А-02-23
|
||||
|
||||
## Задание
|
||||
Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
|
||||
1. Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
|
||||
2. Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
|
||||
3. Записывается кортеж в бинарный файл.
|
||||
4. Записывается в этот же файл список и закрывается файл.
|
||||
5. Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
|
||||
6. Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
|
||||
7. Разделяется кортеж на совокупности по 5 чисел в каждой и они записываются в виде отдельных списков со своими именами.
|
||||
|
||||
## Решение
|
||||
1.
|
||||
```py
|
||||
>>> import random
|
||||
>>> kort = tuple([str(random.randint(6, 56)) for i in range(125)])
|
||||
>>> kort
|
||||
('47', '25', '20', '55', '38', '33', '19', '6', '19', '35', '6', '51', '25', '21', '10', '50', '39', '33', '55', '38', '24', '26', '38', '21', '53', '46', '53', '11', '51', '28', '48', '22', '54', '52', '17', '24', '35', '33', '6', '26', '32', '12', '19', '35', '52', '44', '18', '54', '22', '8', '25', '55', '27', '18', '11', '22', '30', '27', '52', '48', '45', '41', '23', '39', '46', '25', '36', '7', '33', '18', '42', '43', '38', '15', '49', '41', '14', '22', '41', '47', '8', '35', '18', '46', '51', '35', '27', '51', '36', '37', '19', '38', '47', '21', '40', '34', '6', '7', '8', '28', '12', '28', '6', '14', '25', '12', '56', '45', '41', '17', '40', '54', '35', '25', '49', '17', '41', '22', '11', '38', '48', '8', '23', '34', '36')
|
||||
```
|
||||
2.
|
||||
```py
|
||||
>>> lastnames = ['Киреев', 'Беженарь', 'Володин', 'Криви', 'Кузьменко']
|
||||
```
|
||||
3.
|
||||
```py
|
||||
>>> fp = open("binary.bin", "wb")
|
||||
>>> pickle.dump(kort, fp)
|
||||
```
|
||||
4.
|
||||
```py
|
||||
>>> pickle.dump(lastnames, fp)
|
||||
>>> fp.close()
|
||||
```
|
||||
5.
|
||||
```py
|
||||
>>> fp = open("binary.bin", "rb")
|
||||
>>> kort2 = pickle.load(fp)
|
||||
>>> lastnames2 = pickle.load(fp)
|
||||
>>> print(kort2, lastnames2)
|
||||
('47', '25', '20', '55', '38', '33', '19', '6', '19', '35', '6', '51', '25', '21', '10', '50', '39', '33', '55', '38', '24', '26', '38', '21', '53', '46', '53', '11', '51', '28', '48', '22', '54', '52', '17', '24', '35', '33', '6', '26', '32', '12', '19', '35', '52', '44', '18', '54', '22', '8', '25', '55', '27', '18', '11', '22', '30', '27', '52', '48', '45', '41', '23', '39', '46', '25', '36', '7', '33', '18', '42', '43', '38', '15', '49', '41', '14', '22', '41', '47', '8', '35', '18', '46', '51', '35', '27', '51', '36', '37', '19', '38', '47', '21', '40', '34', '6', '7', '8', '28', '12', '28', '6', '14', '25', '12', '56', '45', '41', '17', '40', '54', '35', '25', '49', '17', '41', '22', '11', '38', '48', '8', '23', '34', '36') ['Киреев', 'Беженарь', 'Володин', 'Криви', 'Кузьменко']
|
||||
>>> fp.close()
|
||||
```
|
||||
6.
|
||||
>>> if (kort2 == kort): print("Кортежи совпадают")
|
||||
Кортежи совпадают
|
||||
>>> if (lastnames2 == lastnames): print("Списки совпадают")
|
||||
Списки совпадают
|
||||
7.
|
||||
>>> for i in range(0, len(kort), 5):
|
||||
exec(f'spis{i//5} = list(kort[i:i + 5])')
|
||||
>>> for i in range(len(kort) // 5):
|
||||
exec(f'print("spis" + str(i) + ":", spis{i})')
|
||||
spis0: ['47', '25', '20', '55', '38']
|
||||
spis1: ['33', '19', '6', '19', '35']
|
||||
spis2: ['6', '51', '25', '21', '10']
|
||||
spis3: ['50', '39', '33', '55', '38']
|
||||
spis4: ['24', '26', '38', '21', '53']
|
||||
spis5: ['46', '53', '11', '51', '28']
|
||||
spis6: ['48', '22', '54', '52', '17']
|
||||
spis7: ['24', '35', '33', '6', '26']
|
||||
spis8: ['32', '12', '19', '35', '52']
|
||||
spis9: ['44', '18', '54', '22', '8']
|
||||
spis10: ['25', '55', '27', '18', '11']
|
||||
spis11: ['22', '30', '27', '52', '48']
|
||||
spis12: ['45', '41', '23', '39', '46']
|
||||
spis13: ['25', '36', '7', '33', '18']
|
||||
spis14: ['42', '43', '38', '15', '49']
|
||||
spis15: ['41', '14', '22', '41', '47']
|
||||
spis16: ['8', '35', '18', '46', '51']
|
||||
spis17: ['35', '27', '51', '36', '37']
|
||||
spis18: ['19', '38', '47', '21', '40']
|
||||
spis19: ['34', '6', '7', '8', '28']
|
||||
spis20: ['12', '28', '6', '14', '25']
|
||||
spis21: ['12', '56', '45', '41', '17']
|
||||
spis22: ['40', '54', '35', '25', '49']
|
||||
spis23: ['17', '41', '22', '11', '38']
|
||||
spis24: ['48', '8', '23', '34', '36']
|
||||
```
|
||||
Ссылка в новой задаче
Block a user