From 913805f1499a181fe23bb87f861b18abc60ceafa Mon Sep 17 00:00:00 2001
From: TerekhovFV <TerekhovFV@mpei.ru>
Date: Fri, 26 Sep 2025 12:11:11 +0300
Subject: [PATCH] =?UTF-8?q?=D0=9F=D0=B5=D1=80=D0=B5=D0=BE=D1=84=D0=BE?=
 =?UTF-8?q?=D1=80=D0=BC=D0=B8=D0=BB=20=D0=BE=D1=82=D1=87=D1=91=D1=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 TEMA2/report.md | 1181 +++++++++++++++++++++++++++--------------------
 1 file changed, 692 insertions(+), 489 deletions(-)

diff --git a/TEMA2/report.md b/TEMA2/report.md
index 5e9da40..b99897f 100644
--- a/TEMA2/report.md
+++ b/TEMA2/report.md
@@ -1,10 +1,10 @@
-# Отчет по теме 2
+# Отчет по теме 2  
 
-Терехов Фёдор Валерьевич, А-01-23
+Терехов Фёдор Валерьевич, А-01-23  
 
-## 1. Изучение простых объектов.
+## 1. Изучение простых объектов.  
 
-1. _"Для того, чтобы узнать, какое значение имеет переменная, достаточно перечислить их имена в строке, разделяя их знаком «,» (запятая) или «;» (точка с запятой)."_
+1. _"Для того, чтобы узнать, какое значение имеет переменная, достаточно перечислить их имена в строке, разделяя их знаком «,» (запятая) или «;» (точка с запятой)."_  
 
 ``` python
 f1=16; f2=3
@@ -19,707 +19,910 @@ print(f1); print(f2)
 Ответ программы:  
 ![Task 1.1](images/Task1_1.png)  
 
-2. _"Для того, чтобы узнать, какие объекты уже существуют в данный момент в среде Python (в пространстве имен), используйте функцию dir без аргументов."_
+2. _"Для того, чтобы узнать, какие объекты уже существуют в данный момент в среде Python (в пространстве имен), используйте функцию dir без аргументов."_  
 
-> print("\nСуществующие объекты в пространстве имен:")
-> print(dir())
-
-Ответ программы:![Task 1.2](images/Task1_2.png)
+``` python
+print("\nСуществующие объекты в пространстве имен:")
+print(dir())
+```
 
-3. _"Для получения списка атрибутов любого объекта используйте ту же функцию dir(), с аргументами – именами интересующих объектов"_
+Ответ программы:  
+![Task 1.2](images/Task1_2.png)  
 
-> print("\nАтрибуты объекта f1:")
-> print(dir(f1))
->
-> print("\nАтрибуты объекта f2:")
-> print(dir(f2))
+3. _"Для получения списка атрибутов любого объекта используйте ту же функцию dir(), с аргументами – именами интересующих объектов"_  
 
-Ответ программы:![Task 1.3](images/Task1_3.png)
+``` python
+print("\nАтрибуты объекта f1:")
+print(dir(f1))
 
-4. _"Для определения классовой принадлежности любого объекта следует использовать функцию type()."_
+print("\nАтрибуты объекта f2:")
+print(dir(f2))
+```
 
-> print(f"\nТип f1: {type(f1)}") #f перед текстом обозначает строку, переменные пишутся в {}
-> print(f"Тип f2: {type(f2)}")
+Ответ программы:  
+![Task 1.3](images/Task1_3.png)  
 
-Ответ программы:![Task 1.4](images/Task1_4.png)
+4. _"Для определения классовой принадлежности любого объекта следует использовать функцию type()."_  
 
-5. _"Для удаления объекта или его части из оперативной памяти используйте инструкцию del."_
+``` python
+print(f"\nТип f1: {type(f1)}") #f перед текстом обозначает строку, переменные пишутся в {}
+print(f"Тип f2: {type(f2)}")
+```
 
-> print("\nУдаляем объекты f1 и f2...")
-> del f1, f2
->
-> print("\nСуществующие объекты в пространстве имен ПОСЛЕ удаления:")
-> print(dir())
->
-> print("\nПопытка обратиться к удаленным объектам:")
-> print(f1)
+Ответ программы:  
+![Task 1.4](images/Task1_4.png)  
 
-Ответ программы:
-![Task 1.5](images/Task1_5.png)
+5. _"Для удаления объекта или его части из оперативной памяти используйте инструкцию del."_  
 
-## 2. Изучение правил именования объектов в Python.
+``` python
+print("\nУдаляем объекты f1 и f2...")
+del f1, f2
 
-_"Правила именования:
-•  имена должны состоять из латинских букв, цифр и символов подчеркивания;
-•  имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);
-•  имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python;
-•  большие и малые буквы в именах различаются (имена – чувствительные к регистру)!"_
+print("\nСуществующие объекты в пространстве имен ПОСЛЕ удаления:")
+print(dir())
 
-> gg1=1.6  #значение в виде вещественного числа
-> hh1='Строка'  #значение в виде символьной строки
-> 73sr=3   #неправильное имя – начинается с цифры - будет диагностика!
-> and=7     #недопустимое имя – совпадает с ключевым словом - будет диагностика!
+print("\nПопытка обратиться к удаленным объектам:")
+print(f1)
+```
 
-Ответ программы:
-![Task 2.1](images/Task2_1.png)
-![Task 2.2](images/Task2_2.png)
+Ответ программы:  
+![Task 1.5](images/Task1_5.png)  
 
-## 3. Вывод списка ключевых слов с помощью инструкции import keyword && keyword.kwlist
+## 2. Изучение правил именования объектов в Python.  
 
-> import keyword
->
-> print("Список ключевых слов Python:")
-> print(keyword.kwlist)
-> ![Task 3.1](images/Task3_1.png)
-> Сохранение списка в переменной:
-> keywords_list = keyword.kwlist
-> print("\nСохранение в виде списка:")
-> print(keywords_list)
-> ![Task 3.2](images/Task3_2.png)
+*Правила именования:*  
+* *имена должны состоять из латинских букв, цифр и символов подчеркивания;*  
+* *имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);*  
+* *имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python;*  
+* *большие и малые буквы в именах различаются (имена – чувствительные к регистру)!"*  
 
-## 4. Вывод списка встроенных идентификаторов с помощью инструкций import builtins && dir(builtins)
+``` python
+gg1=1.6  #значение в виде вещественного числа
+hh1='Строка'  #значение в виде символьной строки
+73sr=3   #неправильное имя – начинается с цифры - будет диагностика!
+and=7     #недопустимое имя – совпадает с ключевым словом - будет диагностика!
+```
 
-> import builtins
->
-> print("Список встроенных идентификаторов Python:")
-> builtins_list = dir(builtins)
-> print(builtins_list)
+Ответ программы:  
+![Task 2.1](images/Task2_1.png)  
 
-![Task 4.1](images/Task4_1.png)
+![Task 2.2](images/Task2_2.png)  
 
-> print("Справка по функциям:")
-> print("\n1. Функция abs():")
-> help(abs)
+## 3. Вывод списка ключевых слов с помощью инструкции import keyword && keyword.kwlist  
 
-![Task 4.2.1](images/Task4_2_1.png)
+``` python
+import keyword
 
