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