-> print("\n2. Функция len():")
-> help(len)
+print("Список ключевых слов Python:")
+print(keyword.kwlist)
+```
+Ответ программы:  
+![Task 3.1](images/Task3_1.png)  
 
-![Task 4.2.2](images/Task4_2_2.png)
+*Сохранение списка в переменной:*  
 
-> print("\n3. Функция max():")
-> help(max)
+``` python
+keywords_list = keyword.kwlist
+print("\nСохранение в виде списка:")
+print(keywords_list)
+```
 
-![Task 4.2.3](images/Task4_2_3.png)
+Ответ программы:  
+![Task 3.2](images/Task3_2.png)  
 
-> print("\n4. Функция min():")
-> help(min)
+## 4. Вывод списка встроенных идентификаторов с помощью инструкций import builtins && dir(builtins)  
 
-![Task 4.2.4](images/Task4_2_4.png)
+``` python
+import builtins
 
-> print("\n5. Функция pow():")
-> help(pow)
+print("Список встроенных идентификаторов Python:")
+builtins_list = dir(builtins)
+print(builtins_list)
+```
+Ответ программы:  
+![Task 4.1](images/Task4_1.png)  
 
-![Task 4.2.5](images/Task4_2_5.png)
+``` python 
+print("Справка по функциям:")
+print("\n1. Функция abs():")
+help(abs)
+```
+Ответ программы:  
+![Task 4.2.1](images/Task4_2_1.png)  
 
-> print("\n6. Функция round():")
-> help(round)
+``` python 
+print("\n2. Функция len():")
+help(len)
+```
+Ответ прошграммы:  
+![Task 4.2.2](images/Task4_2_2.png)  
 
-![Task 4.2.6](images/Task4_2_6.png)
+``` python 
+print("\n3. Функция max():")
+help(max)
+```
 
-> print("\n7. Функция sorted():")
-> help(sorted)
+Ответ программы:  
+![Task 4.2.3](images/Task4_2_3.png)  
 
-![Task 4.2.7](images/Task4_2_7.png)
+``` python
+print("\n4. Функция min():")
+help(min)
+```
 
-> print("\n8. Функция sum():")
-> help(sum)
+Ответ программы:  
+![Task 4.2.4](images/Task4_2_4.png)  
 
-![Task 4.2.8](images/Task4_2_8.png)
+``` python
+print("\n5. Функция pow():")
+help(pow)
+```
 
-> print("\n9. Функция zip():")
-> help(zip)
+Ответ программы:  
+![Task 4.2.5](images/Task4_2_5.png)  
 
-![Task 4.2.9](images/Task4_2_9.png)
+``` python
+print("\n6. Функция round():")
+help(round)
+```
 
-## 5. Малые и большие буквы в именах объектов различаются.
+Ответ программы:  
+![Task 4.2.6](images/Task4_2_6.png)  
 
-> Gg1=45
-> print(Gg1)
-> print(gg1)
+``` python
+print("\n7. Функция sorted():")
+help(sorted)
+```
 
-Ответ программы:
-![Task 5](images/Task5.png)
+Ответ программы:  
+![Task 4.2.7](images/Task4_2_7.png)  
 
-## 6. Изучение простых базовых типов объектов: логический (bool), целый (int), вещественный (float), комплексный (complex), строка символов (str).
+``` python
+print("\n8. Функция sum():")
+help(sum)
+```
 
-### 6.1. Числовые типы.
+Ответ программы:  
+![Task 4.2.8](images/Task4_2_8.png)  
 
-1. Логический тип.
+``` python
+print("\n9. Функция zip():")
+help(zip)
+```
 
-> bb1=True
-> bb2=False
-> print(f"bb1 = {bb1}")
-> print(f"bb2 = {bb2}")
-> print(f"Класс объекта: {type(bb1)}")
+Ответ программы:  
+![Task 4.2.9](images/Task4_2_9.png)  
 
-Ответ программы:![Task 6.1.1](images/Task6_1_1.png)
+## 5. Малые и большие буквы в именах объектов различаются.  
 
-2. Целочисленный тип.
+``` python
+Gg1=45
+print(Gg1)
+print(gg1)
+```
 
-> ii1=-1234567890
-> print(f"\nii1 = {ii1}")
-> print(f"Класс объекта: {type(ii1)}")
+Ответ программы:  
+![Task 5](images/Task5.png)  
 
-Ответ программы:![Task 6.1.2](images/Task6_1_2.png)
+## 6. Изучение простых базовых типов объектов: логический (bool), целый (int), вещественный (float), комплексный (complex), строка символов (str).  
 
-3. Экспоненциальная форма записи вещественного числа.
+### 6.1. Числовые типы.  
 
-> ff1=-8.9876e-12
-> print(f"\nff1 = {ff1}")
-> print(f"Класс объекта: {type(ff1)}")
+1. Логический тип.  
 
-Ответ программы:![Task 6.1.3](images/Task6_1_3.png)
+``` python
+bb1=True
+bb2=False
+print(f"bb1 = {bb1}")
+print(f"bb2 = {bb2}")
+print(f"Класс объекта: {type(bb1)}")
+```
 
-4. Двоичное число.
+Ответ программы:  
+![Task 6.1.1](images/Task6_1_1.png)  
 
-> dv1=0b1101010
-> print(f"\ndv1 = {dv1}")
-> print(f"Класс объекта: {type(dv1)}")
+2. Целочисленный тип.  
 
-Ответ программы:![Task 6.1.4](images/Task6_1_4.png)
+``` python
+ii1=-1234567890
+print(f"\nii1 = {ii1}")
+print(f"Класс объекта: {type(ii1)}")
+```
 
-5. Восьмеричное число.
+Ответ программы:  
+![Task 6.1.2](images/Task6_1_2.png)  
 
-> vsm1=0o52765
-> print(f"\nvsm1 = {vsm1}")
-> print(f"Класс объекта: {type(vsm1)}")
+3. Экспоненциальная форма записи вещественного числа.  
 
-Ответ программы:![Task 6.1.5](images/Task6_1_5.png)
+``` python
+ff1=-8.9876e-12
+print(f"\nff1 = {ff1}")
+print(f"Класс объекта: {type(ff1)}")
+```
+Ответ программы:  
+![Task 6.1.3](images/Task6_1_3.png)  
 
-6. Шестнадцатеричное число.
+4. Двоичное число.  
 
-> shest1=0x7109af6
-> print(f"\nshest1 = {shest1}")
-> print(f"Класс объекта: {type(shest1)}")
+``` python
+dv1=0b1101010
+print(f"\ndv1 = {dv1}")
+print(f"Класс объекта: {type(dv1)}")
+```
 
-Ответ программы:![Task 6.1.6](images/Task6_1_6.png)
+Ответ программы:  
+![Task 6.1.4](images/Task6_1_4.png)  
 
-7. Комплексное число.
+5. Восьмеричное число.  
 
-> cc1=2-3j
-> print(f"\ncc1 = {cc1}")
-> print(f"Класс объекта: {type(cc1)}")
+``` python
+vsm1=0o52765
+print(f"\nvsm1 = {vsm1}")
+print(f"Класс объекта: {type(vsm1)}")
+```
 
-Ответ программы:![Task 6.1.7](images/Task6_1_7.png)
+Ответ программы:  
+![Task 6.1.5](images/Task6_1_5.png)  
 
-8. Вещественное число.
+6. Шестнадцатеричное число.  
 
-> a=3.67
-> b=-0.45
-> print(f"\na = {a}")
-> print(f"b = {b}")
-> print(f"Класс объекта a: {type(a)}")
-> print(f"Класс объекта b: {type(b)}")
+``` python
+shest1=0x7109af6
+print(f"\nshest1 = {shest1}")
+print(f"Класс объекта: {type(shest1)}")
+```
+Ответ программы:  
+![Task 6.1.6](images/Task6_1_6.png)  
 
-Ответ программы:![Task 6.1.8](images/Task6_1_8.png)
+7. Комплексное число.  
 
-9. Альтернативный способ задания комплексного числа.
+``` python
+cc1=2-3j
+print(f"\ncc1 = {cc1}")
+print(f"Класс объекта: {type(cc1)}")
+```
 
-> cc2=complex(a,b)
-> print(f"\ncc2 = {cc2}")
-> print(f"Класс объекта cc2: {type(cc2)}")
+Ответ программы:  
+![Task 6.1.7](images/Task6_1_7.png)  
 
-Ответ программы:
-![Task 6.1.9](images/Task6_1_9.png)
+8. Вещественное число.  
 
-### 6.2. Строки.
+``` python
+a=3.67
+b=-0.45
+print(f"\na = {a}")
+print(f"b = {b}")
+print(f"Класс объекта a: {type(a)}")
+print(f"Класс объекта b: {type(b)}")
+```
 
-1. *Строки можно заключать в апострофы или в двойные кавычки. Внутри строки символов можно использовать, так называемые, «экранированные последовательности, начинающиеся со знака «\»(обратный слеш), например, \\, \', \", \t, \n и другие.*
+Ответ программы:  
+![Task 6.1.8](images/Task6_1_8.png)  
 
-> ss1='Это - строка символов'
-> print(f"{ss1}\n")
-> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
-> print(ss1a)
+9. Альтернативный способ задания комплексного числа.  
 
-Ответ программы:![Task 6.2.1](images/Task6_2_1.png)
+``` python
+cc2=complex(a,b)
+print(f"\ncc2 = {cc2}")
+print(f"Класс объекта cc2: {type(cc2)}")
+```
+Ответ программы:  
+![Task 6.1.9](images/Task6_1_9.png)  
 
-2. *Создайте строку по шаблону. Выведите получившуюся строку на экран.*
+### 6.2. Строки.  
 
-> ss1b= 'Меня зовут: \n TerekhovFV'
-> print(ss1b)
+1. *Строки можно заключать в апострофы или в двойные кавычки. Внутри строки символов можно использовать, так называемые, «экранированные последовательности, начинающиеся со знака «\»(обратный слеш), например, \\, \', \", \t, \n и другие.*  
 
-Ответ программы:![Task 6.2.2](images/Task6_2_2.png)
+``` python
+ss1='Это - строка символов'
+print(f"{ss1}\n")
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+print(ss1a)
+```
 
-3. *Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек. При вводе такой строки символ приглашения в начале строки не появится, пока не будет вновь введены тройные кавычки.*
+Ответ программы:  
+![Task 6.2.1](images/Task6_2_1.png)  
 
-> mnogo="""Нетрудно заметить , что в результате операции
-> над числами разных типов получается число,
-> имеющее более сложный тип из тех, которые участвуют в операции."""
-> print(mnogo)
+2. *Создайте строку по шаблону. Выведите получившуюся строку на экран.*  
 
-Ответ программы:![Task 6.2.3](images/Task6_2_3.png)
+``` python
+ss1b= 'Меня зовут: \n TerekhovFV'
+print(ss1b)
+```
 
-4. *Можно обращаться к частям строки символов с использованием индексов символов по их порядку в строке. При этом надо учитывать, что нумерация символов начинается с 0. При знаке «-»(минус) отсчёт от конца строки.*
+Ответ программы:  
+![Task 6.2.2](images/Task6_2_2.png)  
 
-> print(ss1[0])
-> print(ss1[8])
-> print(ss1[-2])
+3. *Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек. При вводе такой строки символ приглашения в начале строки не появится, пока не будет вновь введены тройные кавычки.*  
 
-Ответ программы:![Task 6.2.4](images/Task6_2_4.png)
+``` python
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+print(mnogo)
+```
 
-5. *Операция «разрезания» или «создания среза», создающая новый объект. В срезе указываются не позиции элементов, а их индексы и что указываемая правая граница в срез не включается.*
+Ответ программы:  
+![Task 6.2.3](images/Task6_2_3.png)  
 
-> print(ss1[6:9])  #Это часть строки – символы с 6-го индекса по 8-й (9-й не включается!)
-> print(ss1[13:])  #Это часть строки – с 13-го индекса и до конца
-> print(ss1[:13])  #Это часть строки – с начала и до 12-го индекса включительно
-> print(ss1[5:-8])  #Это часть строки – с 5-го индекса и до 8-го от конца
-> print(ss1[3:17:2])  #Часть строки – с 3-го по 16-й индексы с шагом 2
+4. *Можно обращаться к частям строки символов с использованием индексов символов по их порядку в строке. При этом надо учитывать, что нумерация символов начинается с 0. При знаке «-»(минус) отсчёт от конца строки.*  
 
-Ответ программы:
-![Task 6.2.5](images/Task6_2_5.png)
+``` python
+print(ss1[0])
+print(ss1[8])
+print(ss1[-2])
+```
 
-*При отрицательном значении шага*
+Ответ программы:  
+![Task 6.2.4](images/Task6_2_4.png)  
 
-> print(ss1[17:3:-2])
+5. *Операция «разрезания» или «создания среза», создающая новый объект. В срезе указываются не позиции элементов, а их индексы и что указываемая правая граница в срез не включается.*  
 
-Ответ программы:
-![Task 6.2.5.1](images/Task6_2_5_1.png)
+``` python
+print(ss1[6:9])  #Это часть строки – символы с 6-го индекса по 8-й (9-й не включается!)
+print(ss1[13:])  #Это часть строки – с 13-го индекса и до конца
+print(ss1[:13])  #Это часть строки – с начала и до 12-го индекса включительно
+print(ss1[5:-8])  #Это часть строки – с 5-го индекса и до 8-го от конца
+print(ss1[3:17:2])  #Часть строки – с 3-го по 16-й индексы с шагом 2
+```
+Ответ программы:  
+![Task 6.2.5](images/Task6_2_5.png)  
 
-*Если "17" заменить на "-4", то получим такой же результат.*
+*При отрицательном значении шага*  
 
-> print(ss1[-4:3:-2])
+``` python
+print(ss1[17:3:-2])
+```
+Ответ программы:  
+![Task 6.2.5.1](images/Task6_2_5_1.png)  
 
-Ответ программы:![Task 6.2.5.2](images/Task6_2_5_1.png)
+*Если "17" заменить на "-4", то получим такой же результат.*  
 
-6. *Строка является неизменяемым объектом. Однако, можно это сделать по-другому, переопределив строку.*
+``` python
+print(ss1[-4:3:-2])
+```
 
-> ss1[4]='='
+Ответ программы:  
+![Task 6.2.5.2](images/Task6_2_5_1.png)  
 
-Ответ программы:![Task 6.2.6.1](images/Task6_2_6_1.png)
+6. *Строка является неизменяемым объектом. Однако, можно это сделать по-другому, переопределив строку.*  
 
-> ss1=ss1[:4]+'='+ss1[5:]
-> print(ss1)
+``` python
+ss1[4]='='
+```
 
-Ответ программы:![Task 6.2.6.2](images/Task6_2_6_2.png)
+Ответ программы:  
+![Task 6.2.6.1](images/Task6_2_6_1.png)  
 
-7. *С использованием ранее созданной строки ss1b попробуйте создать объекты с разными срезами исходной строки.*
+``` python
+ss1=ss1[:4]+'='+ss1[5:]
+print(ss1)
+```
 
-> print(ss1b[-10:])
->
-> print("\n")
-> ss1b="My name is "+ ss1b[-10:]
-> print(ss1b)
+Ответ программы:  
+![Task 6.2.6.2](images/Task6_2_6_2.png)  
 
-Ответ программы:![Task 6.2.7](images/Task6_2_7.png)
+7. *С использованием ранее созданной строки ss1b попробуйте создать объекты с разными срезами исходной строки.*  
 
-8. *Самостоятельно придумайте значения и создайте объекты разных типов. После этого отобразите типы и значения созданных объектов.*
+``` python
+print(ss1b[-10:])
 
-> целое_число = 42
-> вещественное_число = 3.14159
-> комплексное_число = 2 + 3j
-> строка = "Привет, мир!"
-> многострочная_строка = """Это
-> многострочная
-> строка"""
-> логическое_значение = True
-> print(целое_число)
-> print(вещественное_число)
-> print(комплексное_число)
-> print(строка)
-> print(многострочная_строка)
+print("\n")
+ss1b="My name is "+ ss1b[-10:]
+print(ss1b)
+```
 
-Ответ программы:
-![Task 6.2.8](images/Task6_2_8.png)
+Ответ программы:  
+![Task 6.2.7](images/Task6_2_7.png)  
 
-## 7. Изучение более сложных типов объектов: списки (list), кортежи (tuple), словари (dict), множества (set).
+8. *Самостоятельно придумайте значения и создайте объекты разных типов. После этого отобразите типы и значения созданных объектов.*  
 
-### 7.1. Список.
+``` python
+целое_число = 42
+вещественное_число = 3.14159
+комплексное_число = 2 + 3j
+строка = "Привет, мир!"
+многострочная_строка = """Это
+многострочная
+строка"""
+логическое_значение = True
+print(целое_число)
+print(вещественное_число)
+print(комплексное_число)
+print(строка)
+print(многострочная_строка)
+```
 
-1. *Список – это последовательность:  упорядоченная по местоположению коллекция объектов произвольных типов, размер которых практически не ограничен. В отличие от символьных строк, списки являются изменяемыми последовательностями, т.е. их элементы могут изменяться с помощью операций присваивания.*
+Ответ программы:  
+![Task 6.2.8](images/Task6_2_8.png)  
 
-> spis1=[111,'Spisok',5-9j]
-> print(spis1)
+## 7. Изучение более сложных типов объектов: списки (list), кортежи (tuple), словари (dict), множества (set).  
 
-Ответ программы:![Task 7.1.1.](images/Task7_1_1.png)
+### 7.1. Список.  
 
-2. *Cписок, содержащий последовательность отсчетов сигнала в виде «единичной ступеньки».*
+1. *Список – это последовательность:  упорядоченная по местоположению коллекция объектов произвольных типов, размер которых практически не ограничен. В отличие от символьных строк, списки являются изменяемыми последовательностями, т.е. их элементы могут изменяться с помощью операций присваивания.*  
 
-> stup=[0,0,1,1,1,1,1,1,1]
-> print(stup)
+``` python
+spis1=[111,'Spisok',5-9j]
+print(spis1)
+```
 
-Ответ программы:![Task 7.1.2.](images/Task7_1_2.png)
+Ответ программы:  
+![Task 7.1.1.](images/Task7_1_1.png)  
 
-3. *Список можно вводить на нескольких строках. При этом список будет считаться незавершенным, пока не будет введена закрывающая квадратная скобка.*
+2. *Cписок, содержащий последовательность отсчетов сигнала в виде «единичной ступеньки».*  
 
-> spis=[1,2,3,4,
-> 5,6,7,
-> 8,9,10]
-> print(spis)
+``` python
+stup=[0,0,1,1,1,1,1,1,1]
+print(stup)
+```
 
-Ответ программы:![Task 7.1.3.](images/Task7_1_3.png)
+Ответ программы:  
+![Task 7.1.2.](images/Task7_1_2.png)  
 
-4. *При работе с элементами списка можно использовать индексы точно так же, как это делали с элементами символьной строки.*
+3. *Список можно вводить на нескольких строках. При этом список будет считаться незавершенным, пока не будет введена закрывающая квадратная скобка.*  
 
-> print(stup[-8::2])
+``` python
+spis=[1,2,3,4,
+5,6,7,
+8,9,10]
+print(spis)
+```
 
-Ответ программы:![Task 7.1.4.](images/Task7_1_4.png)
+Ответ программы:  
+![Task 7.1.3.](images/Task7_1_3.png)  
 
-> spis1[1]='Список'
-> print(spis1)
+4. *При работе с элементами списка можно использовать индексы точно так же, как это делали с элементами символьной строки.*  
 
-Ответ программы:![Task 7.1.5.](images/Task7_1_5.png)
+``` python
+print(stup[-8::2])
+```
 
-5. *Текущее число элементов в списке можно узнать с помощью функции len().*
+Ответ программы:  
+![Task 7.1.4.](images/Task7_1_4.png)  
 
-> print(len(spis1))
+``` python
+spis1[1]='Список'
+print(spis1)
+```
 
-Ответ программы:![Task 7.1.6.](images/Task7_1_6.png)
+Ответ программы:  
+![Task 7.1.5.](images/Task7_1_5.png)  
 
-6. *Описание метода можно вывести с помощью функции help().*
+5. *Текущее число элементов в списке можно узнать с помощью функции len().*  
 
-> help(spis1.append)
+``` python
+print(len(spis1))
+```
 
-Ответ программы:![Task 7.1.7.](images/Task7_1_7.png)
+Ответ программы:  
+![Task 7.1.6.](images/Task7_1_6.png)  
 
-7. *С помощью методов объектов-списков можно добавлять и удалять элементы.*
+6. *Описание метода можно вывести с помощью функции help().*  
 
-> spis1.append('New item1')
-> spis1=spis1+["New item2"]
-> spis1=spis1+[ss1b]
-> print(spis1)
+``` python
+help(spis1.append)
+```
 
-Ответ программы:![Task 7.1.8.](images/Task7_1_8.png)
+Ответ программы:  
+![Task 7.1.7.](images/Task7_1_7.png)  
 
-8. *Также могут использоваться методы insert, remove, extend, clear, sort, reverse, copy, count, index.*
+7. *С помощью методов объектов-списков можно добавлять и удалять элементы.*  
 
-> #Создадим список для экспериментов
-> fruits = ["яблоко", "банан", "апельсин", "киви", "банан", "манго"]
-> print("Исходный список:", fruits)
-> print()
->
-> #1. append() - добавление элемента в конец
-> fruits.append("виноград")
-> print("1. После append('виноград'):", fruits)
->
-> #2. insert() - вставка элемента по индексу
-> fruits.insert(2, "лимон")
-> print("2. После insert(2, 'лимон'):", fruits)
->
-> #3. extend() - расширение списка другим списком
-> more_fruits = ["груша", "персик"]
-> fruits.extend(more_fruits)
-> print("3. После extend(['груша', 'персик']):", fruits)
->
-> #4. remove() - удаление первого найденного элемента по значению
-> fruits.remove("банан")
-> print("4. После remove('банан'):", fruits)
->
-> #5. pop() - удаление элемента по индексу (и возврат значения)
-> removed_fruit = fruits.pop(1)
-> print("5. После pop(3):", fruits)
-> print("   Удаленный элемент:", removed_fruit)
->
-> #6. clear() - полная очистка списка (создадим копию для демонстрации)
-> fruits_copy = fruits.copy()
-> fruits_copy.clear()
-> print("6. После clear() копии:", fruits_copy)
->
-> #7. index() - поиск индекса элемента
-> index_kiwi = fruits.index("киви")
-> print("7. Индекс элемента 'киви':", index_kiwi)
->
-> #8. count() - подсчет количества элементов
-> count_banana = fruits.count("банан")
-> print("8. Количество 'банан' в списке:", count_banana)
->
-> #9. sort() - сортировка списка
-> fruits.sort()
-> print("9. После sort() (по алфавиту):", fruits)
->
-> #10. reverse() - обратный порядок элементов
-> fruits.reverse()
-> print("10. После reverse():", fruits)
->
-> #11. copy() - создание копии списка
-> fruits_copy2 = fruits.copy()
-> fruits_copy2.append("ананас")
-> print("11. Оригинал после copy():", fruits)
-> print("    Копия после append('ананас'):", fruits_copy2)
->
-> #12. Дополнительно: len() - длина списка
-> print("12. Длина списка:", len(fruits))
->
-> #13. Дополнительно: проверка наличия элемента
-> print("13. 'яблоко' в списке?", "яблоко" in fruits)
-> print("    'арбуз' в списке?", "арбуз" in fruits)
+``` python
+pis1.append('New item1')
+spis1=spis1+["New item2"]
+spis1=spis1+[ss1b]
+print(spis1)
+```
 
-Ответ программы:![Task 7.1.9.](images/Task7_1_9.png)
+Ответ программы:  
+![Task 7.1.8.](images/Task7_1_8.png)  
 
-9. *Списки могут быть вложенными.*
+8. *Также могут использоваться методы insert, remove, extend, clear, sort, reverse, copy, count, index.*  
 
-> spis2=[spis1,[4,5,6,7]]
-> print(spis2)
+Создадим список для экспериментов:  
 
-Ответ программы:![Task 7.1.10.](images/Task7_1_10.png)
+``` python
+fruits = ["яблоко", "банан", "апельсин", "киви", "банан", "манго"]
+print("Исходный список:", fruits)
+print()
+
+#1. append() - добавление элемента в конец
+fruits.append("виноград")
+print("1. После append('виноград'):", fruits)
+
+#2. insert() - вставка элемента по индексу
+fruits.insert(2, "лимон")
+print("2. После insert(2, 'лимон'):", fruits)
+
+#3. extend() - расширение списка другим списком
+more_fruits = ["груша", "персик"]
+fruits.extend(more_fruits)
+print("3. После extend(['груша', 'персик']):", fruits)
+
+#4. remove() - удаление первого найденного элемента по значению
+fruits.remove("банан")
+print("4. После remove('банан'):", fruits)
+
+#5. pop() - удаление элемента по индексу (и возврат значения)
+removed_fruit = fruits.pop(1)
+print("5. После pop(3):", fruits)
+print("   Удаленный элемент:", removed_fruit)
+
+#6. clear() - полная очистка списка (создадим копию для демонстрации)
+fruits_copy = fruits.copy()
+fruits_copy.clear()
+print("6. После clear() копии:", fruits_copy)
+
+#7. index() - поиск индекса элемента
+index_kiwi = fruits.index("киви")
+print("7. Индекс элемента 'киви':", index_kiwi)
+
+#8. count() - подсчет количества элементов
+count_banana = fruits.count("банан")
+print("8. Количество 'банан' в списке:", count_banana)
+
+#9. sort() - сортировка списка
+fruits.sort()
+print("9. После sort() (по алфавиту):", fruits)
+
+#10. reverse() - обратный порядок элементов
+fruits.reverse()
+print("10. После reverse():", fruits)
+
+#11. copy() - создание копии списка
+fruits_copy2 = fruits.copy()
+fruits_copy2.append("ананас")
+print("11. Оригинал после copy():", fruits)
+print("    Копия после append('ананас'):", fruits_copy2)
+
+#12. Дополнительно: len() - длина списка
+ print("12. Длина списка:", len(fruits))
+
+#13. Дополнительно: проверка наличия элемента
+print("13. 'яблоко' в списке?", "яблоко" in fruits)
+print("    'арбуз' в списке?", "арбуз" in fruits)
+```
 
-10. *Обращение к элементам вложенного списка.*
+Ответ программы:  
+![Task 7.1.9.](images/Task7_1_9.png)  
 
-> print(spis2[0][1])
+9. *Списки могут быть вложенными.*  
 
-Ответ программы:![Task 7.1.11.](images/Task7_1_11.png)
+``` python
+spis2=[spis1,[4,5,6,7]]
+print(spis2)
+```
 
-11. *Изменение элемента вложенного списка.*
+Ответ программы:  
+![Task 7.1.10.](images/Task7_1_10.png)  
 
-> spis2[0][1]=78
-> print(spis2[0][1])
+10. *Обращение к элементам вложенного списка.*  
 
-Ответ программы:![Task 7.1.12.](images/Task7_1_12.png)
+``` python
+print(spis2[0][1])
+```
 
-12. *Объект-список, элементами которого будут объекты разных типов.*
+Ответ программы:  
+![Task 7.1.11.](images/Task7_1_11.png)  
 
-> разнообразный_список = [
-> 42,                                  # целое число
-> "Привет, мир!",                      # строка
-> True,                               # логическое значение
-> 3.14159,                            # вещественное число
-> ["вложенный", "список", 123],       # вложенный список
-> {"ключ": "значение"},               # словарь
-> None,                               # специальное значение
-> complex(2, 3),                      # комплексное число
-> False                               # еще одно логическое значение
-> ]
-> print(разнообразный_список)
+11. *Изменение элемента вложенного списка.*  
 
-Ответ программы:
-![Task 7.1.13.](images/Task7_1_13.png)
+``` python
+spis2[0][1]=78
+print(spis2[0][1])
+```
 
-### 7.2. Кортеж.
+Ответ программы:  
+![Task 7.1.12.](images/Task7_1_12.png)  
 
-1. *Объект-кортеж похож на список, но его нельзя изменить – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки. Кортежи также поддер­живают включение в них объектов различных типов и операции, типич­ные для последовательностей.*
+12. *Объект-список, элементами которого будут объекты разных типов.*  
 
-> kort1=(222,'Kortezh',77+8j)
-> print(kort1)
+``` python
+разнообразный_список = [
+42,                                  # целое число
+"Привет, мир!",                      # строка
+True,                               # логическое значение
+3.14159,                            # вещественное число
+["вложенный", "список", 123],       # вложенный список
+{"ключ": "значение"},               # словарь
+None,                               # специальное значение
+complex(2, 3),                      # комплексное число
+False                               # еще одно логическое значение
+]
+print(разнообразный_список)
+```
 
-Ответ программы:![Task 7.2.1.](images/Task7_2_1.png)
+Ответ программы:  
+![Task 7.1.13.](images/Task7_1_13.png)  
 
-2. *Изменить кортеж нельзя, но можно его переопределить.*
+### 7.2. Кортеж.  
 
-> kort1= kort1+(1,2)
-> print(kort1)
+1. *Объект-кортеж похож на список, но его нельзя изменить – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки. Кортежи также поддер­живают включение в них объектов различных типов и операции, типич­ные для последовательностей.*  
 
-Ответ программы:![Task 7.2.2](images/Task7_2_2.png)
+``` python
+kort1=(222,'Kortezh',77+8j)
+print(kort1)
+```
+Ответ программы:  
+![Task 7.2.1.](images/Task7_2_1.png)  
 
-3. *Если надо добавить еще один элемент в кортеж.*
+2. *Изменить кортеж нельзя, но можно его переопределить.*  
 
-> ss1b= 'Меня зовут: \n TerekhovFV'
-> kort1= kort1+(ss1b,)  #ЗДЕСЬ ЗАПЯТАЯ ОБЯЗАТЕЛЬНА, ИНАЧЕ ОШИБКА
-> print(kort1)
+```python
+kort1= kort1+(1,2)
+print(kort1)
+```
 
-Ответ программы:![Task 7.2.3](images/Task7_2_3.png)
+Ответ программы:  
+![Task 7.2.2](images/Task7_2_2.png)  
 
-4. *Теперь переопределим кортеж с удалением комплексного элемента.*
+3. *Если надо добавить еще один элемент в кортеж.*  
 
-> kort2=kort1[:2]+kort1[3:]
-> print(kort2)
+```python
+ss1b= 'Меня зовут: \n TerekhovFV'
+kort1= kort1+(ss1b,)  #ЗДЕСЬ ЗАПЯТАЯ ОБЯЗАТЕЛЬНА, ИНАЧЕ ОШИБКА
+print(kort1)
+```
 
-Ответ программы:![Task 7.2.4](images/Task7_2_4.png)
+Ответ программы:  
+![Task 7.2.3](images/Task7_2_3.png)  
 
-5. *Два важных метода кортежа (они есть также и у списков):*
+4. *Теперь переопределим кортеж с удалением комплексного элемента.*  
 
-* Определение индекса заданного элемента:
+```python
+kort2=kort1[:2]+kort1[3:]
+print(kort2)
+```
 
-> print(kort1.index(2))
+Ответ программы:  
+![Task 7.2.4](images/Task7_2_4.png)  
 
-Ответ программы:![Task 7.2.5](images/Task7_2_5.png)
+5. *Два важных метода кортежа (они есть также и у списков):*  
 
-* Подсчет числа вхождений заданного элемента в кортеже:
+* Определение индекса заданного элемента:  
 
-> print(kort1.count(222))
+```python
+print(kort1.index(2))
+```
 
-Ответ программы:![Task 7.2.6](images/Task7_2_6.png)
+Ответ программы:  
+![Task 7.2.5](images/Task7_2_5.png)  
 
-6. *Методов append и pop у кортежей нет, т.к. они являются неизменяемыми.*
+* Подсчет числа вхождений заданного элемента в кортеже:  
 
-> kort1[2]=90
+```python
+print(kort1.count(222))
+```
 
-Ответ программы:![Task 7.2.7](images/Task7_2_7.png)
+Ответ программы:  
+![Task 7.2.6](images/Task7_2_6.png)  
 
-7. *Объект-кортеж с элементами разных типов: число, строка, список, кортеж.*
+6. *Методов append и pop у кортежей нет, т.к. они являются неизменяемыми.*  
 
-> разнообразный_кортеж = (
-> 100,                                # целое число
-> "Hello, Tuple!",                    # строка
-> [1, 2, 3, "список внутри кортежа"], # список
-> (4, 5, 6),                         # вложенный кортеж
-> 3.14,                              # вещественное число
-> True,                              # логическое значение
-> None                               # специальное значение
-> )
-> print(разнообразный_кортеж)
+```python
+kort1[2]=90
+```
 
-Ответ программы:
-![Task 7.2.8](images/Task7_2_8.png)
+Ответ программы:  
+![Task 7.2.7](images/Task7_2_7.png)  
+
+7. *Объект-кортеж с элементами разных типов: число, строка, список, кортеж.*  
+
+```python
+разнообразный_кортеж = (
+100,                                # целое число
+"Hello, Tuple!",                    # строка
+[1, 2, 3, "список внутри кортежа"], # список
+(4, 5, 6),                         # вложенный кортеж
+3.14,                              # вещественное число
+True,                              # логическое значение
+None                               # специальное значение
+)
+print(разнообразный_кортеж)
+```
+Ответ программы:  
+![Task 7.2.8](images/Task7_2_8.png)  
 
-### 7.3. Словарь.
+### 7.3. Словарь.  
 
-1. *Объект-словарь похож на ассоциативные массивы в других языках программирования. Его содержанием является совокупность пар: «ключ (key)»:«значение (value)». В качестве ключей могут использоваться неизменяемые типы объектов. Значениями могут быть объекты любого типа. Ссылка на ключ обеспечивает быстрый доступ к связанному с ним значению. В отличие от списков и кортежей совокупность элементов словаря не является упорядоченной (последовательностью). Его элементы могут изменяться с помощью операции присваивания значений.*
+1. *Объект-словарь похож на ассоциативные массивы в других языках программирования. Его содержанием является совокупность пар: «ключ (key)»:«значение (value)». В качестве ключей могут использоваться неизменяемые типы объектов. Значениями могут быть объекты любого типа. Ссылка на ключ обеспечивает быстрый доступ к связанному с ним значению. В отличие от списков и кортежей совокупность элементов словаря не является упорядоченной (последовательностью). Его элементы могут изменяться с помощью операции присваивания значений.*  
 
-> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
-> print(dic1)
+```python
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+print(dic1)
+```
 
-Ответ программы:![Task 7.3.1](images/Task7_3_1.png)
+Ответ программы:  
+![Task 7.3.1](images/Task7_3_1.png)  
 
-2. *Обращение к элементам словаря не по индексам, а по ключам:*
+2. *Обращение к элементам словаря не по индексам, а по ключам:*  
 
-> print(dic1['Orel'])
+```python
+print(dic1['Orel'])
+```
 
-Ответ программы:![Task 7.3.2](images/Task7_3_2.png)
+Ответ программы:  
+![Task 7.3.2](images/Task7_3_2.png)  
 
-3. *Пополнение словаря (добавление элемента, изменение словаря):*
+3. *Пополнение словаря (добавление элемента, изменение словаря):*  
 
-> dic1['Pskov']=78
-> print(dic1)
+```python
+dic1['Pskov']=78
+print(dic1)
+```
 
-Ответ программы:
-![Task 7.3.3](images/Task7_3_3.png)
+Ответ программы:  
+![Task 7.3.3](images/Task7_3_3.png)  
 
-*Обратите внимание на то, что в силу неупорядоченности словаря при его выводе элементы могут располагаться не в том порядке, в каком они задавались при его формировании.**Для того, чтобы получить перечень ключей или значений из словаря следует использовать методы keys или values, создающие списки, соответственно, ключей или значений из словаря.*
+*Обратите внимание на то, что в силу неупорядоченности словаря при его выводе элементы могут располагаться не в том порядке, в каком они задавались при его формировании.*  
+*Для того, чтобы получить перечень ключей или значений из словаря следует использовать методы keys или values, создающие списки, соответственно, ключей или значений из словаря.*  
 
-4. *Функция sorted позволяет увидеть список упорядоченным по ключам или по значениям:*
+4. *Функция sorted позволяет увидеть список упорядоченным по ключам или по значениям:*  
 
-> print(sorted(dic1.keys()))
-> print(sorted(dic1.values()))
+```python
+print(sorted(dic1.keys()))
+print(sorted(dic1.values()))
+```
 
-Ответ программы:![Task 7.3.4](images/Task7_3_4.png)
+Ответ программы:  
+![Task 7.3.4](images/Task7_3_4.png)  
 
-5. *Элементы словаря могут быть любого типа, в том числе и словарями.*
+5. *Элементы словаря могут быть любого типа, в том числе и словарями.*  
 
-> dic2={1:'mean',2:'standart deviation',3:'correlation'}
-> dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
-> print(dic3['statistics'][2])
+```python
+dic2={1:'mean',2:'standart deviation',3:'correlation'}
+dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+print(dic3['statistics'][2])
+```
 
-Ответ программы:![Task 7.3.5](images/Task7_3_5.png)
+Ответ программы:  
+![Task 7.3.5](images/Task7_3_5.png)  
 
-6. *Более сложный словарь из списка с элементами-кортежами с использованием функции dict:*
+6. *Более сложный словарь из списка с элементами-кортежами с использованием функции dict:*  
 
-> ss1b= 'Меня зовут: \n TerekhovFV'
-> dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
-> print(dic4)
+```python
+ss1b= 'Меня зовут: \n TerekhovFV'
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+print(dic4)
+```
 
-Ответ программы:![Task 7.3.6](images/Task7_3_6.png)
+Ответ программы:  
+![Task 7.3.6](images/Task7_3_6.png)  
 
-7. *Еще один словарь из двух списков: один для ключей и другой – для значений, с помощью функций dict и zip:*
+7. *Еще один словарь из двух списков: один для ключей и другой – для значений, с помощью функций dict и zip:*  
 
-> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
-> print(dic5)
+```python
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+print(dic5)
+```
 
-Ответ программы:![Task 7.3.7](images/Task7_3_7.png)
+Ответ программы:  
+![Task 7.3.7](images/Task7_3_7.png)  
 
-8. *Объект-кортеж с 7 элементами и объект-список с 5 элементами и попробуйте создать из них словарь с помощью функций dict и zip.*
+8. *Объект-кортеж с 7 элементами и объект-список с 5 элементами и попробуйте создать из них словарь с помощью функций dict и zip.*  
 
-> ключи = ('имя', 'возраст', 'город', 'профессия', 'стаж', 'зарплата', 'активен')
-> значения = ['Анна', 28, 'Москва', 'программист', True]
-> словарь = dict(zip(ключи, значения))
-> print(словарь)
-> print(f"Количество элементов в словаре: {len(словарь)}")
+```python
+ключи = ('имя', 'возраст', 'город', 'профессия', 'стаж', 'зарплата', 'активен')
+значения = ['Анна', 28, 'Москва', 'программист', True]
+словарь = dict(zip(ключи, значения))
+print(словарь)
+print(f"Количество элементов в словаре: {len(словарь)}")
+```
 
-Ответ программы:
-![Task 7.3.7](images/Task7_3_7.png)
+Ответ программы:  
+![Task 7.3.7](images/Task7_3_7.png)  
 
-### 7.4. Множество.
+### 7.4. Множество.  
 
-1. *Объект-множество – это неупорядоченная совокупность неповторяющихся элементов. Эти элементы могут быть разных, но только неизменяемых типов (числа, строки, кортежи).*
+1. *Объект-множество – это неупорядоченная совокупность неповторяющихся элементов. Эти элементы могут быть разных, но только неизменяемых типов (числа, строки, кортежи).*  
 
-> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
-> print(mnoz1)
+```python
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+print(mnoz1)
+```
 
-Ответ программы:![Task 7.4.1.](images/Task7_4_1.png)
+Ответ программы:  
+![Task 7.4.1.](images/Task7_4_1.png)  
 
-2. *Определение числа элементов:*
+2. *Определение числа элементов:*  
 
-> print(len(mnoz1))
+```python
+print(len(mnoz1))
+```
 
-Ответ программы:![Task 7.4.2.](images/Task7_4_2.png)
+Ответ программы:  
+![Task 7.4.2.](images/Task7_4_2.png)  
 
-3. *Проверка наличия элемента во множестве:*
+3. *Проверка наличия элемента во множестве:*  
 
-> print('датчик' in mnoz1)
+```python
+print('датчик' in mnoz1)
+```
 
-Ответ программы:![Task 7.4.3.](images/Task7_4_3.png)
+Ответ программы:  
+![Task 7.4.3.](images/Task7_4_3.png)  
 
-4. *Добавление элемента:*
+4. *Добавление элемента:*  
 
-> mnoz1.add('реле')
-> print(mnoz1)
+```python
+mnoz1.add('реле')
+print(mnoz1)
+```
 
-Ответ программы:![Task 7.4.4.](images/Task7_4_4.png)
+Ответ программы:  
+![Task 7.4.4.](images/Task7_4_4.png)  
 
-5. *Удаление элемента:*
+5. *Удаление элемента:*  
 
-> mnoz1.remove('линия связи')
-> print(mnoz1)
+```python
+mnoz1.remove('линия связи')
+print(mnoz1)
+```
 
 Ответ программы:  
 ![Task 7.4.5.](images/Task7_4_5.png)  
 
-6. *Объект-множество с элементами разных типов.*
-
-> разнообразное_множество = {
-> 42,                    # целое число
-> "hello",               # строка
-> 3.14,                  # вещественное число
-> True,                  # логическое значение (True = 1)
-> (1, 2, 3),             # кортеж (неизменяемый)
-> "world",               # еще одна строка
-> 100,                   # еще одно число
-> False                  # логическое значение (False = 0)
-> }
-> print(разнообразное_множество)
-> print('\n')
-> разнообразное_множество.add("новый элемент")
-> print(разнообразное_множество)
-> print('\n')
-> разнообразное_множество.remove("hello")
-> print(разнообразное_множество)
-> print('\n')
-> print('hello' in разнообразное_множество)
-
+6. *Объект-множество с элементами разных типов.*  
+
+```python
+разнообразное_множество = {
+42,                    # целое число
+"hello",               # строка
+3.14,                  # вещественное число
+True,                  # логическое значение (True = 1)
+(1, 2, 3),             # кортеж (неизменяемый)
+"world",               # еще одна строка
+100,                   # еще одно число
+False                  # логическое значение (False = 0)
+}
+print(разнообразное_множество)
+print('\n')
+разнообразное_множество.add("новый элемент")
+print(разнообразное_множество)
+print('\n')
+разнообразное_множество.remove("hello")
+print(разнообразное_множество)
+print('\n')
+print('hello' in разнообразное_множество)
+```
 Ответ программы:  
 ![Task 7.4.6.](images/Task7_4_6.png)  
 
-## Общее контрольное задание.
-
->import keyword  
->  
->familia = "Terekhov"  
->first_letter = familia[0]  
->  
->sp_kw = list(keyword.kwlist)  
->  
->kort_nam = ("Фёдор", "Дима", "Вадим", "Екатерина")  
->is_tuple = (type(kort_nam) is tuple)  
->kort_nam = kort_nam + ("Павел", "Иван")  
->count_dima = kort_nam.count("Дима")  
->  
->dict_bas = {  
->"строка": familia,  
->"символ (строка из 1 буквы)": first_letter,  
->"список": sp_kw,  
->"кортеж": kort_nam,  
->"логический": is_tuple,  
->}  
->  
->print(f"familia = {familia}")  
->print(f"first_letter = {first_letter}")  
->print(f"sp_kw (без 'nonlocal') содержит {len(sp_kw)} ключевых слов")  
->print(f"Проверка типа kort_nam — tuple: {is_tuple}")  
->print(f"kort_nam = {kort_nam}")  
->print(f"Количество вхождений 'Дима' в kort_nam: {count_dima}")  
->print("dict_bas (ключи → значение):")  
->for k in dict_bas:  
->print(f"  {k}: {dict_bas[k]}")  
+## Общее контрольное задание.  
+
+```python
+import keyword  
+  
+familia = "Terekhov"  
+first_letter = familia[0]  
+  
+sp_kw = list(keyword.kwlist)  
+  
+kort_nam = ("Фёдор", "Дима", "Вадим", "Екатерина")  
+is_tuple = (type(kort_nam) is tuple)  
+kort_nam = kort_nam + ("Павел", "Иван")  
+count_dima = kort_nam.count("Дима")  
+  
+dict_bas = {  
+"строка": familia,  
+"символ (строка из 1 буквы)": first_letter,  
+"список": sp_kw,  
+"кортеж": kort_nam,  
+"логический": is_tuple,  
+}  
+  
+print(f"familia = {familia}")  
+print(f"first_letter = {first_letter}")  
+print(f"sp_kw (без 'nonlocal') содержит {len(sp_kw)} ключевых слов")  
+print(f"Проверка типа kort_nam — tuple: {is_tuple}")  
+print(f"kort_nam = {kort_nam}")  
+print(f"Количество вхождений 'Дима' в kort_nam: {count_dima}")  
+print("dict_bas (ключи → значение):")  
+for k in dict_bas:  
+print(f"  {k}: {dict_bas[k]}")  
+```
 
 Ответ программы:  
 ![Control task](images/control_task.png)  
\ No newline at end of file